dll/win32/mshtml/htmlstyle.c

   1 /*
   2  * Copyright 2006 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "mshtml_private.h"
  20
  21 static const WCHAR attrBackground[] =
  22     {'b','a','c','k','g','r','o','u','n','d',0};
  23 static const WCHAR attrBackgroundAttachment[] =
  24     {'b','a','c','k','g','r','o','u','n','d','-','a','t','t','a','c','h','m','e','n','t',0};
  25 static const WCHAR attrBackgroundColor[] =
  26     {'b','a','c','k','g','r','o','u','n','d','-','c','o','l','o','r',0};
  27 static const WCHAR attrBackgroundImage[] =
  28     {'b','a','c','k','g','r','o','u','n','d','-','i','m','a','g','e',0};
  29 static const WCHAR attrBackgroundPosition[] =
  30     {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n',0};
  31 static const WCHAR attrBackgroundPositionX[] =
  32     {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n','-','x',0};
  33 static const WCHAR attrBackgroundPositionY[] =
  34     {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n','-','y',0};
  35 static const WCHAR attrBackgroundRepeat[] =
  36     {'b','a','c','k','g','r','o','u','n','d','-','r','e','p','e','a','t',0};
  37 static const WCHAR attrBorder[] =
  38     {'b','o','r','d','e','r',0};
  39 static const WCHAR attrBorderBottom[] =
  40     {'b','o','r','d','e','r','-','b','o','t','t','o','m',0};
  41 static const WCHAR attrBorderBottomColor[] =
  42     {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','c','o','l','o','r',0};
  43 static const WCHAR attrBorderBottomStyle[] =
  44     {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','s','t','y','l','e',0};
  45 static const WCHAR attrBorderBottomWidth[] =
  46     {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','w','i','d','t','h',0};
  47 static const WCHAR attrBorderColor[] =
  48     {'b','o','r','d','e','r','-','c','o','l','o','r',0};
  49 static const WCHAR attrBorderLeft[] =
  50     {'b','o','r','d','e','r','-','l','e','f','t',0};
  51 static const WCHAR attrBorderLeftColor[] =
  52     {'b','o','r','d','e','r','-','l','e','f','t','-','c','o','l','o','r',0};
  53 static const WCHAR attrBorderLeftStyle[] =
  54     {'b','o','r','d','e','r','-','l','e','f','t','-','s','t','y','l','e',0};
  55 static const WCHAR attrBorderLeftWidth[] =
  56     {'b','o','r','d','e','r','-','l','e','f','t','-','w','i','d','t','h',0};
  57 static const WCHAR attrBorderRight[] =
  58     {'b','o','r','d','e','r','-','r','i','g','h','t',0};
  59 static const WCHAR attrBorderRightColor[] =
  60     {'b','o','r','d','e','r','-','r','i','g','h','t','-','c','o','l','o','r',0};
  61 static const WCHAR attrBorderRightStyle[] =
  62     {'b','o','r','d','e','r','-','r','i','g','h','t','-','s','t','y','l','e',0};
  63 static const WCHAR attrBorderRightWidth[] =
  64     {'b','o','r','d','e','r','-','r','i','g','h','t','-','w','i','d','t','h',0};
  65 static const WCHAR attrBorderTop[] =
  66     {'b','o','r','d','e','r','-','t','o','p',0};
  67 static const WCHAR attrBorderTopColor[] =
  68     {'b','o','r','d','e','r','-','t','o','p','-','c','o','l','o','r',0};
  69 static const WCHAR attrBorderStyle[] =
  70     {'b','o','r','d','e','r','-','s','t','y','l','e',0};
  71 static const WCHAR attrBorderTopStyle[] =
  72     {'b','o','r','d','e','r','-','t','o','p','-','s','t','y','l','e',0};
  73 static const WCHAR attrBorderTopWidth[] =
  74     {'b','o','r','d','e','r','-','t','o','p','-','w','i','d','t','h',0};
  75 static const WCHAR attrBorderWidth[] =
  76     {'b','o','r','d','e','r','-','w','i','d','t','h',0};
  77 static const WCHAR attrBottom[] =
  78     {'b','o','t','t','o','m',0};
  79 /* FIXME: Use unprefixed version (requires Gecko changes). */
  80 static const WCHAR attrBoxSizing[] =
  81     {'-','m','o','z','-','b','o','x','-','s','i','z','i','n','g',0};
  82 static const WCHAR attrClear[] =
  83     {'c','l','e','a','r',0};
  84 static const WCHAR attrClip[] =
  85     {'c','l','i','p',0};
  86 static const WCHAR attrColor[] =
  87     {'c','o','l','o','r',0};
  88 static const WCHAR attrCursor[] =
  89     {'c','u','r','s','o','r',0};
  90 static const WCHAR attrDirection[] =
  91     {'d','i','r','e','c','t','i','o','n',0};
  92 static const WCHAR attrDisplay[] =
  93     {'d','i','s','p','l','a','y',0};
  94 static const WCHAR attrFilter[] =
  95     {'f','i','l','e','t','e','r',0};
  96 static const WCHAR attrFloat[] =
  97     {'f','l','o','a','t',0};
  98 static const WCHAR attrFontFamily[] =
  99     {'f','o','n','t','-','f','a','m','i','l','y',0};
 100 static const WCHAR attrFontSize[] =
 101     {'f','o','n','t','-','s','i','z','e',0};
 102 static const WCHAR attrFontStyle[] =
 103     {'f','o','n','t','-','s','t','y','l','e',0};
 104 static const WCHAR attrFontVariant[] =
 105     {'f','o','n','t','-','v','a','r','i','a','n','t',0};
 106 static const WCHAR attrFontWeight[] =
 107     {'f','o','n','t','-','w','e','i','g','h','t',0};
 108 static const WCHAR attrHeight[] =
 109     {'h','e','i','g','h','t',0};
 110 static const WCHAR attrLeft[] =
 111     {'l','e','f','t',0};
 112 static const WCHAR attrLetterSpacing[] =
 113     {'l','e','t','t','e','r','-','s','p','a','c','i','n','g',0};
 114 static const WCHAR attrLineHeight[] =
 115     {'l','i','n','e','-','h','e','i','g','h','t',0};
 116 static const WCHAR attrListStyle[] =
 117     {'l','i','s','t','-','s','t','y','l','e',0};
 118 static const WCHAR attrListStyleType[] =
 119     {'l','i','s','t','-','s','t','y','l','e','-','t','y','p','e',0};
 120 static const WCHAR attrListStylePosition[] =
 121     {'l','i','s','t','-','s','t','y','l','e','-','p','o','s','i','t','i','o','n',0};
 122 static const WCHAR attrMargin[] =
 123     {'m','a','r','g','i','n',0};
 124 static const WCHAR attrMarginBottom[] =
 125     {'m','a','r','g','i','n','-','b','o','t','t','o','m',0};
 126 static const WCHAR attrMarginLeft[] =
 127     {'m','a','r','g','i','n','-','l','e','f','t',0};
 128 static const WCHAR attrMarginRight[] =
 129     {'m','a','r','g','i','n','-','r','i','g','h','t',0};
 130 static const WCHAR attrMarginTop[] =
 131     {'m','a','r','g','i','n','-','t','o','p',0};
 132 static const WCHAR attrMaxHeight[] =
 133     {'m','a','x','-','h','e','i','g','h','t',0};
 134 static const WCHAR attrMaxWidth[] =
 135     {'m','a','x','-','w','i','d','t','h',0};
 136 static const WCHAR attrMinHeight[] =
 137     {'m','i','n','-','h','e','i','g','h','t',0};
 138 static const WCHAR attrMinWidth[] =
 139     {'m','i','n','-','w','i','d','t','h',0};
 140 static const WCHAR attrOutline[] =
 141     {'o','u','t','l','i','n','e',0};
 142 static const WCHAR attrOverflow[] =
 143     {'o','v','e','r','f','l','o','w',0};
 144 static const WCHAR attrOverflowX[] =
 145     {'o','v','e','r','f','l','o','w','-','x',0};
 146 static const WCHAR attrOverflowY[] =
 147     {'o','v','e','r','f','l','o','w','-','y',0};
 148 static const WCHAR attrPadding[] =
 149     {'p','a','d','d','i','n','g',0};
 150 static const WCHAR attrPaddingBottom[] =
 151     {'p','a','d','d','i','n','g','-','b','o','t','t','o','m',0};
 152 static const WCHAR attrPaddingLeft[] =
 153     {'p','a','d','d','i','n','g','-','l','e','f','t',0};
 154 static const WCHAR attrPaddingRight[] =
 155     {'p','a','d','d','i','n','g','-','r','i','g','h','t',0};
 156 static const WCHAR attrPaddingTop[] =
 157     {'p','a','d','d','i','n','g','-','t','o','p',0};
 158 static const WCHAR attrPageBreakAfter[] =
 159     {'p','a','g','e','-','b','r','e','a','k','-','a','f','t','e','r',0};
 160 static const WCHAR attrPageBreakBefore[] =
 161     {'p','a','g','e','-','b','r','e','a','k','-','b','e','f','o','r','e',0};
 162 static const WCHAR attrPosition[] =
 163     {'p','o','s','i','t','i','o','n',0};
 164 static const WCHAR attrRight[] =
 165     {'r','i','g','h','t',0};
 166 static const WCHAR attrTableLayout[] =
 167     {'t','a','b','l','e','-','l','a','y','o','u','t',0};
 168 static const WCHAR attrTextAlign[] =
 169     {'t','e','x','t','-','a','l','i','g','n',0};
 170 static const WCHAR attrTextDecoration[] =
 171     {'t','e','x','t','-','d','e','c','o','r','a','t','i','o','n',0};
 172 static const WCHAR attrTextIndent[] =
 173     {'t','e','x','t','-','i','n','d','e','n','t',0};
 174 static const WCHAR attrTextTransform[] =
 175     {'t','e','x','t','-','t','r','a','n','s','f','o','r','m',0};
 176 static const WCHAR attrTop[] =
 177     {'t','o','p',0};
 178 static const WCHAR attrVerticalAlign[] =
 179     {'v','e','r','t','i','c','a','l','-','a','l','i','g','n',0};
 180 static const WCHAR attrVisibility[] =
 181     {'v','i','s','i','b','i','l','i','t','y',0};
 182 static const WCHAR attrWhiteSpace[] =
 183     {'w','h','i','t','e','-','s','p','a','c','e',0};
 184 static const WCHAR attrWidth[] =
 185     {'w','i','d','t','h',0};
 186 static const WCHAR attrWordSpacing[] =
 187     {'w','o','r','d','-','s','p','a','c','i','n','g',0};
 188 static const WCHAR attrWordWrap[] =
 189     {'w','o','r','d','-','w','r','a','p',0};
 190 static const WCHAR attrZIndex[] =
 191     {'z','-','i','n','d','e','x',0};
 192
 193
 194 static const WCHAR pxW[] = {'p','x',0};
 195
 196 typedef struct {
 197     const WCHAR *name;
 198     DISPID dispid;
 199 } style_tbl_entry_t;
 200
 201 static const style_tbl_entry_t style_tbl[] = {
 202     {attrBackground,           DISPID_IHTMLSTYLE_BACKGROUND},
 203     {attrBackgroundAttachment, DISPID_IHTMLSTYLE_BACKGROUNDATTACHMENT},
 204     {attrBackgroundColor,      DISPID_IHTMLSTYLE_BACKGROUNDCOLOR},
 205     {attrBackgroundImage,      DISPID_IHTMLSTYLE_BACKGROUNDIMAGE},
 206     {attrBackgroundPosition,   DISPID_IHTMLSTYLE_BACKGROUNDPOSITION},
 207     {attrBackgroundPositionX,  DISPID_IHTMLSTYLE_BACKGROUNDPOSITIONX},
 208     {attrBackgroundPositionY,  DISPID_IHTMLSTYLE_BACKGROUNDPOSITIONY},
 209     {attrBackgroundRepeat,     DISPID_IHTMLSTYLE_BACKGROUNDREPEAT},
 210     {attrBorder,               DISPID_IHTMLSTYLE_BORDER},
 211     {attrBorderBottom,         DISPID_IHTMLSTYLE_BORDERBOTTOM},
 212     {attrBorderBottomColor,    DISPID_IHTMLSTYLE_BORDERBOTTOMCOLOR},
 213     {attrBorderBottomStyle,    DISPID_IHTMLSTYLE_BORDERBOTTOMSTYLE},
 214     {attrBorderBottomWidth,    DISPID_IHTMLSTYLE_BORDERBOTTOMWIDTH},
 215     {attrBorderColor,          DISPID_IHTMLSTYLE_BORDERCOLOR},
 216     {attrBorderLeft,           DISPID_IHTMLSTYLE_BORDERLEFT},
 217     {attrBorderLeftColor,      DISPID_IHTMLSTYLE_BORDERLEFTCOLOR},
 218     {attrBorderLeftStyle,      DISPID_IHTMLSTYLE_BORDERLEFTSTYLE},
 219     {attrBorderLeftWidth,      DISPID_IHTMLSTYLE_BORDERLEFTWIDTH},
 220     {attrBorderRight,          DISPID_IHTMLSTYLE_BORDERRIGHT},
 221     {attrBorderRightColor,     DISPID_IHTMLSTYLE_BORDERRIGHTCOLOR},
 222     {attrBorderRightStyle,     DISPID_IHTMLSTYLE_BORDERRIGHTSTYLE},
 223     {attrBorderRightWidth,     DISPID_IHTMLSTYLE_BORDERRIGHTWIDTH},
 224     {attrBorderStyle,          DISPID_IHTMLSTYLE_BORDERSTYLE},
 225     {attrBorderTop,            DISPID_IHTMLSTYLE_BORDERTOP},
 226     {attrBorderTopColor,       DISPID_IHTMLSTYLE_BORDERTOPCOLOR},
 227     {attrBorderTopStyle,       DISPID_IHTMLSTYLE_BORDERTOPSTYLE},
 228     {attrBorderTopWidth,       DISPID_IHTMLSTYLE_BORDERTOPWIDTH},
 229     {attrBorderWidth,          DISPID_IHTMLSTYLE_BORDERWIDTH},
 230     {attrBottom,               DISPID_IHTMLSTYLE2_BOTTOM},
 231     {attrBoxSizing,            DISPID_IHTMLSTYLE6_BOXSIZING},
 232     {attrClear,                DISPID_IHTMLSTYLE_CLEAR},
 233     {attrClip,                 DISPID_IHTMLSTYLE_CLIP},
 234     {attrColor,                DISPID_IHTMLSTYLE_COLOR},
 235     {attrCursor,               DISPID_IHTMLSTYLE_CURSOR},
 236     {attrDirection,            DISPID_IHTMLSTYLE2_DIRECTION},
 237     {attrDisplay,              DISPID_IHTMLSTYLE_DISPLAY},
 238     {attrFilter,               DISPID_IHTMLSTYLE_FILTER},
 239     {attrFloat,                DISPID_IHTMLSTYLE_STYLEFLOAT},
 240     {attrFontFamily,           DISPID_IHTMLSTYLE_FONTFAMILY},
 241     {attrFontSize,             DISPID_IHTMLSTYLE_FONTSIZE},
 242     {attrFontStyle,            DISPID_IHTMLSTYLE_FONTSTYLE},
 243     {attrFontVariant,          DISPID_IHTMLSTYLE_FONTVARIANT},
 244     {attrFontWeight,           DISPID_IHTMLSTYLE_FONTWEIGHT},
 245     {attrHeight,               DISPID_IHTMLSTYLE_HEIGHT},
 246     {attrLeft,                 DISPID_IHTMLSTYLE_LEFT},
 247     {attrLetterSpacing,        DISPID_IHTMLSTYLE_LETTERSPACING},
 248     {attrLineHeight,           DISPID_IHTMLSTYLE_LINEHEIGHT},
 249     {attrListStyle,            DISPID_IHTMLSTYLE_LISTSTYLE},
 250     {attrListStylePosition,    DISPID_IHTMLSTYLE_LISTSTYLEPOSITION},
 251     {attrListStyleType,        DISPID_IHTMLSTYLE_LISTSTYLETYPE},
 252     {attrMargin,               DISPID_IHTMLSTYLE_MARGIN},
 253     {attrMarginBottom,         DISPID_IHTMLSTYLE_MARGINBOTTOM},
 254     {attrMarginLeft,           DISPID_IHTMLSTYLE_MARGINLEFT},
 255     {attrMarginRight,          DISPID_IHTMLSTYLE_MARGINRIGHT},
 256     {attrMarginTop,            DISPID_IHTMLSTYLE_MARGINTOP},
 257     {attrMaxHeight,            DISPID_IHTMLSTYLE5_MAXHEIGHT},
 258     {attrMaxWidth,             DISPID_IHTMLSTYLE5_MAXWIDTH},
 259     {attrMinHeight,            DISPID_IHTMLSTYLE4_MINHEIGHT},
 260     {attrMinWidth,             DISPID_IHTMLSTYLE5_MINWIDTH},
 261     {attrOutline,              DISPID_IHTMLSTYLE6_OUTLINE},
 262     {attrOverflow,             DISPID_IHTMLSTYLE_OVERFLOW},
 263     {attrOverflowX,            DISPID_IHTMLSTYLE2_OVERFLOWX},
 264     {attrOverflowY,            DISPID_IHTMLSTYLE2_OVERFLOWY},
 265     {attrPadding,              DISPID_IHTMLSTYLE_PADDING},
 266     {attrPaddingBottom,        DISPID_IHTMLSTYLE_PADDINGBOTTOM},
 267     {attrPaddingLeft,          DISPID_IHTMLSTYLE_PADDINGLEFT},
 268     {attrPaddingRight,         DISPID_IHTMLSTYLE_PADDINGRIGHT},
 269     {attrPaddingTop,           DISPID_IHTMLSTYLE_PADDINGTOP},
 270     {attrPageBreakAfter,       DISPID_IHTMLSTYLE_PAGEBREAKAFTER},
 271     {attrPageBreakBefore,      DISPID_IHTMLSTYLE_PAGEBREAKBEFORE},
 272     {attrPosition,             DISPID_IHTMLSTYLE2_POSITION},
 273     {attrRight,                DISPID_IHTMLSTYLE2_RIGHT},
 274     {attrTableLayout,          DISPID_IHTMLSTYLE2_TABLELAYOUT},
 275     {attrTextAlign,            DISPID_IHTMLSTYLE_TEXTALIGN},
 276     {attrTextDecoration,       DISPID_IHTMLSTYLE_TEXTDECORATION},
 277     {attrTextIndent,           DISPID_IHTMLSTYLE_TEXTINDENT},
 278     {attrTextTransform,        DISPID_IHTMLSTYLE_TEXTTRANSFORM},
 279     {attrTop,                  DISPID_IHTMLSTYLE_TOP},
 280     {attrVerticalAlign,        DISPID_IHTMLSTYLE_VERTICALALIGN},
 281     {attrVisibility,           DISPID_IHTMLSTYLE_VISIBILITY},
 282     {attrWhiteSpace,           DISPID_IHTMLSTYLE_WHITESPACE},
 283     {attrWidth,                DISPID_IHTMLSTYLE_WIDTH},
 284     {attrWordSpacing,          DISPID_IHTMLSTYLE_WORDSPACING},
 285     {attrWordWrap,             DISPID_IHTMLSTYLE3_WORDWRAP},
 286     {attrZIndex,               DISPID_IHTMLSTYLE_ZINDEX}
 287 };
 288
 289 C_ASSERT(sizeof(style_tbl)/sizeof(*style_tbl) == STYLEID_MAX_VALUE);
 290
 291 static const WCHAR valLineThrough[] =
 292     {'l','i','n','e','-','t','h','r','o','u','g','h',0};
 293 static const WCHAR valUnderline[] =
 294     {'u','n','d','e','r','l','i','n','e',0};
 295 static const WCHAR szNormal[] =
 296     {'n','o','r','m','a','l',0};
 297 static const WCHAR styleNone[] =
 298     {'n','o','n','e',0};
 299 static const WCHAR valOverline[] =
 300     {'o','v','e','r','l','i','n','e',0};
 301 static const WCHAR valBlink[] =
 302     {'b','l','i','n','k',0};
 303
 304 static const WCHAR px_formatW[] = {'%','d','p','x',0};
 305 static const WCHAR emptyW[] = {0};
 306
 307 static const style_tbl_entry_t *lookup_style_tbl(const WCHAR *name)
 308 {
 309     int c, i, min = 0, max = sizeof(style_tbl)/sizeof(*style_tbl)-1;
 310
 311     while(min <= max) {
 312         i = (min+max)/2;
 313
 314         c = strcmpW(style_tbl[i].name, name);
 315         if(!c)
 316             return style_tbl+i;
 317
 318         if(c > 0)
 319             max = i-1;
 320         else
 321             min = i+1;
 322     }
 323
 324     return NULL;
 325 }
 326
 327 static LPWSTR fix_px_value(LPCWSTR val)
 328 {
 329     LPCWSTR ptr = val;
 330
 331     while(*ptr) {
 332         while(*ptr && isspaceW(*ptr))
 333             ptr++;
 334         if(!*ptr)
 335             break;
 336
 337         while(*ptr && isdigitW(*ptr))
 338             ptr++;
 339
 340         if(!*ptr || isspaceW(*ptr)) {
 341             LPWSTR ret, p;
 342             int len = strlenW(val)+1;
 343
 344             ret = heap_alloc((len+2)*sizeof(WCHAR));
 345             memcpy(ret, val, (ptr-val)*sizeof(WCHAR));
 346             p = ret + (ptr-val);
 347             *p++ = 'p';
 348             *p++ = 'x';
 349             strcpyW(p, ptr);
 350
 351             TRACE("fixed %s -> %s\n", debugstr_w(val), debugstr_w(ret));
 352
 353             return ret;
 354         }
 355
 356         while(*ptr && !isspaceW(*ptr))
 357             ptr++;
 358     }
 359
 360     return NULL;
 361 }
 362
 363 static LPWSTR fix_url_value(LPCWSTR val)
 364 {
 365     WCHAR *ret, *ptr;
 366
 367     static const WCHAR urlW[] = {'u','r','l','('};
 368
 369     if(strncmpW(val, urlW, sizeof(urlW)/sizeof(WCHAR)) || !strchrW(val, '\\'))
 370         return NULL;
 371
 372     ret = heap_strdupW(val);
 373
 374     for(ptr = ret; *ptr; ptr++) {
 375         if(*ptr == '\\')
 376             *ptr = '/';
 377     }
 378
 379     return ret;
 380 }
 381
 382 HRESULT set_nsstyle_attr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, const WCHAR *value, DWORD flags)
 383 {
 384     nsAString str_name, str_value, str_empty;
 385     LPWSTR val = NULL;
 386     nsresult nsres;
 387
 388     if(value) {
 389         if(flags & ATTR_FIX_PX)
 390             val = fix_px_value(value);
 391         else if(flags & ATTR_FIX_URL)
 392             val = fix_url_value(value);
 393     }
 394
 395     nsAString_InitDepend(&str_name, style_tbl[sid].name);
 396     nsAString_InitDepend(&str_value, val ? val : value);
 397     nsAString_InitDepend(&str_empty, emptyW);
 398
 399     nsres = nsIDOMCSSStyleDeclaration_SetProperty(nsstyle, &str_name, &str_value, &str_empty);
 400     if(NS_FAILED(nsres))
 401         ERR("SetProperty failed: %08x\n", nsres);
 402
 403     nsAString_Finish(&str_name);
 404     nsAString_Finish(&str_value);
 405     nsAString_Finish(&str_empty);
 406     heap_free(val);
 407
 408     return S_OK;
 409 }
 410
 411 static HRESULT var_to_styleval(const VARIANT *v, WCHAR *buf, DWORD flags, const WCHAR **ret)
 412 {
 413     switch(V_VT(v)) {
 414     case VT_NULL:
 415         *ret = emptyW;
 416         return S_OK;
 417
 418     case VT_BSTR:
 419         *ret = V_BSTR(v);
 420         return S_OK;
 421
 422     case VT_BSTR|VT_BYREF:
 423         *ret = *V_BSTRREF(v);
 424         return S_OK;
 425
 426     case VT_I4: {
 427         static const WCHAR formatW[] = {'%','d',0};
 428         static const WCHAR hex_formatW[] = {'#','%','0','6','x',0};
 429
 430         if(flags & ATTR_HEX_INT)
 431             wsprintfW(buf, hex_formatW, V_I4(v));
 432         else if(flags & ATTR_FIX_PX)
 433             wsprintfW(buf, px_formatW, V_I4(v));
 434         else
 435             wsprintfW(buf, formatW, V_I4(v));
 436
 437         *ret = buf;
 438         return S_OK;
 439     }
 440     default:
 441         FIXME("not implemented for %s\n", debugstr_variant(v));
 442         return E_NOTIMPL;
 443
 444     }
 445 }
 446
 447 HRESULT set_nsstyle_attr_var(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, VARIANT *value, DWORD flags)
 448 {
 449     const WCHAR *val;
 450     WCHAR buf[14];
 451     HRESULT hres;
 452
 453     hres = var_to_styleval(value, buf, flags, &val);
 454     if(FAILED(hres))
 455         return hres;
 456
 457     return set_nsstyle_attr(nsstyle, sid, val, flags);
 458 }
 459
 460 static inline HRESULT set_style_attr(HTMLStyle *This, styleid_t sid, LPCWSTR value, DWORD flags)
 461 {
 462     return set_nsstyle_attr(This->nsstyle, sid, value, flags);
 463 }
 464
 465 static HRESULT get_nsstyle_attr_nsval(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, nsAString *value)
 466 {
 467     nsAString str_name;
 468     nsresult nsres;
 469
 470     nsAString_InitDepend(&str_name, style_tbl[sid].name);
 471
 472     nsres = nsIDOMCSSStyleDeclaration_GetPropertyValue(nsstyle, &str_name, value);
 473     if(NS_FAILED(nsres)) {
 474         ERR("SetProperty failed: %08x\n", nsres);
 475         return E_FAIL;
 476     }
 477
 478     nsAString_Finish(&str_name);
 479
 480     return NS_OK;
 481 }
 482
 483 static HRESULT nsstyle_to_bstr(const WCHAR *val, DWORD flags, BSTR *p)
 484 {
 485     BSTR ret;
 486     DWORD len;
 487
 488     if(!*val) {
 489         *p = (flags & ATTR_NO_NULL) ? SysAllocStringLen(NULL, 0) : NULL;
 490         return S_OK;
 491     }
 492
 493     ret = SysAllocString(val);
 494     if(!ret)
 495         return E_OUTOFMEMORY;
 496
 497     len = SysStringLen(ret);
 498
 499     if(flags & ATTR_REMOVE_COMMA) {
 500         DWORD new_len = len;
 501         WCHAR *ptr, *ptr2;
 502
 503         for(ptr = ret; (ptr = strchrW(ptr, ',')); ptr++)
 504             new_len--;
 505
 506         if(new_len != len) {
 507             BSTR new_ret;
 508
 509             new_ret = SysAllocStringLen(NULL, new_len);
 510             if(!new_ret) {
 511                 SysFreeString(ret);
 512                 return E_OUTOFMEMORY;
 513             }
 514
 515             for(ptr2 = new_ret, ptr = ret; *ptr; ptr++) {
 516                 if(*ptr != ',')
 517                     *ptr2++ = *ptr;
 518             }
 519
 520             SysFreeString(ret);
 521             ret = new_ret;
 522         }
 523     }
 524
 525     *p = ret;
 526     return S_OK;
 527 }
 528
 529 HRESULT get_nsstyle_attr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, BSTR *p, DWORD flags)
 530 {
 531     nsAString str_value;
 532     const PRUnichar *value;
 533     HRESULT hres;
 534
 535     nsAString_Init(&str_value, NULL);
 536
 537     get_nsstyle_attr_nsval(nsstyle, sid, &str_value);
 538
 539     nsAString_GetData(&str_value, &value);
 540     hres = nsstyle_to_bstr(value, flags, p);
 541     nsAString_Finish(&str_value);
 542
 543     TRACE("%s -> %s\n", debugstr_w(style_tbl[sid].name), debugstr_w(*p));
 544     return hres;
 545 }
 546
 547 HRESULT get_nsstyle_attr_var(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, VARIANT *p, DWORD flags)
 548 {
 549     nsAString str_value;
 550     const PRUnichar *value;
 551     BOOL set = FALSE;
 552     HRESULT hres = S_OK;
 553
 554     nsAString_Init(&str_value, NULL);
 555
 556     get_nsstyle_attr_nsval(nsstyle, sid, &str_value);
 557
 558     nsAString_GetData(&str_value, &value);
 559
 560     if(flags & ATTR_STR_TO_INT) {
 561         const PRUnichar *ptr = value;
 562         BOOL neg = FALSE;
 563         INT i = 0;
 564
 565         if(*ptr == '-') {
 566             neg = TRUE;
 567             ptr++;
 568         }
 569
 570         while(isdigitW(*ptr))
 571             i = i*10 + (*ptr++ - '0');
 572
 573         if(!*ptr) {
 574             V_VT(p) = VT_I4;
 575             V_I4(p) = neg ? -i : i;
 576             set = TRUE;
 577         }
 578     }
 579
 580     if(!set) {
 581         BSTR str;
 582
 583         hres = nsstyle_to_bstr(value, flags, &str);
 584         if(SUCCEEDED(hres)) {
 585             V_VT(p) = VT_BSTR;
 586             V_BSTR(p) = str;
 587         }
 588     }
 589
 590     nsAString_Finish(&str_value);
 591
 592     TRACE("%s -> %s\n", debugstr_w(style_tbl[sid].name), debugstr_variant(p));
 593     return S_OK;
 594 }
 595
 596 static inline HRESULT get_style_attr(HTMLStyle *This, styleid_t sid, BSTR *p)
 597 {
 598     return get_nsstyle_attr(This->nsstyle, sid, p, 0);
 599 }
 600
 601 static HRESULT check_style_attr_value(HTMLStyle *This, styleid_t sid, LPCWSTR exval, VARIANT_BOOL *p)
 602 {
 603     nsAString str_value;
 604     const PRUnichar *value;
 605
 606     nsAString_Init(&str_value, NULL);
 607
 608     get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
 609
 610     nsAString_GetData(&str_value, &value);
 611     *p = strcmpW(value, exval) ? VARIANT_FALSE : VARIANT_TRUE;
 612     nsAString_Finish(&str_value);
 613
 614     TRACE("%s -> %x\n", debugstr_w(style_tbl[sid].name), *p);
 615     return S_OK;
 616 }
 617
 618 static inline HRESULT set_style_pos(HTMLStyle *This, styleid_t sid, float value)
 619 {
 620     WCHAR szValue[25];
 621     WCHAR szFormat[] = {'%','.','0','f','p','x',0};
 622
 623     value = floor(value);
 624
 625     sprintfW(szValue, szFormat, value);
 626
 627     return set_style_attr(This, sid, szValue, 0);
 628 }
 629
 630 static HRESULT set_style_pxattr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, LONG value)
 631 {
 632     WCHAR value_str[16];
 633
 634     sprintfW(value_str, px_formatW, value);
 635
 636     return set_nsstyle_attr(nsstyle, sid, value_str, 0);
 637 }
 638
 639 static HRESULT get_nsstyle_pos(HTMLStyle *This, styleid_t sid, float *p)
 640 {
 641     nsAString str_value;
 642     HRESULT hres;
 643
 644     TRACE("%p %d %p\n", This, sid, p);
 645
 646     *p = 0.0f;
 647
 648     nsAString_Init(&str_value, NULL);
 649
 650     hres = get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
 651     if(hres == S_OK)
 652     {
 653         WCHAR *ptr;
 654         const PRUnichar *value;
 655
 656         nsAString_GetData(&str_value, &value);
 657         if(value)
 658         {
 659             *p = strtolW(value, &ptr, 10);
 660
 661             if(*ptr && strcmpW(ptr, pxW))
 662             {
 663                 nsAString_Finish(&str_value);
 664                 FIXME("only px values are currently supported\n");
 665                 hres = E_FAIL;
 666             }
 667         }
 668     }
 669
 670     TRACE("ret %f\n", *p);
 671
 672     nsAString_Finish(&str_value);
 673     return hres;
 674 }
 675
 676 static HRESULT get_nsstyle_pixel_val(HTMLStyle *This, styleid_t sid, LONG *p)
 677 {
 678     nsAString str_value;
 679     HRESULT hres;
 680
 681     if(!p)
 682         return E_POINTER;
 683
 684     nsAString_Init(&str_value, NULL);
 685
 686     hres = get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
 687     if(hres == S_OK) {
 688         WCHAR *ptr;
 689         const PRUnichar *value;
 690
 691         nsAString_GetData(&str_value, &value);
 692         if(value) {
 693             *p = strtolW(value, &ptr, 10);
 694
 695             if(*ptr == '.') {
 696                 /* Skip all digits. We have tests showing that we should not round the value. */
 697                 while(isdigitW(*++ptr));
 698             }
 699
 700             if(*ptr && strcmpW(ptr, pxW)) {
 701                 nsAString_Finish(&str_value);
 702                 FIXME("%s: only px values are currently supported\n", debugstr_w(value));
 703                 hres = E_NOTIMPL;
 704             }
 705         }else {
 706             *p = 0;
 707         }
 708     }
 709
 710     nsAString_Finish(&str_value);
 711     return hres;
 712 }
 713
 714 static BOOL is_valid_border_style(BSTR v)
 715 {
 716     static const WCHAR styleDotted[] = {'d','o','t','t','e','d',0};
 717     static const WCHAR styleDashed[] = {'d','a','s','h','e','d',0};
 718     static const WCHAR styleSolid[]  = {'s','o','l','i','d',0};
 719     static const WCHAR styleDouble[] = {'d','o','u','b','l','e',0};
 720     static const WCHAR styleGroove[] = {'g','r','o','o','v','e',0};
 721     static const WCHAR styleRidge[]  = {'r','i','d','g','e',0};
 722     static const WCHAR styleInset[]  = {'i','n','s','e','t',0};
 723     static const WCHAR styleOutset[] = {'o','u','t','s','e','t',0};
 724
 725     TRACE("%s\n", debugstr_w(v));
 726
 727     if(!v || strcmpiW(v, styleNone)   == 0 || strcmpiW(v, styleDotted) == 0 ||
 728              strcmpiW(v, styleDashed) == 0 || strcmpiW(v, styleSolid)  == 0 ||
 729              strcmpiW(v, styleDouble) == 0 || strcmpiW(v, styleGroove) == 0 ||
 730              strcmpiW(v, styleRidge)  == 0 || strcmpiW(v, styleInset)  == 0 ||
 731              strcmpiW(v, styleOutset) == 0 )
 732     {
 733         return TRUE;
 734     }
 735
 736     return FALSE;
 737 }
 738
 739 static inline HTMLStyle *impl_from_IHTMLStyle(IHTMLStyle *iface)
 740 {
 741     return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle_iface);
 742 }
 743
 744 static HRESULT WINAPI HTMLStyle_QueryInterface(IHTMLStyle *iface, REFIID riid, void **ppv)
 745 {
 746     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 747
 748     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 749
 750     if(IsEqualGUID(&IID_IUnknown, riid)) {
 751         *ppv = &This->IHTMLStyle_iface;
 752     }else if(IsEqualGUID(&IID_IHTMLStyle, riid)) {
 753         *ppv = &This->IHTMLStyle_iface;
 754     }else if(IsEqualGUID(&IID_IHTMLStyle2, riid)) {
 755         *ppv = &This->IHTMLStyle2_iface;
 756     }else if(IsEqualGUID(&IID_IHTMLStyle3, riid)) {
 757         *ppv = &This->IHTMLStyle3_iface;
 758     }else if(IsEqualGUID(&IID_IHTMLStyle4, riid)) {
 759         *ppv = &This->IHTMLStyle4_iface;
 760     }else if(IsEqualGUID(&IID_IHTMLStyle5, riid)) {
 761         *ppv = &This->IHTMLStyle5_iface;
 762     }else if(IsEqualGUID(&IID_IHTMLStyle6, riid)) {
 763         *ppv = &This->IHTMLStyle6_iface;
 764     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 765         return *ppv ? S_OK : E_NOINTERFACE;
 766     }else {
 767         *ppv = NULL;
 768         WARN("unsupported iface %s\n", debugstr_mshtml_guid(riid));
 769         return E_NOINTERFACE;
 770     }
 771
 772     IUnknown_AddRef((IUnknown*)*ppv);
 773     return S_OK;
 774 }
 775
 776 static ULONG WINAPI HTMLStyle_AddRef(IHTMLStyle *iface)
 777 {
 778     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 779     LONG ref = InterlockedIncrement(&This->ref);
 780
 781     TRACE("(%p) ref=%d\n", This, ref);
 782
 783     return ref;
 784 }
 785
 786 static ULONG WINAPI HTMLStyle_Release(IHTMLStyle *iface)
 787 {
 788     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 789     LONG ref = InterlockedDecrement(&This->ref);
 790
 791     TRACE("(%p) ref=%d\n", This, ref);
 792
 793     if(!ref) {
 794         assert(!This->elem);
 795         if(This->nsstyle)
 796             nsIDOMCSSStyleDeclaration_Release(This->nsstyle);
 797         release_dispex(&This->dispex);
 798         heap_free(This);
 799     }
 800
 801     return ref;
 802 }
 803
 804 static HRESULT WINAPI HTMLStyle_GetTypeInfoCount(IHTMLStyle *iface, UINT *pctinfo)
 805 {
 806     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 807     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 808 }
 809
 810 static HRESULT WINAPI HTMLStyle_GetTypeInfo(IHTMLStyle *iface, UINT iTInfo,
 811                                               LCID lcid, ITypeInfo **ppTInfo)
 812 {
 813     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 814     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 815 }
 816
 817 static HRESULT WINAPI HTMLStyle_GetIDsOfNames(IHTMLStyle *iface, REFIID riid,
 818                                                 LPOLESTR *rgszNames, UINT cNames,
 819                                                 LCID lcid, DISPID *rgDispId)
 820 {
 821     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 822     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 823             lcid, rgDispId);
 824 }
 825
 826 static HRESULT WINAPI HTMLStyle_Invoke(IHTMLStyle *iface, DISPID dispIdMember,
 827                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 828                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 829 {
 830     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 831     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 832             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 833 }
 834
 835 static HRESULT WINAPI HTMLStyle_put_fontFamily(IHTMLStyle *iface, BSTR v)
 836 {
 837     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 838
 839     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 840
 841     return set_style_attr(This, STYLEID_FONT_FAMILY, v, 0);
 842 }
 843
 844 static HRESULT WINAPI HTMLStyle_get_fontFamily(IHTMLStyle *iface, BSTR *p)
 845 {
 846     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 847
 848     TRACE("(%p)->(%p)\n", This, p);
 849
 850     return get_style_attr(This, STYLEID_FONT_FAMILY, p);
 851 }
 852
 853 static HRESULT WINAPI HTMLStyle_put_fontStyle(IHTMLStyle *iface, BSTR v)
 854 {
 855     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 856     static const WCHAR szItalic[]  = {'i','t','a','l','i','c',0};
 857     static const WCHAR szOblique[]  = {'o','b','l','i','q','u','e',0};
 858
 859     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 860
 861     /* fontStyle can only be one of the follow values. */
 862     if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szItalic, v) == 0 ||
 863              strcmpiW(szOblique, v) == 0)
 864     {
 865         return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_STYLE, v, 0);
 866     }
 867
 868     return E_INVALIDARG;
 869 }
 870
 871 static HRESULT WINAPI HTMLStyle_get_fontStyle(IHTMLStyle *iface, BSTR *p)
 872 {
 873     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 874
 875     TRACE("(%p)->(%p)\n", This, p);
 876
 877     return get_style_attr(This, STYLEID_FONT_STYLE, p);
 878 }
 879
 880 static HRESULT WINAPI HTMLStyle_put_fontVariant(IHTMLStyle *iface, BSTR v)
 881 {
 882     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 883     static const WCHAR szCaps[]  = {'s','m','a','l','l','-','c','a','p','s',0};
 884
 885     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 886
 887     /* fontVariant can only be one of the follow values. */
 888     if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szCaps, v) == 0)
 889     {
 890         return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_VARIANT, v, 0);
 891     }
 892
 893     return E_INVALIDARG;
 894 }
 895
 896 static HRESULT WINAPI HTMLStyle_get_fontVariant(IHTMLStyle *iface, BSTR *p)
 897 {
 898     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 899     TRACE("(%p)->(%p)\n", This, p);
 900
 901     if(!p)
 902        return E_INVALIDARG;
 903
 904     return get_style_attr(This, STYLEID_FONT_VARIANT, p);
 905 }
 906
 907 static HRESULT WINAPI HTMLStyle_put_fontWeight(IHTMLStyle *iface, BSTR v)
 908 {
 909     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 910     static const WCHAR styleBold[] = {'b','o','l','d',0};
 911     static const WCHAR styleBolder[] = {'b','o','l','d','e','r',0};
 912     static const WCHAR styleLighter[]  = {'l','i','g','h','t','e','r',0};
 913     static const WCHAR style100[] = {'1','0','0',0};
 914     static const WCHAR style200[] = {'2','0','0',0};
 915     static const WCHAR style300[] = {'3','0','0',0};
 916     static const WCHAR style400[] = {'4','0','0',0};
 917     static const WCHAR style500[] = {'5','0','0',0};
 918     static const WCHAR style600[] = {'6','0','0',0};
 919     static const WCHAR style700[] = {'7','0','0',0};
 920     static const WCHAR style800[] = {'8','0','0',0};
 921     static const WCHAR style900[] = {'9','0','0',0};
 922
 923     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 924
 925     /* fontWeight can only be one of the following */
 926     if(v && *v && strcmpiW(szNormal, v) && strcmpiW(styleBold, v) &&  strcmpiW(styleBolder, v)
 927             && strcmpiW(styleLighter, v) && strcmpiW(style100, v) && strcmpiW(style200, v)
 928             && strcmpiW(style300, v) && strcmpiW(style400, v) && strcmpiW(style500, v) && strcmpiW(style600, v)
 929             && strcmpiW(style700, v) && strcmpiW(style800, v) && strcmpiW(style900, v))
 930         return E_INVALIDARG;
 931
 932     return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_WEIGHT, v, 0);
 933 }
 934
 935 static HRESULT WINAPI HTMLStyle_get_fontWeight(IHTMLStyle *iface, BSTR *p)
 936 {
 937     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 938
 939     TRACE("(%p)->(%p)\n", This, p);
 940
 941     return get_style_attr(This, STYLEID_FONT_WEIGHT, p);
 942 }
 943
 944 static HRESULT WINAPI HTMLStyle_put_fontSize(IHTMLStyle *iface, VARIANT v)
 945 {
 946     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 947
 948     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 949
 950     return set_nsstyle_attr_var(This->nsstyle, STYLEID_FONT_SIZE, &v, ATTR_FIX_PX);
 951 }
 952
 953 static HRESULT WINAPI HTMLStyle_get_fontSize(IHTMLStyle *iface, VARIANT *p)
 954 {
 955     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 956
 957     TRACE("(%p)->(%p)\n", This, p);
 958
 959     return get_nsstyle_attr_var(This->nsstyle, STYLEID_FONT_SIZE, p, 0);
 960 }
 961
 962 static HRESULT WINAPI HTMLStyle_put_font(IHTMLStyle *iface, BSTR v)
 963 {
 964     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 965     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI HTMLStyle_get_font(IHTMLStyle *iface, BSTR *p)
 970 {
 971     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 972     FIXME("(%p)->(%p)\n", This, p);
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI HTMLStyle_put_color(IHTMLStyle *iface, VARIANT v)
 977 {
 978     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 979
 980     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 981
 982     return set_nsstyle_attr_var(This->nsstyle, STYLEID_COLOR, &v, ATTR_HEX_INT);
 983 }
 984
 985 static HRESULT WINAPI HTMLStyle_get_color(IHTMLStyle *iface, VARIANT *p)
 986 {
 987     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 988
 989     TRACE("(%p)->(%p)\n", This, p);
 990
 991     return get_nsstyle_attr_var(This->nsstyle, STYLEID_COLOR, p, 0);
 992 }
 993
 994 static HRESULT WINAPI HTMLStyle_put_background(IHTMLStyle *iface, BSTR v)
 995 {
 996     HTMLStyle *This = impl_from_IHTMLStyle(iface);
 997
 998     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 999
1000     return set_style_attr(This, STYLEID_BACKGROUND, v, 0);
1001 }
1002
1003 static HRESULT WINAPI HTMLStyle_get_background(IHTMLStyle *iface, BSTR *p)
1004 {
1005     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1006
1007     TRACE("(%p)->(%p)\n", This, p);
1008
1009     return get_style_attr(This, STYLEID_BACKGROUND, p);
1010 }
1011
1012 static HRESULT WINAPI HTMLStyle_put_backgroundColor(IHTMLStyle *iface, VARIANT v)
1013 {
1014     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1015
1016     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1017
1018     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BACKGROUND_COLOR, &v, ATTR_HEX_INT);
1019 }
1020
1021 static HRESULT WINAPI HTMLStyle_get_backgroundColor(IHTMLStyle *iface, VARIANT *p)
1022 {
1023     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1024
1025     TRACE("(%p)->(%p)\n", This, p);
1026
1027     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BACKGROUND_COLOR, p, 0);
1028 }
1029
1030 static HRESULT WINAPI HTMLStyle_put_backgroundImage(IHTMLStyle *iface, BSTR v)
1031 {
1032     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1033
1034     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1035
1036     return set_style_attr(This, STYLEID_BACKGROUND_IMAGE, v, ATTR_FIX_URL);
1037 }
1038
1039 static HRESULT WINAPI HTMLStyle_get_backgroundImage(IHTMLStyle *iface, BSTR *p)
1040 {
1041     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1042
1043     TRACE("(%p)->(%p)\n", This, p);
1044
1045     return get_style_attr(This, STYLEID_BACKGROUND_IMAGE, p);
1046 }
1047
1048 static HRESULT WINAPI HTMLStyle_put_backgroundRepeat(IHTMLStyle *iface, BSTR v)
1049 {
1050     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1051     static const WCHAR styleRepeat[]   = {'r','e','p','e','a','t',0};
1052     static const WCHAR styleNoRepeat[] = {'n','o','-','r','e','p','e','a','t',0};
1053     static const WCHAR styleRepeatX[]  = {'r','e','p','e','a','t','-','x',0};
1054     static const WCHAR styleRepeatY[]  = {'r','e','p','e','a','t','-','y',0};
1055
1056     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1057
1058     /* fontWeight can only be one of the following */
1059     if(!v || strcmpiW(styleRepeat, v) == 0    || strcmpiW(styleNoRepeat, v) == 0    ||
1060              strcmpiW(styleRepeatX, v) == 0 || strcmpiW(styleRepeatY, v) == 0 )
1061     {
1062         return set_style_attr(This, STYLEID_BACKGROUND_REPEAT , v, 0);
1063     }
1064
1065     return E_INVALIDARG;
1066 }
1067
1068 static HRESULT WINAPI HTMLStyle_get_backgroundRepeat(IHTMLStyle *iface, BSTR *p)
1069 {
1070     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1071
1072     TRACE("(%p)->(%p)\n", This, p);
1073
1074     return get_style_attr(This, STYLEID_BACKGROUND_REPEAT, p);
1075 }
1076
1077 static HRESULT WINAPI HTMLStyle_put_backgroundAttachment(IHTMLStyle *iface, BSTR v)
1078 {
1079     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1080
1081     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1082
1083     return set_style_attr(This, STYLEID_BACKGROUND_ATTACHMENT, v, 0);
1084 }
1085
1086 static HRESULT WINAPI HTMLStyle_get_backgroundAttachment(IHTMLStyle *iface, BSTR *p)
1087 {
1088     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1089
1090     TRACE("(%p)->(%p)\n", This, p);
1091
1092     return get_style_attr(This, STYLEID_BACKGROUND_ATTACHMENT, p);
1093 }
1094
1095 static HRESULT WINAPI HTMLStyle_put_backgroundPosition(IHTMLStyle *iface, BSTR v)
1096 {
1097     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1098
1099     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1100
1101     return set_style_attr(This, STYLEID_BACKGROUND_POSITION, v, 0);
1102 }
1103
1104 static HRESULT WINAPI HTMLStyle_get_backgroundPosition(IHTMLStyle *iface, BSTR *p)
1105 {
1106     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1107
1108     TRACE("(%p)->(%p)\n", This, p);
1109
1110     return get_style_attr(This, STYLEID_BACKGROUND_POSITION, p);
1111 }
1112
1113 static HRESULT WINAPI HTMLStyle_put_backgroundPositionX(IHTMLStyle *iface, VARIANT v)
1114 {
1115     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1116     WCHAR buf[14], *pos_val;
1117     nsAString pos_str;
1118     const WCHAR *val;
1119     DWORD val_len;
1120     HRESULT hres;
1121
1122     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1123
1124     hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1125     if(FAILED(hres))
1126         return hres;
1127
1128     val_len = val ? strlenW(val) : 0;
1129
1130     nsAString_Init(&pos_str, NULL);
1131     hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1132     if(SUCCEEDED(hres)) {
1133         const PRUnichar *pos, *posy;
1134         DWORD posy_len;
1135
1136         nsAString_GetData(&pos_str, &pos);
1137         posy = strchrW(pos, ' ');
1138         if(!posy) {
1139             static const WCHAR zero_pxW[] = {' ','0','p','x',0};
1140
1141             TRACE("no space in %s\n", debugstr_w(pos));
1142             posy = zero_pxW;
1143         }
1144
1145         posy_len = strlenW(posy);
1146         pos_val = heap_alloc((val_len+posy_len+1)*sizeof(WCHAR));
1147         if(pos_val) {
1148             if(val_len)
1149                 memcpy(pos_val, val, val_len*sizeof(WCHAR));
1150             if(posy_len)
1151                 memcpy(pos_val+val_len, posy, posy_len*sizeof(WCHAR));
1152             pos_val[val_len+posy_len] = 0;
1153         }else {
1154             hres = E_OUTOFMEMORY;
1155         }
1156     }
1157     nsAString_Finish(&pos_str);
1158     if(FAILED(hres))
1159         return hres;
1160
1161     TRACE("setting position to %s\n", debugstr_w(pos_val));
1162     hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1163     heap_free(pos_val);
1164     return hres;
1165 }
1166
1167 static HRESULT WINAPI HTMLStyle_get_backgroundPositionX(IHTMLStyle *iface, VARIANT *p)
1168 {
1169     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1170     nsAString pos_str;
1171     BSTR ret;
1172     HRESULT hres;
1173
1174     TRACE("(%p)->(%p)\n", This, p);
1175
1176     nsAString_Init(&pos_str, NULL);
1177     hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1178     if(SUCCEEDED(hres)) {
1179         const PRUnichar *pos, *space;
1180
1181         nsAString_GetData(&pos_str, &pos);
1182         space = strchrW(pos, ' ');
1183         if(!space) {
1184             WARN("no space in %s\n", debugstr_w(pos));
1185             space = pos + strlenW(pos);
1186         }
1187
1188         if(space != pos) {
1189             ret = SysAllocStringLen(pos, space-pos);
1190             if(!ret)
1191                 hres = E_OUTOFMEMORY;
1192         }else {
1193             ret = NULL;
1194         }
1195     }
1196     nsAString_Finish(&pos_str);
1197     if(FAILED(hres))
1198         return hres;
1199
1200     TRACE("returning %s\n", debugstr_w(ret));
1201     V_VT(p) = VT_BSTR;
1202     V_BSTR(p) = ret;
1203     return S_OK;
1204 }
1205
1206 static HRESULT WINAPI HTMLStyle_put_backgroundPositionY(IHTMLStyle *iface, VARIANT v)
1207 {
1208     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1209     WCHAR buf[14], *pos_val;
1210     nsAString pos_str;
1211     const WCHAR *val;
1212     DWORD val_len;
1213     HRESULT hres;
1214
1215     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1216
1217     hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1218     if(FAILED(hres))
1219         return hres;
1220
1221     val_len = val ? strlenW(val) : 0;
1222
1223     nsAString_Init(&pos_str, NULL);
1224     hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1225     if(SUCCEEDED(hres)) {
1226         const PRUnichar *pos, *space;
1227         DWORD posx_len;
1228
1229         nsAString_GetData(&pos_str, &pos);
1230         space = strchrW(pos, ' ');
1231         if(space) {
1232             space++;
1233         }else {
1234             static const WCHAR zero_pxW[] = {'0','p','x',' ',0};
1235
1236             TRACE("no space in %s\n", debugstr_w(pos));
1237             pos = zero_pxW;
1238             space = pos + sizeof(zero_pxW)/sizeof(WCHAR)-1;
1239         }
1240
1241         posx_len = space-pos;
1242
1243         pos_val = heap_alloc((posx_len+val_len+1)*sizeof(WCHAR));
1244         if(pos_val) {
1245             memcpy(pos_val, pos, posx_len*sizeof(WCHAR));
1246             if(val_len)
1247                 memcpy(pos_val+posx_len, val, val_len*sizeof(WCHAR));
1248             pos_val[posx_len+val_len] = 0;
1249         }else {
1250             hres = E_OUTOFMEMORY;
1251         }
1252     }
1253     nsAString_Finish(&pos_str);
1254     if(FAILED(hres))
1255         return hres;
1256
1257     TRACE("setting position to %s\n", debugstr_w(pos_val));
1258     hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1259     heap_free(pos_val);
1260     return hres;
1261 }
1262
1263 static HRESULT WINAPI HTMLStyle_get_backgroundPositionY(IHTMLStyle *iface, VARIANT *p)
1264 {
1265     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1266     nsAString pos_str;
1267     BSTR ret;
1268     HRESULT hres;
1269
1270     TRACE("(%p)->(%p)\n", This, p);
1271
1272     nsAString_Init(&pos_str, NULL);
1273     hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1274     if(SUCCEEDED(hres)) {
1275         const PRUnichar *pos, *posy;
1276
1277         nsAString_GetData(&pos_str, &pos);
1278         posy = strchrW(pos, ' ');
1279         if(posy) {
1280             ret = SysAllocString(posy+1);
1281             if(!ret)
1282                 hres = E_OUTOFMEMORY;
1283         }else {
1284             ret = NULL;
1285         }
1286     }
1287     nsAString_Finish(&pos_str);
1288     if(FAILED(hres))
1289         return hres;
1290
1291     TRACE("returning %s\n", debugstr_w(ret));
1292     V_VT(p) = VT_BSTR;
1293     V_BSTR(p) = ret;
1294     return S_OK;
1295 }
1296
1297 static HRESULT WINAPI HTMLStyle_put_wordSpacing(IHTMLStyle *iface, VARIANT v)
1298 {
1299     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1300
1301     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1302
1303     return set_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, &v, 0);
1304 }
1305
1306 static HRESULT WINAPI HTMLStyle_get_wordSpacing(IHTMLStyle *iface, VARIANT *p)
1307 {
1308     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1309     TRACE("(%p)->(%p)\n", This, p);
1310     return get_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, p, 0);
1311 }
1312
1313 static HRESULT WINAPI HTMLStyle_put_letterSpacing(IHTMLStyle *iface, VARIANT v)
1314 {
1315     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1316
1317     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1318
1319     return set_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, &v, 0);
1320 }
1321
1322 static HRESULT WINAPI HTMLStyle_get_letterSpacing(IHTMLStyle *iface, VARIANT *p)
1323 {
1324     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1325     TRACE("(%p)->(%p)\n", This, p);
1326     return get_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, p, 0);
1327 }
1328
1329 static HRESULT WINAPI HTMLStyle_put_textDecoration(IHTMLStyle *iface, BSTR v)
1330 {
1331     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1332
1333     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1334
1335     /* textDecoration can only be one of the following */
1336     if(!v || strcmpiW(styleNone, v)   == 0 || strcmpiW(valUnderline, v)   == 0 ||
1337              strcmpiW(valOverline, v) == 0 || strcmpiW(valLineThrough, v) == 0 ||
1338              strcmpiW(valBlink, v)    == 0)
1339     {
1340         return set_style_attr(This, STYLEID_TEXT_DECORATION , v, 0);
1341     }
1342
1343     return E_INVALIDARG;
1344 }
1345
1346 static HRESULT WINAPI HTMLStyle_get_textDecoration(IHTMLStyle *iface, BSTR *p)
1347 {
1348     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1349
1350     TRACE("(%p)->(%p)\n", This, p);
1351
1352     return get_style_attr(This, STYLEID_TEXT_DECORATION, p);
1353 }
1354
1355 static HRESULT WINAPI HTMLStyle_put_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL v)
1356 {
1357     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1358
1359     TRACE("(%p)->(%x)\n", This, v);
1360
1361     return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? styleNone : emptyW, 0);
1362 }
1363
1364 static HRESULT WINAPI HTMLStyle_get_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL *p)
1365 {
1366     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1367
1368     TRACE("(%p)->(%p)\n", This, p);
1369
1370     return check_style_attr_value(This, STYLEID_TEXT_DECORATION, styleNone, p);
1371 }
1372
1373 static HRESULT WINAPI HTMLStyle_put_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL v)
1374 {
1375     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1376
1377     TRACE("(%p)->(%x)\n", This, v);
1378
1379     return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valUnderline : emptyW, 0);
1380 }
1381
1382 static HRESULT WINAPI HTMLStyle_get_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL *p)
1383 {
1384     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1385
1386     TRACE("(%p)->(%p)\n", This, p);
1387
1388     return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valUnderline, p);
1389 }
1390
1391 static HRESULT WINAPI HTMLStyle_put_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL v)
1392 {
1393     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1394
1395     TRACE("(%p)->(%x)\n", This, v);
1396
1397     return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valOverline : emptyW, 0);
1398 }
1399
1400 static HRESULT WINAPI HTMLStyle_get_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL *p)
1401 {
1402     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1403
1404     TRACE("(%p)->(%p)\n", This, p);
1405
1406     return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valOverline, p);
1407 }
1408
1409 static HRESULT WINAPI HTMLStyle_put_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL v)
1410 {
1411     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1412
1413     TRACE("(%p)->(%x)\n", This, v);
1414
1415     return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valLineThrough : emptyW, 0);
1416 }
1417
1418 static HRESULT WINAPI HTMLStyle_get_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL *p)
1419 {
1420     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1421
1422     TRACE("(%p)->(%p)\n", This, p);
1423
1424     return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valLineThrough, p);
1425 }
1426
1427 static HRESULT WINAPI HTMLStyle_put_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL v)
1428 {
1429     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1430
1431     TRACE("(%p)->(%x)\n", This, v);
1432
1433     return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valBlink : emptyW, 0);
1434 }
1435
1436 static HRESULT WINAPI HTMLStyle_get_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL *p)
1437 {
1438     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1439
1440     TRACE("(%p)->(%p)\n", This, p);
1441
1442     return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valBlink, p);
1443 }
1444
1445 static HRESULT WINAPI HTMLStyle_put_verticalAlign(IHTMLStyle *iface, VARIANT v)
1446 {
1447     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1448
1449     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1450
1451     return set_nsstyle_attr_var(This->nsstyle, STYLEID_VERTICAL_ALIGN, &v, ATTR_FIX_PX);
1452 }
1453
1454 static HRESULT WINAPI HTMLStyle_get_verticalAlign(IHTMLStyle *iface, VARIANT *p)
1455 {
1456     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1457
1458     TRACE("(%p)->(%p)\n", This, p);
1459
1460     return get_nsstyle_attr_var(This->nsstyle, STYLEID_VERTICAL_ALIGN, p, 0);
1461 }
1462
1463 static HRESULT WINAPI HTMLStyle_put_textTransform(IHTMLStyle *iface, BSTR v)
1464 {
1465     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1466
1467     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1468
1469     return set_style_attr(This, STYLEID_TEXT_TRANSFORM, v, 0);
1470 }
1471
1472 static HRESULT WINAPI HTMLStyle_get_textTransform(IHTMLStyle *iface, BSTR *p)
1473 {
1474     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1475
1476     TRACE("(%p)->(%p)\n", This, p);
1477
1478     return get_style_attr(This, STYLEID_TEXT_TRANSFORM, p);
1479 }
1480
1481 static HRESULT WINAPI HTMLStyle_put_textAlign(IHTMLStyle *iface, BSTR v)
1482 {
1483     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1484
1485     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1486
1487     return set_style_attr(This, STYLEID_TEXT_ALIGN, v, 0);
1488 }
1489
1490 static HRESULT WINAPI HTMLStyle_get_textAlign(IHTMLStyle *iface, BSTR *p)
1491 {
1492     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1493
1494     TRACE("(%p)->(%p)\n", This, p);
1495
1496     return get_style_attr(This, STYLEID_TEXT_ALIGN, p);
1497 }
1498
1499 static HRESULT WINAPI HTMLStyle_put_textIndent(IHTMLStyle *iface, VARIANT v)
1500 {
1501     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1502
1503     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1504
1505     return set_nsstyle_attr_var(This->nsstyle, STYLEID_TEXT_INDENT, &v, ATTR_FIX_PX);
1506 }
1507
1508 static HRESULT WINAPI HTMLStyle_get_textIndent(IHTMLStyle *iface, VARIANT *p)
1509 {
1510     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1511
1512     TRACE("(%p)->(%p)\n", This, p);
1513
1514     return get_nsstyle_attr_var(This->nsstyle, STYLEID_TEXT_INDENT, p, 0);
1515 }
1516
1517 static HRESULT WINAPI HTMLStyle_put_lineHeight(IHTMLStyle *iface, VARIANT v)
1518 {
1519     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1520
1521     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1522
1523     return set_nsstyle_attr_var(This->nsstyle, STYLEID_LINE_HEIGHT, &v, 0);
1524 }
1525
1526 static HRESULT WINAPI HTMLStyle_get_lineHeight(IHTMLStyle *iface, VARIANT *p)
1527 {
1528     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1529
1530     TRACE("(%p)->(%p)\n", This, p);
1531
1532     return get_nsstyle_attr_var(This->nsstyle, STYLEID_LINE_HEIGHT, p, 0);
1533 }
1534
1535 static HRESULT WINAPI HTMLStyle_put_marginTop(IHTMLStyle *iface, VARIANT v)
1536 {
1537     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1538
1539     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1540
1541     return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, &v, ATTR_FIX_PX);
1542 }
1543
1544 static HRESULT WINAPI HTMLStyle_get_marginTop(IHTMLStyle *iface, VARIANT *p)
1545 {
1546     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1547
1548     TRACE("(%p)->(%p)\n", This, p);
1549
1550     return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, p, 0);
1551 }
1552
1553 static HRESULT WINAPI HTMLStyle_put_marginRight(IHTMLStyle *iface, VARIANT v)
1554 {
1555     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1556
1557     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1558
1559     return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, &v, ATTR_FIX_PX);
1560 }
1561
1562 static HRESULT WINAPI HTMLStyle_get_marginRight(IHTMLStyle *iface, VARIANT *p)
1563 {
1564     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1565     TRACE("(%p)->(%p)\n", This, p);
1566     return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, p, 0);
1567 }
1568
1569 static HRESULT WINAPI HTMLStyle_put_marginBottom(IHTMLStyle *iface, VARIANT v)
1570 {
1571     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1572
1573     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1574
1575     return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, &v, ATTR_FIX_PX);
1576 }
1577
1578 static HRESULT WINAPI HTMLStyle_get_marginBottom(IHTMLStyle *iface, VARIANT *p)
1579 {
1580     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1581
1582     TRACE("(%p)->(%p)\n", This, p);
1583
1584     return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, p, 0);
1585 }
1586
1587 static HRESULT WINAPI HTMLStyle_put_marginLeft(IHTMLStyle *iface, VARIANT v)
1588 {
1589     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1590
1591     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1592
1593     return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, &v, ATTR_FIX_PX);
1594 }
1595
1596 static HRESULT WINAPI HTMLStyle_put_margin(IHTMLStyle *iface, BSTR v)
1597 {
1598     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1599
1600     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1601
1602     return set_style_attr(This, STYLEID_MARGIN, v, 0);
1603 }
1604
1605 static HRESULT WINAPI HTMLStyle_get_margin(IHTMLStyle *iface, BSTR *p)
1606 {
1607     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1608
1609     TRACE("(%p)->(%p)\n", This, p);
1610
1611     return get_style_attr(This, STYLEID_MARGIN, p);
1612 }
1613
1614 static HRESULT WINAPI HTMLStyle_get_marginLeft(IHTMLStyle *iface, VARIANT *p)
1615 {
1616     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1617     TRACE("(%p)->(%p)\n", This, p);
1618     return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, p, 0);
1619 }
1620
1621 static HRESULT WINAPI HTMLStyle_put_paddingTop(IHTMLStyle *iface, VARIANT v)
1622 {
1623     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1624
1625     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1626
1627     return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, &v, ATTR_FIX_PX);
1628 }
1629
1630 static HRESULT WINAPI HTMLStyle_get_paddingTop(IHTMLStyle *iface, VARIANT *p)
1631 {
1632     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1633
1634     TRACE("(%p)->(%p)\n", This, p);
1635
1636     return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, p, 0);
1637 }
1638
1639 static HRESULT WINAPI HTMLStyle_put_paddingRight(IHTMLStyle *iface, VARIANT v)
1640 {
1641     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1642
1643     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1644
1645     return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, &v, ATTR_FIX_PX);
1646 }
1647
1648 static HRESULT WINAPI HTMLStyle_get_paddingRight(IHTMLStyle *iface, VARIANT *p)
1649 {
1650     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1651
1652     TRACE("(%p)->(%p)\n", This, p);
1653
1654     return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, p, 0);
1655 }
1656
1657 static HRESULT WINAPI HTMLStyle_put_paddingBottom(IHTMLStyle *iface, VARIANT v)
1658 {
1659     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1660
1661     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1662
1663     return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, &v, ATTR_FIX_PX);
1664 }
1665
1666 static HRESULT WINAPI HTMLStyle_get_paddingBottom(IHTMLStyle *iface, VARIANT *p)
1667 {
1668     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1669
1670     TRACE("(%p)->(%p)\n", This, p);
1671
1672     return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, p, 0);
1673 }
1674
1675 static HRESULT WINAPI HTMLStyle_put_paddingLeft(IHTMLStyle *iface, VARIANT v)
1676 {
1677     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1678
1679     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1680
1681     return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, &v, ATTR_FIX_PX);
1682 }
1683
1684 static HRESULT WINAPI HTMLStyle_get_paddingLeft(IHTMLStyle *iface, VARIANT *p)
1685 {
1686     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1687
1688     TRACE("(%p)->(%p)\n", This, p);
1689
1690     return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, p, 0);
1691 }
1692
1693 static HRESULT WINAPI HTMLStyle_put_padding(IHTMLStyle *iface, BSTR v)
1694 {
1695     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1696
1697     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1698
1699     return set_style_attr(This, STYLEID_PADDING, v, 0);
1700 }
1701
1702 static HRESULT WINAPI HTMLStyle_get_padding(IHTMLStyle *iface, BSTR *p)
1703 {
1704     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1705
1706     TRACE("(%p)->(%p)\n", This, p);
1707
1708     return get_style_attr(This, STYLEID_PADDING, p);
1709 }
1710
1711 static HRESULT WINAPI HTMLStyle_put_border(IHTMLStyle *iface, BSTR v)
1712 {
1713     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1714
1715     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1716
1717     return set_style_attr(This, STYLEID_BORDER, v, 0);
1718 }
1719
1720 static HRESULT WINAPI HTMLStyle_get_border(IHTMLStyle *iface, BSTR *p)
1721 {
1722     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1723
1724     TRACE("(%p)->(%p)\n", This, p);
1725
1726     return get_style_attr(This, STYLEID_BORDER, p);
1727 }
1728
1729 static HRESULT WINAPI HTMLStyle_put_borderTop(IHTMLStyle *iface, BSTR v)
1730 {
1731     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1732     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1733     return set_style_attr(This, STYLEID_BORDER_TOP, v, ATTR_FIX_PX);
1734 }
1735
1736 static HRESULT WINAPI HTMLStyle_get_borderTop(IHTMLStyle *iface, BSTR *p)
1737 {
1738     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1739     TRACE("(%p)->(%p)\n", This, p);
1740     return get_style_attr(This, STYLEID_BORDER_TOP, p);
1741 }
1742
1743 static HRESULT WINAPI HTMLStyle_put_borderRight(IHTMLStyle *iface, BSTR v)
1744 {
1745     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1746     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1747     return set_style_attr(This, STYLEID_BORDER_RIGHT, v, ATTR_FIX_PX);
1748 }
1749
1750 static HRESULT WINAPI HTMLStyle_get_borderRight(IHTMLStyle *iface, BSTR *p)
1751 {
1752     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1753     TRACE("(%p)->(%p)\n", This, p);
1754     return get_style_attr(This, STYLEID_BORDER_RIGHT, p);
1755 }
1756
1757 static HRESULT WINAPI HTMLStyle_put_borderBottom(IHTMLStyle *iface, BSTR v)
1758 {
1759     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1760     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1761     return set_style_attr(This, STYLEID_BORDER_BOTTOM, v, ATTR_FIX_PX);
1762 }
1763
1764 static HRESULT WINAPI HTMLStyle_get_borderBottom(IHTMLStyle *iface, BSTR *p)
1765 {
1766     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1767     TRACE("(%p)->(%p)\n", This, p);
1768     return get_style_attr(This, STYLEID_BORDER_BOTTOM, p);
1769 }
1770
1771 static HRESULT WINAPI HTMLStyle_put_borderLeft(IHTMLStyle *iface, BSTR v)
1772 {
1773     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1774
1775     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1776
1777     return set_style_attr(This, STYLEID_BORDER_LEFT, v, ATTR_FIX_PX);
1778 }
1779
1780 static HRESULT WINAPI HTMLStyle_get_borderLeft(IHTMLStyle *iface, BSTR *p)
1781 {
1782     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1783
1784     TRACE("(%p)->(%p)\n", This, p);
1785
1786     return get_style_attr(This, STYLEID_BORDER_LEFT, p);
1787 }
1788
1789 static HRESULT WINAPI HTMLStyle_put_borderColor(IHTMLStyle *iface, BSTR v)
1790 {
1791     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1792
1793     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1794
1795     return set_style_attr(This, STYLEID_BORDER_COLOR, v, 0);
1796 }
1797
1798 static HRESULT WINAPI HTMLStyle_get_borderColor(IHTMLStyle *iface, BSTR *p)
1799 {
1800     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1801
1802     TRACE("(%p)->(%p)\n", This, p);
1803
1804     return get_style_attr(This, STYLEID_BORDER_COLOR, p);
1805 }
1806
1807 static HRESULT WINAPI HTMLStyle_put_borderTopColor(IHTMLStyle *iface, VARIANT v)
1808 {
1809     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1810
1811     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1812
1813     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, &v, ATTR_HEX_INT);
1814 }
1815
1816 static HRESULT WINAPI HTMLStyle_get_borderTopColor(IHTMLStyle *iface, VARIANT *p)
1817 {
1818     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1819
1820     TRACE("(%p)->(%p)\n", This, p);
1821
1822     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, p, 0);
1823 }
1824
1825 static HRESULT WINAPI HTMLStyle_put_borderRightColor(IHTMLStyle *iface, VARIANT v)
1826 {
1827     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1828
1829     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1830
1831     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, &v, ATTR_HEX_INT);
1832 }
1833
1834 static HRESULT WINAPI HTMLStyle_get_borderRightColor(IHTMLStyle *iface, VARIANT *p)
1835 {
1836     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1837
1838     TRACE("(%p)->(%p)\n", This, p);
1839
1840     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, p, 0);
1841 }
1842
1843 static HRESULT WINAPI HTMLStyle_put_borderBottomColor(IHTMLStyle *iface, VARIANT v)
1844 {
1845     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1846
1847     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1848
1849     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, &v, ATTR_HEX_INT);
1850 }
1851
1852 static HRESULT WINAPI HTMLStyle_get_borderBottomColor(IHTMLStyle *iface, VARIANT *p)
1853 {
1854     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1855
1856     TRACE("(%p)->(%p)\n", This, p);
1857
1858     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, p, 0);
1859 }
1860
1861 static HRESULT WINAPI HTMLStyle_put_borderLeftColor(IHTMLStyle *iface, VARIANT v)
1862 {
1863     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1864
1865     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1866
1867     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, &v, ATTR_HEX_INT);
1868 }
1869
1870 static HRESULT WINAPI HTMLStyle_get_borderLeftColor(IHTMLStyle *iface, VARIANT *p)
1871 {
1872     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1873
1874     TRACE("(%p)->(%p)\n", This, p);
1875
1876     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, p, 0);
1877 }
1878
1879 static HRESULT WINAPI HTMLStyle_put_borderWidth(IHTMLStyle *iface, BSTR v)
1880 {
1881     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1882     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1883     return set_style_attr(This, STYLEID_BORDER_WIDTH, v, ATTR_FIX_PX);
1884 }
1885
1886 static HRESULT WINAPI HTMLStyle_get_borderWidth(IHTMLStyle *iface, BSTR *p)
1887 {
1888     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1889     TRACE("(%p)->(%p)\n", This, p);
1890     return get_style_attr(This, STYLEID_BORDER_WIDTH, p);
1891 }
1892
1893 static HRESULT WINAPI HTMLStyle_put_borderTopWidth(IHTMLStyle *iface, VARIANT v)
1894 {
1895     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1896
1897     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1898
1899     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, &v, 0);
1900 }
1901
1902 static HRESULT WINAPI HTMLStyle_get_borderTopWidth(IHTMLStyle *iface, VARIANT *p)
1903 {
1904     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1905
1906     TRACE("(%p)->(%p)\n", This, p);
1907
1908     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, p, 0);
1909 }
1910
1911 static HRESULT WINAPI HTMLStyle_put_borderRightWidth(IHTMLStyle *iface, VARIANT v)
1912 {
1913     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1914
1915     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1916
1917     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, &v, 0);
1918 }
1919
1920 static HRESULT WINAPI HTMLStyle_get_borderRightWidth(IHTMLStyle *iface, VARIANT *p)
1921 {
1922     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1923
1924     TRACE("(%p)->(%p)\n", This, p);
1925
1926     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, p, 0);
1927 }
1928
1929 static HRESULT WINAPI HTMLStyle_put_borderBottomWidth(IHTMLStyle *iface, VARIANT v)
1930 {
1931     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1932
1933     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1934
1935     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, &v, 0);
1936 }
1937
1938 static HRESULT WINAPI HTMLStyle_get_borderBottomWidth(IHTMLStyle *iface, VARIANT *p)
1939 {
1940     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1941     TRACE("(%p)->(%p)\n", This, p);
1942     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, p, 0);
1943 }
1944
1945 static HRESULT WINAPI HTMLStyle_put_borderLeftWidth(IHTMLStyle *iface, VARIANT v)
1946 {
1947     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1948
1949     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1950
1951     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, &v, 0);
1952 }
1953
1954 static HRESULT WINAPI HTMLStyle_get_borderLeftWidth(IHTMLStyle *iface, VARIANT *p)
1955 {
1956     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1957     TRACE("(%p)->(%p)\n", This, p);
1958     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, p, 0);
1959 }
1960
1961 static HRESULT WINAPI HTMLStyle_put_borderStyle(IHTMLStyle *iface, BSTR v)
1962 {
1963     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1964     static const WCHAR styleWindowInset[]  = {'w','i','n','d','o','w','-','i','n','s','e','t',0};
1965     HRESULT hres = S_OK;
1966     BSTR pstyle;
1967     int i=0;
1968     int last = 0;
1969
1970     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1971
1972     while(v[i] && hres == S_OK)
1973     {
1974         if(v[i] == (WCHAR)' ')
1975         {
1976             pstyle = SysAllocStringLen(&v[last], (i-last));
1977             if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1978             {
1979                 TRACE("1. Invalid style (%s)\n", debugstr_w(pstyle));
1980                 hres = E_INVALIDARG;
1981             }
1982             SysFreeString(pstyle);
1983             last = i+1;
1984         }
1985         i++;
1986     }
1987
1988     if(hres == S_OK)
1989     {
1990         pstyle = SysAllocStringLen(&v[last], i-last);
1991         if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1992         {
1993             TRACE("2. Invalid style (%s)\n", debugstr_w(pstyle));
1994             hres = E_INVALIDARG;
1995         }
1996         SysFreeString(pstyle);
1997     }
1998
1999     if(hres == S_OK)
2000         hres = set_nsstyle_attr(This->nsstyle, STYLEID_BORDER_STYLE, v, 0);
2001
2002     return hres;
2003 }
2004
2005 static HRESULT WINAPI HTMLStyle_get_borderStyle(IHTMLStyle *iface, BSTR *p)
2006 {
2007     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2008     TRACE("(%p)->(%p)\n", This, p);
2009     return get_style_attr(This, STYLEID_BORDER_STYLE, p);
2010 }
2011
2012 static HRESULT WINAPI HTMLStyle_put_borderTopStyle(IHTMLStyle *iface, BSTR v)
2013 {
2014     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2015     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2016
2017     if(!is_valid_border_style(v))
2018         return E_INVALIDARG;
2019
2020     return set_style_attr(This, STYLEID_BORDER_TOP_STYLE, v, 0);
2021 }
2022
2023 static HRESULT WINAPI HTMLStyle_get_borderTopStyle(IHTMLStyle *iface, BSTR *p)
2024 {
2025     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2026     TRACE("(%p)->(%p)\n", This, p);
2027     return get_style_attr(This, STYLEID_BORDER_TOP_STYLE, p);
2028 }
2029
2030 static HRESULT WINAPI HTMLStyle_put_borderRightStyle(IHTMLStyle *iface, BSTR v)
2031 {
2032     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2033     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2034
2035     if(!is_valid_border_style(v))
2036         return E_INVALIDARG;
2037
2038     return set_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, v, 0);
2039 }
2040
2041 static HRESULT WINAPI HTMLStyle_get_borderRightStyle(IHTMLStyle *iface, BSTR *p)
2042 {
2043     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2044     TRACE("(%p)->(%p)\n", This, p);
2045     return get_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, p);
2046 }
2047
2048 static HRESULT WINAPI HTMLStyle_put_borderBottomStyle(IHTMLStyle *iface, BSTR v)
2049 {
2050     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2051     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2052
2053     if(!is_valid_border_style(v))
2054         return E_INVALIDARG;
2055
2056     return set_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, v, 0);
2057 }
2058
2059 static HRESULT WINAPI HTMLStyle_get_borderBottomStyle(IHTMLStyle *iface, BSTR *p)
2060 {
2061     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2062     TRACE("(%p)->(%p)\n", This, p);
2063     return get_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, p);
2064 }
2065
2066 static HRESULT WINAPI HTMLStyle_put_borderLeftStyle(IHTMLStyle *iface, BSTR v)
2067 {
2068     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2069     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2070
2071     if(!is_valid_border_style(v))
2072         return E_INVALIDARG;
2073
2074     return set_style_attr(This, STYLEID_BORDER_LEFT_STYLE, v, 0);
2075 }
2076
2077 static HRESULT WINAPI HTMLStyle_get_borderLeftStyle(IHTMLStyle *iface, BSTR *p)
2078 {
2079     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2080     TRACE("(%p)->(%p)\n", This, p);
2081     return get_style_attr(This, STYLEID_BORDER_LEFT_STYLE, p);
2082 }
2083
2084 static HRESULT WINAPI HTMLStyle_put_width(IHTMLStyle *iface, VARIANT v)
2085 {
2086     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2087
2088     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2089
2090     return set_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, &v, ATTR_FIX_PX);
2091 }
2092
2093 static HRESULT WINAPI HTMLStyle_get_width(IHTMLStyle *iface, VARIANT *p)
2094 {
2095     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2096
2097     TRACE("(%p)->(%p)\n", This, p);
2098
2099     return get_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, p, 0);
2100 }
2101
2102 static HRESULT WINAPI HTMLStyle_put_height(IHTMLStyle *iface, VARIANT v)
2103 {
2104     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2105
2106     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2107
2108     return set_nsstyle_attr_var(This->nsstyle, STYLEID_HEIGHT, &v, ATTR_FIX_PX);
2109 }
2110
2111 static HRESULT WINAPI HTMLStyle_get_height(IHTMLStyle *iface, VARIANT *p)
2112 {
2113     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2114
2115     TRACE("(%p)->(%p)\n", This, p);
2116
2117     return get_nsstyle_attr_var(This->nsstyle, STYLEID_HEIGHT, p, 0);
2118 }
2119
2120 static HRESULT WINAPI HTMLStyle_put_styleFloat(IHTMLStyle *iface, BSTR v)
2121 {
2122     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2123
2124     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2125
2126     return set_style_attr(This, STYLEID_FLOAT, v, 0);
2127 }
2128
2129 static HRESULT WINAPI HTMLStyle_get_styleFloat(IHTMLStyle *iface, BSTR *p)
2130 {
2131     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2132
2133     TRACE("(%p)->(%p)\n", This, p);
2134
2135     return get_style_attr(This, STYLEID_FLOAT, p);
2136 }
2137
2138 static HRESULT WINAPI HTMLStyle_put_clear(IHTMLStyle *iface, BSTR v)
2139 {
2140     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2141
2142     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2143
2144     return set_style_attr(This, STYLEID_CLEAR, v, 0);
2145 }
2146
2147 static HRESULT WINAPI HTMLStyle_get_clear(IHTMLStyle *iface, BSTR *p)
2148 {
2149     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2150
2151     TRACE("(%p)->(%p)\n", This, p);
2152
2153     return get_style_attr(This, STYLEID_CLEAR, p);
2154 }
2155
2156 static HRESULT WINAPI HTMLStyle_put_display(IHTMLStyle *iface, BSTR v)
2157 {
2158     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2159
2160     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2161
2162     return set_style_attr(This, STYLEID_DISPLAY, v, 0);
2163 }
2164
2165 static HRESULT WINAPI HTMLStyle_get_display(IHTMLStyle *iface, BSTR *p)
2166 {
2167     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2168
2169     TRACE("(%p)->(%p)\n", This, p);
2170
2171     return get_style_attr(This, STYLEID_DISPLAY, p);
2172 }
2173
2174 static HRESULT WINAPI HTMLStyle_put_visibility(IHTMLStyle *iface, BSTR v)
2175 {
2176     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2177
2178     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2179
2180     return set_style_attr(This, STYLEID_VISIBILITY, v, 0);
2181 }
2182
2183 static HRESULT WINAPI HTMLStyle_get_visibility(IHTMLStyle *iface, BSTR *p)
2184 {
2185     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2186
2187     TRACE("(%p)->(%p)\n", This, p);
2188
2189     return get_style_attr(This, STYLEID_VISIBILITY, p);
2190 }
2191
2192 static HRESULT WINAPI HTMLStyle_put_listStyleType(IHTMLStyle *iface, BSTR v)
2193 {
2194     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2195
2196     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2197
2198     return set_style_attr(This, STYLEID_LISTSTYLETYPE, v, 0);
2199 }
2200
2201 static HRESULT WINAPI HTMLStyle_get_listStyleType(IHTMLStyle *iface, BSTR *p)
2202 {
2203     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2204
2205     TRACE("(%p)->(%p)\n", This, p);
2206
2207     return get_style_attr(This, STYLEID_LISTSTYLETYPE, p);
2208 }
2209
2210 static HRESULT WINAPI HTMLStyle_put_listStylePosition(IHTMLStyle *iface, BSTR v)
2211 {
2212     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2213
2214     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2215
2216     return set_style_attr(This, STYLEID_LISTSTYLEPOSITION, v, 0);
2217 }
2218
2219 static HRESULT WINAPI HTMLStyle_get_listStylePosition(IHTMLStyle *iface, BSTR *p)
2220 {
2221     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2222
2223     TRACE("(%p)->(%p)\n", This, p);
2224
2225     return get_style_attr(This, STYLEID_LISTSTYLEPOSITION, p);
2226 }
2227
2228 static HRESULT WINAPI HTMLStyle_put_listStyleImage(IHTMLStyle *iface, BSTR v)
2229 {
2230     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2231     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2232     return E_NOTIMPL;
2233 }
2234
2235 static HRESULT WINAPI HTMLStyle_get_listStyleImage(IHTMLStyle *iface, BSTR *p)
2236 {
2237     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2238     FIXME("(%p)->(%p)\n", This, p);
2239     return E_NOTIMPL;
2240 }
2241
2242 static HRESULT WINAPI HTMLStyle_put_listStyle(IHTMLStyle *iface, BSTR v)
2243 {
2244     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2245
2246     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2247
2248     return set_style_attr(This, STYLEID_LIST_STYLE, v, 0);
2249 }
2250
2251 static HRESULT WINAPI HTMLStyle_get_listStyle(IHTMLStyle *iface, BSTR *p)
2252 {
2253     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2254
2255     TRACE("(%p)->(%p)\n", This, p);
2256
2257     return get_style_attr(This, STYLEID_LIST_STYLE, p);
2258 }
2259
2260 static HRESULT WINAPI HTMLStyle_put_whiteSpace(IHTMLStyle *iface, BSTR v)
2261 {
2262     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2263
2264     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2265
2266     return set_nsstyle_attr(This->nsstyle, STYLEID_WHITE_SPACE, v, 0);
2267 }
2268
2269 static HRESULT WINAPI HTMLStyle_get_whiteSpace(IHTMLStyle *iface, BSTR *p)
2270 {
2271     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2272
2273     TRACE("(%p)->(%p)\n", This, p);
2274
2275     return get_nsstyle_attr(This->nsstyle, STYLEID_WHITE_SPACE, p, 0);
2276 }
2277
2278 static HRESULT WINAPI HTMLStyle_put_top(IHTMLStyle *iface, VARIANT v)
2279 {
2280     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2281
2282     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2283
2284     return set_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, &v, 0);
2285 }
2286
2287 static HRESULT WINAPI HTMLStyle_get_top(IHTMLStyle *iface, VARIANT *p)
2288 {
2289     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2290
2291     TRACE("(%p)->(%p)\n", This, p);
2292
2293     return get_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, p, 0);
2294 }
2295
2296 static HRESULT WINAPI HTMLStyle_put_left(IHTMLStyle *iface, VARIANT v)
2297 {
2298     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2299
2300     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2301
2302     return set_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, &v, 0);
2303 }
2304
2305 static HRESULT WINAPI HTMLStyle_get_left(IHTMLStyle *iface, VARIANT *p)
2306 {
2307     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2308
2309     TRACE("(%p)->(%p)\n", This, p);
2310
2311     return get_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, p, 0);
2312 }
2313
2314 static HRESULT WINAPI HTMLStyle_get_position(IHTMLStyle *iface, BSTR *p)
2315 {
2316     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2317     TRACE("(%p)->(%p)\n", This, p);
2318     return IHTMLStyle2_get_position(&This->IHTMLStyle2_iface, p);
2319 }
2320
2321 static HRESULT WINAPI HTMLStyle_put_zIndex(IHTMLStyle *iface, VARIANT v)
2322 {
2323     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2324
2325     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2326
2327     return set_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, &v, 0);
2328 }
2329
2330 static HRESULT WINAPI HTMLStyle_get_zIndex(IHTMLStyle *iface, VARIANT *p)
2331 {
2332     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2333
2334     TRACE("(%p)->(%p)\n", This, p);
2335
2336     return get_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, p, ATTR_STR_TO_INT);
2337 }
2338
2339 static HRESULT WINAPI HTMLStyle_put_overflow(IHTMLStyle *iface, BSTR v)
2340 {
2341     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2342     static const WCHAR szVisible[] = {'v','i','s','i','b','l','e',0};
2343     static const WCHAR szScroll[]  = {'s','c','r','o','l','l',0};
2344     static const WCHAR szHidden[]  = {'h','i','d','d','e','n',0};
2345     static const WCHAR szAuto[]    = {'a','u','t','o',0};
2346
2347     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2348
2349     /* overflow can only be one of the follow values. */
2350     if(!v || !*v || strcmpiW(szVisible, v) == 0 || strcmpiW(szScroll, v) == 0 ||
2351              strcmpiW(szHidden, v) == 0  || strcmpiW(szAuto, v) == 0)
2352     {
2353         return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW, v, 0);
2354     }
2355
2356     return E_INVALIDARG;
2357 }
2358
2359
2360 static HRESULT WINAPI HTMLStyle_get_overflow(IHTMLStyle *iface, BSTR *p)
2361 {
2362     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2363
2364     TRACE("(%p)->(%p)\n", This, p);
2365
2366     if(!p)
2367        return E_INVALIDARG;
2368
2369     return get_style_attr(This, STYLEID_OVERFLOW, p);
2370 }
2371
2372 static HRESULT WINAPI HTMLStyle_put_pageBreakBefore(IHTMLStyle *iface, BSTR v)
2373 {
2374     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2375
2376     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2377
2378     return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, v, 0);
2379 }
2380
2381 static HRESULT WINAPI HTMLStyle_get_pageBreakBefore(IHTMLStyle *iface, BSTR *p)
2382 {
2383     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2384
2385     TRACE("(%p)->(%p)\n", This, p);
2386
2387     return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, p, 0);
2388 }
2389
2390 static HRESULT WINAPI HTMLStyle_put_pageBreakAfter(IHTMLStyle *iface, BSTR v)
2391 {
2392     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2393
2394     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2395
2396     return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, v, 0);
2397 }
2398
2399 static HRESULT WINAPI HTMLStyle_get_pageBreakAfter(IHTMLStyle *iface, BSTR *p)
2400 {
2401     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2402
2403     TRACE("(%p)->(%p)\n", This, p);
2404
2405     return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, p, 0);
2406 }
2407
2408 static HRESULT WINAPI HTMLStyle_put_cssText(IHTMLStyle *iface, BSTR v)
2409 {
2410     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2411     nsAString text_str;
2412     nsresult nsres;
2413
2414     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2415
2416     nsAString_InitDepend(&text_str, v);
2417     nsres = nsIDOMCSSStyleDeclaration_SetCssText(This->nsstyle, &text_str);
2418     nsAString_Finish(&text_str);
2419     if(NS_FAILED(nsres)) {
2420         FIXME("SetCssStyle failed: %08x\n", nsres);
2421         return E_FAIL;
2422     }
2423
2424     return S_OK;
2425 }
2426
2427 static HRESULT WINAPI HTMLStyle_get_cssText(IHTMLStyle *iface, BSTR *p)
2428 {
2429     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2430     nsAString text_str;
2431     nsresult nsres;
2432
2433     TRACE("(%p)->(%p)\n", This, p);
2434
2435     /* FIXME: Gecko style formatting is different than IE (uppercase). */
2436     nsAString_Init(&text_str, NULL);
2437     nsres = nsIDOMCSSStyleDeclaration_GetCssText(This->nsstyle, &text_str);
2438     if(NS_SUCCEEDED(nsres)) {
2439         const PRUnichar *text;
2440
2441         nsAString_GetData(&text_str, &text);
2442         *p = *text ? SysAllocString(text) : NULL;
2443     }else {
2444         FIXME("GetCssStyle failed: %08x\n", nsres);
2445         *p = NULL;
2446     }
2447
2448     nsAString_Finish(&text_str);
2449     return S_OK;
2450 }
2451
2452 static HRESULT WINAPI HTMLStyle_put_pixelTop(IHTMLStyle *iface, LONG v)
2453 {
2454     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2455
2456     TRACE("(%p)->(%d)\n", This, v);
2457
2458     return set_style_pxattr(This->nsstyle, STYLEID_TOP, v);
2459 }
2460
2461 static HRESULT WINAPI HTMLStyle_get_pixelTop(IHTMLStyle *iface, LONG *p)
2462 {
2463     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2464
2465     TRACE("(%p)->(%p)\n", This, p);
2466
2467     return get_nsstyle_pixel_val(This, STYLEID_TOP, p);
2468 }
2469
2470 static HRESULT WINAPI HTMLStyle_put_pixelLeft(IHTMLStyle *iface, LONG v)
2471 {
2472     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2473
2474     TRACE("(%p)->(%d)\n", This, v);
2475
2476     return set_style_pxattr(This->nsstyle, STYLEID_LEFT, v);
2477 }
2478
2479 static HRESULT WINAPI HTMLStyle_get_pixelLeft(IHTMLStyle *iface, LONG *p)
2480 {
2481     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2482
2483     TRACE("(%p)->(%p)\n", This, p);
2484
2485     return get_nsstyle_pixel_val(This, STYLEID_LEFT, p);
2486 }
2487
2488 static HRESULT WINAPI HTMLStyle_put_pixelWidth(IHTMLStyle *iface, LONG v)
2489 {
2490     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2491
2492     TRACE("(%p)->()\n", This);
2493
2494     return set_style_pxattr(This->nsstyle, STYLEID_WIDTH, v);
2495 }
2496
2497 static HRESULT WINAPI HTMLStyle_get_pixelWidth(IHTMLStyle *iface, LONG *p)
2498 {
2499     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2500
2501     TRACE("(%p)->(%p)\n", This, p);
2502
2503     return get_nsstyle_pixel_val(This, STYLEID_WIDTH, p);
2504 }
2505
2506 static HRESULT WINAPI HTMLStyle_put_pixelHeight(IHTMLStyle *iface, LONG v)
2507 {
2508     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2509
2510     TRACE("(%p)->(%d)\n", This, v);
2511
2512     return set_style_pxattr(This->nsstyle, STYLEID_HEIGHT, v);
2513 }
2514
2515 static HRESULT WINAPI HTMLStyle_get_pixelHeight(IHTMLStyle *iface, LONG *p)
2516 {
2517     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2518
2519     TRACE("(%p)->(%p)\n", This, p);
2520
2521     return get_nsstyle_pixel_val(This, STYLEID_HEIGHT, p);
2522 }
2523
2524 static HRESULT WINAPI HTMLStyle_put_posTop(IHTMLStyle *iface, float v)
2525 {
2526     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2527
2528     TRACE("(%p)->(%f)\n", This, v);
2529
2530     return set_style_pos(This, STYLEID_TOP, v);
2531 }
2532
2533 static HRESULT WINAPI HTMLStyle_get_posTop(IHTMLStyle *iface, float *p)
2534 {
2535     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2536
2537     TRACE("(%p)->(%p)\n", This, p);
2538
2539     if(!p)
2540         return E_POINTER;
2541
2542     return get_nsstyle_pos(This, STYLEID_TOP, p);
2543 }
2544
2545 static HRESULT WINAPI HTMLStyle_put_posLeft(IHTMLStyle *iface, float v)
2546 {
2547     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2548
2549     TRACE("(%p)->(%f)\n", This, v);
2550
2551     return set_style_pos(This, STYLEID_LEFT, v);
2552 }
2553
2554 static HRESULT WINAPI HTMLStyle_get_posLeft(IHTMLStyle *iface, float *p)
2555 {
2556     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2557
2558     TRACE("(%p)->(%p)\n", This, p);
2559
2560     if(!p)
2561         return E_POINTER;
2562
2563     return get_nsstyle_pos(This, STYLEID_LEFT, p);
2564 }
2565
2566 static HRESULT WINAPI HTMLStyle_put_posWidth(IHTMLStyle *iface, float v)
2567 {
2568     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2569
2570     TRACE("(%p)->(%f)\n", This, v);
2571
2572     return set_style_pos(This, STYLEID_WIDTH, v);
2573 }
2574
2575 static HRESULT WINAPI HTMLStyle_get_posWidth(IHTMLStyle *iface, float *p)
2576 {
2577     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2578
2579     TRACE("(%p)->(%p)\n", This, p);
2580
2581     if(!p)
2582         return E_POINTER;
2583
2584     if(get_nsstyle_pos(This, STYLEID_WIDTH, p) != S_OK)
2585         *p = 0.0f;
2586
2587     return S_OK;
2588 }
2589
2590 static HRESULT WINAPI HTMLStyle_put_posHeight(IHTMLStyle *iface, float v)
2591 {
2592     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2593
2594     TRACE("(%p)->(%f)\n", This, v);
2595
2596     return set_style_pos(This, STYLEID_HEIGHT, v);
2597 }
2598
2599 static HRESULT WINAPI HTMLStyle_get_posHeight(IHTMLStyle *iface, float *p)
2600 {
2601     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2602
2603     TRACE("(%p)->(%p)\n", This, p);
2604
2605     if(!p)
2606         return E_POINTER;
2607
2608     if(get_nsstyle_pos(This, STYLEID_HEIGHT, p) != S_OK)
2609         *p = 0.0f;
2610
2611     return S_OK;
2612 }
2613
2614 static HRESULT WINAPI HTMLStyle_put_cursor(IHTMLStyle *iface, BSTR v)
2615 {
2616     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2617
2618     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2619
2620     return set_style_attr(This, STYLEID_CURSOR, v, 0);
2621 }
2622
2623 static HRESULT WINAPI HTMLStyle_get_cursor(IHTMLStyle *iface, BSTR *p)
2624 {
2625     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2626
2627     TRACE("(%p)->(%p)\n", This, p);
2628
2629     return get_style_attr(This, STYLEID_CURSOR, p);
2630 }
2631
2632 static HRESULT WINAPI HTMLStyle_put_clip(IHTMLStyle *iface, BSTR v)
2633 {
2634     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2635
2636     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2637
2638     return set_style_attr(This, STYLEID_CLIP, v, 0);
2639 }
2640
2641 static HRESULT WINAPI HTMLStyle_get_clip(IHTMLStyle *iface, BSTR *p)
2642 {
2643     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2644
2645     TRACE("(%p)->(%p)\n", This, p);
2646
2647     return get_nsstyle_attr(This->nsstyle, STYLEID_CLIP, p, ATTR_REMOVE_COMMA);
2648 }
2649
2650 static void set_opacity(HTMLStyle *This, const WCHAR *val)
2651 {
2652     nsAString name_str, val_str, empty_str;
2653     nsresult nsres;
2654
2655     static const WCHAR opacityW[] = {'o','p','a','c','i','t','y',0};
2656
2657     TRACE("%s\n", debugstr_w(val));
2658
2659     nsAString_InitDepend(&name_str, opacityW);
2660     nsAString_InitDepend(&val_str, val);
2661     nsAString_InitDepend(&empty_str, emptyW);
2662
2663     nsres = nsIDOMCSSStyleDeclaration_SetProperty(This->nsstyle, &name_str, &val_str, &empty_str);
2664     if(NS_FAILED(nsres))
2665         ERR("SetProperty failed: %08x\n", nsres);
2666
2667     nsAString_Finish(&name_str);
2668     nsAString_Finish(&val_str);
2669     nsAString_Finish(&empty_str);
2670 }
2671
2672 static void update_filter(HTMLStyle *This)
2673 {
2674     const WCHAR *ptr = This->elem->filter, *ptr2;
2675
2676     static const WCHAR alphaW[] = {'a','l','p','h','a'};
2677
2678     if(!ptr) {
2679         set_opacity(This, emptyW);
2680         return;
2681     }
2682
2683     while(1) {
2684         while(isspaceW(*ptr))
2685             ptr++;
2686         if(!*ptr)
2687             break;
2688
2689         ptr2 = ptr;
2690         while(isalnumW(*ptr))
2691             ptr++;
2692         if(ptr == ptr2) {
2693             WARN("unexpected char '%c'\n", *ptr);
2694             break;
2695         }
2696         if(*ptr != '(') {
2697             WARN("expected '('\n");
2698             continue;
2699         }
2700
2701         if(ptr2 + sizeof(alphaW)/sizeof(WCHAR) == ptr && !memcmp(ptr2, alphaW, sizeof(alphaW))) {
2702             static const WCHAR formatW[] = {'%','f',0};
2703             static const WCHAR opacityW[] = {'o','p','a','c','i','t','y','='};
2704
2705             ptr++;
2706             do {
2707                 while(isspaceW(*ptr))
2708                     ptr++;
2709
2710                 ptr2 = ptr;
2711                 while(*ptr && *ptr != ',' && *ptr != ')')
2712                     ptr++;
2713                 if(!*ptr) {
2714                     WARN("unexpected end of string\n");
2715                     break;
2716                 }
2717
2718                 if(ptr-ptr2 > sizeof(opacityW)/sizeof(WCHAR) && !memcmp(ptr2, opacityW, sizeof(opacityW))) {
2719                     float fval = 0.0f, e = 0.1f;
2720                     WCHAR buf[32];
2721
2722                     ptr2 += sizeof(opacityW)/sizeof(WCHAR);
2723
2724                     while(isdigitW(*ptr2))
2725                         fval = fval*10.0f + (float)(*ptr2++ - '0');
2726
2727                     if(*ptr2 == '.') {
2728                         while(isdigitW(*++ptr2)) {
2729                             fval += e * (float)(*ptr2++ - '0');
2730                             e *= 0.1f;
2731                         }
2732                     }
2733
2734                     sprintfW(buf, formatW, fval * 0.01f);
2735                     set_opacity(This, buf);
2736                 }else {
2737                     FIXME("unknown param %s\n", debugstr_wn(ptr2, ptr-ptr2));
2738                 }
2739
2740                 if(*ptr == ',')
2741                     ptr++;
2742             }while(*ptr != ')');
2743         }else {
2744             FIXME("unknown filter %s\n", debugstr_wn(ptr2, ptr-ptr2));
2745             ptr = strchrW(ptr, ')');
2746             if(!ptr)
2747                 break;
2748             ptr++;
2749         }
2750     }
2751 }
2752
2753 static HRESULT WINAPI HTMLStyle_put_filter(IHTMLStyle *iface, BSTR v)
2754 {
2755     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2756     WCHAR *new_filter = NULL;
2757
2758     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2759
2760     if(!This->elem) {
2761         FIXME("Element already destroyed\n");
2762         return E_UNEXPECTED;
2763     }
2764
2765     if(v) {
2766         new_filter = heap_strdupW(v);
2767         if(!new_filter)
2768             return E_OUTOFMEMORY;
2769     }
2770
2771     heap_free(This->elem->filter);
2772     This->elem->filter = new_filter;
2773
2774     update_filter(This);
2775     return S_OK;
2776 }
2777
2778 static HRESULT WINAPI HTMLStyle_get_filter(IHTMLStyle *iface, BSTR *p)
2779 {
2780     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2781
2782     TRACE("(%p)->(%p)\n", This, p);
2783
2784     if(!This->elem) {
2785         FIXME("Element already destroyed\n");
2786         return E_UNEXPECTED;
2787     }
2788
2789     if(This->elem->filter) {
2790         *p = SysAllocString(This->elem->filter);
2791         if(!*p)
2792             return E_OUTOFMEMORY;
2793     }else {
2794         *p = NULL;
2795     }
2796
2797     return S_OK;
2798 }
2799
2800 static HRESULT WINAPI HTMLStyle_setAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2801         VARIANT AttributeValue, LONG lFlags)
2802 {
2803     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2804     HRESULT hres;
2805     DISPID dispid;
2806
2807     TRACE("(%p)->(%s %s %08x)\n", This, debugstr_w(strAttributeName),
2808           debugstr_variant(&AttributeValue), lFlags);
2809
2810     if(!strAttributeName)
2811         return E_INVALIDARG;
2812
2813     if(lFlags == 1)
2814         FIXME("Parameter lFlags ignored\n");
2815
2816     hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2817                         LOCALE_USER_DEFAULT, &dispid);
2818     if(hres == S_OK)
2819     {
2820         VARIANT ret;
2821         DISPID dispidNamed = DISPID_PROPERTYPUT;
2822         DISPPARAMS params;
2823
2824         params.cArgs = 1;
2825         params.rgvarg = &AttributeValue;
2826         params.cNamedArgs = 1;
2827         params.rgdispidNamedArgs = &dispidNamed;
2828
2829         hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2830             DISPATCH_PROPERTYPUT, &params, &ret, NULL, NULL);
2831     }
2832     else
2833     {
2834         FIXME("Custom attributes not supported.\n");
2835     }
2836
2837     TRACE("ret: %08x\n", hres);
2838
2839     return hres;
2840 }
2841
2842 static HRESULT WINAPI HTMLStyle_getAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2843         LONG lFlags, VARIANT *AttributeValue)
2844 {
2845     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2846     HRESULT hres;
2847     DISPID dispid;
2848
2849     TRACE("(%p)->(%s v%p %08x)\n", This, debugstr_w(strAttributeName),
2850           AttributeValue, lFlags);
2851
2852     if(!AttributeValue || !strAttributeName)
2853         return E_INVALIDARG;
2854
2855     if(lFlags == 1)
2856         FIXME("Parameter lFlags ignored\n");
2857
2858     hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2859                         LOCALE_USER_DEFAULT, &dispid);
2860     if(hres == S_OK)
2861     {
2862         DISPPARAMS params = {NULL, NULL, 0, 0 };
2863
2864         hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2865             DISPATCH_PROPERTYGET, &params, AttributeValue, NULL, NULL);
2866     }
2867     else
2868     {
2869         FIXME("Custom attributes not supported.\n");
2870     }
2871
2872     return hres;
2873 }
2874
2875 static HRESULT WINAPI HTMLStyle_removeAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2876                                                 LONG lFlags, VARIANT_BOOL *pfSuccess)
2877 {
2878     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2879     const style_tbl_entry_t *style_entry;
2880     nsAString name_str, ret_str;
2881     nsresult nsres;
2882     HRESULT hres;
2883
2884     TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
2885
2886     style_entry = lookup_style_tbl(strAttributeName);
2887     if(!style_entry) {
2888         DISPID dispid;
2889         unsigned i;
2890
2891         hres = IDispatchEx_GetDispID(&This->dispex.IDispatchEx_iface, strAttributeName,
2892                 (lFlags&1) ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &dispid);
2893         if(hres != S_OK) {
2894             *pfSuccess = VARIANT_FALSE;
2895             return S_OK;
2896         }
2897
2898         for(i=0; i < sizeof(style_tbl)/sizeof(*style_tbl); i++) {
2899             if(dispid == style_tbl[i].dispid)
2900                 break;
2901         }
2902
2903         if(i == sizeof(style_tbl)/sizeof(*style_tbl))
2904             return remove_attribute(&This->dispex, dispid, pfSuccess);
2905         style_entry = style_tbl+i;
2906     }
2907
2908     /* filter property is a special case */
2909     if(style_entry->dispid == DISPID_IHTMLSTYLE_FILTER) {
2910         *pfSuccess = This->elem->filter && *This->elem->filter ? VARIANT_TRUE : VARIANT_FALSE;
2911         heap_free(This->elem->filter);
2912         This->elem->filter = NULL;
2913         update_filter(This);
2914         return S_OK;
2915     }
2916
2917     nsAString_InitDepend(&name_str, style_entry->name);
2918     nsAString_Init(&ret_str, NULL);
2919     nsres = nsIDOMCSSStyleDeclaration_RemoveProperty(This->nsstyle, &name_str, &ret_str);
2920     if(NS_SUCCEEDED(nsres)) {
2921         const PRUnichar *ret;
2922         nsAString_GetData(&ret_str, &ret);
2923         *pfSuccess = *ret ? VARIANT_TRUE : VARIANT_FALSE;
2924     }else {
2925         ERR("RemoveProperty failed: %08x\n", nsres);
2926     }
2927     nsAString_Finish(&name_str);
2928     nsAString_Finish(&ret_str);
2929     return NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
2930 }
2931
2932 static HRESULT WINAPI HTMLStyle_toString(IHTMLStyle *iface, BSTR *String)
2933 {
2934     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2935     FIXME("(%p)->(%p)\n", This, String);
2936     return E_NOTIMPL;
2937 }
2938
2939 static const IHTMLStyleVtbl HTMLStyleVtbl = {
2940     HTMLStyle_QueryInterface,
2941     HTMLStyle_AddRef,
2942     HTMLStyle_Release,
2943     HTMLStyle_GetTypeInfoCount,
2944     HTMLStyle_GetTypeInfo,
2945     HTMLStyle_GetIDsOfNames,
2946     HTMLStyle_Invoke,
2947     HTMLStyle_put_fontFamily,
2948     HTMLStyle_get_fontFamily,
2949     HTMLStyle_put_fontStyle,
2950     HTMLStyle_get_fontStyle,
2951     HTMLStyle_put_fontVariant,
2952     HTMLStyle_get_fontVariant,
2953     HTMLStyle_put_fontWeight,
2954     HTMLStyle_get_fontWeight,
2955     HTMLStyle_put_fontSize,
2956     HTMLStyle_get_fontSize,
2957     HTMLStyle_put_font,
2958     HTMLStyle_get_font,
2959     HTMLStyle_put_color,
2960     HTMLStyle_get_color,
2961     HTMLStyle_put_background,
2962     HTMLStyle_get_background,
2963     HTMLStyle_put_backgroundColor,
2964     HTMLStyle_get_backgroundColor,
2965     HTMLStyle_put_backgroundImage,
2966     HTMLStyle_get_backgroundImage,
2967     HTMLStyle_put_backgroundRepeat,
2968     HTMLStyle_get_backgroundRepeat,
2969     HTMLStyle_put_backgroundAttachment,
2970     HTMLStyle_get_backgroundAttachment,
2971     HTMLStyle_put_backgroundPosition,
2972     HTMLStyle_get_backgroundPosition,
2973     HTMLStyle_put_backgroundPositionX,
2974     HTMLStyle_get_backgroundPositionX,
2975     HTMLStyle_put_backgroundPositionY,
2976     HTMLStyle_get_backgroundPositionY,
2977     HTMLStyle_put_wordSpacing,
2978     HTMLStyle_get_wordSpacing,
2979     HTMLStyle_put_letterSpacing,
2980     HTMLStyle_get_letterSpacing,
2981     HTMLStyle_put_textDecoration,
2982     HTMLStyle_get_textDecoration,
2983     HTMLStyle_put_textDecorationNone,
2984     HTMLStyle_get_textDecorationNone,
2985     HTMLStyle_put_textDecorationUnderline,
2986     HTMLStyle_get_textDecorationUnderline,
2987     HTMLStyle_put_textDecorationOverline,
2988     HTMLStyle_get_textDecorationOverline,
2989     HTMLStyle_put_textDecorationLineThrough,
2990     HTMLStyle_get_textDecorationLineThrough,
2991     HTMLStyle_put_textDecorationBlink,
2992     HTMLStyle_get_textDecorationBlink,
2993     HTMLStyle_put_verticalAlign,
2994     HTMLStyle_get_verticalAlign,
2995     HTMLStyle_put_textTransform,
2996     HTMLStyle_get_textTransform,
2997     HTMLStyle_put_textAlign,
2998     HTMLStyle_get_textAlign,
2999     HTMLStyle_put_textIndent,
3000     HTMLStyle_get_textIndent,
3001     HTMLStyle_put_lineHeight,
3002     HTMLStyle_get_lineHeight,
3003     HTMLStyle_put_marginTop,
3004     HTMLStyle_get_marginTop,
3005     HTMLStyle_put_marginRight,
3006     HTMLStyle_get_marginRight,
3007     HTMLStyle_put_marginBottom,
3008     HTMLStyle_get_marginBottom,
3009     HTMLStyle_put_marginLeft,
3010     HTMLStyle_get_marginLeft,
3011     HTMLStyle_put_margin,
3012     HTMLStyle_get_margin,
3013     HTMLStyle_put_paddingTop,
3014     HTMLStyle_get_paddingTop,
3015     HTMLStyle_put_paddingRight,
3016     HTMLStyle_get_paddingRight,
3017     HTMLStyle_put_paddingBottom,
3018     HTMLStyle_get_paddingBottom,
3019     HTMLStyle_put_paddingLeft,
3020     HTMLStyle_get_paddingLeft,
3021     HTMLStyle_put_padding,
3022     HTMLStyle_get_padding,
3023     HTMLStyle_put_border,
3024     HTMLStyle_get_border,
3025     HTMLStyle_put_borderTop,
3026     HTMLStyle_get_borderTop,
3027     HTMLStyle_put_borderRight,
3028     HTMLStyle_get_borderRight,
3029     HTMLStyle_put_borderBottom,
3030     HTMLStyle_get_borderBottom,
3031     HTMLStyle_put_borderLeft,
3032     HTMLStyle_get_borderLeft,
3033     HTMLStyle_put_borderColor,
3034     HTMLStyle_get_borderColor,
3035     HTMLStyle_put_borderTopColor,
3036     HTMLStyle_get_borderTopColor,
3037     HTMLStyle_put_borderRightColor,
3038     HTMLStyle_get_borderRightColor,
3039     HTMLStyle_put_borderBottomColor,
3040     HTMLStyle_get_borderBottomColor,
3041     HTMLStyle_put_borderLeftColor,
3042     HTMLStyle_get_borderLeftColor,
3043     HTMLStyle_put_borderWidth,
3044     HTMLStyle_get_borderWidth,
3045     HTMLStyle_put_borderTopWidth,
3046     HTMLStyle_get_borderTopWidth,
3047     HTMLStyle_put_borderRightWidth,
3048     HTMLStyle_get_borderRightWidth,
3049     HTMLStyle_put_borderBottomWidth,
3050     HTMLStyle_get_borderBottomWidth,
3051     HTMLStyle_put_borderLeftWidth,
3052     HTMLStyle_get_borderLeftWidth,
3053     HTMLStyle_put_borderStyle,
3054     HTMLStyle_get_borderStyle,
3055     HTMLStyle_put_borderTopStyle,
3056     HTMLStyle_get_borderTopStyle,
3057     HTMLStyle_put_borderRightStyle,
3058     HTMLStyle_get_borderRightStyle,
3059     HTMLStyle_put_borderBottomStyle,
3060     HTMLStyle_get_borderBottomStyle,
3061     HTMLStyle_put_borderLeftStyle,
3062     HTMLStyle_get_borderLeftStyle,
3063     HTMLStyle_put_width,
3064     HTMLStyle_get_width,
3065     HTMLStyle_put_height,
3066     HTMLStyle_get_height,
3067     HTMLStyle_put_styleFloat,
3068     HTMLStyle_get_styleFloat,
3069     HTMLStyle_put_clear,
3070     HTMLStyle_get_clear,
3071     HTMLStyle_put_display,
3072     HTMLStyle_get_display,
3073     HTMLStyle_put_visibility,
3074     HTMLStyle_get_visibility,
3075     HTMLStyle_put_listStyleType,
3076     HTMLStyle_get_listStyleType,
3077     HTMLStyle_put_listStylePosition,
3078     HTMLStyle_get_listStylePosition,
3079     HTMLStyle_put_listStyleImage,
3080     HTMLStyle_get_listStyleImage,
3081     HTMLStyle_put_listStyle,
3082     HTMLStyle_get_listStyle,
3083     HTMLStyle_put_whiteSpace,
3084     HTMLStyle_get_whiteSpace,
3085     HTMLStyle_put_top,
3086     HTMLStyle_get_top,
3087     HTMLStyle_put_left,
3088     HTMLStyle_get_left,
3089     HTMLStyle_get_position,
3090     HTMLStyle_put_zIndex,
3091     HTMLStyle_get_zIndex,
3092     HTMLStyle_put_overflow,
3093     HTMLStyle_get_overflow,
3094     HTMLStyle_put_pageBreakBefore,
3095     HTMLStyle_get_pageBreakBefore,
3096     HTMLStyle_put_pageBreakAfter,
3097     HTMLStyle_get_pageBreakAfter,
3098     HTMLStyle_put_cssText,
3099     HTMLStyle_get_cssText,
3100     HTMLStyle_put_pixelTop,
3101     HTMLStyle_get_pixelTop,
3102     HTMLStyle_put_pixelLeft,
3103     HTMLStyle_get_pixelLeft,
3104     HTMLStyle_put_pixelWidth,
3105     HTMLStyle_get_pixelWidth,
3106     HTMLStyle_put_pixelHeight,
3107     HTMLStyle_get_pixelHeight,
3108     HTMLStyle_put_posTop,
3109     HTMLStyle_get_posTop,
3110     HTMLStyle_put_posLeft,
3111     HTMLStyle_get_posLeft,
3112     HTMLStyle_put_posWidth,
3113     HTMLStyle_get_posWidth,
3114     HTMLStyle_put_posHeight,
3115     HTMLStyle_get_posHeight,
3116     HTMLStyle_put_cursor,
3117     HTMLStyle_get_cursor,
3118     HTMLStyle_put_clip,
3119     HTMLStyle_get_clip,
3120     HTMLStyle_put_filter,
3121     HTMLStyle_get_filter,
3122     HTMLStyle_setAttribute,
3123     HTMLStyle_getAttribute,
3124     HTMLStyle_removeAttribute,
3125     HTMLStyle_toString
3126 };
3127
3128 static HRESULT HTMLStyle_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
3129 {
3130     const style_tbl_entry_t *style_entry;
3131
3132     style_entry = lookup_style_tbl(name);
3133     if(style_entry) {
3134         *dispid = style_entry->dispid;
3135         return S_OK;
3136     }
3137
3138     return DISP_E_UNKNOWNNAME;
3139 }
3140
3141 static const dispex_static_data_vtbl_t HTMLStyle_dispex_vtbl = {
3142     NULL,
3143     HTMLStyle_get_dispid,
3144     NULL,
3145     NULL
3146 };
3147
3148 static const tid_t HTMLStyle_iface_tids[] = {
3149     IHTMLStyle6_tid,
3150     IHTMLStyle5_tid,
3151     IHTMLStyle4_tid,
3152     IHTMLStyle3_tid,
3153     IHTMLStyle2_tid,
3154     IHTMLStyle_tid,
3155     0
3156 };
3157 static dispex_static_data_t HTMLStyle_dispex = {
3158     &HTMLStyle_dispex_vtbl,
3159     DispHTMLStyle_tid,
3160     NULL,
3161     HTMLStyle_iface_tids
3162 };
3163
3164 static HRESULT get_style_from_elem(HTMLElement *elem, nsIDOMCSSStyleDeclaration **ret)
3165 {
3166     nsIDOMElementCSSInlineStyle *nselemstyle;
3167     nsresult nsres;
3168
3169     if(!elem->nselem) {
3170         FIXME("NULL nselem\n");
3171         return E_NOTIMPL;
3172     }
3173
3174     nsres = nsIDOMHTMLElement_QueryInterface(elem->nselem, &IID_nsIDOMElementCSSInlineStyle,
3175             (void**)&nselemstyle);
3176     assert(nsres == NS_OK);
3177
3178     nsres = nsIDOMElementCSSInlineStyle_GetStyle(nselemstyle, ret);
3179     nsIDOMElementCSSInlineStyle_Release(nselemstyle);
3180     if(NS_FAILED(nsres)) {
3181         ERR("GetStyle failed: %08x\n", nsres);
3182         return E_FAIL;
3183     }
3184
3185     return S_OK;
3186 }
3187
3188 HRESULT HTMLStyle_Create(HTMLElement *elem, HTMLStyle **ret)
3189 {
3190     nsIDOMCSSStyleDeclaration *nsstyle;
3191     HTMLStyle *style;
3192     HRESULT hres;
3193
3194     hres = get_style_from_elem(elem, &nsstyle);
3195     if(FAILED(hres))
3196         return hres;
3197
3198     style = heap_alloc_zero(sizeof(HTMLStyle));
3199     if(!style) {
3200         nsIDOMCSSStyleDeclaration_Release(nsstyle);
3201         return E_OUTOFMEMORY;
3202     }
3203
3204     style->IHTMLStyle_iface.lpVtbl = &HTMLStyleVtbl;
3205     style->ref = 1;
3206     style->nsstyle = nsstyle;
3207     style->elem = elem;
3208     HTMLStyle2_Init(style);
3209     HTMLStyle3_Init(style);
3210
3211     nsIDOMCSSStyleDeclaration_AddRef(nsstyle);
3212
3213     init_dispex(&style->dispex, (IUnknown*)&style->IHTMLStyle_iface, &HTMLStyle_dispex);
3214
3215     *ret = style;
3216     return S_OK;
3217 }
3218
3219 HRESULT get_elem_style(HTMLElement *elem, styleid_t styleid, BSTR *ret)
3220 {
3221     nsIDOMCSSStyleDeclaration *style;
3222     HRESULT hres;
3223
3224     hres = get_style_from_elem(elem, &style);
3225     if(FAILED(hres))
3226         return hres;
3227
3228     hres = get_nsstyle_attr(style, styleid, ret, 0);
3229     nsIDOMCSSStyleDeclaration_Release(style);
3230     return hres;
3231 }
3232
3233 HRESULT set_elem_style(HTMLElement *elem, styleid_t styleid, const WCHAR *val)
3234 {
3235     nsIDOMCSSStyleDeclaration *style;
3236     HRESULT hres;
3237
3238     hres = get_style_from_elem(elem, &style);
3239     if(FAILED(hres))
3240         return hres;
3241
3242     hres = set_nsstyle_attr(style, styleid, val, 0);
3243     nsIDOMCSSStyleDeclaration_Release(style);
3244     return hres;
3245 }