Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include <libcss/computed.h>
  2. #include <libcss/properties.h>
  3. #include <libcss/types.h>
  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.  
  2495.