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