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