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