WebSVN – Kolibri OS – Blame – /programs/network/netsurf/libcss/test/dump

Rev	Author	Line No.	Line
3584	sourcerer	1	#include
		2	#include
		3	#include
		4
		5	static size_t dump_css_fixed(css_fixed f, char *ptr, size_t len)
		6	{
		7	#define ABS(x) (uint32_t)((x) < 0 ? -(x) : (x))
		8	uint32_t uintpart = FIXTOINT(ABS(f));
		9	/* + 500 to ensure round to nearest (division will truncate) */
		10	uint32_t fracpart = ((ABS(f) & 0x3ff) * 1000 + 500) / (1 << 10);
		11	#undef ABS
		12	size_t flen = 0;
		13	char tmp[20];
		14	size_t tlen = 0;
		15	char *buf = ptr;
		16
		17	if (len == 0)
		18	return 0;
		19
		20	if (f < 0) {
		21	buf[0] = '-';
		22	buf++;
		23	len--;
		24	}
		25
		26	do {
		27	tmp[tlen] = "0123456789"[uintpart % 10];
		28	tlen++;
		29
		30	uintpart /= 10;
		31	} while (tlen < 20 && uintpart != 0);
		32
		33	while (tlen > 0 && len > 0) {
		34	buf[0] = tmp[--tlen];
		35	buf++;
		36	len--;
		37	}
		38
		39	if (len > 0) {
		40	buf[0] = '.';
		41	buf++;
		42	len--;
		43	}
		44
		45	do {
		46	tmp[tlen] = "0123456789"[fracpart % 10];
		47	tlen++;
		48
		49	fracpart /= 10;
		50	} while (tlen < 20 && fracpart != 0);
		51
		52	while (tlen > 0 && len > 0) {
		53	buf[0] = tmp[--tlen];
		54	buf++;
		55	flen++;
		56	len--;
		57	}
		58
		59	while (flen < 3 && len > 0) {
		60	buf[0] = '0';
		61	buf++;
		62	flen++;
		63	len--;
		64	}
		65
		66	if (len > 0)
		67	buf[0] = '\0';
		68
		69	return buf - ptr;
		70	}
		71	static size_t dump_css_number(css_fixed val, char *ptr, size_t len)
		72	{
		73	if (INTTOFIX(FIXTOINT(val)) == val)
		74	return snprintf(ptr, len, "%d", FIXTOINT(val));
		75	else
		76	return dump_css_fixed(val, ptr, len);
		77	}
		78
		79	static size_t dump_css_unit(css_fixed val, css_unit unit, char *ptr, size_t len)
		80	{
		81	size_t ret = dump_css_number(val, ptr, len);
		82
		83	switch (unit) {
		84	case CSS_UNIT_PX:
		85	ret += snprintf(ptr + ret, len - ret, "px");
		86	break;
		87	case CSS_UNIT_EX:
		88	ret += snprintf(ptr + ret, len - ret, "ex");
		89	break;
		90	case CSS_UNIT_EM:
		91	ret += snprintf(ptr + ret, len - ret, "em");
		92	break;
		93	case CSS_UNIT_IN:
		94	ret += snprintf(ptr + ret, len - ret, "in");
		95	break;
		96	case CSS_UNIT_CM:
		97	ret += snprintf(ptr + ret, len - ret, "cm");
		98	break;
		99	case CSS_UNIT_MM:
		100	ret += snprintf(ptr + ret, len - ret, "mm");
		101	break;
		102	case CSS_UNIT_PT:
		103	ret += snprintf(ptr + ret, len - ret, "pt");
		104	break;
		105	case CSS_UNIT_PC:
		106	ret += snprintf(ptr + ret, len - ret, "pc");
		107	break;
		108	case CSS_UNIT_PCT:
		109	ret += snprintf(ptr + ret, len - ret, "%%");
		110	break;
		111	case CSS_UNIT_DEG:
		112	ret += snprintf(ptr + ret, len - ret, "deg");
		113	break;
		114	case CSS_UNIT_GRAD:
		115	ret += snprintf(ptr + ret, len - ret, "grad");
		116	break;
		117	case CSS_UNIT_RAD:
		118	ret += snprintf(ptr + ret, len - ret, "rad");
		119	break;
		120	case CSS_UNIT_MS:
		121	ret += snprintf(ptr + ret, len - ret, "ms");
		122	break;
		123	case CSS_UNIT_S:
		124	ret += snprintf(ptr + ret, len - ret, "s");
		125	break;
		126	case CSS_UNIT_HZ:
		127	ret += snprintf(ptr + ret, len - ret, "Hz");
		128	break;
		129	case CSS_UNIT_KHZ:
		130	ret += snprintf(ptr + ret, len - ret, "kHz");
		131	break;
		132	}
		133
		134	return ret;
		135	}
		136
		137
		138	static void dump_computed_style(const css_computed_style style, char buf,
		139	size_t *len)
		140	{
		141	char *ptr = buf;
		142	size_t wrote = 0;
		143	uint8_t val;
		144	css_color color = 0;
		145	lwc_string *url = NULL;
		146	css_fixed len1 = 0, len2 = 0;
		147	css_unit unit1 = CSS_UNIT_PX, unit2 = CSS_UNIT_PX;
		148	css_computed_clip_rect rect = { 0, 0, 0, 0, CSS_UNIT_PX, CSS_UNIT_PX,
		149	CSS_UNIT_PX, CSS_UNIT_PX, true, true,
		150	true, true };
		151	const css_computed_content_item *content = NULL;
		152	const css_computed_counter *counter = NULL;
		153	lwc_string **string_list = NULL;
		154	int32_t zindex = 0;
		155
		156	/* background-attachment */
		157	val = css_computed_background_attachment(style);
		158	switch (val) {
		159	case CSS_BACKGROUND_ATTACHMENT_INHERIT:
		160	wrote = snprintf(ptr, *len, "background-attachment: inherit\n");
		161	break;
		162	case CSS_BACKGROUND_ATTACHMENT_FIXED:
		163	wrote = snprintf(ptr, *len, "background-attachment: fixed\n");
		164	break;
		165	case CSS_BACKGROUND_ATTACHMENT_SCROLL:
		166	wrote = snprintf(ptr, *len, "background-attachment: scroll\n");
		167	break;
		168	default:
		169	wrote = 0;
		170	break;
		171	}
		172	ptr += wrote;
		173	*len -= wrote;
		174
		175	/* background-color */
		176	val = css_computed_background_color(style, &color);
		177	switch (val) {
		178	case CSS_BACKGROUND_COLOR_INHERIT:
		179	wrote = snprintf(ptr, *len, "background-color: inherit\n");
		180	break;
		181	case CSS_BACKGROUND_COLOR_COLOR:
		182	wrote = snprintf(ptr, *len, "background-color: #%08x\n", color);
		183	break;
		184	default:
		185	wrote = 0;
		186	break;
		187	}
		188	ptr += wrote;
		189	*len -= wrote;
		190
		191	/* background-image */
		192	val = css_computed_background_image(style, &url);
		193	if (val == CSS_BACKGROUND_IMAGE_INHERIT) {
		194	wrote = snprintf(ptr, *len, "background-image: inherit\n");
		195	} else if (val == CSS_BACKGROUND_IMAGE_IMAGE && url != NULL) {
		196	wrote = snprintf(ptr, len, "background-image: url('%.s')\n",
		197	(int) lwc_string_length(url),
		198	lwc_string_data(url));
		199	} else if (val == CSS_BACKGROUND_IMAGE_NONE) {
		200	wrote = snprintf(ptr, *len, "background-image: none\n");
		201	} else {
		202	wrote = 0;
		203	}
		204	ptr += wrote;
		205	*len -= wrote;
		206
		207	/* background-position */
		208	val = css_computed_background_position(style, &len1, &unit1,
		209	&len2, &unit2);
		210	if (val == CSS_BACKGROUND_POSITION_INHERIT) {
		211	wrote = snprintf(ptr, *len, "background-position: inherit\n");
		212	ptr += wrote;
		213	*len -= wrote;
		214	} else if (val == CSS_BACKGROUND_POSITION_SET) {
		215	wrote = snprintf(ptr, *len, "background-position: ");
		216	ptr += wrote;
		217	*len -= wrote;
		218
		219	wrote = dump_css_unit(len1, unit1, ptr, *len);
		220	ptr += wrote;
		221	*len -= wrote;
		222
		223	wrote = snprintf(ptr, *len, " ");
		224	ptr += wrote;
		225	*len -= wrote;
		226
		227	wrote = dump_css_unit(len2, unit2, ptr, *len);
		228	ptr += wrote;
		229	*len -= wrote;
		230
		231	wrote = snprintf(ptr, *len, "\n");
		232	ptr += wrote;
		233	*len -= wrote;
		234	}
		235
		236	/* background-repeat */
		237	val = css_computed_background_repeat(style);
		238	switch (val) {
		239	case CSS_BACKGROUND_REPEAT_INHERIT:
		240	wrote = snprintf(ptr, *len, "background-repeat: inherit\n");
		241	break;
		242	case CSS_BACKGROUND_REPEAT_REPEAT_X:
		243	wrote = snprintf(ptr, *len, "background-repeat: repeat-x\n");
		244	break;
		245	case CSS_BACKGROUND_REPEAT_REPEAT_Y:
		246	wrote = snprintf(ptr, *len, "background-repeat: repeat-y\n");
		247	break;
		248	case CSS_BACKGROUND_REPEAT_REPEAT:
		249	wrote = snprintf(ptr, *len, "background-repeat: repeat\n");
		250	break;
		251	case CSS_BACKGROUND_REPEAT_NO_REPEAT:
		252	wrote = snprintf(ptr, *len, "background-repeat: no-repeat\n");
		253	break;
		254	default:
		255	wrote = 0;
		256	break;
		257	}
		258	ptr += wrote;
		259	*len -= wrote;
		260
		261	/* border-collapse */
		262	val = css_computed_border_collapse(style);
		263	switch (val) {
		264	case CSS_BORDER_COLLAPSE_INHERIT:
		265	wrote = snprintf(ptr, *len, "border-collapse: inherit\n");
		266	break;
		267	case CSS_BORDER_COLLAPSE_SEPARATE:
		268	wrote = snprintf(ptr, *len, "border-collapse: separate\n");
		269	break;
		270	case CSS_BORDER_COLLAPSE_COLLAPSE:
		271	wrote = snprintf(ptr, *len, "border-collapse: collapse\n");
		272	break;
		273	default:
		274	wrote = 0;
		275	break;
		276	}
		277	ptr += wrote;
		278	*len -= wrote;
		279
		280	/* border-spacing */
		281	val = css_computed_border_spacing(style, &len1, &unit1, &len2, &unit2);
		282	if (val == CSS_BORDER_SPACING_INHERIT) {
		283	wrote = snprintf(ptr, *len, "border-spacing: inherit\n");
		284	ptr += wrote;
		285	*len -= wrote;
		286	} else if (val == CSS_BORDER_SPACING_SET) {
		287	wrote = snprintf(ptr, *len, "border-spacing: ");
		288	ptr += wrote;
		289	*len -= wrote;
		290
		291	wrote = dump_css_unit(len1, unit1, ptr, *len);
		292	ptr += wrote;
		293	*len -= wrote;
		294
		295	wrote = snprintf(ptr, *len, " ");
		296	ptr += wrote;
		297	*len -= wrote;
		298
		299	wrote = dump_css_unit(len2, unit2, ptr, *len);
		300	ptr += wrote;
		301	*len -= wrote;
		302
		303	wrote = snprintf(ptr, *len, "\n");
		304	ptr += wrote;
		305	*len -= wrote;
		306	}
		307
		308	/* border-top-color */
		309	val = css_computed_border_top_color(style, &color);
		310	switch (val) {
		311	case CSS_BORDER_COLOR_INHERIT:
		312	wrote = snprintf(ptr, *len, "border-top-color: inherit\n");
		313	break;
		314	case CSS_BORDER_COLOR_CURRENT_COLOR:
		315	wrote = snprintf(ptr, *len, "border-top-color: currentColor\n");
		316	break;
		317	case CSS_BORDER_COLOR_COLOR:
		318	wrote = snprintf(ptr, *len, "border-top-color: #%08x\n", color);
		319	break;
		320	default:
		321	wrote = 0;
		322	break;
		323	}
		324	ptr += wrote;
		325	*len -= wrote;
		326
		327	/* border-right-color */
		328	val = css_computed_border_right_color(style, &color);
		329	switch (val) {
		330	case CSS_BORDER_COLOR_INHERIT:
		331	wrote = snprintf(ptr, *len, "border-right-color: inherit\n");
		332	break;
		333	case CSS_BORDER_COLOR_CURRENT_COLOR:
		334	wrote = snprintf(ptr, *len, "border-right-color: currentColor\n");
		335	break;
		336	case CSS_BORDER_COLOR_COLOR:
		337	wrote = snprintf(ptr, *len,
		338	"border-right-color: #%08x\n", color);
		339	break;
		340	default:
		341	wrote = 0;
		342	break;
		343	}
		344	ptr += wrote;
		345	*len -= wrote;
		346
		347	/* border-bottom-color */
		348	val = css_computed_border_bottom_color(style, &color);
		349	switch (val) {
		350	case CSS_BORDER_COLOR_INHERIT:
		351	wrote = snprintf(ptr, *len, "border-bottom-color: inherit\n");
		352	break;
		353	case CSS_BORDER_COLOR_CURRENT_COLOR:
		354	wrote = snprintf(ptr, *len, "border-bottom-color: currentColor\n");
		355	break;
		356	case CSS_BORDER_COLOR_COLOR:
		357	wrote = snprintf(ptr, *len,
		358	"border-bottom-color: #%08x\n", color);
		359	break;
		360	default:
		361	wrote = 0;
		362	break;
		363	}
		364	ptr += wrote;
		365	*len -= wrote;
		366
		367	/* border-left-color */
		368	val = css_computed_border_left_color(style, &color);
		369	switch (val) {
		370	case CSS_BORDER_COLOR_INHERIT:
		371	wrote = snprintf(ptr, *len, "border-left-color: inherit\n");
		372	break;
		373	case CSS_BORDER_COLOR_CURRENT_COLOR:
		374	wrote = snprintf(ptr, *len, "border-left-color: currentColor\n");
		375	break;
		376	case CSS_BORDER_COLOR_COLOR:
		377	wrote = snprintf(ptr, *len,
		378	"border-left-color: #%08x\n", color);
		379	break;
		380	default:
		381	wrote = 0;
		382	break;
		383	}
		384	ptr += wrote;
		385	*len -= wrote;
		386
		387	/* border-top-style */
		388	val = css_computed_border_top_style(style);
		389	switch (val) {
		390	case CSS_BORDER_STYLE_INHERIT:
		391	wrote = snprintf(ptr, *len, "border-top-style: inherit\n");
		392	break;
		393	case CSS_BORDER_STYLE_NONE:
		394	wrote = snprintf(ptr, *len, "border-top-style: none\n");
		395	break;
		396	case CSS_BORDER_STYLE_HIDDEN:
		397	wrote = snprintf(ptr, *len, "border-top-style: hidden\n");
		398	break;
		399	case CSS_BORDER_STYLE_DOTTED:
		400	wrote = snprintf(ptr, *len, "border-top-style: dotted\n");
		401	break;
		402	case CSS_BORDER_STYLE_DASHED:
		403	wrote = snprintf(ptr, *len, "border-top-style: dashed\n");
		404	break;
		405	case CSS_BORDER_STYLE_SOLID:
		406	wrote = snprintf(ptr, *len, "border-top-style: solid\n");
		407	break;
		408	case CSS_BORDER_STYLE_DOUBLE:
		409	wrote = snprintf(ptr, *len, "border-top-style: double\n");
		410	break;
		411	case CSS_BORDER_STYLE_GROOVE:
		412	wrote = snprintf(ptr, *len, "border-top-style: groove\n");
		413	break;
		414	case CSS_BORDER_STYLE_RIDGE:
		415	wrote = snprintf(ptr, *len, "border-top-style: ridge\n");
		416	break;
		417	case CSS_BORDER_STYLE_INSET:
		418	wrote = snprintf(ptr, *len, "border-top-style: inset\n");
		419	break;
		420	case CSS_BORDER_STYLE_OUTSET:
		421	wrote = snprintf(ptr, *len, "border-top-style: outset\n");
		422	break;
		423	default:
		424	wrote = 0;
		425	break;
		426	}
		427	ptr += wrote;
		428	*len -= wrote;
		429
		430	/* border-right-style */
		431	val = css_computed_border_right_style(style);
		432	switch (val) {
		433	case CSS_BORDER_STYLE_INHERIT:
		434	wrote = snprintf(ptr, *len, "border-right-style: inherit\n");
		435	break;
		436	case CSS_BORDER_STYLE_NONE:
		437	wrote = snprintf(ptr, *len, "border-right-style: none\n");
		438	break;
		439	case CSS_BORDER_STYLE_HIDDEN:
		440	wrote = snprintf(ptr, *len, "border-right-style: hidden\n");
		441	break;
		442	case CSS_BORDER_STYLE_DOTTED:
		443	wrote = snprintf(ptr, *len, "border-right-style: dotted\n");
		444	break;
		445	case CSS_BORDER_STYLE_DASHED:
		446	wrote = snprintf(ptr, *len, "border-right-style: dashed\n");
		447	break;
		448	case CSS_BORDER_STYLE_SOLID:
		449	wrote = snprintf(ptr, *len, "border-right-style: solid\n");
		450	break;
		451	case CSS_BORDER_STYLE_DOUBLE:
		452	wrote = snprintf(ptr, *len, "border-right-style: double\n");
		453	break;
		454	case CSS_BORDER_STYLE_GROOVE:
		455	wrote = snprintf(ptr, *len, "border-right-style: groove\n");
		456	break;
		457	case CSS_BORDER_STYLE_RIDGE:
		458	wrote = snprintf(ptr, *len, "border-right-style: ridge\n");
		459	break;
		460	case CSS_BORDER_STYLE_INSET:
		461	wrote = snprintf(ptr, *len, "border-right-style: inset\n");
		462	break;
		463	case CSS_BORDER_STYLE_OUTSET:
		464	wrote = snprintf(ptr, *len, "border-right-style: outset\n");
		465	break;
		466	default:
		467	wrote = 0;
		468	break;
		469	}
		470	ptr += wrote;
		471	*len -= wrote;
		472
		473	/* border-bottom-style */
		474	val = css_computed_border_bottom_style(style);
		475	switch (val) {
		476	case CSS_BORDER_STYLE_INHERIT:
		477	wrote = snprintf(ptr, *len, "border-bottom-style: inherit\n");
		478	break;
		479	case CSS_BORDER_STYLE_NONE:
		480	wrote = snprintf(ptr, *len, "border-bottom-style: none\n");
		481	break;
		482	case CSS_BORDER_STYLE_HIDDEN:
		483	wrote = snprintf(ptr, *len, "border-bottom-style: hidden\n");
		484	break;
		485	case CSS_BORDER_STYLE_DOTTED:
		486	wrote = snprintf(ptr, *len, "border-bottom-style: dotted\n");
		487	break;
		488	case CSS_BORDER_STYLE_DASHED:
		489	wrote = snprintf(ptr, *len, "border-bottom-style: dashed\n");
		490	break;
		491	case CSS_BORDER_STYLE_SOLID:
		492	wrote = snprintf(ptr, *len, "border-bottom-style: solid\n");
		493	break;
		494	case CSS_BORDER_STYLE_DOUBLE:
		495	wrote = snprintf(ptr, *len, "border-bottom-style: double\n");
		496	break;
		497	case CSS_BORDER_STYLE_GROOVE:
		498	wrote = snprintf(ptr, *len, "border-bottom-style: groove\n");
		499	break;
		500	case CSS_BORDER_STYLE_RIDGE:
		501	wrote = snprintf(ptr, *len, "border-bottom-style: ridge\n");
		502	break;
		503	case CSS_BORDER_STYLE_INSET:
		504	wrote = snprintf(ptr, *len, "border-bottom-style: inset\n");
		505	break;
		506	case CSS_BORDER_STYLE_OUTSET:
		507	wrote = snprintf(ptr, *len, "border-bottom-style: outset\n");
		508	break;
		509	default:
		510	wrote = 0;
		511	break;
		512	}
		513	ptr += wrote;
		514	*len -= wrote;
		515
		516	/* border-left-style */
		517	val = css_computed_border_left_style(style);
		518	switch (val) {
		519	case CSS_BORDER_STYLE_INHERIT:
		520	wrote = snprintf(ptr, *len, "border-left-style: inherit\n");
		521	break;
		522	case CSS_BORDER_STYLE_NONE:
		523	wrote = snprintf(ptr, *len, "border-left-style: none\n");
		524	break;
		525	case CSS_BORDER_STYLE_HIDDEN:
		526	wrote = snprintf(ptr, *len, "border-left-style: hidden\n");
		527	break;
		528	case CSS_BORDER_STYLE_DOTTED:
		529	wrote = snprintf(ptr, *len, "border-left-style: dotted\n");
		530	break;
		531	case CSS_BORDER_STYLE_DASHED:
		532	wrote = snprintf(ptr, *len, "border-left-style: dashed\n");
		533	break;
		534	case CSS_BORDER_STYLE_SOLID:
		535	wrote = snprintf(ptr, *len, "border-left-style: solid\n");
		536	break;
		537	case CSS_BORDER_STYLE_DOUBLE:
		538	wrote = snprintf(ptr, *len, "border-left-style: double\n");
		539	break;
		540	case CSS_BORDER_STYLE_GROOVE:
		541	wrote = snprintf(ptr, *len, "border-left-style: groove\n");
		542	break;
		543	case CSS_BORDER_STYLE_RIDGE:
		544	wrote = snprintf(ptr, *len, "border-left-style: ridge\n");
		545	break;
		546	case CSS_BORDER_STYLE_INSET:
		547	wrote = snprintf(ptr, *len, "border-left-style: inset\n");
		548	break;
		549	case CSS_BORDER_STYLE_OUTSET:
		550	wrote = snprintf(ptr, *len, "border-left-style: outset\n");
		551	break;
		552	default:
		553	wrote = 0;
		554	break;
		555	}
		556	ptr += wrote;
		557	*len -= wrote;
		558
		559	/* border-top-width */
		560	val = css_computed_border_top_width(style, &len1, &unit1);
		561	switch (val) {
		562	case CSS_BORDER_WIDTH_INHERIT:
		563	wrote = snprintf(ptr, *len, "border-top-width: inherit\n");
		564	break;
		565	case CSS_BORDER_WIDTH_THIN:
		566	wrote = snprintf(ptr, *len, "border-top-width: thin\n");
		567	break;
		568	case CSS_BORDER_WIDTH_MEDIUM:
		569	wrote = snprintf(ptr, *len, "border-top-width: medium\n");
		570	break;
		571	case CSS_BORDER_WIDTH_THICK:
		572	wrote = snprintf(ptr, *len, "border-top-width: thick\n");
		573	break;
		574	case CSS_BORDER_WIDTH_WIDTH:
		575	wrote = snprintf(ptr, *len, "border-top-width: ");
		576	ptr += wrote;
		577	*len -= wrote;
		578
		579	wrote = dump_css_unit(len1, unit1, ptr, *len);
		580	ptr += wrote;
		581	*len -= wrote;
		582
		583	wrote = snprintf(ptr, *len, "\n");
		584	break;
		585	default:
		586	wrote = 0;
		587	break;
		588	}
		589	ptr += wrote;
		590	*len -= wrote;
		591
		592	/* border-right-width */
		593	val = css_computed_border_right_width(style, &len1, &unit1);
		594	switch (val) {
		595	case CSS_BORDER_WIDTH_INHERIT:
		596	wrote = snprintf(ptr, *len, "border-right-width: inherit\n");
		597	break;
		598	case CSS_BORDER_WIDTH_THIN:
		599	wrote = snprintf(ptr, *len, "border-right-width: thin\n");
		600	break;
		601	case CSS_BORDER_WIDTH_MEDIUM:
		602	wrote = snprintf(ptr, *len, "border-right-width: medium\n");
		603	break;
		604	case CSS_BORDER_WIDTH_THICK:
		605	wrote = snprintf(ptr, *len, "border-right-width: thick\n");
		606	break;
		607	case CSS_BORDER_WIDTH_WIDTH:
		608	wrote = snprintf(ptr, *len, "border-right-width: ");
		609	ptr += wrote;
		610	*len -= wrote;
		611
		612	wrote = dump_css_unit(len1, unit1, ptr, *len);
		613	ptr += wrote;
		614	*len -= wrote;
		615
		616	wrote = snprintf(ptr, *len, "\n");
		617	break;
		618	default:
		619	wrote = 0;
		620	break;
		621	}
		622	ptr += wrote;
		623	*len -= wrote;
		624
		625	/* border-bottom-width */
		626	val = css_computed_border_bottom_width(style, &len1, &unit1);
		627	switch (val) {
		628	case CSS_BORDER_WIDTH_INHERIT:
		629	wrote = snprintf(ptr, *len, "border-bottom-width: inherit\n");
		630	break;
		631	case CSS_BORDER_WIDTH_THIN:
		632	wrote = snprintf(ptr, *len, "border-bottom-width: thin\n");
		633	break;
		634	case CSS_BORDER_WIDTH_MEDIUM:
		635	wrote = snprintf(ptr, *len, "border-bottom-width: medium\n");
		636	break;
		637	case CSS_BORDER_WIDTH_THICK:
		638	wrote = snprintf(ptr, *len, "border-bottom-width: thick\n");
		639	break;
		640	case CSS_BORDER_WIDTH_WIDTH:
		641	wrote = snprintf(ptr, *len, "border-bottom-width: ");
		642	ptr += wrote;
		643	*len -= wrote;
		644
		645	wrote = dump_css_unit(len1, unit1, ptr, *len);
		646	ptr += wrote;
		647	*len -= wrote;
		648
		649	wrote = snprintf(ptr, *len, "\n");
		650	break;
		651	default:
		652	wrote = 0;
		653	break;
		654	}
		655	ptr += wrote;
		656	*len -= wrote;
		657
		658	/* border-left-width */
		659	val = css_computed_border_left_width(style, &len1, &unit1);
		660	switch (val) {
		661	case CSS_BORDER_WIDTH_INHERIT:
		662	wrote = snprintf(ptr, *len, "border-left-width: inherit\n");
		663	break;
		664	case CSS_BORDER_WIDTH_THIN:
		665	wrote = snprintf(ptr, *len, "border-left-width: thin\n");
		666	break;
		667	case CSS_BORDER_WIDTH_MEDIUM:
		668	wrote = snprintf(ptr, *len, "border-left-width: medium\n");
		669	break;
		670	case CSS_BORDER_WIDTH_THICK:
		671	wrote = snprintf(ptr, *len, "border-left-width: thick\n");
		672	break;
		673	case CSS_BORDER_WIDTH_WIDTH:
		674	wrote = snprintf(ptr, *len, "border-left-width: ");
		675	ptr += wrote;
		676	*len -= wrote;
		677
		678	wrote = dump_css_unit(len1, unit1, ptr, *len);
		679	ptr += wrote;
		680	*len -= wrote;
		681
		682	wrote = snprintf(ptr, *len, "\n");
		683	break;
		684	default:
		685	wrote = 0;
		686	break;
		687	}
		688	ptr += wrote;
		689	*len -= wrote;
		690
		691	/* bottom */
		692	val = css_computed_bottom(style, &len1, &unit1);
		693	switch (val) {
		694	case CSS_BOTTOM_INHERIT:
		695	wrote = snprintf(ptr, *len, "bottom: inherit\n");
		696	break;
		697	case CSS_BOTTOM_AUTO:
		698	wrote = snprintf(ptr, *len, "bottom: auto\n");
		699	break;
		700	case CSS_BOTTOM_SET:
		701	wrote = snprintf(ptr, *len, "bottom: ");
		702	ptr += wrote;
		703	*len -= wrote;
		704
		705	wrote = dump_css_unit(len1, unit1, ptr, *len);
		706	ptr += wrote;
		707	*len -= wrote;
		708
		709	wrote = snprintf(ptr, *len, "\n");
		710	break;
		711	default:
		712	wrote = 0;
		713	break;
		714	}
		715	ptr += wrote;
		716	*len -= wrote;
		717
		718	/* caption-side */
		719	val = css_computed_caption_side(style);
		720	switch (val) {
		721	case CSS_CAPTION_SIDE_INHERIT:
		722	wrote = snprintf(ptr, *len, "caption-side: inherit\n");
		723	break;
		724	case CSS_CAPTION_SIDE_TOP:
		725	wrote = snprintf(ptr, *len, "caption-side: top\n");
		726	break;
		727	case CSS_CAPTION_SIDE_BOTTOM:
		728	wrote = snprintf(ptr, *len, "caption-side: bottom\n");
		729	break;
		730	default:
		731	wrote = 0;
		732	break;
		733	}
		734	ptr += wrote;
		735	*len -= wrote;
		736
		737	/* clear */
		738	val = css_computed_clear(style);
		739	switch (val) {
		740	case CSS_CLEAR_INHERIT:
		741	wrote = snprintf(ptr, *len, "clear: inherit\n");
		742	break;
		743	case CSS_CLEAR_NONE:
		744	wrote = snprintf(ptr, *len, "clear: none\n");
		745	break;
		746	case CSS_CLEAR_LEFT:
		747	wrote = snprintf(ptr, *len, "clear: left\n");
		748	break;
		749	case CSS_CLEAR_RIGHT:
		750	wrote = snprintf(ptr, *len, "clear: right\n");
		751	break;
		752	case CSS_CLEAR_BOTH:
		753	wrote = snprintf(ptr, *len, "clear: both\n");
		754	break;
		755	default:
		756	wrote = 0;
		757	break;
		758	}
		759	ptr += wrote;
		760	*len -= wrote;
		761
		762	/* clip */
		763	val = css_computed_clip(style, &rect);
		764	switch (val) {
		765	case CSS_CLIP_INHERIT:
		766	wrote = snprintf(ptr, *len, "clip: inherit\n");
		767	break;
		768	case CSS_CLIP_AUTO:
		769	wrote = snprintf(ptr, *len, "clip: auto\n");
		770	break;
		771	case CSS_CLIP_RECT:
		772	wrote = snprintf(ptr, *len, "clip: rect( ");
		773	ptr += wrote;
		774	*len -= wrote;
		775
		776	if (rect.top_auto)
		777	wrote = snprintf(ptr, *len, "auto");
		778	else
		779	wrote = dump_css_unit(rect.top, rect.tunit,
		780	ptr, *len);
		781	wrote += snprintf(ptr + wrote, *len - wrote, ", ");
		782	ptr += wrote;
		783	*len -= wrote;
		784
		785	if (rect.right_auto)
		786	wrote = snprintf(ptr, *len, "auto");
		787	else
		788	wrote = dump_css_unit(rect.right, rect.runit,
		789	ptr, *len);
		790	wrote += snprintf(ptr + wrote, *len - wrote, ", ");
		791	ptr += wrote;
		792	*len -= wrote;
		793
		794	if (rect.bottom_auto)
		795	wrote = snprintf(ptr, *len, "auto");
		796	else
		797	wrote = dump_css_unit(rect.bottom, rect.bunit,
		798	ptr, *len);
		799	wrote += snprintf(ptr + wrote, *len - wrote, ", ");
		800	ptr += wrote;
		801	*len -= wrote;
		802
		803	if (rect.left_auto)
		804	wrote = snprintf(ptr, *len, "auto");
		805	else
		806	wrote = dump_css_unit(rect.left, rect.lunit,
		807	ptr, *len);
		808	wrote += snprintf(ptr + wrote, *len - wrote, ")\n");
		809	break;
		810	default:
		811	wrote = 0;
		812	break;
		813	}
		814	ptr += wrote;
		815	*len -= wrote;
		816
		817	/* color */
		818	val = css_computed_color(style, &color);
		819	if (val == CSS_COLOR_INHERIT) {
		820	wrote = snprintf(ptr, *len, "color: inherit\n");
		821	} else if (val == CSS_COLOR_COLOR) {
		822	wrote = snprintf(ptr, *len, "color: #%08x\n", color);
		823	}
		824	ptr += wrote;
		825	*len -= wrote;
		826
		827	/* content */
		828	val = css_computed_content(style, &content);
		829	switch (val) {
		830	case CSS_CONTENT_INHERIT:
		831	wrote = snprintf(ptr, *len, "content: inherit\n");
		832	break;
		833	case CSS_CONTENT_NONE:
		834	wrote = snprintf(ptr, *len, "content: none\n");
		835	break;
		836	case CSS_CONTENT_NORMAL:
		837	wrote = snprintf(ptr, *len, "content: normal\n");
		838	break;
		839	case CSS_CONTENT_SET:
		840	wrote = snprintf(ptr, *len, "content:");
		841	ptr += wrote;
		842	*len -= wrote;
		843
		844	while (content->type != CSS_COMPUTED_CONTENT_NONE) {
		845	wrote = snprintf(ptr, *len, " ");
		846
		847	switch (content->type) {
		848	case CSS_COMPUTED_CONTENT_STRING:
		849	wrote += snprintf(ptr + wrote,
		850	*len - wrote,
		851	"\"%.*s\"",
		852	(int) lwc_string_length(
		853	content->data.string),
		854	lwc_string_data(
		855	content->data.string));
		856	break;
		857	case CSS_COMPUTED_CONTENT_URI:
		858	wrote += snprintf(ptr + wrote,
		859	*len - wrote,
		860	"uri(\"%.*s\")",
		861	(int) lwc_string_length(
		862	content->data.uri),
		863	lwc_string_data(
		864	content->data.uri));
		865	break;
		866	case CSS_COMPUTED_CONTENT_COUNTER:
		867	wrote += snprintf(ptr + wrote,
		868	*len - wrote,
		869	"counter(%.*s)",
		870	(int) lwc_string_length(
		871	content->data.counter.name),
		872	lwc_string_data(
		873	content->data.counter.name));
		874	break;
		875	case CSS_COMPUTED_CONTENT_COUNTERS:
		876	wrote += snprintf(ptr + wrote,
		877	*len - wrote,
		878	"counters(%.*s, "
		879	"\"%.*s\")",
		880	(int) lwc_string_length(
		881	content->data.counters.name),
		882	lwc_string_data(
		883	content->data.counters.name),
		884	(int) lwc_string_length(
		885	content->data.counters.sep),
		886	lwc_string_data(
		887	content->data.counters.sep));
		888	break;
		889	case CSS_COMPUTED_CONTENT_ATTR:
		890	wrote += snprintf(ptr + wrote,
		891	*len - wrote,
		892	"attr(%.*s)",
		893	(int) lwc_string_length(
		894	content->data.attr),
		895	lwc_string_data(
		896	content->data.attr));
		897	break;
		898	case CSS_COMPUTED_CONTENT_OPEN_QUOTE:
		899	wrote += snprintf(ptr + wrote,
		900	*len - wrote,
		901	"open-quote");
		902	break;
		903	case CSS_COMPUTED_CONTENT_CLOSE_QUOTE:
		904	wrote += snprintf(ptr + wrote,
		905	*len - wrote,
		906	"close-quote");
		907	break;
		908	case CSS_COMPUTED_CONTENT_NO_OPEN_QUOTE:
		909	wrote += snprintf(ptr + wrote,
		910	*len - wrote,
		911	"no-open-quote");
		912	break;
		913	case CSS_COMPUTED_CONTENT_NO_CLOSE_QUOTE:
		914	wrote += snprintf(ptr + wrote,
		915	*len - wrote,
		916	"no-close-quote");
		917	break;
		918	}
		919
		920	ptr += wrote;
		921	*len -= wrote;
		922
		923	content++;
		924	}
		925
		926	wrote = snprintf(ptr, *len, "\n");
		927	break;
		928	default:
		929	wrote = 0;
		930	break;
		931	}
		932	ptr += wrote;
		933	*len -= wrote;
		934
		935	/* counter-increment */
		936	val = css_computed_counter_increment(style, &counter);
		937	if (val == CSS_COUNTER_INCREMENT_INHERIT) {
		938	wrote = snprintf(ptr, *len, "counter-increment: inherit\n");
		939	} else if (counter == NULL) {
		940	wrote = snprintf(ptr, *len, "counter-increment: none\n");
		941	} else {
		942	wrote = snprintf(ptr, *len, "counter-increment:");
		943	ptr += wrote;
		944	*len -= wrote;
		945
		946	while (counter->name != NULL) {
		947	wrote = snprintf(ptr, len, " %.s ",
		948	(int) lwc_string_length(counter->name),
		949	lwc_string_data(counter->name));
		950	ptr += wrote;
		951	*len -= wrote;
		952
		953	wrote = dump_css_fixed(counter->value, ptr, *len);
		954	ptr += wrote;
		955	*len -= wrote;
		956
		957	counter++;
		958	}
		959
		960	wrote = snprintf(ptr, *len, "\n");
		961	}
		962	ptr += wrote;
		963	*len -= wrote;
		964
		965	/* counter-reset */
		966	val = css_computed_counter_reset(style, &counter);
		967	if (val == CSS_COUNTER_RESET_INHERIT) {
		968	wrote = snprintf(ptr, *len, "counter-reset: inherit\n");
		969	} else if (counter == NULL) {
		970	wrote = snprintf(ptr, *len, "counter-reset: none\n");
		971	} else {
		972	wrote = snprintf(ptr, *len, "counter-reset:");
		973	ptr += wrote;
		974	*len -= wrote;
		975
		976	while (counter->name != NULL) {
		977	wrote = snprintf(ptr, len, " %.s ",
		978	(int) lwc_string_length(counter->name),
		979	lwc_string_data(counter->name));
		980	ptr += wrote;
		981	*len -= wrote;
		982
		983	wrote = dump_css_fixed(counter->value, ptr, *len);
		984	ptr += wrote;
		985	*len -= wrote;
		986
		987	counter++;
		988	}
		989
		990	wrote = snprintf(ptr, *len, "\n");
		991	}
		992	ptr += wrote;
		993	*len -= wrote;
		994
		995	/* cursor */
		996	val = css_computed_cursor(style, &string_list);
		997	wrote = snprintf(ptr, *len, "cursor:");
		998	ptr += wrote;
		999	*len -= wrote;
		1000
		1001	if (string_list != NULL) {
		1002	while (*string_list != NULL) {
		1003	wrote = snprintf(ptr, len, " url('%.s')",
		1004	(int) lwc_string_length(*string_list),
		1005	lwc_string_data(*string_list));
		1006	ptr += wrote;
		1007	*len -= wrote;
		1008
		1009	string_list++;
		1010	}
		1011	}
		1012	switch (val) {
		1013	case CSS_CURSOR_INHERIT:
		1014	wrote = snprintf(ptr, *len, " inherit\n");
		1015	break;
		1016	case CSS_CURSOR_AUTO:
		1017	wrote = snprintf(ptr, *len, " auto\n");
		1018	break;
		1019	case CSS_CURSOR_CROSSHAIR:
		1020	wrote = snprintf(ptr, *len, " crosshair\n");
		1021	break;
		1022	case CSS_CURSOR_DEFAULT:
		1023	wrote = snprintf(ptr, *len, " default\n");
		1024	break;
		1025	case CSS_CURSOR_POINTER:
		1026	wrote = snprintf(ptr, *len, " pointer\n");
		1027	break;
		1028	case CSS_CURSOR_MOVE:
		1029	wrote = snprintf(ptr, *len, " move\n");
		1030	break;
		1031	case CSS_CURSOR_E_RESIZE:
		1032	wrote = snprintf(ptr, *len, " e-resize\n");
		1033	break;
		1034	case CSS_CURSOR_NE_RESIZE:
		1035	wrote = snprintf(ptr, *len, " ne-resize\n");
		1036	break;
		1037	case CSS_CURSOR_NW_RESIZE:
		1038	wrote = snprintf(ptr, *len, " nw-resize\n");
		1039	break;
		1040	case CSS_CURSOR_N_RESIZE:
		1041	wrote = snprintf(ptr, *len, " n-resize\n");
		1042	break;
		1043	case CSS_CURSOR_SE_RESIZE:
		1044	wrote = snprintf(ptr, *len, " se-resize\n");
		1045	break;
		1046	case CSS_CURSOR_SW_RESIZE:
		1047	wrote = snprintf(ptr, *len, " sw-resize\n");
		1048	break;
		1049	case CSS_CURSOR_S_RESIZE:
		1050	wrote = snprintf(ptr, *len, " s-resize\n");
		1051	break;
		1052	case CSS_CURSOR_W_RESIZE:
		1053	wrote = snprintf(ptr, *len, " w-resize\n");
		1054	break;
		1055	case CSS_CURSOR_TEXT:
		1056	wrote = snprintf(ptr, *len, " text\n");
		1057	break;
		1058	case CSS_CURSOR_WAIT:
		1059	wrote = snprintf(ptr, *len, " wait\n");
		1060	break;
		1061	case CSS_CURSOR_HELP:
		1062	wrote = snprintf(ptr, *len, " help\n");
		1063	break;
		1064	case CSS_CURSOR_PROGRESS:
		1065	wrote = snprintf(ptr, *len, " progress\n");
		1066	break;
		1067	default:
		1068	wrote = 0;
		1069	break;
		1070	}
		1071	ptr += wrote;
		1072	*len -= wrote;
		1073
		1074	/* direction */
		1075	val = css_computed_direction(style);
		1076	switch (val) {
		1077	case CSS_DIRECTION_INHERIT:
		1078	wrote = snprintf(ptr, *len, "direction: inherit\n");
		1079	break;
		1080	case CSS_DIRECTION_LTR:
		1081	wrote = snprintf(ptr, *len, "direction: ltr\n");
		1082	break;
		1083	case CSS_DIRECTION_RTL:
		1084	wrote = snprintf(ptr, *len, "direction: rtl\n");
		1085	break;
		1086	default:
		1087	wrote = 0;
		1088	break;
		1089	}
		1090	ptr += wrote;
		1091	*len -= wrote;
		1092
		1093	/* display */
		1094	val = css_computed_display_static(style);
		1095	switch (val) {
		1096	case CSS_DISPLAY_INHERIT:
		1097	wrote = snprintf(ptr, *len, "display: inherit\n");
		1098	break;
		1099	case CSS_DISPLAY_INLINE:
		1100	wrote = snprintf(ptr, *len, "display: inline\n");
		1101	break;
		1102	case CSS_DISPLAY_BLOCK:
		1103	wrote = snprintf(ptr, *len, "display: block\n");
		1104	break;
		1105	case CSS_DISPLAY_LIST_ITEM:
		1106	wrote = snprintf(ptr, *len, "display: list-item\n");
		1107	break;
		1108	case CSS_DISPLAY_RUN_IN:
		1109	wrote = snprintf(ptr, *len, "display: run-in\n");
		1110	break;
		1111	case CSS_DISPLAY_INLINE_BLOCK:
		1112	wrote = snprintf(ptr, *len, "display: inline-block\n");
		1113	break;
		1114	case CSS_DISPLAY_TABLE:
		1115	wrote = snprintf(ptr, *len, "display: table\n");
		1116	break;
		1117	case CSS_DISPLAY_INLINE_TABLE:
		1118	wrote = snprintf(ptr, *len, "display: inline-table\n");
		1119	break;
		1120	case CSS_DISPLAY_TABLE_ROW_GROUP:
		1121	wrote = snprintf(ptr, *len, "display: table-row-group\n");
		1122	break;
		1123	case CSS_DISPLAY_TABLE_HEADER_GROUP:
		1124	wrote = snprintf(ptr, *len, "display: table-header-group\n");
		1125	break;
		1126	case CSS_DISPLAY_TABLE_FOOTER_GROUP:
		1127	wrote = snprintf(ptr, *len, "display: table-footer-group\n");
		1128	break;
		1129	case CSS_DISPLAY_TABLE_ROW:
		1130	wrote = snprintf(ptr, *len, "display: table-row\n");
		1131	break;
		1132	case CSS_DISPLAY_TABLE_COLUMN_GROUP:
		1133	wrote = snprintf(ptr, *len, "display: table-column-group\n");
		1134	break;
		1135	case CSS_DISPLAY_TABLE_COLUMN:
		1136	wrote = snprintf(ptr, *len, "display: table-column\n");
		1137	break;
		1138	case CSS_DISPLAY_TABLE_CELL:
		1139	wrote = snprintf(ptr, *len, "display: table-cell\n");
		1140	break;
		1141	case CSS_DISPLAY_TABLE_CAPTION:
		1142	wrote = snprintf(ptr, *len, "display: table-caption\n");
		1143	break;
		1144	case CSS_DISPLAY_NONE:
		1145	wrote = snprintf(ptr, *len, "display: none\n");
		1146	break;
		1147	default:
		1148	wrote = 0;
		1149	break;
		1150	}
		1151	ptr += wrote;
		1152	*len -= wrote;
		1153
		1154	/* empty-cells */
		1155	val = css_computed_empty_cells(style);
		1156	switch (val) {
		1157	case CSS_EMPTY_CELLS_INHERIT:
		1158	wrote = snprintf(ptr, *len, "empty-cells: inherit\n");
		1159	break;
		1160	case CSS_EMPTY_CELLS_SHOW:
		1161	wrote = snprintf(ptr, *len, "empty-cells: show\n");
		1162	break;
		1163	case CSS_EMPTY_CELLS_HIDE:
		1164	wrote = snprintf(ptr, *len, "empty-cells: hide\n");
		1165	break;
		1166	default:
		1167	wrote = 0;
		1168	break;
		1169	}
		1170	ptr += wrote;
		1171	*len -= wrote;
		1172
		1173	/* float */
		1174	val = css_computed_float(style);
		1175	switch (val) {
		1176	case CSS_FLOAT_INHERIT:
		1177	wrote = snprintf(ptr, *len, "float: inherit\n");
		1178	break;
		1179	case CSS_FLOAT_LEFT:
		1180	wrote = snprintf(ptr, *len, "float: left\n");
		1181	break;
		1182	case CSS_FLOAT_RIGHT:
		1183	wrote = snprintf(ptr, *len, "float: right\n");
		1184	break;
		1185	case CSS_FLOAT_NONE:
		1186	wrote = snprintf(ptr, *len, "float: none\n");
		1187	break;
		1188	default:
		1189	wrote = 0;
		1190	break;
		1191	}
		1192	ptr += wrote;
		1193	*len -= wrote;
		1194
		1195	/* font-family */
		1196	val = css_computed_font_family(style, &string_list);
		1197	if (val == CSS_FONT_FAMILY_INHERIT) {
		1198	wrote = snprintf(ptr, *len, "font-family: inherit\n");
		1199	ptr += wrote;
		1200	*len -= wrote;
		1201	} else {
		1202	wrote = snprintf(ptr, *len, "font-family:");
		1203	ptr += wrote;
		1204	*len -= wrote;
		1205
		1206	if (string_list != NULL) {
		1207	while (*string_list != NULL) {
		1208	wrote = snprintf(ptr, len, " \"%.s\"",
		1209	(int) lwc_string_length(*string_list),
		1210	lwc_string_data(*string_list));
		1211	ptr += wrote;
		1212	*len -= wrote;
		1213
		1214	string_list++;
		1215	}
		1216	}
		1217	switch (val) {
		1218	case CSS_FONT_FAMILY_SERIF:
		1219	wrote = snprintf(ptr, *len, " serif\n");
		1220	break;
		1221	case CSS_FONT_FAMILY_SANS_SERIF:
		1222	wrote = snprintf(ptr, *len, " sans-serif\n");
		1223	break;
		1224	case CSS_FONT_FAMILY_CURSIVE:
		1225	wrote = snprintf(ptr, *len, " cursive\n");
		1226	break;
		1227	case CSS_FONT_FAMILY_FANTASY:
		1228	wrote = snprintf(ptr, *len, " fantasy\n");
		1229	break;
		1230	case CSS_FONT_FAMILY_MONOSPACE:
		1231	wrote = snprintf(ptr, *len, " monospace\n");
		1232	break;
		1233	}
		1234	ptr += wrote;
		1235	*len -= wrote;
		1236	}
		1237
		1238	/* font-size */
		1239	val = css_computed_font_size(style, &len1, &unit1);
		1240	switch (val) {
		1241	case CSS_FONT_SIZE_INHERIT:
		1242	wrote = snprintf(ptr, *len, "font-size: inherit\n");
		1243	break;
		1244	case CSS_FONT_SIZE_XX_SMALL:
		1245	wrote = snprintf(ptr, *len, "font-size: xx-small\n");
		1246	break;
		1247	case CSS_FONT_SIZE_X_SMALL:
		1248	wrote = snprintf(ptr, *len, "font-size: x-small\n");
		1249	break;
		1250	case CSS_FONT_SIZE_SMALL:
		1251	wrote = snprintf(ptr, *len, "font-size: small\n");
		1252	break;
		1253	case CSS_FONT_SIZE_MEDIUM:
		1254	wrote = snprintf(ptr, *len, "font-size: medium\n");
		1255	break;
		1256	case CSS_FONT_SIZE_LARGE:
		1257	wrote = snprintf(ptr, *len, "font-size: large\n");
		1258	break;
		1259	case CSS_FONT_SIZE_X_LARGE:
		1260	wrote = snprintf(ptr, *len, "font-size: x-large\n");
		1261	break;
		1262	case CSS_FONT_SIZE_XX_LARGE:
		1263	wrote = snprintf(ptr, *len, "font-size: xx-large\n");
		1264	break;
		1265	case CSS_FONT_SIZE_LARGER:
		1266	wrote = snprintf(ptr, *len, "font-size: larger\n");
		1267	break;
		1268	case CSS_FONT_SIZE_SMALLER:
		1269	wrote = snprintf(ptr, *len, "font-size: smaller\n");
		1270	break;
		1271	case CSS_FONT_SIZE_DIMENSION:
		1272	wrote = snprintf(ptr, *len, "font-size: ");
		1273	ptr += wrote;
		1274	*len -= wrote;
		1275
		1276	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1277	ptr += wrote;
		1278	*len -= wrote;
		1279
		1280	wrote = snprintf(ptr, *len, "\n");
		1281	break;
		1282	default:
		1283	wrote = 0;
		1284	break;
		1285	}
		1286	ptr += wrote;
		1287	*len -= wrote;
		1288
		1289	/* font-style */
		1290	val = css_computed_font_style(style);
		1291	switch (val) {
		1292	case CSS_FONT_STYLE_INHERIT:
		1293	wrote = snprintf(ptr, *len, "font-style: inherit\n");
		1294	break;
		1295	case CSS_FONT_STYLE_NORMAL:
		1296	wrote = snprintf(ptr, *len, "font-style: normal\n");
		1297	break;
		1298	case CSS_FONT_STYLE_ITALIC:
		1299	wrote = snprintf(ptr, *len, "font-style: italic\n");
		1300	break;
		1301	case CSS_FONT_STYLE_OBLIQUE:
		1302	wrote = snprintf(ptr, *len, "font-style: oblique\n");
		1303	break;
		1304	default:
		1305	wrote = 0;
		1306	break;
		1307	}
		1308	ptr += wrote;
		1309	*len -= wrote;
		1310
		1311	/* font-variant */
		1312	val = css_computed_font_variant(style);
		1313	switch (val) {
		1314	case CSS_FONT_VARIANT_INHERIT:
		1315	wrote = snprintf(ptr, *len, "font-variant: inherit\n");
		1316	break;
		1317	case CSS_FONT_VARIANT_NORMAL:
		1318	wrote = snprintf(ptr, *len, "font-variant: normal\n");
		1319	break;
		1320	case CSS_FONT_VARIANT_SMALL_CAPS:
		1321	wrote = snprintf(ptr, *len, "font-variant: small-caps\n");
		1322	break;
		1323	default:
		1324	wrote = 0;
		1325	break;
		1326	}
		1327	ptr += wrote;
		1328	*len -= wrote;
		1329
		1330	/* font-weight */
		1331	val = css_computed_font_weight(style);
		1332	switch (val) {
		1333	case CSS_FONT_WEIGHT_INHERIT:
		1334	wrote = snprintf(ptr, *len, "font-weight: inherit\n");
		1335	break;
		1336	case CSS_FONT_WEIGHT_NORMAL:
		1337	wrote = snprintf(ptr, *len, "font-weight: normal\n");
		1338	break;
		1339	case CSS_FONT_WEIGHT_BOLD:
		1340	wrote = snprintf(ptr, *len, "font-weight: bold\n");
		1341	break;
		1342	case CSS_FONT_WEIGHT_BOLDER:
		1343	wrote = snprintf(ptr, *len, "font-weight: bolder\n");
		1344	break;
		1345	case CSS_FONT_WEIGHT_LIGHTER:
		1346	wrote = snprintf(ptr, *len, "font-weight: lighter\n");
		1347	break;
		1348	case CSS_FONT_WEIGHT_100:
		1349	wrote = snprintf(ptr, *len, "font-weight: 100\n");
		1350	break;
		1351	case CSS_FONT_WEIGHT_200:
		1352	wrote = snprintf(ptr, *len, "font-weight: 200\n");
		1353	break;
		1354	case CSS_FONT_WEIGHT_300:
		1355	wrote = snprintf(ptr, *len, "font-weight: 300\n");
		1356	break;
		1357	case CSS_FONT_WEIGHT_400:
		1358	wrote = snprintf(ptr, *len, "font-weight: 400\n");
		1359	break;
		1360	case CSS_FONT_WEIGHT_500:
		1361	wrote = snprintf(ptr, *len, "font-weight: 500\n");
		1362	break;
		1363	case CSS_FONT_WEIGHT_600:
		1364	wrote = snprintf(ptr, *len, "font-weight: 600\n");
		1365	break;
		1366	case CSS_FONT_WEIGHT_700:
		1367	wrote = snprintf(ptr, *len, "font-weight: 700\n");
		1368	break;
		1369	case CSS_FONT_WEIGHT_800:
		1370	wrote = snprintf(ptr, *len, "font-weight: 800\n");
		1371	break;
		1372	case CSS_FONT_WEIGHT_900:
		1373	wrote = snprintf(ptr, *len, "font-weight: 900\n");
		1374	break;
		1375	default:
		1376	wrote = 0;
		1377	break;
		1378	}
		1379	ptr += wrote;
		1380	*len -= wrote;
		1381
		1382	/* height */
		1383	val = css_computed_height(style, &len1, &unit1);
		1384	switch (val) {
		1385	case CSS_HEIGHT_INHERIT:
		1386	wrote = snprintf(ptr, *len, "height: inherit\n");
		1387	break;
		1388	case CSS_HEIGHT_AUTO:
		1389	wrote = snprintf(ptr, *len, "height: auto\n");
		1390	break;
		1391	case CSS_HEIGHT_SET:
		1392	wrote = snprintf(ptr, *len, "height: ");
		1393	ptr += wrote;
		1394	*len -= wrote;
		1395
		1396	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1397	ptr += wrote;
		1398	*len -= wrote;
		1399
		1400	wrote = snprintf(ptr, *len, "\n");
		1401	break;
		1402	default:
		1403	wrote = 0;
		1404	break;
		1405	}
		1406	ptr += wrote;
		1407	*len -= wrote;
		1408
		1409	/* left */
		1410	val = css_computed_left(style, &len1, &unit1);
		1411	switch (val) {
		1412	case CSS_LEFT_INHERIT:
		1413	wrote = snprintf(ptr, *len, "left: inherit\n");
		1414	break;
		1415	case CSS_LEFT_AUTO:
		1416	wrote = snprintf(ptr, *len, "left: auto\n");
		1417	break;
		1418	case CSS_LEFT_SET:
		1419	wrote = snprintf(ptr, *len, "left: ");
		1420	ptr += wrote;
		1421	*len -= wrote;
		1422
		1423	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1424	ptr += wrote;
		1425	*len -= wrote;
		1426
		1427	wrote = snprintf(ptr, *len, "\n");
		1428	break;
		1429	default:
		1430	wrote = 0;
		1431	break;
		1432	}
		1433	ptr += wrote;
		1434	*len -= wrote;
		1435
		1436	/* letter-spacing */
		1437	val = css_computed_letter_spacing(style, &len1, &unit1);
		1438	switch (val) {
		1439	case CSS_LETTER_SPACING_INHERIT:
		1440	wrote = snprintf(ptr, *len, "letter-spacing: inherit\n");
		1441	break;
		1442	case CSS_LETTER_SPACING_NORMAL:
		1443	wrote = snprintf(ptr, *len, "letter-spacing: normal\n");
		1444	break;
		1445	case CSS_LETTER_SPACING_SET:
		1446	wrote = snprintf(ptr, *len, "letter-spacing: ");
		1447	ptr += wrote;
		1448	*len -= wrote;
		1449
		1450	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1451	ptr += wrote;
		1452	*len -= wrote;
		1453
		1454	wrote = snprintf(ptr, *len, "\n");
		1455	break;
		1456	default:
		1457	wrote = 0;
		1458	break;
		1459	}
		1460	ptr += wrote;
		1461	*len -= wrote;
		1462
		1463	/* line-height */
		1464	val = css_computed_line_height(style, &len1, &unit1);
		1465	switch (val) {
		1466	case CSS_LINE_HEIGHT_INHERIT:
		1467	wrote = snprintf(ptr, *len, "line-height: inherit\n");
		1468	break;
		1469	case CSS_LINE_HEIGHT_NORMAL:
		1470	wrote = snprintf(ptr, *len, "line-height: normal\n");
		1471	break;
		1472	case CSS_LINE_HEIGHT_NUMBER:
		1473	wrote = snprintf(ptr, *len, "line-height: ");
		1474	ptr += wrote;
		1475	*len -= wrote;
		1476
		1477	wrote = dump_css_fixed(len1, ptr, *len);
		1478	ptr += wrote;
		1479	*len -= wrote;
		1480
		1481	wrote = snprintf(ptr, *len, "\n");
		1482	break;
		1483	case CSS_LINE_HEIGHT_DIMENSION:
		1484	wrote = snprintf(ptr, *len, "line-height: ");
		1485	ptr += wrote;
		1486	*len -= wrote;
		1487
		1488	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1489	ptr += wrote;
		1490	*len -= wrote;
		1491
		1492	wrote = snprintf(ptr, *len, "\n");
		1493	break;
		1494	default:
		1495	wrote = 0;
		1496	break;
		1497	}
		1498	ptr += wrote;
		1499	*len -= wrote;
		1500
		1501	/* list-style-image */
		1502	val = css_computed_list_style_image(style, &url);
		1503	if (val == CSS_LIST_STYLE_IMAGE_INHERIT) {
		1504	wrote = snprintf(ptr, *len, "list-style-image: inherit\n");
		1505	} else if (url != NULL) {
		1506	wrote = snprintf(ptr, len, "list-style-image: url('%.s')\n",
		1507	(int) lwc_string_length(url),
		1508	lwc_string_data(url));
		1509	} else if (val == CSS_LIST_STYLE_IMAGE_NONE) {
		1510	wrote = snprintf(ptr, *len, "list-style-image: none\n");
		1511	} else {
		1512	wrote = 0;
		1513	}
		1514	ptr += wrote;
		1515	*len -= wrote;
		1516
		1517	/* list-style-position */
		1518	val = css_computed_list_style_position(style);
		1519	switch (val) {
		1520	case CSS_LIST_STYLE_POSITION_INHERIT:
		1521	wrote = snprintf(ptr, *len, "list-style-position: inherit\n");
		1522	break;
		1523	case CSS_LIST_STYLE_POSITION_INSIDE:
		1524	wrote = snprintf(ptr, *len, "list-style-position: inside\n");
		1525	break;
		1526	case CSS_LIST_STYLE_POSITION_OUTSIDE:
		1527	wrote = snprintf(ptr, *len, "list-style-position: outside\n");
		1528	break;
		1529	default:
		1530	wrote = 0;
		1531	break;
		1532	}
		1533	ptr += wrote;
		1534	*len -= wrote;
		1535
		1536	/* list-style-type */
		1537	val = css_computed_list_style_type(style);
		1538	switch (val) {
		1539	case CSS_LIST_STYLE_TYPE_INHERIT:
		1540	wrote = snprintf(ptr, *len, "list-style-type: inherit\n");
		1541	break;
		1542	case CSS_LIST_STYLE_TYPE_DISC:
		1543	wrote = snprintf(ptr, *len, "list-style-type: disc\n");
		1544	break;
		1545	case CSS_LIST_STYLE_TYPE_CIRCLE:
		1546	wrote = snprintf(ptr, *len, "list-style-type: circle\n");
		1547	break;
		1548	case CSS_LIST_STYLE_TYPE_SQUARE:
		1549	wrote = snprintf(ptr, *len, "list-style-type: square\n");
		1550	break;
		1551	case CSS_LIST_STYLE_TYPE_DECIMAL:
		1552	wrote = snprintf(ptr, *len, "list-style-type: decimal\n");
		1553	break;
		1554	case CSS_LIST_STYLE_TYPE_DECIMAL_LEADING_ZERO:
		1555	wrote = snprintf(ptr, *len,
		1556	"list-style-type: decimal-leading-zero\n");
		1557	break;
		1558	case CSS_LIST_STYLE_TYPE_LOWER_ROMAN:
		1559	wrote = snprintf(ptr, *len, "list-style-type: lower-roman\n");
		1560	break;
		1561	case CSS_LIST_STYLE_TYPE_UPPER_ROMAN:
		1562	wrote = snprintf(ptr, *len, "list-style-type: upper-roman\n");
		1563	break;
		1564	case CSS_LIST_STYLE_TYPE_LOWER_GREEK:
		1565	wrote = snprintf(ptr, *len, "list-style-type: lower-greek\n");
		1566	break;
		1567	case CSS_LIST_STYLE_TYPE_LOWER_LATIN:
		1568	wrote = snprintf(ptr, *len, "list-style-type: lower-latin\n");
		1569	break;
		1570	case CSS_LIST_STYLE_TYPE_UPPER_LATIN:
		1571	wrote = snprintf(ptr, *len, "list-style-type: upper-latin\n");
		1572	break;
		1573	case CSS_LIST_STYLE_TYPE_ARMENIAN:
		1574	wrote = snprintf(ptr, *len, "list-style-type: armenian\n");
		1575	break;
		1576	case CSS_LIST_STYLE_TYPE_GEORGIAN:
		1577	wrote = snprintf(ptr, *len, "list-style-type: georgian\n");
		1578	break;
		1579	case CSS_LIST_STYLE_TYPE_LOWER_ALPHA:
		1580	wrote = snprintf(ptr, *len, "list-style-type: lower-alpha\n");
		1581	break;
		1582	case CSS_LIST_STYLE_TYPE_UPPER_ALPHA:
		1583	wrote = snprintf(ptr, *len, "list-style-type: upper-alpha\n");
		1584	break;
		1585	case CSS_LIST_STYLE_TYPE_NONE:
		1586	wrote = snprintf(ptr, *len, "list-style-type: none\n");
		1587	break;
		1588	default:
		1589	wrote = 0;
		1590	break;
		1591	}
		1592	ptr += wrote;
		1593	*len -= wrote;
		1594
		1595	/* margin-top */
		1596	val = css_computed_margin_top(style, &len1, &unit1);
		1597	switch (val) {
		1598	case CSS_MARGIN_INHERIT:
		1599	wrote = snprintf(ptr, *len, "margin-top: inherit\n");
		1600	break;
		1601	case CSS_MARGIN_AUTO:
		1602	wrote = snprintf(ptr, *len, "margin-top: auto\n");
		1603	break;
		1604	case CSS_MARGIN_SET:
		1605	wrote = snprintf(ptr, *len, "margin-top: ");
		1606	ptr += wrote;
		1607	*len -= wrote;
		1608
		1609	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1610	ptr += wrote;
		1611	*len -= wrote;
		1612
		1613	wrote = snprintf(ptr, *len, "\n");
		1614	break;
		1615	default:
		1616	wrote = 0;
		1617	break;
		1618	}
		1619	ptr += wrote;
		1620	*len -= wrote;
		1621
		1622	/* margin-right */
		1623	val = css_computed_margin_right(style, &len1, &unit1);
		1624	switch (val) {
		1625	case CSS_MARGIN_INHERIT:
		1626	wrote = snprintf(ptr, *len, "margin-right: inherit\n");
		1627	break;
		1628	case CSS_MARGIN_AUTO:
		1629	wrote = snprintf(ptr, *len, "margin-right: auto\n");
		1630	break;
		1631	case CSS_MARGIN_SET:
		1632	wrote = snprintf(ptr, *len, "margin-right: ");
		1633	ptr += wrote;
		1634	*len -= wrote;
		1635
		1636	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1637	ptr += wrote;
		1638	*len -= wrote;
		1639
		1640	wrote = snprintf(ptr, *len, "\n");
		1641	break;
		1642	default:
		1643	wrote = 0;
		1644	break;
		1645	}
		1646	ptr += wrote;
		1647	*len -= wrote;
		1648
		1649	/* margin-bottom */
		1650	val = css_computed_margin_bottom(style, &len1, &unit1);
		1651	switch (val) {
		1652	case CSS_MARGIN_INHERIT:
		1653	wrote = snprintf(ptr, *len, "margin-bottom: inherit\n");
		1654	break;
		1655	case CSS_MARGIN_AUTO:
		1656	wrote = snprintf(ptr, *len, "margin-bottom: auto\n");
		1657	break;
		1658	case CSS_MARGIN_SET:
		1659	wrote = snprintf(ptr, *len, "margin-bottom: ");
		1660	ptr += wrote;
		1661	*len -= wrote;
		1662
		1663	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1664	ptr += wrote;
		1665	*len -= wrote;
		1666
		1667	wrote = snprintf(ptr, *len, "\n");
		1668	break;
		1669	default:
		1670	wrote = 0;
		1671	break;
		1672	}
		1673	ptr += wrote;
		1674	*len -= wrote;
		1675
		1676	/* margin-left */
		1677	val = css_computed_margin_left(style, &len1, &unit1);
		1678	switch (val) {
		1679	case CSS_MARGIN_INHERIT:
		1680	wrote = snprintf(ptr, *len, "margin-left: inherit\n");
		1681	break;
		1682	case CSS_MARGIN_AUTO:
		1683	wrote = snprintf(ptr, *len, "margin-left: auto\n");
		1684	break;
		1685	case CSS_MARGIN_SET:
		1686	wrote = snprintf(ptr, *len, "margin-left: ");
		1687	ptr += wrote;
		1688	*len -= wrote;
		1689
		1690	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1691	ptr += wrote;
		1692	*len -= wrote;
		1693
		1694	wrote = snprintf(ptr, *len, "\n");
		1695	break;
		1696	default:
		1697	wrote = 0;
		1698	break;
		1699	}
		1700	ptr += wrote;
		1701	*len -= wrote;
		1702
		1703	/* max-height */
		1704	val = css_computed_max_height(style, &len1, &unit1);
		1705	switch (val) {
		1706	case CSS_MAX_HEIGHT_INHERIT:
		1707	wrote = snprintf(ptr, *len, "max-height: inherit\n");
		1708	break;
		1709	case CSS_MAX_HEIGHT_NONE:
		1710	wrote = snprintf(ptr, *len, "max-height: none\n");
		1711	break;
		1712	case CSS_MAX_HEIGHT_SET:
		1713	wrote = snprintf(ptr, *len, "max-height: ");
		1714	ptr += wrote;
		1715	*len -= wrote;
		1716
		1717	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1718	ptr += wrote;
		1719	*len -= wrote;
		1720
		1721	wrote = snprintf(ptr, *len, "\n");
		1722	break;
		1723	default:
		1724	wrote = 0;
		1725	break;
		1726	}
		1727	ptr += wrote;
		1728	*len -= wrote;
		1729
		1730	/* max-width */
		1731	val = css_computed_max_width(style, &len1, &unit1);
		1732	switch (val) {
		1733	case CSS_MAX_WIDTH_INHERIT:
		1734	wrote = snprintf(ptr, *len, "max-width: inherit\n");
		1735	break;
		1736	case CSS_MAX_WIDTH_NONE:
		1737	wrote = snprintf(ptr, *len, "max-width: none\n");
		1738	break;
		1739	case CSS_MAX_WIDTH_SET:
		1740	wrote = snprintf(ptr, *len, "max-width: ");
		1741	ptr += wrote;
		1742	*len -= wrote;
		1743
		1744	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1745	ptr += wrote;
		1746	*len -= wrote;
		1747
		1748	wrote = snprintf(ptr, *len, "\n");
		1749	break;
		1750	default:
		1751	wrote = 0;
		1752	break;
		1753	}
		1754	ptr += wrote;
		1755	*len -= wrote;
		1756
		1757	/* min-height */
		1758	val = css_computed_min_height(style, &len1, &unit1);
		1759	switch (val) {
		1760	case CSS_MIN_HEIGHT_INHERIT:
		1761	wrote = snprintf(ptr, *len, "min-height: inherit\n");
		1762	break;
		1763	case CSS_MIN_HEIGHT_SET:
		1764	wrote = snprintf(ptr, *len, "min-height: ");
		1765	ptr += wrote;
		1766	*len -= wrote;
		1767
		1768	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1769	ptr += wrote;
		1770	*len -= wrote;
		1771
		1772	wrote = snprintf(ptr, *len, "\n");
		1773	break;
		1774	default:
		1775	wrote = 0;
		1776	break;
		1777	}
		1778	ptr += wrote;
		1779	*len -= wrote;
		1780
		1781	/* min-width */
		1782	val = css_computed_min_width(style, &len1, &unit1);
		1783	switch (val) {
		1784	case CSS_MIN_WIDTH_INHERIT:
		1785	wrote = snprintf(ptr, *len, "min-width: inherit\n");
		1786	break;
		1787	case CSS_MIN_WIDTH_SET:
		1788	wrote = snprintf(ptr, *len, "min-width: ");
		1789	ptr += wrote;
		1790	*len -= wrote;
		1791
		1792	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1793	ptr += wrote;
		1794	*len -= wrote;
		1795
		1796	wrote = snprintf(ptr, *len, "\n");
		1797	break;
		1798	default:
		1799	wrote = 0;
		1800	break;
		1801	}
		1802	ptr += wrote;
		1803	*len -= wrote;
		1804
		1805	/* opacity */
		1806	val = css_computed_opacity(style, &len1);
		1807	switch (val) {
		1808	case CSS_OPACITY_INHERIT:
		1809	wrote = snprintf(ptr, *len, "opacity: inherit\n");
		1810	break;
		1811	case CSS_OPACITY_SET:
		1812	wrote = snprintf(ptr, *len, "opacity: ");
		1813	ptr += wrote;
		1814	*len -= wrote;
		1815
		1816	wrote = dump_css_fixed(len1, ptr, *len);
		1817	ptr += wrote;
		1818	*len -= wrote;
		1819
		1820	wrote = snprintf(ptr, *len, "\n");
		1821	break;
		1822	default:
		1823	wrote = 0;
		1824	break;
		1825	}
		1826	ptr += wrote;
		1827	*len -= wrote;
		1828
		1829	/* outline-color */
		1830	val = css_computed_outline_color(style, &color);
		1831	switch (val) {
		1832	case CSS_OUTLINE_COLOR_INHERIT:
		1833	wrote = snprintf(ptr, *len, "outline-color: inherit\n");
		1834	break;
		1835	case CSS_OUTLINE_COLOR_INVERT:
		1836	wrote = snprintf(ptr, *len, "outline-color: invert\n");
		1837	break;
		1838	case CSS_OUTLINE_COLOR_COLOR:
		1839	wrote = snprintf(ptr, *len, "outline-color: #%08x\n", color);
		1840	break;
		1841	default:
		1842	wrote = 0;
		1843	break;
		1844	}
		1845	ptr += wrote;
		1846	*len -= wrote;
		1847
		1848	/* outline-style */
		1849	val = css_computed_outline_style(style);
		1850	switch (val) {
		1851	case CSS_OUTLINE_STYLE_INHERIT:
		1852	wrote = snprintf(ptr, *len, "outline-style: inherit\n");
		1853	break;
		1854	case CSS_OUTLINE_STYLE_NONE:
		1855	wrote = snprintf(ptr, *len, "outline-style: none\n");
		1856	break;
		1857	case CSS_OUTLINE_STYLE_DOTTED:
		1858	wrote = snprintf(ptr, *len, "outline-style: dotted\n");
		1859	break;
		1860	case CSS_OUTLINE_STYLE_DASHED:
		1861	wrote = snprintf(ptr, *len, "outline-style: dashed\n");
		1862	break;
		1863	case CSS_OUTLINE_STYLE_SOLID:
		1864	wrote = snprintf(ptr, *len, "outline-style: solid\n");
		1865	break;
		1866	case CSS_OUTLINE_STYLE_DOUBLE:
		1867	wrote = snprintf(ptr, *len, "outline-style: double\n");
		1868	break;
		1869	case CSS_OUTLINE_STYLE_GROOVE:
		1870	wrote = snprintf(ptr, *len, "outline-style: groove\n");
		1871	break;
		1872	case CSS_OUTLINE_STYLE_RIDGE:
		1873	wrote = snprintf(ptr, *len, "outline-style: ridge\n");
		1874	break;
		1875	case CSS_OUTLINE_STYLE_INSET:
		1876	wrote = snprintf(ptr, *len, "outline-style: inset\n");
		1877	break;
		1878	case CSS_OUTLINE_STYLE_OUTSET:
		1879	wrote = snprintf(ptr, *len, "outline-style: outset\n");
		1880	break;
		1881	default:
		1882	wrote = 0;
		1883	break;
		1884	}
		1885	ptr += wrote;
		1886	*len -= wrote;
		1887
		1888	/* outline-width */
		1889	val = css_computed_outline_width(style, &len1, &unit1);
		1890	switch (val) {
		1891	case CSS_OUTLINE_WIDTH_INHERIT:
		1892	wrote = snprintf(ptr, *len, "outline-width: inherit\n");
		1893	break;
		1894	case CSS_OUTLINE_WIDTH_THIN:
		1895	wrote = snprintf(ptr, *len, "outline-width: thin\n");
		1896	break;
		1897	case CSS_OUTLINE_WIDTH_MEDIUM:
		1898	wrote = snprintf(ptr, *len, "outline-width: medium\n");
		1899	break;
		1900	case CSS_OUTLINE_WIDTH_THICK:
		1901	wrote = snprintf(ptr, *len, "outline-width: thick\n");
		1902	break;
		1903	case CSS_OUTLINE_WIDTH_WIDTH:
		1904	wrote = snprintf(ptr, *len, "outline-width: ");
		1905	ptr += wrote;
		1906	*len -= wrote;
		1907
		1908	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1909	ptr += wrote;
		1910	*len -= wrote;
		1911
		1912	wrote = snprintf(ptr, *len, "\n");
		1913	break;
		1914	default:
		1915	wrote = 0;
		1916	break;
		1917	}
		1918	ptr += wrote;
		1919	*len -= wrote;
		1920
		1921	/* overflow */
		1922	val = css_computed_overflow(style);
		1923	switch (val) {
		1924	case CSS_OVERFLOW_INHERIT:
		1925	wrote = snprintf(ptr, *len, "overflow: inherit\n");
		1926	break;
		1927	case CSS_OVERFLOW_VISIBLE:
		1928	wrote = snprintf(ptr, *len, "overflow: visible\n");
		1929	break;
		1930	case CSS_OVERFLOW_HIDDEN:
		1931	wrote = snprintf(ptr, *len, "overflow: hidden\n");
		1932	break;
		1933	case CSS_OVERFLOW_SCROLL:
		1934	wrote = snprintf(ptr, *len, "overflow: scroll\n");
		1935	break;
		1936	case CSS_OVERFLOW_AUTO:
		1937	wrote = snprintf(ptr, *len, "overflow: auto\n");
		1938	break;
		1939	default:
		1940	wrote = 0;
		1941	break;
		1942	}
		1943	ptr += wrote;
		1944	*len -= wrote;
		1945
		1946	/* padding-top */
		1947	val = css_computed_padding_top(style, &len1, &unit1);
		1948	switch (val) {
		1949	case CSS_PADDING_INHERIT:
		1950	wrote = snprintf(ptr, *len, "padding-top: inherit\n");
		1951	break;
		1952	case CSS_PADDING_SET:
		1953	wrote = snprintf(ptr, *len, "padding-top: ");
		1954	ptr += wrote;
		1955	*len -= wrote;
		1956
		1957	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1958	ptr += wrote;
		1959	*len -= wrote;
		1960
		1961	wrote = snprintf(ptr, *len, "\n");
		1962	break;
		1963	default:
		1964	wrote = 0;
		1965	break;
		1966	}
		1967	ptr += wrote;
		1968	*len -= wrote;
		1969
		1970	/* padding-right */
		1971	val = css_computed_padding_right(style, &len1, &unit1);
		1972	switch (val) {
		1973	case CSS_PADDING_INHERIT:
		1974	wrote = snprintf(ptr, *len, "padding-right: inherit\n");
		1975	break;
		1976	case CSS_PADDING_SET:
		1977	wrote = snprintf(ptr, *len, "padding-right: ");
		1978	ptr += wrote;
		1979	*len -= wrote;
		1980
		1981	wrote = dump_css_unit(len1, unit1, ptr, *len);
		1982	ptr += wrote;
		1983	*len -= wrote;
		1984
		1985	wrote = snprintf(ptr, *len, "\n");
		1986	break;
		1987	default:
		1988	wrote = 0;
		1989	break;
		1990	}
		1991	ptr += wrote;
		1992	*len -= wrote;
		1993
		1994	/* padding-bottom */
		1995	val = css_computed_padding_bottom(style, &len1, &unit1);
		1996	switch (val) {
		1997	case CSS_PADDING_INHERIT:
		1998	wrote = snprintf(ptr, *len, "padding-bottom: inherit\n");
		1999	break;
		2000	case CSS_PADDING_SET:
		2001	wrote = snprintf(ptr, *len, "padding-bottom: ");
		2002	ptr += wrote;
		2003	*len -= wrote;
		2004
		2005	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2006	ptr += wrote;
		2007	*len -= wrote;
		2008
		2009	wrote = snprintf(ptr, *len, "\n");
		2010	break;
		2011	default:
		2012	wrote = 0;
		2013	break;
		2014	}
		2015	ptr += wrote;
		2016	*len -= wrote;
		2017
		2018	/* padding-left */
		2019	val = css_computed_padding_left(style, &len1, &unit1);
		2020	switch (val) {
		2021	case CSS_PADDING_INHERIT:
		2022	wrote = snprintf(ptr, *len, "padding-left: inherit\n");
		2023	break;
		2024	case CSS_PADDING_SET:
		2025	wrote = snprintf(ptr, *len, "padding-left: ");
		2026	ptr += wrote;
		2027	*len -= wrote;
		2028
		2029	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2030	ptr += wrote;
		2031	*len -= wrote;
		2032
		2033	wrote = snprintf(ptr, *len, "\n");
		2034	break;
		2035	default:
		2036	wrote = 0;
		2037	break;
		2038	}
		2039	ptr += wrote;
		2040	*len -= wrote;
		2041
		2042	/* position */
		2043	val = css_computed_position(style);
		2044	switch (val) {
		2045	case CSS_POSITION_INHERIT:
		2046	wrote = snprintf(ptr, *len, "position: inherit\n");
		2047	break;
		2048	case CSS_POSITION_STATIC:
		2049	wrote = snprintf(ptr, *len, "position: static\n");
		2050	break;
		2051	case CSS_POSITION_RELATIVE:
		2052	wrote = snprintf(ptr, *len, "position: relative\n");
		2053	break;
		2054	case CSS_POSITION_ABSOLUTE:
		2055	wrote = snprintf(ptr, *len, "position: absolute\n");
		2056	break;
		2057	case CSS_POSITION_FIXED:
		2058	wrote = snprintf(ptr, *len, "position: fixed\n");
		2059	break;
		2060	default:
		2061	wrote = 0;
		2062	break;
		2063	}
		2064	ptr += wrote;
		2065	*len -= wrote;
		2066
		2067	/* quotes */
		2068	val = css_computed_quotes(style, &string_list);
		2069	if (val == CSS_QUOTES_STRING && string_list != NULL) {
		2070	wrote = snprintf(ptr, *len, "quotes:");
		2071	ptr += wrote;
		2072	*len -= wrote;
		2073
		2074	while (*string_list != NULL) {
		2075	wrote = snprintf(ptr, len, " \"%.s\"",
		2076	(int) lwc_string_length(*string_list),
		2077	lwc_string_data(*string_list));
		2078	ptr += wrote;
		2079	*len -= wrote;
		2080
		2081	string_list++;
		2082	}
		2083
		2084	wrote = snprintf(ptr, *len, "\n");
		2085	} else {
		2086	switch (val) {
		2087	case CSS_QUOTES_INHERIT:
		2088	wrote = snprintf(ptr, *len, "quotes: inherit\n");
		2089	break;
		2090	case CSS_QUOTES_NONE:
		2091	wrote = snprintf(ptr, *len, "quotes: none\n");
		2092	break;
		2093	default:
		2094	wrote = 0;
		2095	break;
		2096	}
		2097	}
		2098	ptr += wrote;
		2099	*len -= wrote;
		2100
		2101	/* right */
		2102	val = css_computed_right(style, &len1, &unit1);
		2103	switch (val) {
		2104	case CSS_RIGHT_INHERIT:
		2105	wrote = snprintf(ptr, *len, "right: inherit\n");
		2106	break;
		2107	case CSS_RIGHT_AUTO:
		2108	wrote = snprintf(ptr, *len, "right: auto\n");
		2109	break;
		2110	case CSS_RIGHT_SET:
		2111	wrote = snprintf(ptr, *len, "right: ");
		2112	ptr += wrote;
		2113	*len -= wrote;
		2114
		2115	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2116	ptr += wrote;
		2117	*len -= wrote;
		2118
		2119	wrote = snprintf(ptr, *len, "\n");
		2120	break;
		2121	default:
		2122	wrote = 0;
		2123	break;
		2124	}
		2125	ptr += wrote;
		2126	*len -= wrote;
		2127
		2128	/* table-layout */
		2129	val = css_computed_table_layout(style);
		2130	switch (val) {
		2131	case CSS_TABLE_LAYOUT_INHERIT:
		2132	wrote = snprintf(ptr, *len, "table-layout: inherit\n");
		2133	break;
		2134	case CSS_TABLE_LAYOUT_AUTO:
		2135	wrote = snprintf(ptr, *len, "table-layout: auto\n");
		2136	break;
		2137	case CSS_TABLE_LAYOUT_FIXED:
		2138	wrote = snprintf(ptr, *len, "table-layout: fixed\n");
		2139	break;
		2140	default:
		2141	wrote = 0;
		2142	break;
		2143	}
		2144	ptr += wrote;
		2145	*len -= wrote;
		2146
		2147	/* text-align */
		2148	val = css_computed_text_align(style);
		2149	switch (val) {
		2150	case CSS_TEXT_ALIGN_INHERIT:
		2151	wrote = snprintf(ptr, *len, "text-align: inherit\n");
		2152	break;
		2153	case CSS_TEXT_ALIGN_LEFT:
		2154	wrote = snprintf(ptr, *len, "text-align: left\n");
		2155	break;
		2156	case CSS_TEXT_ALIGN_RIGHT:
		2157	wrote = snprintf(ptr, *len, "text-align: right\n");
		2158	break;
		2159	case CSS_TEXT_ALIGN_CENTER:
		2160	wrote = snprintf(ptr, *len, "text-align: center\n");
		2161	break;
		2162	case CSS_TEXT_ALIGN_JUSTIFY:
		2163	wrote = snprintf(ptr, *len, "text-align: justify\n");
		2164	break;
		2165	case CSS_TEXT_ALIGN_DEFAULT:
		2166	wrote = snprintf(ptr, *len, "text-align: default\n");
		2167	break;
		2168	case CSS_TEXT_ALIGN_LIBCSS_LEFT:
		2169	wrote = snprintf(ptr, *len, "text-align: -libcss-left\n");
		2170	break;
		2171	case CSS_TEXT_ALIGN_LIBCSS_CENTER:
		2172	wrote = snprintf(ptr, *len, "text-align: -libcss-center\n");
		2173	break;
		2174	case CSS_TEXT_ALIGN_LIBCSS_RIGHT:
		2175	wrote = snprintf(ptr, *len, "text-align: -libcss-right\n");
		2176	break;
		2177	default:
		2178	wrote = 0;
		2179	break;
		2180	}
		2181	ptr += wrote;
		2182	*len -= wrote;
		2183
		2184	/* text-decoration */
		2185	val = css_computed_text_decoration(style);
		2186	if (val == CSS_TEXT_DECORATION_INHERIT) {
		2187	wrote = snprintf(ptr, *len, "text-decoration: inherit\n");
		2188	ptr += wrote;
		2189	*len -= wrote;
		2190	} else if (val == CSS_TEXT_DECORATION_NONE) {
		2191	wrote = snprintf(ptr, *len, "text-decoration: none\n");
		2192	ptr += wrote;
		2193	*len -= wrote;
		2194	} else {
		2195	wrote = snprintf(ptr, *len, "text-decoration:");
		2196	ptr += wrote;
		2197	*len -= wrote;
		2198
		2199	if (val & CSS_TEXT_DECORATION_BLINK) {
		2200	wrote = snprintf(ptr, *len, " blink");
		2201	ptr += wrote;
		2202	*len -= wrote;
		2203	}
		2204	if (val & CSS_TEXT_DECORATION_LINE_THROUGH) {
		2205	wrote = snprintf(ptr, *len, " line-through");
		2206	ptr += wrote;
		2207	*len -= wrote;
		2208	}
		2209	if (val & CSS_TEXT_DECORATION_OVERLINE) {
		2210	wrote = snprintf(ptr, *len, " overline");
		2211	ptr += wrote;
		2212	*len -= wrote;
		2213	}
		2214	if (val & CSS_TEXT_DECORATION_UNDERLINE) {
		2215	wrote = snprintf(ptr, *len, " underline");
		2216	ptr += wrote;
		2217	*len -= wrote;
		2218	}
		2219
		2220	wrote = snprintf(ptr, *len, "\n");
		2221	ptr += wrote;
		2222	*len -= wrote;
		2223	}
		2224
		2225	/* text-indent */
		2226	val = css_computed_text_indent(style, &len1, &unit1);
		2227	switch (val) {
		2228	case CSS_TEXT_INDENT_INHERIT:
		2229	wrote = snprintf(ptr, *len, "text-indent: inherit\n");
		2230	break;
		2231	case CSS_TEXT_INDENT_SET:
		2232	wrote = snprintf(ptr, *len, "text-indent: ");
		2233	ptr += wrote;
		2234	*len -= wrote;
		2235
		2236	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2237	ptr += wrote;
		2238	*len -= wrote;
		2239
		2240	wrote = snprintf(ptr, *len, "\n");
		2241	break;
		2242	default:
		2243	wrote = 0;
		2244	break;
		2245	}
		2246	ptr += wrote;
		2247	*len -= wrote;
		2248
		2249	/* text-transform */
		2250	val = css_computed_text_transform(style);
		2251	switch (val) {
		2252	case CSS_TEXT_TRANSFORM_INHERIT:
		2253	wrote = snprintf(ptr, *len, "text-transform: inherit\n");
		2254	break;
		2255	case CSS_TEXT_TRANSFORM_CAPITALIZE:
		2256	wrote = snprintf(ptr, *len, "text-transform: capitalize\n");
		2257	break;
		2258	case CSS_TEXT_TRANSFORM_UPPERCASE:
		2259	wrote = snprintf(ptr, *len, "text-transform: uppercase\n");
		2260	break;
		2261	case CSS_TEXT_TRANSFORM_LOWERCASE:
		2262	wrote = snprintf(ptr, *len, "text-transform: lowercase\n");
		2263	break;
		2264	case CSS_TEXT_TRANSFORM_NONE:
		2265	wrote = snprintf(ptr, *len, "text-transform: none\n");
		2266	break;
		2267	default:
		2268	wrote = 0;
		2269	break;
		2270	}
		2271	ptr += wrote;
		2272	*len -= wrote;
		2273
		2274	/* top */
		2275	val = css_computed_top(style, &len1, &unit1);
		2276	switch (val) {
		2277	case CSS_TOP_INHERIT:
		2278	wrote = snprintf(ptr, *len, "top: inherit\n");
		2279	break;
		2280	case CSS_TOP_AUTO:
		2281	wrote = snprintf(ptr, *len, "top: auto\n");
		2282	break;
		2283	case CSS_TOP_SET:
		2284	wrote = snprintf(ptr, *len, "top: ");
		2285	ptr += wrote;
		2286	*len -= wrote;
		2287
		2288	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2289	ptr += wrote;
		2290	*len -= wrote;
		2291
		2292	wrote = snprintf(ptr, *len, "\n");
		2293	break;
		2294	default:
		2295	wrote = 0;
		2296	break;
		2297	}
		2298	ptr += wrote;
		2299	*len -= wrote;
		2300
		2301	/* unicode-bidi */
		2302	val = css_computed_unicode_bidi(style);
		2303	switch (val) {
		2304	case CSS_UNICODE_BIDI_INHERIT:
		2305	wrote = snprintf(ptr, *len, "unicode-bidi: inherit\n");
		2306	break;
		2307	case CSS_UNICODE_BIDI_NORMAL:
		2308	wrote = snprintf(ptr, *len, "unicode-bidi: normal\n");
		2309	break;
		2310	case CSS_UNICODE_BIDI_EMBED:
		2311	wrote = snprintf(ptr, *len, "unicode-bidi: embed\n");
		2312	break;
		2313	case CSS_UNICODE_BIDI_BIDI_OVERRIDE:
		2314	wrote = snprintf(ptr, *len, "unicode-bidi: bidi-override\n");
		2315	break;
		2316	default:
		2317	wrote = 0;
		2318	break;
		2319	}
		2320	ptr += wrote;
		2321	*len -= wrote;
		2322
		2323	/* vertical-align */
		2324	val = css_computed_vertical_align(style, &len1, &unit1);
		2325	switch (val) {
		2326	case CSS_VERTICAL_ALIGN_INHERIT:
		2327	wrote = snprintf(ptr, *len, "vertical-align: inherit\n");
		2328	break;
		2329	case CSS_VERTICAL_ALIGN_BASELINE:
		2330	wrote = snprintf(ptr, *len, "vertical-align: baseline\n");
		2331	break;
		2332	case CSS_VERTICAL_ALIGN_SUB:
		2333	wrote = snprintf(ptr, *len, "vertical-align: sub\n");
		2334	break;
		2335	case CSS_VERTICAL_ALIGN_SUPER:
		2336	wrote = snprintf(ptr, *len, "vertical-align: super\n");
		2337	break;
		2338	case CSS_VERTICAL_ALIGN_TOP:
		2339	wrote = snprintf(ptr, *len, "vertical-align: top\n");
		2340	break;
		2341	case CSS_VERTICAL_ALIGN_TEXT_TOP:
		2342	wrote = snprintf(ptr, *len, "vertical-align: text-top\n");
		2343	break;
		2344	case CSS_VERTICAL_ALIGN_MIDDLE:
		2345	wrote = snprintf(ptr, *len, "vertical-align: middle\n");
		2346	break;
		2347	case CSS_VERTICAL_ALIGN_BOTTOM:
		2348	wrote = snprintf(ptr, *len, "vertical-align: bottom\n");
		2349	break;
		2350	case CSS_VERTICAL_ALIGN_TEXT_BOTTOM:
		2351	wrote = snprintf(ptr, *len, "vertical-align: text-bottom\n");
		2352	break;
		2353	case CSS_VERTICAL_ALIGN_SET:
		2354	wrote = snprintf(ptr, *len, "vertical-align: ");
		2355	ptr += wrote;
		2356	*len -= wrote;
		2357
		2358	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2359	ptr += wrote;
		2360	*len -= wrote;
		2361
		2362	wrote = snprintf(ptr, *len, "\n");
		2363	break;
		2364	default:
		2365	wrote = 0;
		2366	break;
		2367	}
		2368	ptr += wrote;
		2369	*len -= wrote;
		2370
		2371	/* visibility */
		2372	val = css_computed_visibility(style);
		2373	switch (val) {
		2374	case CSS_VISIBILITY_INHERIT:
		2375	wrote = snprintf(ptr, *len, "visibility: inherit\n");
		2376	break;
		2377	case CSS_VISIBILITY_VISIBLE:
		2378	wrote = snprintf(ptr, *len, "visibility: visible\n");
		2379	break;
		2380	case CSS_VISIBILITY_HIDDEN:
		2381	wrote = snprintf(ptr, *len, "visibility: hidden\n");
		2382	break;
		2383	case CSS_VISIBILITY_COLLAPSE:
		2384	wrote = snprintf(ptr, *len, "visibility: collapse\n");
		2385	break;
		2386	default:
		2387	wrote = 0;
		2388	break;
		2389	}
		2390	ptr += wrote;
		2391	*len -= wrote;
		2392
		2393	/* white-space */
		2394	val = css_computed_white_space(style);
		2395	switch (val) {
		2396	case CSS_WHITE_SPACE_INHERIT:
		2397	wrote = snprintf(ptr, *len, "white-space: inherit\n");
		2398	break;
		2399	case CSS_WHITE_SPACE_NORMAL:
		2400	wrote = snprintf(ptr, *len, "white-space: normal\n");
		2401	break;
		2402	case CSS_WHITE_SPACE_PRE:
		2403	wrote = snprintf(ptr, *len, "white-space: pre\n");
		2404	break;
		2405	case CSS_WHITE_SPACE_NOWRAP:
		2406	wrote = snprintf(ptr, *len, "white-space: nowrap\n");
		2407	break;
		2408	case CSS_WHITE_SPACE_PRE_WRAP:
		2409	wrote = snprintf(ptr, *len, "white-space: pre-wrap\n");
		2410	break;
		2411	case CSS_WHITE_SPACE_PRE_LINE:
		2412	wrote = snprintf(ptr, *len, "white-space: pre-line\n");
		2413	break;
		2414	default:
		2415	wrote = 0;
		2416	break;
		2417	}
		2418	ptr += wrote;
		2419	*len -= wrote;
		2420
		2421	/* width */
		2422	val = css_computed_width(style, &len1, &unit1);
		2423	switch (val) {
		2424	case CSS_WIDTH_INHERIT:
		2425	wrote = snprintf(ptr, *len, "width: inherit\n");
		2426	break;
		2427	case CSS_WIDTH_AUTO:
		2428	wrote = snprintf(ptr, *len, "width: auto\n");
		2429	break;
		2430	case CSS_WIDTH_SET:
		2431	wrote = snprintf(ptr, *len, "width: ");
		2432	ptr += wrote;
		2433	*len -= wrote;
		2434
		2435	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2436	ptr += wrote;
		2437	*len -= wrote;
		2438
		2439	wrote = snprintf(ptr, *len, "\n");
		2440	break;
		2441	default:
		2442	wrote = 0;
		2443	break;
		2444	}
		2445	ptr += wrote;
		2446	*len -= wrote;
		2447
		2448	/* word-spacing */
		2449	val = css_computed_word_spacing(style, &len1, &unit1);
		2450	switch (val) {
		2451	case CSS_WORD_SPACING_INHERIT:
		2452	wrote = snprintf(ptr, *len, "word-spacing: inherit\n");
		2453	break;
		2454	case CSS_WORD_SPACING_NORMAL:
		2455	wrote = snprintf(ptr, *len, "word-spacing: normal\n");
		2456	break;
		2457	case CSS_WORD_SPACING_SET:
		2458	wrote = snprintf(ptr, *len, "word-spacing: ");
		2459	ptr += wrote;
		2460	*len -= wrote;
		2461
		2462	wrote = dump_css_unit(len1, unit1, ptr, *len);
		2463	ptr += wrote;
		2464	*len -= wrote;
		2465
		2466	wrote = snprintf(ptr, *len, "\n");
		2467	break;
		2468	default:
		2469	wrote = 0;
		2470	break;
		2471	}
		2472	ptr += wrote;
		2473	*len -= wrote;
		2474
		2475	/* z-index */
		2476	val = css_computed_z_index(style, &zindex);
		2477	switch (val) {
		2478	case CSS_Z_INDEX_INHERIT:
		2479	wrote = snprintf(ptr, *len, "z-index: inherit\n");
		2480	break;
		2481	case CSS_Z_INDEX_AUTO:
		2482	wrote = snprintf(ptr, *len, "z-index: auto\n");
		2483	break;
		2484	case CSS_Z_INDEX_SET:
		2485	wrote = snprintf(ptr, *len, "z-index: %d\n", zindex);
		2486	break;
		2487	default:
		2488	wrote = 0;
		2489	break;
		2490	}
		2491	ptr += wrote;
		2492	*len -= wrote;
		2493	}
		2494

Subversion Repositories Kolibri OS

(root)/programs/network/netsurf/libcss/test/dump_computed.h @ 3584 – Rev