git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlstyle.c

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