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