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