?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Wine Gecko 1.5 release.
[wine/multimedia.git] / dlls / mshtml / htmlstyle.c
blob0487992a5ec96010d359c3f7dab3fc5879e328e3
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 vt %d\n", V_VT(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 heap_free(This->filter);
698 release_dispex(&This->dispex);
699 heap_free(This);
700 }
701
702 return ref;
703 }
704
705 static HRESULT WINAPI HTMLStyle_GetTypeInfoCount(IHTMLStyle *iface, UINT *pctinfo)
706 {
707 HTMLStyle *This = impl_from_IHTMLStyle(iface);
708 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
709 }
710
711 static HRESULT WINAPI HTMLStyle_GetTypeInfo(IHTMLStyle *iface, UINT iTInfo,
712 LCID lcid, ITypeInfo **ppTInfo)
713 {
714 HTMLStyle *This = impl_from_IHTMLStyle(iface);
715 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
716 }
717
718 static HRESULT WINAPI HTMLStyle_GetIDsOfNames(IHTMLStyle *iface, REFIID riid,
719 LPOLESTR *rgszNames, UINT cNames,
720 LCID lcid, DISPID *rgDispId)
721 {
722 HTMLStyle *This = impl_from_IHTMLStyle(iface);
723 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
724 lcid, rgDispId);
725 }
726
727 static HRESULT WINAPI HTMLStyle_Invoke(IHTMLStyle *iface, DISPID dispIdMember,
728 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
729 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
730 {
731 HTMLStyle *This = impl_from_IHTMLStyle(iface);
732 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
733 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
734 }
735
736 static HRESULT WINAPI HTMLStyle_put_fontFamily(IHTMLStyle *iface, BSTR v)
737 {
738 HTMLStyle *This = impl_from_IHTMLStyle(iface);
739
740 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
741
742 return set_style_attr(This, STYLEID_FONT_FAMILY, v, 0);
743 }
744
745 static HRESULT WINAPI HTMLStyle_get_fontFamily(IHTMLStyle *iface, BSTR *p)
746 {
747 HTMLStyle *This = impl_from_IHTMLStyle(iface);
748
749 TRACE("(%p)->(%p)\n", This, p);
750
751 return get_style_attr(This, STYLEID_FONT_FAMILY, p);
752 }
753
754 static HRESULT WINAPI HTMLStyle_put_fontStyle(IHTMLStyle *iface, BSTR v)
755 {
756 HTMLStyle *This = impl_from_IHTMLStyle(iface);
757 static const WCHAR szItalic[] = {'i','t','a','l','i','c',0};
758 static const WCHAR szOblique[] = {'o','b','l','i','q','u','e',0};
759
760 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
761
762 /* fontStyle can only be one of the follow values. */
763 if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szItalic, v) == 0 ||
764 strcmpiW(szOblique, v) == 0)
765 {
766 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_STYLE, v, 0);
767 }
768
769 return E_INVALIDARG;
770 }
771
772 static HRESULT WINAPI HTMLStyle_get_fontStyle(IHTMLStyle *iface, BSTR *p)
773 {
774 HTMLStyle *This = impl_from_IHTMLStyle(iface);
775
776 TRACE("(%p)->(%p)\n", This, p);
777
778 return get_style_attr(This, STYLEID_FONT_STYLE, p);
779 }
780
781 static HRESULT WINAPI HTMLStyle_put_fontVariant(IHTMLStyle *iface, BSTR v)
782 {
783 HTMLStyle *This = impl_from_IHTMLStyle(iface);
784 static const WCHAR szCaps[] = {'s','m','a','l','l','-','c','a','p','s',0};
785
786 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
787
788 /* fontVariant can only be one of the follow values. */
789 if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szCaps, v) == 0)
790 {
791 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_VARIANT, v, 0);
792 }
793
794 return E_INVALIDARG;
795 }
796
797 static HRESULT WINAPI HTMLStyle_get_fontVariant(IHTMLStyle *iface, BSTR *p)
798 {
799 HTMLStyle *This = impl_from_IHTMLStyle(iface);
800 TRACE("(%p)->(%p)\n", This, p);
801
802 if(!p)
803 return E_INVALIDARG;
804
805 return get_style_attr(This, STYLEID_FONT_VARIANT, p);
806 }
807
808 static HRESULT WINAPI HTMLStyle_put_fontWeight(IHTMLStyle *iface, BSTR v)
809 {
810 HTMLStyle *This = impl_from_IHTMLStyle(iface);
811 static const WCHAR styleBold[] = {'b','o','l','d',0};
812 static const WCHAR styleBolder[] = {'b','o','l','d','e','r',0};
813 static const WCHAR styleLighter[] = {'l','i','g','h','t','e','r',0};
814 static const WCHAR style100[] = {'1','0','0',0};
815 static const WCHAR style200[] = {'2','0','0',0};
816 static const WCHAR style300[] = {'3','0','0',0};
817 static const WCHAR style400[] = {'4','0','0',0};
818 static const WCHAR style500[] = {'5','0','0',0};
819 static const WCHAR style600[] = {'6','0','0',0};
820 static const WCHAR style700[] = {'7','0','0',0};
821 static const WCHAR style800[] = {'8','0','0',0};
822 static const WCHAR style900[] = {'9','0','0',0};
823
824 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
825
826 /* fontWeight can only be one of the following */
827 if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(styleBold, v) == 0 ||
828 strcmpiW(styleBolder, v) == 0 || strcmpiW(styleLighter, v) == 0 ||
829 strcmpiW(style100, v) == 0 || strcmpiW(style200, v) == 0 ||
830 strcmpiW(style300, v) == 0 || strcmpiW(style400, v) == 0 ||
831 strcmpiW(style500, v) == 0 || strcmpiW(style600, v) == 0 ||
832 strcmpiW(style700, v) == 0 || strcmpiW(style800, v) == 0 ||
833 strcmpiW(style900, v) == 0
834 )
835 {
836 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_WEIGHT, v, 0);
837 }
838
839 return E_INVALIDARG;
840 }
841
842 static HRESULT WINAPI HTMLStyle_get_fontWeight(IHTMLStyle *iface, BSTR *p)
843 {
844 HTMLStyle *This = impl_from_IHTMLStyle(iface);
845
846 TRACE("(%p)->(%p)\n", This, p);
847
848 return get_style_attr(This, STYLEID_FONT_WEIGHT, p);
849 }
850
851 static HRESULT WINAPI HTMLStyle_put_fontSize(IHTMLStyle *iface, VARIANT v)
852 {
853 HTMLStyle *This = impl_from_IHTMLStyle(iface);
854
855 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
856
857 switch(V_VT(&v)) {
858 case VT_BSTR:
859 return set_style_attr(This, STYLEID_FONT_SIZE, V_BSTR(&v), 0);
860 default:
861 FIXME("not supported vt %d\n", V_VT(&v));
862 }
863
864 return S_OK;
865 }
866
867 static HRESULT WINAPI HTMLStyle_get_fontSize(IHTMLStyle *iface, VARIANT *p)
868 {
869 HTMLStyle *This = impl_from_IHTMLStyle(iface);
870
871 TRACE("(%p)->(%p)\n", This, p);
872
873 V_VT(p) = VT_BSTR;
874 return get_style_attr(This, STYLEID_FONT_SIZE, &V_BSTR(p));
875 }
876
877 static HRESULT WINAPI HTMLStyle_put_font(IHTMLStyle *iface, BSTR v)
878 {
879 HTMLStyle *This = impl_from_IHTMLStyle(iface);
880 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
881 return E_NOTIMPL;
882 }
883
884 static HRESULT WINAPI HTMLStyle_get_font(IHTMLStyle *iface, BSTR *p)
885 {
886 HTMLStyle *This = impl_from_IHTMLStyle(iface);
887 FIXME("(%p)->(%p)\n", This, p);
888 return E_NOTIMPL;
889 }
890
891 static HRESULT WINAPI HTMLStyle_put_color(IHTMLStyle *iface, VARIANT v)
892 {
893 HTMLStyle *This = impl_from_IHTMLStyle(iface);
894
895 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
896
897 switch(V_VT(&v)) {
898 case VT_BSTR:
899 TRACE("%s\n", debugstr_w(V_BSTR(&v)));
900 return set_style_attr(This, STYLEID_COLOR, V_BSTR(&v), 0);
901
902 default:
903 FIXME("unsupported vt=%d\n", V_VT(&v));
904 }
905
906 return E_NOTIMPL;
907 }
908
909 static HRESULT WINAPI HTMLStyle_get_color(IHTMLStyle *iface, VARIANT *p)
910 {
911 HTMLStyle *This = impl_from_IHTMLStyle(iface);
912
913 TRACE("(%p)->(%p)\n", This, p);
914
915 V_VT(p) = VT_BSTR;
916 return get_style_attr(This, STYLEID_COLOR, &V_BSTR(p));
917 }
918
919 static HRESULT WINAPI HTMLStyle_put_background(IHTMLStyle *iface, BSTR v)
920 {
921 HTMLStyle *This = impl_from_IHTMLStyle(iface);
922
923 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
924
925 return set_style_attr(This, STYLEID_BACKGROUND, v, 0);
926 }
927
928 static HRESULT WINAPI HTMLStyle_get_background(IHTMLStyle *iface, BSTR *p)
929 {
930 HTMLStyle *This = impl_from_IHTMLStyle(iface);
931
932 TRACE("(%p)->(%p)\n", This, p);
933
934 return get_style_attr(This, STYLEID_BACKGROUND, p);
935 }
936
937 static HRESULT WINAPI HTMLStyle_put_backgroundColor(IHTMLStyle *iface, VARIANT v)
938 {
939 HTMLStyle *This = impl_from_IHTMLStyle(iface);
940
941 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
942
943 switch(V_VT(&v)) {
944 case VT_BSTR:
945 return set_style_attr(This, STYLEID_BACKGROUND_COLOR, V_BSTR(&v), 0);
946 case VT_I4: {
947 WCHAR value[10];
948 static const WCHAR format[] = {'#','%','0','6','x',0};
949
950 wsprintfW(value, format, V_I4(&v));
951 return set_style_attr(This, STYLEID_BACKGROUND_COLOR, value, 0);
952 }
953 default:
954 FIXME("unsupported vt %d\n", V_VT(&v));
955 }
956
957 return S_OK;
958 }
959
960 static HRESULT WINAPI HTMLStyle_get_backgroundColor(IHTMLStyle *iface, VARIANT *p)
961 {
962 HTMLStyle *This = impl_from_IHTMLStyle(iface);
963 TRACE("(%p)->(%p)\n", This, p);
964
965 V_VT(p) = VT_BSTR;
966 return get_style_attr(This, STYLEID_BACKGROUND_COLOR, &V_BSTR(p));
967 }
968
969 static HRESULT WINAPI HTMLStyle_put_backgroundImage(IHTMLStyle *iface, BSTR v)
970 {
971 HTMLStyle *This = impl_from_IHTMLStyle(iface);
972
973 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
974
975 return set_style_attr(This, STYLEID_BACKGROUND_IMAGE, v, ATTR_FIX_URL);
976 }
977
978 static HRESULT WINAPI HTMLStyle_get_backgroundImage(IHTMLStyle *iface, BSTR *p)
979 {
980 HTMLStyle *This = impl_from_IHTMLStyle(iface);
981
982 TRACE("(%p)->(%p)\n", This, p);
983
984 return get_style_attr(This, STYLEID_BACKGROUND_IMAGE, p);
985 }
986
987 static HRESULT WINAPI HTMLStyle_put_backgroundRepeat(IHTMLStyle *iface, BSTR v)
988 {
989 HTMLStyle *This = impl_from_IHTMLStyle(iface);
990 static const WCHAR styleRepeat[] = {'r','e','p','e','a','t',0};
991 static const WCHAR styleNoRepeat[] = {'n','o','-','r','e','p','e','a','t',0};
992 static const WCHAR styleRepeatX[] = {'r','e','p','e','a','t','-','x',0};
993 static const WCHAR styleRepeatY[] = {'r','e','p','e','a','t','-','y',0};
994
995 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
996
997 /* fontWeight can only be one of the following */
998 if(!v || strcmpiW(styleRepeat, v) == 0 || strcmpiW(styleNoRepeat, v) == 0 ||
999 strcmpiW(styleRepeatX, v) == 0 || strcmpiW(styleRepeatY, v) == 0 )
1000 {
1001 return set_style_attr(This, STYLEID_BACKGROUND_REPEAT , v, 0);
1002 }
1003
1004 return E_INVALIDARG;
1005 }
1006
1007 static HRESULT WINAPI HTMLStyle_get_backgroundRepeat(IHTMLStyle *iface, BSTR *p)
1008 {
1009 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1010
1011 TRACE("(%p)->(%p)\n", This, p);
1012
1013 return get_style_attr(This, STYLEID_BACKGROUND_REPEAT, p);
1014 }
1015
1016 static HRESULT WINAPI HTMLStyle_put_backgroundAttachment(IHTMLStyle *iface, BSTR v)
1017 {
1018 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1019 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1020 return E_NOTIMPL;
1021 }
1022
1023 static HRESULT WINAPI HTMLStyle_get_backgroundAttachment(IHTMLStyle *iface, BSTR *p)
1024 {
1025 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1026 FIXME("(%p)->(%p)\n", This, p);
1027 return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI HTMLStyle_put_backgroundPosition(IHTMLStyle *iface, BSTR v)
1031 {
1032 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1033
1034 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1035
1036 return set_style_attr(This, STYLEID_BACKGROUND_POSITION, v, 0);
1037 }
1038
1039 static HRESULT WINAPI HTMLStyle_get_backgroundPosition(IHTMLStyle *iface, BSTR *p)
1040 {
1041 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1042
1043 TRACE("(%p)->(%p)\n", This, p);
1044
1045 return get_style_attr(This, STYLEID_BACKGROUND_POSITION, p);
1046 }
1047
1048 static HRESULT WINAPI HTMLStyle_put_backgroundPositionX(IHTMLStyle *iface, VARIANT v)
1049 {
1050 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1051 WCHAR buf[14], *pos_val;
1052 nsAString pos_str;
1053 const WCHAR *val;
1054 DWORD val_len;
1055 HRESULT hres;
1056
1057 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1058
1059 hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1060 if(FAILED(hres))
1061 return hres;
1062
1063 val_len = val ? strlenW(val) : 0;
1064
1065 nsAString_Init(&pos_str, NULL);
1066 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1067 if(SUCCEEDED(hres)) {
1068 const PRUnichar *pos, *posy;
1069 DWORD posy_len;
1070
1071 nsAString_GetData(&pos_str, &pos);
1072 posy = strchrW(pos, ' ');
1073 if(!posy) {
1074 static const WCHAR zero_pxW[] = {' ','0','p','x',0};
1075
1076 TRACE("no space in %s\n", debugstr_w(pos));
1077 posy = zero_pxW;
1078 }
1079
1080 posy_len = strlenW(posy);
1081 pos_val = heap_alloc((val_len+posy_len+1)*sizeof(WCHAR));
1082 if(pos_val) {
1083 if(val_len)
1084 memcpy(pos_val, val, val_len*sizeof(WCHAR));
1085 if(posy_len)
1086 memcpy(pos_val+val_len, posy, posy_len*sizeof(WCHAR));
1087 pos_val[val_len+posy_len] = 0;
1088 }else {
1089 hres = E_OUTOFMEMORY;
1090 }
1091 }
1092 nsAString_Finish(&pos_str);
1093 if(FAILED(hres))
1094 return hres;
1095
1096 TRACE("setting position to %s\n", debugstr_w(pos_val));
1097 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1098 heap_free(pos_val);
1099 return hres;
1100 }
1101
1102 static HRESULT WINAPI HTMLStyle_get_backgroundPositionX(IHTMLStyle *iface, VARIANT *p)
1103 {
1104 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1105 nsAString pos_str;
1106 BSTR ret;
1107 HRESULT hres;
1108
1109 TRACE("(%p)->(%p)\n", This, p);
1110
1111 nsAString_Init(&pos_str, NULL);
1112 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1113 if(SUCCEEDED(hres)) {
1114 const PRUnichar *pos, *space;
1115
1116 nsAString_GetData(&pos_str, &pos);
1117 space = strchrW(pos, ' ');
1118 if(!space) {
1119 WARN("no space in %s\n", debugstr_w(pos));
1120 space = pos + strlenW(pos);
1121 }
1122
1123 if(space != pos) {
1124 ret = SysAllocStringLen(pos, space-pos);
1125 if(!ret)
1126 hres = E_OUTOFMEMORY;
1127 }else {
1128 ret = NULL;
1129 }
1130 }
1131 nsAString_Finish(&pos_str);
1132 if(FAILED(hres))
1133 return hres;
1134
1135 TRACE("returning %s\n", debugstr_w(ret));
1136 V_VT(p) = VT_BSTR;
1137 V_BSTR(p) = ret;
1138 return S_OK;
1139 }
1140
1141 static HRESULT WINAPI HTMLStyle_put_backgroundPositionY(IHTMLStyle *iface, VARIANT v)
1142 {
1143 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1144 WCHAR buf[14], *pos_val;
1145 nsAString pos_str;
1146 const WCHAR *val;
1147 DWORD val_len;
1148 HRESULT hres;
1149
1150 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1151
1152 hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1153 if(FAILED(hres))
1154 return hres;
1155
1156 val_len = val ? strlenW(val) : 0;
1157
1158 nsAString_Init(&pos_str, NULL);
1159 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1160 if(SUCCEEDED(hres)) {
1161 const PRUnichar *pos, *space;
1162 DWORD posx_len;
1163
1164 nsAString_GetData(&pos_str, &pos);
1165 space = strchrW(pos, ' ');
1166 if(space) {
1167 space++;
1168 }else {
1169 static const WCHAR zero_pxW[] = {'0','p','x',' ',0};
1170
1171 TRACE("no space in %s\n", debugstr_w(pos));
1172 pos = zero_pxW;
1173 space = pos + sizeof(zero_pxW)/sizeof(WCHAR)-1;
1174 }
1175
1176 posx_len = space-pos;
1177
1178 pos_val = heap_alloc((posx_len+val_len+1)*sizeof(WCHAR));
1179 if(pos_val) {
1180 memcpy(pos_val, pos, posx_len*sizeof(WCHAR));
1181 if(val_len)
1182 memcpy(pos_val+posx_len, val, val_len*sizeof(WCHAR));
1183 pos_val[posx_len+val_len] = 0;
1184 }else {
1185 hres = E_OUTOFMEMORY;
1186 }
1187 }
1188 nsAString_Finish(&pos_str);
1189 if(FAILED(hres))
1190 return hres;
1191
1192 TRACE("setting position to %s\n", debugstr_w(pos_val));
1193 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1194 heap_free(pos_val);
1195 return hres;
1196 }
1197
1198 static HRESULT WINAPI HTMLStyle_get_backgroundPositionY(IHTMLStyle *iface, VARIANT *p)
1199 {
1200 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1201 nsAString pos_str;
1202 BSTR ret;
1203 HRESULT hres;
1204
1205 TRACE("(%p)->(%p)\n", This, p);
1206
1207 nsAString_Init(&pos_str, NULL);
1208 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1209 if(SUCCEEDED(hres)) {
1210 const PRUnichar *pos, *posy;
1211
1212 nsAString_GetData(&pos_str, &pos);
1213 posy = strchrW(pos, ' ');
1214 if(posy) {
1215 ret = SysAllocString(posy+1);
1216 if(!ret)
1217 hres = E_OUTOFMEMORY;
1218 }else {
1219 ret = NULL;
1220 }
1221 }
1222 nsAString_Finish(&pos_str);
1223 if(FAILED(hres))
1224 return hres;
1225
1226 TRACE("returning %s\n", debugstr_w(ret));
1227 V_VT(p) = VT_BSTR;
1228 V_BSTR(p) = ret;
1229 return S_OK;
1230 }
1231
1232 static HRESULT WINAPI HTMLStyle_put_wordSpacing(IHTMLStyle *iface, VARIANT v)
1233 {
1234 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1235 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1236 return set_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, &v, 0);
1237 }
1238
1239 static HRESULT WINAPI HTMLStyle_get_wordSpacing(IHTMLStyle *iface, VARIANT *p)
1240 {
1241 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1242 TRACE("(%p)->(%p)\n", This, p);
1243 return get_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, p, 0);
1244 }
1245
1246 static HRESULT WINAPI HTMLStyle_put_letterSpacing(IHTMLStyle *iface, VARIANT v)
1247 {
1248 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1249 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1250 return set_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, &v, 0);
1251 }
1252
1253 static HRESULT WINAPI HTMLStyle_get_letterSpacing(IHTMLStyle *iface, VARIANT *p)
1254 {
1255 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1256 TRACE("(%p)->(%p)\n", This, p);
1257 return get_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, p, 0);
1258 }
1259
1260 static HRESULT WINAPI HTMLStyle_put_textDecoration(IHTMLStyle *iface, BSTR v)
1261 {
1262 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1263
1264 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1265
1266 /* textDecoration can only be one of the following */
1267 if(!v || strcmpiW(styleNone, v) == 0 || strcmpiW(valUnderline, v) == 0 ||
1268 strcmpiW(valOverline, v) == 0 || strcmpiW(valLineThrough, v) == 0 ||
1269 strcmpiW(valBlink, v) == 0)
1270 {
1271 return set_style_attr(This, STYLEID_TEXT_DECORATION , v, 0);
1272 }
1273
1274 return E_INVALIDARG;
1275 }
1276
1277 static HRESULT WINAPI HTMLStyle_get_textDecoration(IHTMLStyle *iface, BSTR *p)
1278 {
1279 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1280
1281 TRACE("(%p)->(%p)\n", This, p);
1282
1283 return get_style_attr(This, STYLEID_TEXT_DECORATION, p);
1284 }
1285
1286 static HRESULT WINAPI HTMLStyle_put_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL v)
1287 {
1288 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1289
1290 TRACE("(%p)->(%x)\n", This, v);
1291
1292 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? styleNone : emptyW, 0);
1293 }
1294
1295 static HRESULT WINAPI HTMLStyle_get_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL *p)
1296 {
1297 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1298
1299 TRACE("(%p)->(%p)\n", This, p);
1300
1301 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, styleNone, p);
1302 }
1303
1304 static HRESULT WINAPI HTMLStyle_put_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL v)
1305 {
1306 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1307
1308 TRACE("(%p)->(%x)\n", This, v);
1309
1310 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valUnderline : emptyW, 0);
1311 }
1312
1313 static HRESULT WINAPI HTMLStyle_get_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL *p)
1314 {
1315 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1316
1317 TRACE("(%p)->(%p)\n", This, p);
1318
1319 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valUnderline, p);
1320 }
1321
1322 static HRESULT WINAPI HTMLStyle_put_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL v)
1323 {
1324 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1325
1326 TRACE("(%p)->(%x)\n", This, v);
1327
1328 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valOverline : emptyW, 0);
1329 }
1330
1331 static HRESULT WINAPI HTMLStyle_get_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL *p)
1332 {
1333 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1334
1335 TRACE("(%p)->(%p)\n", This, p);
1336
1337 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valOverline, p);
1338 }
1339
1340 static HRESULT WINAPI HTMLStyle_put_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL v)
1341 {
1342 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1343
1344 TRACE("(%p)->(%x)\n", This, v);
1345
1346 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valLineThrough : emptyW, 0);
1347 }
1348
1349 static HRESULT WINAPI HTMLStyle_get_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL *p)
1350 {
1351 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1352
1353 TRACE("(%p)->(%p)\n", This, p);
1354
1355 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valLineThrough, p);
1356 }
1357
1358 static HRESULT WINAPI HTMLStyle_put_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL v)
1359 {
1360 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1361
1362 TRACE("(%p)->(%x)\n", This, v);
1363
1364 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valBlink : emptyW, 0);
1365 }
1366
1367 static HRESULT WINAPI HTMLStyle_get_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL *p)
1368 {
1369 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1370
1371 TRACE("(%p)->(%p)\n", This, p);
1372
1373 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valBlink, p);
1374 }
1375
1376 static HRESULT WINAPI HTMLStyle_put_verticalAlign(IHTMLStyle *iface, VARIANT v)
1377 {
1378 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1379
1380 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1381
1382 switch(V_VT(&v)) {
1383 case VT_BSTR:
1384 return set_style_attr(This, STYLEID_VERTICAL_ALIGN, V_BSTR(&v), 0);
1385 default:
1386 FIXME("not implemented vt %d\n", V_VT(&v));
1387 return E_NOTIMPL;
1388 }
1389
1390 return S_OK;
1391 }
1392
1393 static HRESULT WINAPI HTMLStyle_get_verticalAlign(IHTMLStyle *iface, VARIANT *p)
1394 {
1395 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1396 BSTR ret;
1397 HRESULT hres;
1398
1399 TRACE("(%p)->(%p)\n", This, p);
1400
1401 hres = get_style_attr(This, STYLEID_VERTICAL_ALIGN, &ret);
1402 if(FAILED(hres))
1403 return hres;
1404
1405 V_VT(p) = VT_BSTR;
1406 V_BSTR(p) = ret;
1407 return S_OK;
1408 }
1409
1410 static HRESULT WINAPI HTMLStyle_put_textTransform(IHTMLStyle *iface, BSTR v)
1411 {
1412 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1413 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1414 return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI HTMLStyle_get_textTransform(IHTMLStyle *iface, BSTR *p)
1418 {
1419 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1420 FIXME("(%p)->(%p)\n", This, p);
1421 return E_NOTIMPL;
1422 }
1423
1424 static HRESULT WINAPI HTMLStyle_put_textAlign(IHTMLStyle *iface, BSTR v)
1425 {
1426 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1427
1428 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1429
1430 return set_style_attr(This, STYLEID_TEXT_ALIGN, v, 0);
1431 }
1432
1433 static HRESULT WINAPI HTMLStyle_get_textAlign(IHTMLStyle *iface, BSTR *p)
1434 {
1435 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1436
1437 TRACE("(%p)->(%p)\n", This, p);
1438
1439 return get_style_attr(This, STYLEID_TEXT_ALIGN, p);
1440 }
1441
1442 static HRESULT WINAPI HTMLStyle_put_textIndent(IHTMLStyle *iface, VARIANT v)
1443 {
1444 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1445 FIXME("(%p)->(v%d)\n", This, V_VT(&v));
1446 return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI HTMLStyle_get_textIndent(IHTMLStyle *iface, VARIANT *p)
1450 {
1451 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1452 FIXME("(%p)->(%p)\n", This, p);
1453 return E_NOTIMPL;
1454 }
1455
1456 static HRESULT WINAPI HTMLStyle_put_lineHeight(IHTMLStyle *iface, VARIANT v)
1457 {
1458 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1459 FIXME("(%p)->(v%d)\n", This, V_VT(&v));
1460 return E_NOTIMPL;
1461 }
1462
1463 static HRESULT WINAPI HTMLStyle_get_lineHeight(IHTMLStyle *iface, VARIANT *p)
1464 {
1465 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1466 FIXME("(%p)->(%p)\n", This, p);
1467 return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI HTMLStyle_put_marginTop(IHTMLStyle *iface, VARIANT v)
1471 {
1472 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1473
1474 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1475
1476 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, &v, ATTR_FIX_PX);
1477 }
1478
1479 static HRESULT WINAPI HTMLStyle_get_marginTop(IHTMLStyle *iface, VARIANT *p)
1480 {
1481 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1482
1483 TRACE("(%p)->(%p)\n", This, p);
1484
1485 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, p, 0);
1486 }
1487
1488 static HRESULT WINAPI HTMLStyle_put_marginRight(IHTMLStyle *iface, VARIANT v)
1489 {
1490 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1491
1492 TRACE("(%p)->(v(%d))\n", This, V_VT(&v));
1493
1494 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, &v, ATTR_FIX_PX);
1495 }
1496
1497 static HRESULT WINAPI HTMLStyle_get_marginRight(IHTMLStyle *iface, VARIANT *p)
1498 {
1499 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1500 TRACE("(%p)->(%p)\n", This, p);
1501 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, p, 0);
1502 }
1503
1504 static HRESULT WINAPI HTMLStyle_put_marginBottom(IHTMLStyle *iface, VARIANT v)
1505 {
1506 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1507
1508 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1509
1510 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, &v, ATTR_FIX_PX);
1511 }
1512
1513 static HRESULT WINAPI HTMLStyle_get_marginBottom(IHTMLStyle *iface, VARIANT *p)
1514 {
1515 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1516
1517 TRACE("(%p)->(%p)\n", This, p);
1518
1519 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, p, 0);
1520 }
1521
1522 static HRESULT WINAPI HTMLStyle_put_marginLeft(IHTMLStyle *iface, VARIANT v)
1523 {
1524 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1525
1526 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1527
1528 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, &v, ATTR_FIX_PX);
1529 }
1530
1531 static HRESULT WINAPI HTMLStyle_put_margin(IHTMLStyle *iface, BSTR v)
1532 {
1533 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1534
1535 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1536
1537 return set_style_attr(This, STYLEID_MARGIN, v, 0);
1538 }
1539
1540 static HRESULT WINAPI HTMLStyle_get_margin(IHTMLStyle *iface, BSTR *p)
1541 {
1542 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1543
1544 TRACE("(%p)->(%p)\n", This, p);
1545
1546 return get_style_attr(This, STYLEID_MARGIN, p);
1547 }
1548
1549 static HRESULT WINAPI HTMLStyle_get_marginLeft(IHTMLStyle *iface, VARIANT *p)
1550 {
1551 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1552 TRACE("(%p)->(%p)\n", This, p);
1553 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, p, 0);
1554 }
1555
1556 static HRESULT WINAPI HTMLStyle_put_paddingTop(IHTMLStyle *iface, VARIANT v)
1557 {
1558 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1559
1560 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1561
1562 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, &v, ATTR_FIX_PX);
1563 }
1564
1565 static HRESULT WINAPI HTMLStyle_get_paddingTop(IHTMLStyle *iface, VARIANT *p)
1566 {
1567 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1568
1569 TRACE("(%p)->(%p)\n", This, p);
1570
1571 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, p, 0);
1572 }
1573
1574 static HRESULT WINAPI HTMLStyle_put_paddingRight(IHTMLStyle *iface, VARIANT v)
1575 {
1576 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1577
1578 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1579
1580 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, &v, ATTR_FIX_PX);
1581 }
1582
1583 static HRESULT WINAPI HTMLStyle_get_paddingRight(IHTMLStyle *iface, VARIANT *p)
1584 {
1585 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1586
1587 TRACE("(%p)->(%p)\n", This, p);
1588
1589 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, p, 0);
1590 }
1591
1592 static HRESULT WINAPI HTMLStyle_put_paddingBottom(IHTMLStyle *iface, VARIANT v)
1593 {
1594 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1595
1596 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1597
1598 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, &v, ATTR_FIX_PX);
1599 }
1600
1601 static HRESULT WINAPI HTMLStyle_get_paddingBottom(IHTMLStyle *iface, VARIANT *p)
1602 {
1603 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1604
1605 TRACE("(%p)->(%p)\n", This, p);
1606
1607 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, p, 0);
1608 }
1609
1610 static HRESULT WINAPI HTMLStyle_put_paddingLeft(IHTMLStyle *iface, VARIANT v)
1611 {
1612 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1613
1614 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1615
1616 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, &v, ATTR_FIX_PX);
1617 }
1618
1619 static HRESULT WINAPI HTMLStyle_get_paddingLeft(IHTMLStyle *iface, VARIANT *p)
1620 {
1621 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1622
1623 TRACE("(%p)->(%p)\n", This, p);
1624
1625 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, p, 0);
1626 }
1627
1628 static HRESULT WINAPI HTMLStyle_put_padding(IHTMLStyle *iface, BSTR v)
1629 {
1630 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1631
1632 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1633
1634 return set_style_attr(This, STYLEID_PADDING, v, 0);
1635 }
1636
1637 static HRESULT WINAPI HTMLStyle_get_padding(IHTMLStyle *iface, BSTR *p)
1638 {
1639 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1640
1641 TRACE("(%p)->(%p)\n", This, p);
1642
1643 return get_style_attr(This, STYLEID_PADDING, p);
1644 }
1645
1646 static HRESULT WINAPI HTMLStyle_put_border(IHTMLStyle *iface, BSTR v)
1647 {
1648 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1649
1650 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1651
1652 return set_style_attr(This, STYLEID_BORDER, v, 0);
1653 }
1654
1655 static HRESULT WINAPI HTMLStyle_get_border(IHTMLStyle *iface, BSTR *p)
1656 {
1657 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1658
1659 TRACE("(%p)->(%p)\n", This, p);
1660
1661 return get_style_attr(This, STYLEID_BORDER, p);
1662 }
1663
1664 static HRESULT WINAPI HTMLStyle_put_borderTop(IHTMLStyle *iface, BSTR v)
1665 {
1666 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1667 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1668 return set_style_attr(This, STYLEID_BORDER_TOP, v, ATTR_FIX_PX);
1669 }
1670
1671 static HRESULT WINAPI HTMLStyle_get_borderTop(IHTMLStyle *iface, BSTR *p)
1672 {
1673 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1674 TRACE("(%p)->(%p)\n", This, p);
1675 return get_style_attr(This, STYLEID_BORDER_TOP, p);
1676 }
1677
1678 static HRESULT WINAPI HTMLStyle_put_borderRight(IHTMLStyle *iface, BSTR v)
1679 {
1680 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1681 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1682 return set_style_attr(This, STYLEID_BORDER_RIGHT, v, ATTR_FIX_PX);
1683 }
1684
1685 static HRESULT WINAPI HTMLStyle_get_borderRight(IHTMLStyle *iface, BSTR *p)
1686 {
1687 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1688 TRACE("(%p)->(%p)\n", This, p);
1689 return get_style_attr(This, STYLEID_BORDER_RIGHT, p);
1690 }
1691
1692 static HRESULT WINAPI HTMLStyle_put_borderBottom(IHTMLStyle *iface, BSTR v)
1693 {
1694 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1695 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1696 return set_style_attr(This, STYLEID_BORDER_BOTTOM, v, ATTR_FIX_PX);
1697 }
1698
1699 static HRESULT WINAPI HTMLStyle_get_borderBottom(IHTMLStyle *iface, BSTR *p)
1700 {
1701 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1702 TRACE("(%p)->(%p)\n", This, p);
1703 return get_style_attr(This, STYLEID_BORDER_BOTTOM, p);
1704 }
1705
1706 static HRESULT WINAPI HTMLStyle_put_borderLeft(IHTMLStyle *iface, BSTR v)
1707 {
1708 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1709
1710 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1711
1712 return set_style_attr(This, STYLEID_BORDER_LEFT, v, ATTR_FIX_PX);
1713 }
1714
1715 static HRESULT WINAPI HTMLStyle_get_borderLeft(IHTMLStyle *iface, BSTR *p)
1716 {
1717 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1718
1719 TRACE("(%p)->(%p)\n", This, p);
1720
1721 return get_style_attr(This, STYLEID_BORDER_LEFT, p);
1722 }
1723
1724 static HRESULT WINAPI HTMLStyle_put_borderColor(IHTMLStyle *iface, BSTR v)
1725 {
1726 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1727
1728 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1729
1730 return set_style_attr(This, STYLEID_BORDER_COLOR, v, 0);
1731 }
1732
1733 static HRESULT WINAPI HTMLStyle_get_borderColor(IHTMLStyle *iface, BSTR *p)
1734 {
1735 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1736
1737 TRACE("(%p)->(%p)\n", This, p);
1738
1739 return get_style_attr(This, STYLEID_BORDER_COLOR, p);
1740 }
1741
1742 static HRESULT WINAPI HTMLStyle_put_borderTopColor(IHTMLStyle *iface, VARIANT v)
1743 {
1744 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1745
1746 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1747
1748 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, &v, ATTR_HEX_INT);
1749 }
1750
1751 static HRESULT WINAPI HTMLStyle_get_borderTopColor(IHTMLStyle *iface, VARIANT *p)
1752 {
1753 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1754
1755 TRACE("(%p)->(%p)\n", This, p);
1756
1757 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, p, 0);
1758 }
1759
1760 static HRESULT WINAPI HTMLStyle_put_borderRightColor(IHTMLStyle *iface, VARIANT v)
1761 {
1762 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1763
1764 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1765
1766 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, &v, ATTR_HEX_INT);
1767 }
1768
1769 static HRESULT WINAPI HTMLStyle_get_borderRightColor(IHTMLStyle *iface, VARIANT *p)
1770 {
1771 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1772
1773 TRACE("(%p)->(%p)\n", This, p);
1774
1775 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, p, 0);
1776 }
1777
1778 static HRESULT WINAPI HTMLStyle_put_borderBottomColor(IHTMLStyle *iface, VARIANT v)
1779 {
1780 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1781
1782 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1783
1784 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, &v, ATTR_HEX_INT);
1785 }
1786
1787 static HRESULT WINAPI HTMLStyle_get_borderBottomColor(IHTMLStyle *iface, VARIANT *p)
1788 {
1789 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1790
1791 TRACE("(%p)->(%p)\n", This, p);
1792
1793 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, p, 0);
1794 }
1795
1796 static HRESULT WINAPI HTMLStyle_put_borderLeftColor(IHTMLStyle *iface, VARIANT v)
1797 {
1798 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1799
1800 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1801
1802 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, &v, ATTR_HEX_INT);
1803 }
1804
1805 static HRESULT WINAPI HTMLStyle_get_borderLeftColor(IHTMLStyle *iface, VARIANT *p)
1806 {
1807 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1808
1809 TRACE("(%p)->(%p)\n", This, p);
1810
1811 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, p, 0);
1812 }
1813
1814 static HRESULT WINAPI HTMLStyle_put_borderWidth(IHTMLStyle *iface, BSTR v)
1815 {
1816 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1817 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1818 return set_style_attr(This, STYLEID_BORDER_WIDTH, v, ATTR_FIX_PX);
1819 }
1820
1821 static HRESULT WINAPI HTMLStyle_get_borderWidth(IHTMLStyle *iface, BSTR *p)
1822 {
1823 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1824 TRACE("(%p)->(%p)\n", This, p);
1825 return get_style_attr(This, STYLEID_BORDER_WIDTH, p);
1826 }
1827
1828 static HRESULT WINAPI HTMLStyle_put_borderTopWidth(IHTMLStyle *iface, VARIANT v)
1829 {
1830 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1831 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1832 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, &v, 0);
1833 }
1834
1835 static HRESULT WINAPI HTMLStyle_get_borderTopWidth(IHTMLStyle *iface, VARIANT *p)
1836 {
1837 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1838
1839 TRACE("(%p)->(%p)\n", This, p);
1840
1841 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, p, 0);
1842 }
1843
1844 static HRESULT WINAPI HTMLStyle_put_borderRightWidth(IHTMLStyle *iface, VARIANT v)
1845 {
1846 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1847 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1848 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, &v, 0);
1849 }
1850
1851 static HRESULT WINAPI HTMLStyle_get_borderRightWidth(IHTMLStyle *iface, VARIANT *p)
1852 {
1853 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1854 TRACE("(%p)->(%p)\n", This, p);
1855 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, p, 0);
1856 }
1857
1858 static HRESULT WINAPI HTMLStyle_put_borderBottomWidth(IHTMLStyle *iface, VARIANT v)
1859 {
1860 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1861
1862 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1863 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, &v, 0);
1864 }
1865
1866 static HRESULT WINAPI HTMLStyle_get_borderBottomWidth(IHTMLStyle *iface, VARIANT *p)
1867 {
1868 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1869 TRACE("(%p)->(%p)\n", This, p);
1870 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, p, 0);
1871 }
1872
1873 static HRESULT WINAPI HTMLStyle_put_borderLeftWidth(IHTMLStyle *iface, VARIANT v)
1874 {
1875 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1876 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
1877 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, &v, 0);
1878 }
1879
1880 static HRESULT WINAPI HTMLStyle_get_borderLeftWidth(IHTMLStyle *iface, VARIANT *p)
1881 {
1882 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1883 TRACE("(%p)->(%p)\n", This, p);
1884 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, p, 0);
1885 }
1886
1887 static HRESULT WINAPI HTMLStyle_put_borderStyle(IHTMLStyle *iface, BSTR v)
1888 {
1889 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1890 static const WCHAR styleWindowInset[] = {'w','i','n','d','o','w','-','i','n','s','e','t',0};
1891 HRESULT hres = S_OK;
1892 BSTR pstyle;
1893 int i=0;
1894 int last = 0;
1895
1896 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1897
1898 while(v[i] && hres == S_OK)
1899 {
1900 if(v[i] == (WCHAR)' ')
1901 {
1902 pstyle = SysAllocStringLen(&v[last], (i-last));
1903 if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1904 {
1905 TRACE("1. Invalid style (%s)\n", debugstr_w(pstyle));
1906 hres = E_INVALIDARG;
1907 }
1908 SysFreeString(pstyle);
1909 last = i+1;
1910 }
1911 i++;
1912 }
1913
1914 if(hres == S_OK)
1915 {
1916 pstyle = SysAllocStringLen(&v[last], i-last);
1917 if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1918 {
1919 TRACE("2. Invalid style (%s)\n", debugstr_w(pstyle));
1920 hres = E_INVALIDARG;
1921 }
1922 SysFreeString(pstyle);
1923 }
1924
1925 if(hres == S_OK)
1926 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BORDER_STYLE, v, 0);
1927
1928 return hres;
1929 }
1930
1931 static HRESULT WINAPI HTMLStyle_get_borderStyle(IHTMLStyle *iface, BSTR *p)
1932 {
1933 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1934 TRACE("(%p)->(%p)\n", This, p);
1935 return get_style_attr(This, STYLEID_BORDER_STYLE, p);
1936 }
1937
1938 static HRESULT WINAPI HTMLStyle_put_borderTopStyle(IHTMLStyle *iface, BSTR v)
1939 {
1940 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1941 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1942
1943 if(!is_valid_border_style(v))
1944 return E_INVALIDARG;
1945
1946 return set_style_attr(This, STYLEID_BORDER_TOP_STYLE, v, 0);
1947 }
1948
1949 static HRESULT WINAPI HTMLStyle_get_borderTopStyle(IHTMLStyle *iface, BSTR *p)
1950 {
1951 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1952 TRACE("(%p)->(%p)\n", This, p);
1953 return get_style_attr(This, STYLEID_BORDER_TOP_STYLE, p);
1954 }
1955
1956 static HRESULT WINAPI HTMLStyle_put_borderRightStyle(IHTMLStyle *iface, BSTR v)
1957 {
1958 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1959 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1960
1961 if(!is_valid_border_style(v))
1962 return E_INVALIDARG;
1963
1964 return set_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, v, 0);
1965 }
1966
1967 static HRESULT WINAPI HTMLStyle_get_borderRightStyle(IHTMLStyle *iface, BSTR *p)
1968 {
1969 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1970 TRACE("(%p)->(%p)\n", This, p);
1971 return get_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, p);
1972 }
1973
1974 static HRESULT WINAPI HTMLStyle_put_borderBottomStyle(IHTMLStyle *iface, BSTR v)
1975 {
1976 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1977 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1978
1979 if(!is_valid_border_style(v))
1980 return E_INVALIDARG;
1981
1982 return set_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, v, 0);
1983 }
1984
1985 static HRESULT WINAPI HTMLStyle_get_borderBottomStyle(IHTMLStyle *iface, BSTR *p)
1986 {
1987 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1988 TRACE("(%p)->(%p)\n", This, p);
1989 return get_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, p);
1990 }
1991
1992 static HRESULT WINAPI HTMLStyle_put_borderLeftStyle(IHTMLStyle *iface, BSTR v)
1993 {
1994 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1995 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1996
1997 if(!is_valid_border_style(v))
1998 return E_INVALIDARG;
1999
2000 return set_style_attr(This, STYLEID_BORDER_LEFT_STYLE, v, 0);
2001 }
2002
2003 static HRESULT WINAPI HTMLStyle_get_borderLeftStyle(IHTMLStyle *iface, BSTR *p)
2004 {
2005 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2006 TRACE("(%p)->(%p)\n", This, p);
2007 return get_style_attr(This, STYLEID_BORDER_LEFT_STYLE, p);
2008 }
2009
2010 static HRESULT WINAPI HTMLStyle_put_width(IHTMLStyle *iface, VARIANT v)
2011 {
2012 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2013
2014 TRACE("(%p)->(v%d)\n", This, V_VT(&v));
2015
2016 return set_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, &v, ATTR_FIX_PX);
2017 }
2018
2019 static HRESULT WINAPI HTMLStyle_get_width(IHTMLStyle *iface, VARIANT *p)
2020 {
2021 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2022
2023 TRACE("(%p)->(%p)\n", This, p);
2024
2025 V_VT(p) = VT_BSTR;
2026 return get_style_attr(This, STYLEID_WIDTH, &V_BSTR(p));
2027 }
2028
2029 static HRESULT WINAPI HTMLStyle_put_height(IHTMLStyle *iface, VARIANT v)
2030 {
2031 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2032
2033 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2034
2035 return set_nsstyle_attr_var(This->nsstyle, STYLEID_HEIGHT, &v, ATTR_FIX_PX);
2036 }
2037
2038 static HRESULT WINAPI HTMLStyle_get_height(IHTMLStyle *iface, VARIANT *p)
2039 {
2040 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2041 BSTR ret;
2042 HRESULT hres;
2043
2044 TRACE("(%p)->(%p)\n", This, p);
2045
2046 hres = get_style_attr(This, STYLEID_HEIGHT, &ret);
2047 if(FAILED(hres))
2048 return hres;
2049
2050 V_VT(p) = VT_BSTR;
2051 V_BSTR(p) = ret;
2052 return S_OK;
2053 }
2054
2055 static HRESULT WINAPI HTMLStyle_put_styleFloat(IHTMLStyle *iface, BSTR v)
2056 {
2057 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2058 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2059 return E_NOTIMPL;
2060 }
2061
2062 static HRESULT WINAPI HTMLStyle_get_styleFloat(IHTMLStyle *iface, BSTR *p)
2063 {
2064 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2065 FIXME("(%p)->(%p)\n", This, p);
2066 return E_NOTIMPL;
2067 }
2068
2069 static HRESULT WINAPI HTMLStyle_put_clear(IHTMLStyle *iface, BSTR v)
2070 {
2071 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2072 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2073 return E_NOTIMPL;
2074 }
2075
2076 static HRESULT WINAPI HTMLStyle_get_clear(IHTMLStyle *iface, BSTR *p)
2077 {
2078 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2079 FIXME("(%p)->(%p)\n", This, p);
2080 return E_NOTIMPL;
2081 }
2082
2083 static HRESULT WINAPI HTMLStyle_put_display(IHTMLStyle *iface, BSTR v)
2084 {
2085 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2086
2087 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2088
2089 return set_style_attr(This, STYLEID_DISPLAY, v, 0);
2090 }
2091
2092 static HRESULT WINAPI HTMLStyle_get_display(IHTMLStyle *iface, BSTR *p)
2093 {
2094 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2095
2096 TRACE("(%p)->(%p)\n", This, p);
2097
2098 return get_style_attr(This, STYLEID_DISPLAY, p);
2099 }
2100
2101 static HRESULT WINAPI HTMLStyle_put_visibility(IHTMLStyle *iface, BSTR v)
2102 {
2103 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2104
2105 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2106
2107 return set_style_attr(This, STYLEID_VISIBILITY, v, 0);
2108 }
2109
2110 static HRESULT WINAPI HTMLStyle_get_visibility(IHTMLStyle *iface, BSTR *p)
2111 {
2112 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2113
2114 TRACE("(%p)->(%p)\n", This, p);
2115
2116 return get_style_attr(This, STYLEID_VISIBILITY, p);
2117 }
2118
2119 static HRESULT WINAPI HTMLStyle_put_listStyleType(IHTMLStyle *iface, BSTR v)
2120 {
2121 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2122 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2123 return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI HTMLStyle_get_listStyleType(IHTMLStyle *iface, BSTR *p)
2127 {
2128 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2129 FIXME("(%p)->(%p)\n", This, p);
2130 return E_NOTIMPL;
2131 }
2132
2133 static HRESULT WINAPI HTMLStyle_put_listStylePosition(IHTMLStyle *iface, BSTR v)
2134 {
2135 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2136 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2137 return E_NOTIMPL;
2138 }
2139
2140 static HRESULT WINAPI HTMLStyle_get_listStylePosition(IHTMLStyle *iface, BSTR *p)
2141 {
2142 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2143 FIXME("(%p)->(%p)\n", This, p);
2144 return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI HTMLStyle_put_listStyleImage(IHTMLStyle *iface, BSTR v)
2148 {
2149 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2150 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2151 return E_NOTIMPL;
2152 }
2153
2154 static HRESULT WINAPI HTMLStyle_get_listStyleImage(IHTMLStyle *iface, BSTR *p)
2155 {
2156 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2157 FIXME("(%p)->(%p)\n", This, p);
2158 return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI HTMLStyle_put_listStyle(IHTMLStyle *iface, BSTR v)
2162 {
2163 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2164 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2165 return E_NOTIMPL;
2166 }
2167
2168 static HRESULT WINAPI HTMLStyle_get_listStyle(IHTMLStyle *iface, BSTR *p)
2169 {
2170 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2171 FIXME("(%p)->(%p)\n", This, p);
2172 return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI HTMLStyle_put_whiteSpace(IHTMLStyle *iface, BSTR v)
2176 {
2177 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2178 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2179 return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI HTMLStyle_get_whiteSpace(IHTMLStyle *iface, BSTR *p)
2183 {
2184 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2185 FIXME("(%p)->(%p)\n", This, p);
2186 return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI HTMLStyle_put_top(IHTMLStyle *iface, VARIANT v)
2190 {
2191 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2192
2193 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2194
2195 return set_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, &v, 0);
2196 }
2197
2198 static HRESULT WINAPI HTMLStyle_get_top(IHTMLStyle *iface, VARIANT *p)
2199 {
2200 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2201 BSTR ret;
2202 HRESULT hres;
2203
2204 TRACE("(%p)->(%p)\n", This, p);
2205
2206 hres = get_style_attr(This, STYLEID_TOP, &ret);
2207 if(FAILED(hres))
2208 return hres;
2209
2210 V_VT(p) = VT_BSTR;
2211 V_BSTR(p) = ret;
2212 return S_OK;
2213 }
2214
2215 static HRESULT WINAPI HTMLStyle_put_left(IHTMLStyle *iface, VARIANT v)
2216 {
2217 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2218
2219 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2220
2221 return set_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, &v, 0);
2222 }
2223
2224 static HRESULT WINAPI HTMLStyle_get_left(IHTMLStyle *iface, VARIANT *p)
2225 {
2226 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2227 BSTR ret;
2228 HRESULT hres;
2229
2230 TRACE("(%p)->(%p)\n", This, p);
2231
2232 hres = get_style_attr(This, STYLEID_LEFT, &ret);
2233 if(FAILED(hres))
2234 return hres;
2235
2236 V_VT(p) = VT_BSTR;
2237 V_BSTR(p) = ret;
2238 return S_OK;
2239 }
2240
2241 static HRESULT WINAPI HTMLStyle_get_position(IHTMLStyle *iface, BSTR *p)
2242 {
2243 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2244 TRACE("(%p)->(%p)\n", This, p);
2245 return IHTMLStyle2_get_position(&This->IHTMLStyle2_iface, p);
2246 }
2247
2248 static HRESULT WINAPI HTMLStyle_put_zIndex(IHTMLStyle *iface, VARIANT v)
2249 {
2250 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2251
2252 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2253
2254 switch(V_VT(&v)) {
2255 case VT_BSTR:
2256 return set_style_attr(This, STYLEID_Z_INDEX, V_BSTR(&v), 0);
2257 case VT_I4: {
2258 WCHAR value[14];
2259 static const WCHAR format[] = {'%','d',0};
2260
2261 wsprintfW(value, format, V_I4(&v));
2262 return set_style_attr(This, STYLEID_Z_INDEX, value, 0);
2263 }
2264 default:
2265 FIXME("unimplemented vt %d\n", V_VT(&v));
2266 return E_NOTIMPL;
2267 }
2268
2269 return S_OK;
2270 }
2271
2272 static HRESULT WINAPI HTMLStyle_get_zIndex(IHTMLStyle *iface, VARIANT *p)
2273 {
2274 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2275
2276 TRACE("(%p)->(%p)\n", This, p);
2277
2278 return get_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, p, ATTR_STR_TO_INT);
2279 }
2280
2281 static HRESULT WINAPI HTMLStyle_put_overflow(IHTMLStyle *iface, BSTR v)
2282 {
2283 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2284 static const WCHAR szVisible[] = {'v','i','s','i','b','l','e',0};
2285 static const WCHAR szScroll[] = {'s','c','r','o','l','l',0};
2286 static const WCHAR szHidden[] = {'h','i','d','d','e','n',0};
2287 static const WCHAR szAuto[] = {'a','u','t','o',0};
2288
2289 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2290
2291 /* overflow can only be one of the follow values. */
2292 if(!v || !*v || strcmpiW(szVisible, v) == 0 || strcmpiW(szScroll, v) == 0 ||
2293 strcmpiW(szHidden, v) == 0 || strcmpiW(szAuto, v) == 0)
2294 {
2295 return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW, v, 0);
2296 }
2297
2298 return E_INVALIDARG;
2299 }
2300
2301
2302 static HRESULT WINAPI HTMLStyle_get_overflow(IHTMLStyle *iface, BSTR *p)
2303 {
2304 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2305
2306 TRACE("(%p)->(%p)\n", This, p);
2307
2308 if(!p)
2309 return E_INVALIDARG;
2310
2311 return get_style_attr(This, STYLEID_OVERFLOW, p);
2312 }
2313
2314 static HRESULT WINAPI HTMLStyle_put_pageBreakBefore(IHTMLStyle *iface, BSTR v)
2315 {
2316 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2317
2318 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2319
2320 return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, v, 0);
2321 }
2322
2323 static HRESULT WINAPI HTMLStyle_get_pageBreakBefore(IHTMLStyle *iface, BSTR *p)
2324 {
2325 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2326
2327 TRACE("(%p)->(%p)\n", This, p);
2328
2329 return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, p, 0);
2330 }
2331
2332 static HRESULT WINAPI HTMLStyle_put_pageBreakAfter(IHTMLStyle *iface, BSTR v)
2333 {
2334 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2335
2336 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2337
2338 return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, v, 0);
2339 }
2340
2341 static HRESULT WINAPI HTMLStyle_get_pageBreakAfter(IHTMLStyle *iface, BSTR *p)
2342 {
2343 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2344
2345 TRACE("(%p)->(%p)\n", This, p);
2346
2347 return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, p, 0);
2348 }
2349
2350 static HRESULT WINAPI HTMLStyle_put_cssText(IHTMLStyle *iface, BSTR v)
2351 {
2352 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2353 nsAString text_str;
2354 nsresult nsres;
2355
2356 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2357
2358 nsAString_InitDepend(&text_str, v);
2359 nsres = nsIDOMCSSStyleDeclaration_SetCssText(This->nsstyle, &text_str);
2360 nsAString_Finish(&text_str);
2361 if(NS_FAILED(nsres)) {
2362 FIXME("SetCssStyle failed: %08x\n", nsres);
2363 return E_FAIL;
2364 }
2365
2366 return S_OK;
2367 }
2368
2369 static HRESULT WINAPI HTMLStyle_get_cssText(IHTMLStyle *iface, BSTR *p)
2370 {
2371 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2372 nsAString text_str;
2373 nsresult nsres;
2374
2375 TRACE("(%p)->(%p)\n", This, p);
2376
2377 /* FIXME: Gecko style formatting is different than IE (uppercase). */
2378 nsAString_Init(&text_str, NULL);
2379 nsres = nsIDOMCSSStyleDeclaration_GetCssText(This->nsstyle, &text_str);
2380 if(NS_SUCCEEDED(nsres)) {
2381 const PRUnichar *text;
2382
2383 nsAString_GetData(&text_str, &text);
2384 *p = *text ? SysAllocString(text) : NULL;
2385 }else {
2386 FIXME("GetCssStyle failed: %08x\n", nsres);
2387 *p = NULL;
2388 }
2389
2390 nsAString_Finish(&text_str);
2391 return S_OK;
2392 }
2393
2394 static HRESULT WINAPI HTMLStyle_put_pixelTop(IHTMLStyle *iface, LONG v)
2395 {
2396 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2397 FIXME("(%p)->()\n", This);
2398 return E_NOTIMPL;
2399 }
2400
2401 static HRESULT WINAPI HTMLStyle_get_pixelTop(IHTMLStyle *iface, LONG *p)
2402 {
2403 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2404 FIXME("(%p)->()\n", This);
2405 return E_NOTIMPL;
2406 }
2407
2408 static HRESULT WINAPI HTMLStyle_put_pixelLeft(IHTMLStyle *iface, LONG v)
2409 {
2410 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2411 FIXME("(%p)->()\n", This);
2412 return E_NOTIMPL;
2413 }
2414
2415 static HRESULT WINAPI HTMLStyle_get_pixelLeft(IHTMLStyle *iface, LONG *p)
2416 {
2417 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2418 FIXME("(%p)->()\n", This);
2419 return E_NOTIMPL;
2420 }
2421
2422 static HRESULT WINAPI HTMLStyle_put_pixelWidth(IHTMLStyle *iface, LONG v)
2423 {
2424 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2425 FIXME("(%p)->()\n", This);
2426 return E_NOTIMPL;
2427 }
2428
2429 static HRESULT WINAPI HTMLStyle_get_pixelWidth(IHTMLStyle *iface, LONG *p)
2430 {
2431 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2432 FIXME("(%p)->()\n", This);
2433 return E_NOTIMPL;
2434 }
2435
2436 static HRESULT WINAPI HTMLStyle_put_pixelHeight(IHTMLStyle *iface, LONG v)
2437 {
2438 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2439 FIXME("(%p)->()\n", This);
2440 return E_NOTIMPL;
2441 }
2442
2443 static HRESULT WINAPI HTMLStyle_get_pixelHeight(IHTMLStyle *iface, LONG *p)
2444 {
2445 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2446 FIXME("(%p)->()\n", This);
2447 return E_NOTIMPL;
2448 }
2449
2450 static HRESULT WINAPI HTMLStyle_put_posTop(IHTMLStyle *iface, float v)
2451 {
2452 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2453
2454 TRACE("(%p)->(%f)\n", This, v);
2455
2456 return set_style_pos(This, STYLEID_TOP, v);
2457 }
2458
2459 static HRESULT WINAPI HTMLStyle_get_posTop(IHTMLStyle *iface, float *p)
2460 {
2461 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2462
2463 TRACE("(%p)->(%p)\n", This, p);
2464
2465 if(!p)
2466 return E_POINTER;
2467
2468 return get_nsstyle_pos(This, STYLEID_TOP, p);
2469 }
2470
2471 static HRESULT WINAPI HTMLStyle_put_posLeft(IHTMLStyle *iface, float v)
2472 {
2473 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2474
2475 TRACE("(%p)->(%f)\n", This, v);
2476
2477 return set_style_pos(This, STYLEID_LEFT, v);
2478 }
2479
2480 static HRESULT WINAPI HTMLStyle_get_posLeft(IHTMLStyle *iface, float *p)
2481 {
2482 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2483
2484 TRACE("(%p)->(%p)\n", This, p);
2485
2486 if(!p)
2487 return E_POINTER;
2488
2489 return get_nsstyle_pos(This, STYLEID_LEFT, p);
2490 }
2491
2492 static HRESULT WINAPI HTMLStyle_put_posWidth(IHTMLStyle *iface, float v)
2493 {
2494 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2495
2496 TRACE("(%p)->(%f)\n", This, v);
2497
2498 return set_style_pos(This, STYLEID_WIDTH, v);
2499 }
2500
2501 static HRESULT WINAPI HTMLStyle_get_posWidth(IHTMLStyle *iface, float *p)
2502 {
2503 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2504
2505 TRACE("(%p)->(%p)\n", This, p);
2506
2507 if(!p)
2508 return E_POINTER;
2509
2510 if(get_nsstyle_pos(This, STYLEID_WIDTH, p) != S_OK)
2511 *p = 0.0f;
2512
2513 return S_OK;
2514 }
2515
2516 static HRESULT WINAPI HTMLStyle_put_posHeight(IHTMLStyle *iface, float v)
2517 {
2518 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2519
2520 TRACE("(%p)->(%f)\n", This, v);
2521
2522 return set_style_pos(This, STYLEID_HEIGHT, v);
2523 }
2524
2525 static HRESULT WINAPI HTMLStyle_get_posHeight(IHTMLStyle *iface, float *p)
2526 {
2527 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2528
2529 TRACE("(%p)->(%p)\n", This, p);
2530
2531 if(!p)
2532 return E_POINTER;
2533
2534 if(get_nsstyle_pos(This, STYLEID_HEIGHT, p) != S_OK)
2535 *p = 0.0f;
2536
2537 return S_OK;
2538 }
2539
2540 static HRESULT WINAPI HTMLStyle_put_cursor(IHTMLStyle *iface, BSTR v)
2541 {
2542 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2543
2544 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2545
2546 return set_style_attr(This, STYLEID_CURSOR, v, 0);
2547 }
2548
2549 static HRESULT WINAPI HTMLStyle_get_cursor(IHTMLStyle *iface, BSTR *p)
2550 {
2551 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2552
2553 TRACE("(%p)->(%p)\n", This, p);
2554
2555 return get_style_attr(This, STYLEID_CURSOR, p);
2556 }
2557
2558 static HRESULT WINAPI HTMLStyle_put_clip(IHTMLStyle *iface, BSTR v)
2559 {
2560 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2561
2562 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2563
2564 return set_style_attr(This, STYLEID_CLIP, v, 0);
2565 }
2566
2567 static HRESULT WINAPI HTMLStyle_get_clip(IHTMLStyle *iface, BSTR *p)
2568 {
2569 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2570
2571 TRACE("(%p)->(%p)\n", This, p);
2572
2573 return get_nsstyle_attr(This->nsstyle, STYLEID_CLIP, p, ATTR_REMOVE_COMMA);
2574 }
2575
2576 static void set_opacity(HTMLStyle *This, const WCHAR *val)
2577 {
2578 nsAString name_str, val_str, empty_str;
2579 nsresult nsres;
2580
2581 static const WCHAR opacityW[] = {'o','p','a','c','i','t','y',0};
2582
2583 TRACE("%s\n", debugstr_w(val));
2584
2585 nsAString_InitDepend(&name_str, opacityW);
2586 nsAString_InitDepend(&val_str, val);
2587 nsAString_InitDepend(&empty_str, emptyW);
2588
2589 nsres = nsIDOMCSSStyleDeclaration_SetProperty(This->nsstyle, &name_str, &val_str, &empty_str);
2590 if(NS_FAILED(nsres))
2591 ERR("SetProperty failed: %08x\n", nsres);
2592
2593 nsAString_Finish(&name_str);
2594 nsAString_Finish(&val_str);
2595 nsAString_Finish(&empty_str);
2596 }
2597
2598 static void update_filter(HTMLStyle *This)
2599 {
2600 const WCHAR *ptr = This->filter, *ptr2;
2601
2602 static const WCHAR alphaW[] = {'a','l','p','h','a'};
2603
2604 if(!ptr) {
2605 set_opacity(This, emptyW);
2606 return;
2607 }
2608
2609 while(1) {
2610 while(isspaceW(*ptr))
2611 ptr++;
2612 if(!*ptr)
2613 break;
2614
2615 ptr2 = ptr;
2616 while(isalnumW(*ptr))
2617 ptr++;
2618 if(ptr == ptr2) {
2619 WARN("unexpected char '%c'\n", *ptr);
2620 break;
2621 }
2622 if(*ptr != '(') {
2623 WARN("expected '('\n");
2624 continue;
2625 }
2626
2627 if(ptr2 + sizeof(alphaW)/sizeof(WCHAR) == ptr && !memcmp(ptr2, alphaW, sizeof(alphaW))) {
2628 static const WCHAR formatW[] = {'%','f',0};
2629 static const WCHAR opacityW[] = {'o','p','a','c','i','t','y','='};
2630
2631 ptr++;
2632 do {
2633 while(isspaceW(*ptr))
2634 ptr++;
2635
2636 ptr2 = ptr;
2637 while(*ptr && *ptr != ',' && *ptr != ')')
2638 ptr++;
2639 if(!*ptr) {
2640 WARN("unexpected end of string\n");
2641 break;
2642 }
2643
2644 if(ptr-ptr2 > sizeof(opacityW)/sizeof(WCHAR) && !memcmp(ptr2, opacityW, sizeof(opacityW))) {
2645 float fval = 0.0f, e = 0.1f;
2646 WCHAR buf[32];
2647
2648 ptr2 += sizeof(opacityW)/sizeof(WCHAR);
2649
2650 while(isdigitW(*ptr2))
2651 fval = fval*10.0f + (float)(*ptr2++ - '0');
2652
2653 if(*ptr2 == '.') {
2654 while(isdigitW(*++ptr2)) {
2655 fval += e * (float)(*ptr2++ - '0');
2656 e *= 0.1f;
2657 }
2658 }
2659
2660 sprintfW(buf, formatW, fval * 0.01f);
2661 set_opacity(This, buf);
2662 }else {
2663 FIXME("unknown param %s\n", debugstr_wn(ptr2, ptr-ptr2));
2664 }
2665
2666 if(*ptr == ',')
2667 ptr++;
2668 }while(*ptr != ')');
2669 }else {
2670 FIXME("unknown filter %s\n", debugstr_wn(ptr2, ptr-ptr2));
2671 ptr = strchrW(ptr, ')');
2672 if(!ptr)
2673 break;
2674 ptr++;
2675 }
2676 }
2677 }
2678
2679 static HRESULT WINAPI HTMLStyle_put_filter(IHTMLStyle *iface, BSTR v)
2680 {
2681 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2682 WCHAR *new_filter = NULL;
2683
2684 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2685
2686 if(v) {
2687 new_filter = heap_strdupW(v);
2688 if(!new_filter)
2689 return E_OUTOFMEMORY;
2690 }
2691
2692 heap_free(This->filter);
2693 This->filter = new_filter;
2694
2695 update_filter(This);
2696 return S_OK;
2697 }
2698
2699 static HRESULT WINAPI HTMLStyle_get_filter(IHTMLStyle *iface, BSTR *p)
2700 {
2701 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2702
2703 TRACE("(%p)->(%p)\n", This, p);
2704
2705 if(This->filter) {
2706 *p = SysAllocString(This->filter);
2707 if(!*p)
2708 return E_OUTOFMEMORY;
2709 }else {
2710 *p = NULL;
2711 }
2712
2713 return S_OK;
2714 }
2715
2716 static HRESULT WINAPI HTMLStyle_setAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2717 VARIANT AttributeValue, LONG lFlags)
2718 {
2719 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2720 HRESULT hres;
2721 DISPID dispid;
2722
2723 TRACE("(%p)->(%s v%d %08x)\n", This, debugstr_w(strAttributeName),
2724 V_VT(&AttributeValue), lFlags);
2725
2726 if(!strAttributeName)
2727 return E_INVALIDARG;
2728
2729 if(lFlags == 1)
2730 FIXME("Parameter lFlags ignored\n");
2731
2732 hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2733 LOCALE_USER_DEFAULT, &dispid);
2734 if(hres == S_OK)
2735 {
2736 VARIANT ret;
2737 DISPID dispidNamed = DISPID_PROPERTYPUT;
2738 DISPPARAMS params;
2739
2740 params.cArgs = 1;
2741 params.rgvarg = &AttributeValue;
2742 params.cNamedArgs = 1;
2743 params.rgdispidNamedArgs = &dispidNamed;
2744
2745 hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2746 DISPATCH_PROPERTYPUT, &params, &ret, NULL, NULL);
2747 }
2748 else
2749 {
2750 FIXME("Custom attributes not supported.\n");
2751 }
2752
2753 TRACE("ret: %08x\n", hres);
2754
2755 return hres;
2756 }
2757
2758 static HRESULT WINAPI HTMLStyle_getAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2759 LONG lFlags, VARIANT *AttributeValue)
2760 {
2761 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2762 HRESULT hres;
2763 DISPID dispid;
2764
2765 TRACE("(%p)->(%s v%p %08x)\n", This, debugstr_w(strAttributeName),
2766 AttributeValue, lFlags);
2767
2768 if(!AttributeValue || !strAttributeName)
2769 return E_INVALIDARG;
2770
2771 if(lFlags == 1)
2772 FIXME("Parameter lFlags ignored\n");
2773
2774 hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2775 LOCALE_USER_DEFAULT, &dispid);
2776 if(hres == S_OK)
2777 {
2778 DISPPARAMS params = {NULL, NULL, 0, 0 };
2779
2780 hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2781 DISPATCH_PROPERTYGET, &params, AttributeValue, NULL, NULL);
2782 }
2783 else
2784 {
2785 FIXME("Custom attributes not supported.\n");
2786 }
2787
2788 return hres;
2789 }
2790
2791 static HRESULT WINAPI HTMLStyle_removeAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2792 LONG lFlags, VARIANT_BOOL *pfSuccess)
2793 {
2794 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2795 FIXME("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName),
2796 lFlags, pfSuccess);
2797 return E_NOTIMPL;
2798 }
2799
2800 static HRESULT WINAPI HTMLStyle_toString(IHTMLStyle *iface, BSTR *String)
2801 {
2802 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2803 FIXME("(%p)->(%p)\n", This, String);
2804 return E_NOTIMPL;
2805 }
2806
2807 static const IHTMLStyleVtbl HTMLStyleVtbl = {
2808 HTMLStyle_QueryInterface,
2809 HTMLStyle_AddRef,
2810 HTMLStyle_Release,
2811 HTMLStyle_GetTypeInfoCount,
2812 HTMLStyle_GetTypeInfo,
2813 HTMLStyle_GetIDsOfNames,
2814 HTMLStyle_Invoke,
2815 HTMLStyle_put_fontFamily,
2816 HTMLStyle_get_fontFamily,
2817 HTMLStyle_put_fontStyle,
2818 HTMLStyle_get_fontStyle,
2819 HTMLStyle_put_fontVariant,
2820 HTMLStyle_get_fontVariant,
2821 HTMLStyle_put_fontWeight,
2822 HTMLStyle_get_fontWeight,
2823 HTMLStyle_put_fontSize,
2824 HTMLStyle_get_fontSize,
2825 HTMLStyle_put_font,
2826 HTMLStyle_get_font,
2827 HTMLStyle_put_color,
2828 HTMLStyle_get_color,
2829 HTMLStyle_put_background,
2830 HTMLStyle_get_background,
2831 HTMLStyle_put_backgroundColor,
2832 HTMLStyle_get_backgroundColor,
2833 HTMLStyle_put_backgroundImage,
2834 HTMLStyle_get_backgroundImage,
2835 HTMLStyle_put_backgroundRepeat,
2836 HTMLStyle_get_backgroundRepeat,
2837 HTMLStyle_put_backgroundAttachment,
2838 HTMLStyle_get_backgroundAttachment,
2839 HTMLStyle_put_backgroundPosition,
2840 HTMLStyle_get_backgroundPosition,
2841 HTMLStyle_put_backgroundPositionX,
2842 HTMLStyle_get_backgroundPositionX,
2843 HTMLStyle_put_backgroundPositionY,
2844 HTMLStyle_get_backgroundPositionY,
2845 HTMLStyle_put_wordSpacing,
2846 HTMLStyle_get_wordSpacing,
2847 HTMLStyle_put_letterSpacing,
2848 HTMLStyle_get_letterSpacing,
2849 HTMLStyle_put_textDecoration,
2850 HTMLStyle_get_textDecoration,
2851 HTMLStyle_put_textDecorationNone,
2852 HTMLStyle_get_textDecorationNone,
2853 HTMLStyle_put_textDecorationUnderline,
2854 HTMLStyle_get_textDecorationUnderline,
2855 HTMLStyle_put_textDecorationOverline,
2856 HTMLStyle_get_textDecorationOverline,
2857 HTMLStyle_put_textDecorationLineThrough,
2858 HTMLStyle_get_textDecorationLineThrough,
2859 HTMLStyle_put_textDecorationBlink,
2860 HTMLStyle_get_textDecorationBlink,
2861 HTMLStyle_put_verticalAlign,
2862 HTMLStyle_get_verticalAlign,
2863 HTMLStyle_put_textTransform,
2864 HTMLStyle_get_textTransform,
2865 HTMLStyle_put_textAlign,
2866 HTMLStyle_get_textAlign,
2867 HTMLStyle_put_textIndent,
2868 HTMLStyle_get_textIndent,
2869 HTMLStyle_put_lineHeight,
2870 HTMLStyle_get_lineHeight,
2871 HTMLStyle_put_marginTop,
2872 HTMLStyle_get_marginTop,
2873 HTMLStyle_put_marginRight,
2874 HTMLStyle_get_marginRight,
2875 HTMLStyle_put_marginBottom,
2876 HTMLStyle_get_marginBottom,
2877 HTMLStyle_put_marginLeft,
2878 HTMLStyle_get_marginLeft,
2879 HTMLStyle_put_margin,
2880 HTMLStyle_get_margin,
2881 HTMLStyle_put_paddingTop,
2882 HTMLStyle_get_paddingTop,
2883 HTMLStyle_put_paddingRight,
2884 HTMLStyle_get_paddingRight,
2885 HTMLStyle_put_paddingBottom,
2886 HTMLStyle_get_paddingBottom,
2887 HTMLStyle_put_paddingLeft,
2888 HTMLStyle_get_paddingLeft,
2889 HTMLStyle_put_padding,
2890 HTMLStyle_get_padding,
2891 HTMLStyle_put_border,
2892 HTMLStyle_get_border,
2893 HTMLStyle_put_borderTop,
2894 HTMLStyle_get_borderTop,
2895 HTMLStyle_put_borderRight,
2896 HTMLStyle_get_borderRight,
2897 HTMLStyle_put_borderBottom,
2898 HTMLStyle_get_borderBottom,
2899 HTMLStyle_put_borderLeft,
2900 HTMLStyle_get_borderLeft,
2901 HTMLStyle_put_borderColor,
2902 HTMLStyle_get_borderColor,
2903 HTMLStyle_put_borderTopColor,
2904 HTMLStyle_get_borderTopColor,
2905 HTMLStyle_put_borderRightColor,
2906 HTMLStyle_get_borderRightColor,
2907 HTMLStyle_put_borderBottomColor,
2908 HTMLStyle_get_borderBottomColor,
2909 HTMLStyle_put_borderLeftColor,
2910 HTMLStyle_get_borderLeftColor,
2911 HTMLStyle_put_borderWidth,
2912 HTMLStyle_get_borderWidth,
2913 HTMLStyle_put_borderTopWidth,
2914 HTMLStyle_get_borderTopWidth,
2915 HTMLStyle_put_borderRightWidth,
2916 HTMLStyle_get_borderRightWidth,
2917 HTMLStyle_put_borderBottomWidth,
2918 HTMLStyle_get_borderBottomWidth,
2919 HTMLStyle_put_borderLeftWidth,
2920 HTMLStyle_get_borderLeftWidth,
2921 HTMLStyle_put_borderStyle,
2922 HTMLStyle_get_borderStyle,
2923 HTMLStyle_put_borderTopStyle,
2924 HTMLStyle_get_borderTopStyle,
2925 HTMLStyle_put_borderRightStyle,
2926 HTMLStyle_get_borderRightStyle,
2927 HTMLStyle_put_borderBottomStyle,
2928 HTMLStyle_get_borderBottomStyle,
2929 HTMLStyle_put_borderLeftStyle,
2930 HTMLStyle_get_borderLeftStyle,
2931 HTMLStyle_put_width,
2932 HTMLStyle_get_width,
2933 HTMLStyle_put_height,
2934 HTMLStyle_get_height,
2935 HTMLStyle_put_styleFloat,
2936 HTMLStyle_get_styleFloat,
2937 HTMLStyle_put_clear,
2938 HTMLStyle_get_clear,
2939 HTMLStyle_put_display,
2940 HTMLStyle_get_display,
2941 HTMLStyle_put_visibility,
2942 HTMLStyle_get_visibility,
2943 HTMLStyle_put_listStyleType,
2944 HTMLStyle_get_listStyleType,
2945 HTMLStyle_put_listStylePosition,
2946 HTMLStyle_get_listStylePosition,
2947 HTMLStyle_put_listStyleImage,
2948 HTMLStyle_get_listStyleImage,
2949 HTMLStyle_put_listStyle,
2950 HTMLStyle_get_listStyle,
2951 HTMLStyle_put_whiteSpace,
2952 HTMLStyle_get_whiteSpace,
2953 HTMLStyle_put_top,
2954 HTMLStyle_get_top,
2955 HTMLStyle_put_left,
2956 HTMLStyle_get_left,
2957 HTMLStyle_get_position,
2958 HTMLStyle_put_zIndex,
2959 HTMLStyle_get_zIndex,
2960 HTMLStyle_put_overflow,
2961 HTMLStyle_get_overflow,
2962 HTMLStyle_put_pageBreakBefore,
2963 HTMLStyle_get_pageBreakBefore,
2964 HTMLStyle_put_pageBreakAfter,
2965 HTMLStyle_get_pageBreakAfter,
2966 HTMLStyle_put_cssText,
2967 HTMLStyle_get_cssText,
2968 HTMLStyle_put_pixelTop,
2969 HTMLStyle_get_pixelTop,
2970 HTMLStyle_put_pixelLeft,
2971 HTMLStyle_get_pixelLeft,
2972 HTMLStyle_put_pixelWidth,
2973 HTMLStyle_get_pixelWidth,
2974 HTMLStyle_put_pixelHeight,
2975 HTMLStyle_get_pixelHeight,
2976 HTMLStyle_put_posTop,
2977 HTMLStyle_get_posTop,
2978 HTMLStyle_put_posLeft,
2979 HTMLStyle_get_posLeft,
2980 HTMLStyle_put_posWidth,
2981 HTMLStyle_get_posWidth,
2982 HTMLStyle_put_posHeight,
2983 HTMLStyle_get_posHeight,
2984 HTMLStyle_put_cursor,
2985 HTMLStyle_get_cursor,
2986 HTMLStyle_put_clip,
2987 HTMLStyle_get_clip,
2988 HTMLStyle_put_filter,
2989 HTMLStyle_get_filter,
2990 HTMLStyle_setAttribute,
2991 HTMLStyle_getAttribute,
2992 HTMLStyle_removeAttribute,
2993 HTMLStyle_toString
2994 };
2995
2996 static HRESULT HTMLStyle_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
2997 {
2998 int c, i, min=0, max = sizeof(style_tbl)/sizeof(*style_tbl)-1;
2999
3000 while(min <= max) {
3001 i = (min+max)/2;
3002
3003 c = strcmpW(style_tbl[i].name, name);
3004 if(!c) {
3005 *dispid = style_tbl[i].dispid;
3006 return S_OK;
3007 }
3008
3009 if(c > 0)
3010 max = i-1;
3011 else
3012 min = i+1;
3013 }
3014
3015 return DISP_E_UNKNOWNNAME;
3016 }
3017
3018 static const dispex_static_data_vtbl_t HTMLStyle_dispex_vtbl = {
3019 NULL,
3020 HTMLStyle_get_dispid,
3021 NULL,
3022 NULL
3023 };
3024
3025 static const tid_t HTMLStyle_iface_tids[] = {
3026 IHTMLStyle_tid,
3027 IHTMLStyle2_tid,
3028 IHTMLStyle3_tid,
3029 IHTMLStyle4_tid,
3030 IHTMLStyle5_tid,
3031 IHTMLStyle6_tid,
3032 0
3033 };
3034 static dispex_static_data_t HTMLStyle_dispex = {
3035 &HTMLStyle_dispex_vtbl,
3036 DispHTMLStyle_tid,
3037 NULL,
3038 HTMLStyle_iface_tids
3039 };
3040
3041 HRESULT HTMLStyle_Create(nsIDOMCSSStyleDeclaration *nsstyle, HTMLStyle **ret)
3042 {
3043 HTMLStyle *style;
3044
3045 style = heap_alloc_zero(sizeof(HTMLStyle));
3046 if(!style)
3047 return E_OUTOFMEMORY;
3048
3049 style->IHTMLStyle_iface.lpVtbl = &HTMLStyleVtbl;
3050 style->ref = 1;
3051 style->nsstyle = nsstyle;
3052 HTMLStyle2_Init(style);
3053 HTMLStyle3_Init(style);
3054
3055 nsIDOMCSSStyleDeclaration_AddRef(nsstyle);
3056
3057 init_dispex(&style->dispex, (IUnknown*)&style->IHTMLStyle_iface, &HTMLStyle_dispex);
3058
3059 *ret = style;
3060 return S_OK;
3061 }
Maarten's multimedia branch