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
1563     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1564
1565     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, &v, ATTR_HEX_INT);
1566 }
1567
1568 static HRESULT WINAPI HTMLStyle_get_borderRightColor(IHTMLStyle *iface, VARIANT *p)
1569 {
1570     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1571
1572     TRACE("(%p)->(%p)\n", This, p);
1573
1574     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, p, 0);
1575 }
1576
1577 static HRESULT WINAPI HTMLStyle_put_borderBottomColor(IHTMLStyle *iface, VARIANT v)
1578 {
1579     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1580
1581     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1582
1583     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, &v, ATTR_HEX_INT);
1584 }
1585
1586 static HRESULT WINAPI HTMLStyle_get_borderBottomColor(IHTMLStyle *iface, VARIANT *p)
1587 {
1588     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1589
1590     TRACE("(%p)->(%p)\n", This, p);
1591
1592     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, p, 0);
1593 }
1594
1595 static HRESULT WINAPI HTMLStyle_put_borderLeftColor(IHTMLStyle *iface, VARIANT v)
1596 {
1597     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1598     FIXME("(%p)->(v%d)\n", This, V_VT(&v));
1599     return E_NOTIMPL;
1600 }
1601
1602 static HRESULT WINAPI HTMLStyle_get_borderLeftColor(IHTMLStyle *iface, VARIANT *p)
1603 {
1604     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1605
1606     TRACE("(%p)->(%p)\n", This, p);
1607
1608     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, p, 0);
1609 }
1610
1611 static HRESULT WINAPI HTMLStyle_put_borderWidth(IHTMLStyle *iface, BSTR v)
1612 {
1613     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1614     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1615     return set_style_attr(This, STYLEID_BORDER_WIDTH, v, ATTR_FIX_PX);
1616 }
1617
1618 static HRESULT WINAPI HTMLStyle_get_borderWidth(IHTMLStyle *iface, BSTR *p)
1619 {
1620     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1621     TRACE("(%p)->(%p)\n", This, p);
1622     return get_style_attr(This, STYLEID_BORDER_WIDTH, p);
1623 }
1624
1625 static HRESULT WINAPI HTMLStyle_put_borderTopWidth(IHTMLStyle *iface, VARIANT v)
1626 {
1627     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1628     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1629     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, &v, 0);
1630 }
1631
1632 static HRESULT WINAPI HTMLStyle_get_borderTopWidth(IHTMLStyle *iface, VARIANT *p)
1633 {
1634     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1635
1636     TRACE("(%p)->(%p)\n", This, p);
1637
1638     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, p, 0);
1639 }
1640
1641 static HRESULT WINAPI HTMLStyle_put_borderRightWidth(IHTMLStyle *iface, VARIANT v)
1642 {
1643     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1644     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1645     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, &v, 0);
1646 }
1647
1648 static HRESULT WINAPI HTMLStyle_get_borderRightWidth(IHTMLStyle *iface, VARIANT *p)
1649 {
1650     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1651     TRACE("(%p)->(%p)\n", This, p);
1652     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, p, 0);
1653 }
1654
1655 static HRESULT WINAPI HTMLStyle_put_borderBottomWidth(IHTMLStyle *iface, VARIANT v)
1656 {
1657     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1658
1659     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1660     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, &v, 0);
1661 }
1662
1663 static HRESULT WINAPI HTMLStyle_get_borderBottomWidth(IHTMLStyle *iface, VARIANT *p)
1664 {
1665     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1666     TRACE("(%p)->(%p)\n", This, p);
1667     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, p, 0);
1668 }
1669
1670 static HRESULT WINAPI HTMLStyle_put_borderLeftWidth(IHTMLStyle *iface, VARIANT v)
1671 {
1672     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1673     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1674     return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, &v, 0);
1675 }
1676
1677 static HRESULT WINAPI HTMLStyle_get_borderLeftWidth(IHTMLStyle *iface, VARIANT *p)
1678 {
1679     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1680     TRACE("(%p)->(%p)\n", This, p);
1681     return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, p, 0);
1682 }
1683
1684 static HRESULT WINAPI HTMLStyle_put_borderStyle(IHTMLStyle *iface, BSTR v)
1685 {
1686     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1687     static const WCHAR styleWindowInset[]  = {'w','i','n','d','o','w','-','i','n','s','e','t',0};
1688     HRESULT hres = S_OK;
1689     BSTR pstyle;
1690     int i=0;
1691     int last = 0;
1692
1693     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1694
1695     while(v[i] && hres == S_OK)
1696     {
1697         if(v[i] == (WCHAR)' ')
1698         {
1699             pstyle = SysAllocStringLen(&v[last], (i-last));
1700             if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1701             {
1702                 TRACE("1. Invalid style (%s)\n", debugstr_w(pstyle));
1703                 hres = E_INVALIDARG;
1704             }
1705             SysFreeString(pstyle);
1706             last = i+1;
1707         }
1708         i++;
1709     }
1710
1711     if(hres == S_OK)
1712     {
1713         pstyle = SysAllocStringLen(&v[last], i-last);
1714         if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1715         {
1716             TRACE("2. Invalid style (%s)\n", debugstr_w(pstyle));
1717             hres = E_INVALIDARG;
1718         }
1719         SysFreeString(pstyle);
1720     }
1721
1722     if(hres == S_OK)
1723         hres = set_nsstyle_attr(This->nsstyle, STYLEID_BORDER_STYLE, v, 0);
1724
1725     return hres;
1726 }
1727
1728 static HRESULT WINAPI HTMLStyle_get_borderStyle(IHTMLStyle *iface, BSTR *p)
1729 {
1730     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1731     TRACE("(%p)->(%p)\n", This, p);
1732     return get_style_attr(This, STYLEID_BORDER_STYLE, p);
1733 }
1734
1735 static HRESULT WINAPI HTMLStyle_put_borderTopStyle(IHTMLStyle *iface, BSTR v)
1736 {
1737     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1738     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1739
1740     if(!is_valid_border_style(v))
1741         return E_INVALIDARG;
1742
1743     return set_style_attr(This, STYLEID_BORDER_TOP_STYLE, v, 0);
1744 }
1745
1746 static HRESULT WINAPI HTMLStyle_get_borderTopStyle(IHTMLStyle *iface, BSTR *p)
1747 {
1748     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1749     TRACE("(%p)->(%p)\n", This, p);
1750     return get_style_attr(This, STYLEID_BORDER_TOP_STYLE, p);
1751 }
1752
1753 static HRESULT WINAPI HTMLStyle_put_borderRightStyle(IHTMLStyle *iface, BSTR v)
1754 {
1755     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1756     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1757
1758     if(!is_valid_border_style(v))
1759         return E_INVALIDARG;
1760
1761     return set_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, v, 0);
1762 }
1763
1764 static HRESULT WINAPI HTMLStyle_get_borderRightStyle(IHTMLStyle *iface, BSTR *p)
1765 {
1766     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1767     TRACE("(%p)->(%p)\n", This, p);
1768     return get_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, p);
1769 }
1770
1771 static HRESULT WINAPI HTMLStyle_put_borderBottomStyle(IHTMLStyle *iface, BSTR v)
1772 {
1773     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1774     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1775
1776     if(!is_valid_border_style(v))
1777         return E_INVALIDARG;
1778
1779     return set_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, v, 0);
1780 }
1781
1782 static HRESULT WINAPI HTMLStyle_get_borderBottomStyle(IHTMLStyle *iface, BSTR *p)
1783 {
1784     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1785     TRACE("(%p)->(%p)\n", This, p);
1786     return get_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, p);
1787 }
1788
1789 static HRESULT WINAPI HTMLStyle_put_borderLeftStyle(IHTMLStyle *iface, BSTR v)
1790 {
1791     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1792     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1793
1794     if(!is_valid_border_style(v))
1795         return E_INVALIDARG;
1796
1797     return set_style_attr(This, STYLEID_BORDER_LEFT_STYLE, v, 0);
1798 }
1799
1800 static HRESULT WINAPI HTMLStyle_get_borderLeftStyle(IHTMLStyle *iface, BSTR *p)
1801 {
1802     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1803     TRACE("(%p)->(%p)\n", This, p);
1804     return get_style_attr(This, STYLEID_BORDER_LEFT_STYLE, p);
1805 }
1806
1807 static HRESULT WINAPI HTMLStyle_put_width(IHTMLStyle *iface, VARIANT v)
1808 {
1809     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1810
1811     TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1812
1813     return set_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, &v, ATTR_FIX_PX);
1814 }
1815
1816 static HRESULT WINAPI HTMLStyle_get_width(IHTMLStyle *iface, VARIANT *p)
1817 {
1818     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1819
1820     TRACE("(%p)->(%p)\n", This, p);
1821
1822     V_VT(p) = VT_BSTR;
1823     return get_style_attr(This, STYLEID_WIDTH, &V_BSTR(p));
1824 }
1825
1826 static HRESULT WINAPI HTMLStyle_put_height(IHTMLStyle *iface, VARIANT v)
1827 {
1828     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1829
1830     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1831
1832     switch(V_VT(&v)) {
1833     case VT_BSTR:
1834         return set_style_attr(This, STYLEID_HEIGHT, V_BSTR(&v), 0);
1835     default:
1836         FIXME("unimplemented vt %d\n", V_VT(&v));
1837         return E_NOTIMPL;
1838     }
1839
1840     return S_OK;
1841 }
1842
1843 static HRESULT WINAPI HTMLStyle_get_height(IHTMLStyle *iface, VARIANT *p)
1844 {
1845     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1846     BSTR ret;
1847     HRESULT hres;
1848
1849     TRACE("(%p)->(%p)\n", This, p);
1850
1851     hres = get_style_attr(This, STYLEID_HEIGHT, &ret);
1852     if(FAILED(hres))
1853         return hres;
1854
1855     V_VT(p) = VT_BSTR;
1856     V_BSTR(p) = ret;
1857     return S_OK;
1858 }
1859
1860 static HRESULT WINAPI HTMLStyle_put_styleFloat(IHTMLStyle *iface, BSTR v)
1861 {
1862     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1863     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1864     return E_NOTIMPL;
1865 }
1866
1867 static HRESULT WINAPI HTMLStyle_get_styleFloat(IHTMLStyle *iface, BSTR *p)
1868 {
1869     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1870     FIXME("(%p)->(%p)\n", This, p);
1871     return E_NOTIMPL;
1872 }
1873
1874 static HRESULT WINAPI HTMLStyle_put_clear(IHTMLStyle *iface, BSTR v)
1875 {
1876     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1877     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1878     return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI HTMLStyle_get_clear(IHTMLStyle *iface, BSTR *p)
1882 {
1883     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1884     FIXME("(%p)->(%p)\n", This, p);
1885     return E_NOTIMPL;
1886 }
1887
1888 static HRESULT WINAPI HTMLStyle_put_display(IHTMLStyle *iface, BSTR v)
1889 {
1890     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1891
1892     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1893
1894     return set_style_attr(This, STYLEID_DISPLAY, v, 0);
1895 }
1896
1897 static HRESULT WINAPI HTMLStyle_get_display(IHTMLStyle *iface, BSTR *p)
1898 {
1899     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1900
1901     TRACE("(%p)->(%p)\n", This, p);
1902
1903     return get_style_attr(This, STYLEID_DISPLAY, p);
1904 }
1905
1906 static HRESULT WINAPI HTMLStyle_put_visibility(IHTMLStyle *iface, BSTR v)
1907 {
1908     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1909
1910     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1911
1912     return set_style_attr(This, STYLEID_VISIBILITY, v, 0);
1913 }
1914
1915 static HRESULT WINAPI HTMLStyle_get_visibility(IHTMLStyle *iface, BSTR *p)
1916 {
1917     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1918
1919     TRACE("(%p)->(%p)\n", This, p);
1920
1921     return get_style_attr(This, STYLEID_VISIBILITY, p);
1922 }
1923
1924 static HRESULT WINAPI HTMLStyle_put_listStyleType(IHTMLStyle *iface, BSTR v)
1925 {
1926     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1927     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1928     return E_NOTIMPL;
1929 }
1930
1931 static HRESULT WINAPI HTMLStyle_get_listStyleType(IHTMLStyle *iface, BSTR *p)
1932 {
1933     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1934     FIXME("(%p)->(%p)\n", This, p);
1935     return E_NOTIMPL;
1936 }
1937
1938 static HRESULT WINAPI HTMLStyle_put_listStylePosition(IHTMLStyle *iface, BSTR v)
1939 {
1940     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1941     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1942     return E_NOTIMPL;
1943 }
1944
1945 static HRESULT WINAPI HTMLStyle_get_listStylePosition(IHTMLStyle *iface, BSTR *p)
1946 {
1947     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1948     FIXME("(%p)->(%p)\n", This, p);
1949     return E_NOTIMPL;
1950 }
1951
1952 static HRESULT WINAPI HTMLStyle_put_listStyleImage(IHTMLStyle *iface, BSTR v)
1953 {
1954     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1955     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1956     return E_NOTIMPL;
1957 }
1958
1959 static HRESULT WINAPI HTMLStyle_get_listStyleImage(IHTMLStyle *iface, BSTR *p)
1960 {
1961     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1962     FIXME("(%p)->(%p)\n", This, p);
1963     return E_NOTIMPL;
1964 }
1965
1966 static HRESULT WINAPI HTMLStyle_put_listStyle(IHTMLStyle *iface, BSTR v)
1967 {
1968     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1969     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1970     return E_NOTIMPL;
1971 }
1972
1973 static HRESULT WINAPI HTMLStyle_get_listStyle(IHTMLStyle *iface, BSTR *p)
1974 {
1975     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1976     FIXME("(%p)->(%p)\n", This, p);
1977     return E_NOTIMPL;
1978 }
1979
1980 static HRESULT WINAPI HTMLStyle_put_whiteSpace(IHTMLStyle *iface, BSTR v)
1981 {
1982     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1983     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1984     return E_NOTIMPL;
1985 }
1986
1987 static HRESULT WINAPI HTMLStyle_get_whiteSpace(IHTMLStyle *iface, BSTR *p)
1988 {
1989     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1990     FIXME("(%p)->(%p)\n", This, p);
1991     return E_NOTIMPL;
1992 }
1993
1994 static HRESULT WINAPI HTMLStyle_put_top(IHTMLStyle *iface, VARIANT v)
1995 {
1996     HTMLStyle *This = impl_from_IHTMLStyle(iface);
1997
1998     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1999
2000     return set_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, &v, 0);
2001 }
2002
2003 static HRESULT WINAPI HTMLStyle_get_top(IHTMLStyle *iface, VARIANT *p)
2004 {
2005     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2006     BSTR ret;
2007     HRESULT hres;
2008
2009     TRACE("(%p)->(%p)\n", This, p);
2010
2011     hres = get_style_attr(This, STYLEID_TOP, &ret);
2012     if(FAILED(hres))
2013         return hres;
2014
2015     V_VT(p) = VT_BSTR;
2016     V_BSTR(p) = ret;
2017     return S_OK;
2018 }
2019
2020 static HRESULT WINAPI HTMLStyle_put_left(IHTMLStyle *iface, VARIANT v)
2021 {
2022     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2023
2024     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2025
2026     return set_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, &v, 0);
2027 }
2028
2029 static HRESULT WINAPI HTMLStyle_get_left(IHTMLStyle *iface, VARIANT *p)
2030 {
2031     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2032     BSTR ret;
2033     HRESULT hres;
2034
2035     TRACE("(%p)->(%p)\n", This, p);
2036
2037     hres = get_style_attr(This, STYLEID_LEFT, &ret);
2038     if(FAILED(hres))
2039         return hres;
2040
2041     V_VT(p) = VT_BSTR;
2042     V_BSTR(p) = ret;
2043     return S_OK;
2044 }
2045
2046 static HRESULT WINAPI HTMLStyle_get_position(IHTMLStyle *iface, BSTR *p)
2047 {
2048     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2049     TRACE("(%p)->(%p)\n", This, p);
2050     return IHTMLStyle2_get_position(&This->IHTMLStyle2_iface, p);
2051 }
2052
2053 static HRESULT WINAPI HTMLStyle_put_zIndex(IHTMLStyle *iface, VARIANT v)
2054 {
2055     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2056
2057     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2058
2059     switch(V_VT(&v)) {
2060     case VT_BSTR:
2061         return set_style_attr(This, STYLEID_Z_INDEX, V_BSTR(&v), 0);
2062     case VT_I4: {
2063         WCHAR value[14];
2064         static const WCHAR format[] = {'%','d',0};
2065
2066         wsprintfW(value, format, V_I4(&v));
2067         return set_style_attr(This, STYLEID_Z_INDEX, value, 0);
2068     }
2069     default:
2070         FIXME("unimplemented vt %d\n", V_VT(&v));
2071         return E_NOTIMPL;
2072     }
2073
2074     return S_OK;
2075 }
2076
2077 static HRESULT WINAPI HTMLStyle_get_zIndex(IHTMLStyle *iface, VARIANT *p)
2078 {
2079     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2080
2081     TRACE("(%p)->(%p)\n", This, p);
2082
2083     return get_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, p, ATTR_STR_TO_INT);
2084 }
2085
2086 static HRESULT WINAPI HTMLStyle_put_overflow(IHTMLStyle *iface, BSTR v)
2087 {
2088     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2089     static const WCHAR szVisible[] = {'v','i','s','i','b','l','e',0};
2090     static const WCHAR szScroll[]  = {'s','c','r','o','l','l',0};
2091     static const WCHAR szHidden[]  = {'h','i','d','d','e','n',0};
2092     static const WCHAR szAuto[]    = {'a','u','t','o',0};
2093
2094     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2095
2096     /* overflow can only be one of the follow values. */
2097     if(!v || !*v || strcmpiW(szVisible, v) == 0 || strcmpiW(szScroll, v) == 0 ||
2098              strcmpiW(szHidden, v) == 0  || strcmpiW(szAuto, v) == 0)
2099     {
2100         return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW, v, 0);
2101     }
2102
2103     return E_INVALIDARG;
2104 }
2105
2106
2107 static HRESULT WINAPI HTMLStyle_get_overflow(IHTMLStyle *iface, BSTR *p)
2108 {
2109     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2110
2111     TRACE("(%p)->(%p)\n", This, p);
2112
2113     if(!p)
2114        return E_INVALIDARG;
2115
2116     return get_style_attr(This, STYLEID_OVERFLOW, p);
2117 }
2118
2119 static HRESULT WINAPI HTMLStyle_put_pageBreakBefore(IHTMLStyle *iface, BSTR v)
2120 {
2121     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2122     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2123     return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI HTMLStyle_get_pageBreakBefore(IHTMLStyle *iface, BSTR *p)
2127 {
2128     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2129     FIXME("(%p)->(%p)\n", This, p);
2130     return E_NOTIMPL;
2131 }
2132
2133 static HRESULT WINAPI HTMLStyle_put_pageBreakAfter(IHTMLStyle *iface, BSTR v)
2134 {
2135     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2136     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2137     return E_NOTIMPL;
2138 }
2139
2140 static HRESULT WINAPI HTMLStyle_get_pageBreakAfter(IHTMLStyle *iface, BSTR *p)
2141 {
2142     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2143     FIXME("(%p)->(%p)\n", This, p);
2144     return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI HTMLStyle_put_cssText(IHTMLStyle *iface, BSTR v)
2148 {
2149     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2150     nsAString text_str;
2151     nsresult nsres;
2152
2153     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2154
2155     nsAString_InitDepend(&text_str, v);
2156     nsres = nsIDOMCSSStyleDeclaration_SetCssText(This->nsstyle, &text_str);
2157     nsAString_Finish(&text_str);
2158     if(NS_FAILED(nsres)) {
2159         FIXME("SetCssStyle failed: %08x\n", nsres);
2160         return E_FAIL;
2161     }
2162
2163     return S_OK;
2164 }
2165
2166 static HRESULT WINAPI HTMLStyle_get_cssText(IHTMLStyle *iface, BSTR *p)
2167 {
2168     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2169     nsAString text_str;
2170     nsresult nsres;
2171
2172     TRACE("(%p)->(%p)\n", This, p);
2173
2174     /* FIXME: Gecko style formatting is different than IE (uppercase). */
2175     nsAString_Init(&text_str, NULL);
2176     nsres = nsIDOMCSSStyleDeclaration_GetCssText(This->nsstyle, &text_str);
2177     if(NS_SUCCEEDED(nsres)) {
2178         const PRUnichar *text;
2179
2180         nsAString_GetData(&text_str, &text);
2181         *p = *text ? SysAllocString(text) : NULL;
2182     }else {
2183         FIXME("GetCssStyle failed: %08x\n", nsres);
2184         *p = NULL;
2185     }
2186
2187     nsAString_Finish(&text_str);
2188     return S_OK;
2189 }
2190
2191 static HRESULT WINAPI HTMLStyle_put_pixelTop(IHTMLStyle *iface, LONG v)
2192 {
2193     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2194     FIXME("(%p)->()\n", This);
2195     return E_NOTIMPL;
2196 }
2197
2198 static HRESULT WINAPI HTMLStyle_get_pixelTop(IHTMLStyle *iface, LONG *p)
2199 {
2200     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2201     FIXME("(%p)->()\n", This);
2202     return E_NOTIMPL;
2203 }
2204
2205 static HRESULT WINAPI HTMLStyle_put_pixelLeft(IHTMLStyle *iface, LONG v)
2206 {
2207     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2208     FIXME("(%p)->()\n", This);
2209     return E_NOTIMPL;
2210 }
2211
2212 static HRESULT WINAPI HTMLStyle_get_pixelLeft(IHTMLStyle *iface, LONG *p)
2213 {
2214     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2215     FIXME("(%p)->()\n", This);
2216     return E_NOTIMPL;
2217 }
2218
2219 static HRESULT WINAPI HTMLStyle_put_pixelWidth(IHTMLStyle *iface, LONG v)
2220 {
2221     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2222     FIXME("(%p)->()\n", This);
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT WINAPI HTMLStyle_get_pixelWidth(IHTMLStyle *iface, LONG *p)
2227 {
2228     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2229     FIXME("(%p)->()\n", This);
2230     return E_NOTIMPL;
2231 }
2232
2233 static HRESULT WINAPI HTMLStyle_put_pixelHeight(IHTMLStyle *iface, LONG v)
2234 {
2235     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2236     FIXME("(%p)->()\n", This);
2237     return E_NOTIMPL;
2238 }
2239
2240 static HRESULT WINAPI HTMLStyle_get_pixelHeight(IHTMLStyle *iface, LONG *p)
2241 {
2242     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2243     FIXME("(%p)->()\n", This);
2244     return E_NOTIMPL;
2245 }
2246
2247 static HRESULT WINAPI HTMLStyle_put_posTop(IHTMLStyle *iface, float v)
2248 {
2249     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2250
2251     TRACE("(%p)->(%f)\n", This, v);
2252
2253     return set_style_pos(This, STYLEID_TOP, v);
2254 }
2255
2256 static HRESULT WINAPI HTMLStyle_get_posTop(IHTMLStyle *iface, float *p)
2257 {
2258     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2259
2260     TRACE("(%p)->(%p)\n", This, p);
2261
2262     if(!p)
2263         return E_POINTER;
2264
2265     return get_nsstyle_pos(This, STYLEID_TOP, p);
2266 }
2267
2268 static HRESULT WINAPI HTMLStyle_put_posLeft(IHTMLStyle *iface, float v)
2269 {
2270     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2271
2272     TRACE("(%p)->(%f)\n", This, v);
2273
2274     return set_style_pos(This, STYLEID_LEFT, v);
2275 }
2276
2277 static HRESULT WINAPI HTMLStyle_get_posLeft(IHTMLStyle *iface, float *p)
2278 {
2279     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2280
2281     TRACE("(%p)->(%p)\n", This, p);
2282
2283     if(!p)
2284         return E_POINTER;
2285
2286     return get_nsstyle_pos(This, STYLEID_LEFT, p);
2287 }
2288
2289 static HRESULT WINAPI HTMLStyle_put_posWidth(IHTMLStyle *iface, float v)
2290 {
2291     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2292
2293     TRACE("(%p)->(%f)\n", This, v);
2294
2295     return set_style_pos(This, STYLEID_WIDTH, v);
2296 }
2297
2298 static HRESULT WINAPI HTMLStyle_get_posWidth(IHTMLStyle *iface, float *p)
2299 {
2300     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2301
2302     TRACE("(%p)->(%p)\n", This, p);
2303
2304     if(!p)
2305         return E_POINTER;
2306
2307     if(get_nsstyle_pos(This, STYLEID_WIDTH, p) != S_OK)
2308         *p = 0.0f;
2309
2310     return S_OK;
2311 }
2312
2313 static HRESULT WINAPI HTMLStyle_put_posHeight(IHTMLStyle *iface, float v)
2314 {
2315     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2316
2317     TRACE("(%p)->(%f)\n", This, v);
2318
2319     return set_style_pos(This, STYLEID_HEIGHT, v);
2320 }
2321
2322 static HRESULT WINAPI HTMLStyle_get_posHeight(IHTMLStyle *iface, float *p)
2323 {
2324     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2325
2326     TRACE("(%p)->(%p)\n", This, p);
2327
2328     if(!p)
2329         return E_POINTER;
2330
2331     if(get_nsstyle_pos(This, STYLEID_HEIGHT, p) != S_OK)
2332         *p = 0.0f;
2333
2334     return S_OK;
2335 }
2336
2337 static HRESULT WINAPI HTMLStyle_put_cursor(IHTMLStyle *iface, BSTR v)
2338 {
2339     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2340
2341     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2342
2343     return set_style_attr(This, STYLEID_CURSOR, v, 0);
2344 }
2345
2346 static HRESULT WINAPI HTMLStyle_get_cursor(IHTMLStyle *iface, BSTR *p)
2347 {
2348     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2349
2350     TRACE("(%p)->(%p)\n", This, p);
2351
2352     return get_style_attr(This, STYLEID_CURSOR, p);
2353 }
2354
2355 static HRESULT WINAPI HTMLStyle_put_clip(IHTMLStyle *iface, BSTR v)
2356 {
2357     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2358     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2359     return E_NOTIMPL;
2360 }
2361
2362 static HRESULT WINAPI HTMLStyle_get_clip(IHTMLStyle *iface, BSTR *p)
2363 {
2364     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2365     FIXME("(%p)->(%p)\n", This, p);
2366     return E_NOTIMPL;
2367 }
2368
2369 static HRESULT WINAPI HTMLStyle_put_filter(IHTMLStyle *iface, BSTR v)
2370 {
2371     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2372
2373     WARN("(%p)->(%s)\n", This, debugstr_w(v));
2374
2375     /* FIXME: Handle MS-style filters */
2376     return set_style_attr(This, STYLEID_FILTER, v, 0);
2377 }
2378
2379 static HRESULT WINAPI HTMLStyle_get_filter(IHTMLStyle *iface, BSTR *p)
2380 {
2381     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2382
2383     WARN("(%p)->(%p)\n", This, p);
2384
2385     /* FIXME: Handle MS-style filters */
2386     return get_style_attr(This, STYLEID_FILTER, p);
2387 }
2388
2389 static HRESULT WINAPI HTMLStyle_setAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2390         VARIANT AttributeValue, LONG lFlags)
2391 {
2392     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2393     HRESULT hres;
2394     DISPID dispid;
2395
2396     TRACE("(%p)->(%s v%d %08x)\n", This, debugstr_w(strAttributeName),
2397            V_VT(&AttributeValue), lFlags);
2398
2399     if(!strAttributeName)
2400         return E_INVALIDARG;
2401
2402     if(lFlags == 1)
2403         FIXME("Parameter lFlags ignored\n");
2404
2405     hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2406                         LOCALE_USER_DEFAULT, &dispid);
2407     if(hres == S_OK)
2408     {
2409         VARIANT ret;
2410         DISPID dispidNamed = DISPID_PROPERTYPUT;
2411         DISPPARAMS params;
2412
2413         params.cArgs = 1;
2414         params.rgvarg = &AttributeValue;
2415         params.cNamedArgs = 1;
2416         params.rgdispidNamedArgs = &dispidNamed;
2417
2418         hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2419             DISPATCH_PROPERTYPUT, &params, &ret, NULL, NULL);
2420     }
2421     else
2422     {
2423         FIXME("Custom attributes not supported.\n");
2424     }
2425
2426     TRACE("ret: %08x\n", hres);
2427
2428     return hres;
2429 }
2430
2431 static HRESULT WINAPI HTMLStyle_getAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2432         LONG lFlags, VARIANT *AttributeValue)
2433 {
2434     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2435     HRESULT hres;
2436     DISPID dispid;
2437
2438     TRACE("(%p)->(%s v%p %08x)\n", This, debugstr_w(strAttributeName),
2439           AttributeValue, lFlags);
2440
2441     if(!AttributeValue || !strAttributeName)
2442         return E_INVALIDARG;
2443
2444     if(lFlags == 1)
2445         FIXME("Parameter lFlags ignored\n");
2446
2447     hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2448                         LOCALE_USER_DEFAULT, &dispid);
2449     if(hres == S_OK)
2450     {
2451         DISPPARAMS params = {NULL, NULL, 0, 0 };
2452
2453         hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2454             DISPATCH_PROPERTYGET, &params, AttributeValue, NULL, NULL);
2455     }
2456     else
2457     {
2458         FIXME("Custom attributes not supported.\n");
2459     }
2460
2461     return hres;
2462 }
2463
2464 static HRESULT WINAPI HTMLStyle_removeAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2465                                                 LONG lFlags, VARIANT_BOOL *pfSuccess)
2466 {
2467     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2468     FIXME("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName),
2469          lFlags, pfSuccess);
2470     return E_NOTIMPL;
2471 }
2472
2473 static HRESULT WINAPI HTMLStyle_toString(IHTMLStyle *iface, BSTR *String)
2474 {
2475     HTMLStyle *This = impl_from_IHTMLStyle(iface);
2476     FIXME("(%p)->(%p)\n", This, String);
2477     return E_NOTIMPL;
2478 }
2479
2480 static const IHTMLStyleVtbl HTMLStyleVtbl = {
2481     HTMLStyle_QueryInterface,
2482     HTMLStyle_AddRef,
2483     HTMLStyle_Release,
2484     HTMLStyle_GetTypeInfoCount,
2485     HTMLStyle_GetTypeInfo,
2486     HTMLStyle_GetIDsOfNames,
2487     HTMLStyle_Invoke,
2488     HTMLStyle_put_fontFamily,
2489     HTMLStyle_get_fontFamily,
2490     HTMLStyle_put_fontStyle,
2491     HTMLStyle_get_fontStyle,
2492     HTMLStyle_put_fontVariant,
2493     HTMLStyle_get_fontVariant,
2494     HTMLStyle_put_fontWeight,
2495     HTMLStyle_get_fontWeight,
2496     HTMLStyle_put_fontSize,
2497     HTMLStyle_get_fontSize,
2498     HTMLStyle_put_font,
2499     HTMLStyle_get_font,
2500     HTMLStyle_put_color,
2501     HTMLStyle_get_color,
2502     HTMLStyle_put_background,
2503     HTMLStyle_get_background,
2504     HTMLStyle_put_backgroundColor,
2505     HTMLStyle_get_backgroundColor,
2506     HTMLStyle_put_backgroundImage,
2507     HTMLStyle_get_backgroundImage,
2508     HTMLStyle_put_backgroundRepeat,
2509     HTMLStyle_get_backgroundRepeat,
2510     HTMLStyle_put_backgroundAttachment,
2511     HTMLStyle_get_backgroundAttachment,
2512     HTMLStyle_put_backgroundPosition,
2513     HTMLStyle_get_backgroundPosition,
2514     HTMLStyle_put_backgroundPositionX,
2515     HTMLStyle_get_backgroundPositionX,
2516     HTMLStyle_put_backgroundPositionY,
2517     HTMLStyle_get_backgroundPositionY,
2518     HTMLStyle_put_wordSpacing,
2519     HTMLStyle_get_wordSpacing,
2520     HTMLStyle_put_letterSpacing,
2521     HTMLStyle_get_letterSpacing,
2522     HTMLStyle_put_textDecoration,
2523     HTMLStyle_get_textDecoration,
2524     HTMLStyle_put_textDecorationNone,
2525     HTMLStyle_get_textDecorationNone,
2526     HTMLStyle_put_textDecorationUnderline,
2527     HTMLStyle_get_textDecorationUnderline,
2528     HTMLStyle_put_textDecorationOverline,
2529     HTMLStyle_get_textDecorationOverline,
2530     HTMLStyle_put_textDecorationLineThrough,
2531     HTMLStyle_get_textDecorationLineThrough,
2532     HTMLStyle_put_textDecorationBlink,
2533     HTMLStyle_get_textDecorationBlink,
2534     HTMLStyle_put_verticalAlign,
2535     HTMLStyle_get_verticalAlign,
2536     HTMLStyle_put_textTransform,
2537     HTMLStyle_get_textTransform,
2538     HTMLStyle_put_textAlign,
2539     HTMLStyle_get_textAlign,
2540     HTMLStyle_put_textIndent,
2541     HTMLStyle_get_textIndent,
2542     HTMLStyle_put_lineHeight,
2543     HTMLStyle_get_lineHeight,
2544     HTMLStyle_put_marginTop,
2545     HTMLStyle_get_marginTop,
2546     HTMLStyle_put_marginRight,
2547     HTMLStyle_get_marginRight,
2548     HTMLStyle_put_marginBottom,
2549     HTMLStyle_get_marginBottom,
2550     HTMLStyle_put_marginLeft,
2551     HTMLStyle_get_marginLeft,
2552     HTMLStyle_put_margin,
2553     HTMLStyle_get_margin,
2554     HTMLStyle_put_paddingTop,
2555     HTMLStyle_get_paddingTop,
2556     HTMLStyle_put_paddingRight,
2557     HTMLStyle_get_paddingRight,
2558     HTMLStyle_put_paddingBottom,
2559     HTMLStyle_get_paddingBottom,
2560     HTMLStyle_put_paddingLeft,
2561     HTMLStyle_get_paddingLeft,
2562     HTMLStyle_put_padding,
2563     HTMLStyle_get_padding,
2564     HTMLStyle_put_border,
2565     HTMLStyle_get_border,
2566     HTMLStyle_put_borderTop,
2567     HTMLStyle_get_borderTop,
2568     HTMLStyle_put_borderRight,
2569     HTMLStyle_get_borderRight,
2570     HTMLStyle_put_borderBottom,
2571     HTMLStyle_get_borderBottom,
2572     HTMLStyle_put_borderLeft,
2573     HTMLStyle_get_borderLeft,
2574     HTMLStyle_put_borderColor,
2575     HTMLStyle_get_borderColor,
2576     HTMLStyle_put_borderTopColor,
2577     HTMLStyle_get_borderTopColor,
2578     HTMLStyle_put_borderRightColor,
2579     HTMLStyle_get_borderRightColor,
2580     HTMLStyle_put_borderBottomColor,
2581     HTMLStyle_get_borderBottomColor,
2582     HTMLStyle_put_borderLeftColor,
2583     HTMLStyle_get_borderLeftColor,
2584     HTMLStyle_put_borderWidth,
2585     HTMLStyle_get_borderWidth,
2586     HTMLStyle_put_borderTopWidth,
2587     HTMLStyle_get_borderTopWidth,
2588     HTMLStyle_put_borderRightWidth,
2589     HTMLStyle_get_borderRightWidth,
2590     HTMLStyle_put_borderBottomWidth,
2591     HTMLStyle_get_borderBottomWidth,
2592     HTMLStyle_put_borderLeftWidth,
2593     HTMLStyle_get_borderLeftWidth,
2594     HTMLStyle_put_borderStyle,
2595     HTMLStyle_get_borderStyle,
2596     HTMLStyle_put_borderTopStyle,
2597     HTMLStyle_get_borderTopStyle,
2598     HTMLStyle_put_borderRightStyle,
2599     HTMLStyle_get_borderRightStyle,
2600     HTMLStyle_put_borderBottomStyle,
2601     HTMLStyle_get_borderBottomStyle,
2602     HTMLStyle_put_borderLeftStyle,
2603     HTMLStyle_get_borderLeftStyle,
2604     HTMLStyle_put_width,
2605     HTMLStyle_get_width,
2606     HTMLStyle_put_height,
2607     HTMLStyle_get_height,
2608     HTMLStyle_put_styleFloat,
2609     HTMLStyle_get_styleFloat,
2610     HTMLStyle_put_clear,
2611     HTMLStyle_get_clear,
2612     HTMLStyle_put_display,
2613     HTMLStyle_get_display,
2614     HTMLStyle_put_visibility,
2615     HTMLStyle_get_visibility,
2616     HTMLStyle_put_listStyleType,
2617     HTMLStyle_get_listStyleType,
2618     HTMLStyle_put_listStylePosition,
2619     HTMLStyle_get_listStylePosition,
2620     HTMLStyle_put_listStyleImage,
2621     HTMLStyle_get_listStyleImage,
2622     HTMLStyle_put_listStyle,
2623     HTMLStyle_get_listStyle,
2624     HTMLStyle_put_whiteSpace,
2625     HTMLStyle_get_whiteSpace,
2626     HTMLStyle_put_top,
2627     HTMLStyle_get_top,
2628     HTMLStyle_put_left,
2629     HTMLStyle_get_left,
2630     HTMLStyle_get_position,
2631     HTMLStyle_put_zIndex,
2632     HTMLStyle_get_zIndex,
2633     HTMLStyle_put_overflow,
2634     HTMLStyle_get_overflow,
2635     HTMLStyle_put_pageBreakBefore,
2636     HTMLStyle_get_pageBreakBefore,
2637     HTMLStyle_put_pageBreakAfter,
2638     HTMLStyle_get_pageBreakAfter,
2639     HTMLStyle_put_cssText,
2640     HTMLStyle_get_cssText,
2641     HTMLStyle_put_pixelTop,
2642     HTMLStyle_get_pixelTop,
2643     HTMLStyle_put_pixelLeft,
2644     HTMLStyle_get_pixelLeft,
2645     HTMLStyle_put_pixelWidth,
2646     HTMLStyle_get_pixelWidth,
2647     HTMLStyle_put_pixelHeight,
2648     HTMLStyle_get_pixelHeight,
2649     HTMLStyle_put_posTop,
2650     HTMLStyle_get_posTop,
2651     HTMLStyle_put_posLeft,
2652     HTMLStyle_get_posLeft,
2653     HTMLStyle_put_posWidth,
2654     HTMLStyle_get_posWidth,
2655     HTMLStyle_put_posHeight,
2656     HTMLStyle_get_posHeight,
2657     HTMLStyle_put_cursor,
2658     HTMLStyle_get_cursor,
2659     HTMLStyle_put_clip,
2660     HTMLStyle_get_clip,
2661     HTMLStyle_put_filter,
2662     HTMLStyle_get_filter,
2663     HTMLStyle_setAttribute,
2664     HTMLStyle_getAttribute,
2665     HTMLStyle_removeAttribute,
2666     HTMLStyle_toString
2667 };
2668
2669 static HRESULT HTMLStyle_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
2670 {
2671     int c, i, min=0, max = sizeof(style_tbl)/sizeof(*style_tbl)-1;
2672
2673     while(min <= max) {
2674         i = (min+max)/2;
2675
2676         c = strcmpW(style_tbl[i].name, name);
2677         if(!c) {
2678             *dispid = style_tbl[i].dispid;
2679             return S_OK;
2680         }
2681
2682         if(c > 0)
2683             max = i-1;
2684         else
2685             min = i+1;
2686     }
2687
2688     return DISP_E_UNKNOWNNAME;
2689 }
2690
2691 static const dispex_static_data_vtbl_t HTMLStyle_dispex_vtbl = {
2692     NULL,
2693     HTMLStyle_get_dispid,
2694     NULL
2695 };
2696
2697 static const tid_t HTMLStyle_iface_tids[] = {
2698     IHTMLStyle_tid,
2699     IHTMLStyle2_tid,
2700     IHTMLStyle3_tid,
2701     IHTMLStyle4_tid,
2702     0
2703 };
2704 static dispex_static_data_t HTMLStyle_dispex = {
2705     &HTMLStyle_dispex_vtbl,
2706     DispHTMLStyle_tid,
2707     NULL,
2708     HTMLStyle_iface_tids
2709 };
2710
2711 IHTMLStyle *HTMLStyle_Create(nsIDOMCSSStyleDeclaration *nsstyle)
2712 {
2713     HTMLStyle *ret = heap_alloc_zero(sizeof(HTMLStyle));
2714
2715     ret->IHTMLStyle_iface.lpVtbl = &HTMLStyleVtbl;
2716     ret->ref = 1;
2717     ret->nsstyle = nsstyle;
2718     HTMLStyle2_Init(ret);
2719     HTMLStyle3_Init(ret);
2720
2721     nsIDOMCSSStyleDeclaration_AddRef(nsstyle);
2722
2723     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLStyle_iface, &HTMLStyle_dispex);
2724
2725     return &ret->IHTMLStyle_iface;
2726 }