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