?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Store style property flags in an array and use it in set_nsstyle_attr and...
[wine.git] / dlls / mshtml / htmlstyle.c
blobcbc270657f3e3193d752fd59770394a34e8307cc
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 <assert.h>
21 #include <math.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "ole2.h"
29 #include "mshtmdid.h"
30
31 #include "mshtml_private.h"
32 #include "htmlstyle.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 static const WCHAR backgroundW[] =
39 {'b','a','c','k','g','r','o','u','n','d',0};
40 static const WCHAR background_attachmentW[] =
41 {'b','a','c','k','g','r','o','u','n','d','-','a','t','t','a','c','h','m','e','n','t',0};
42 static const WCHAR background_colorW[] =
43 {'b','a','c','k','g','r','o','u','n','d','-','c','o','l','o','r',0};
44 static const WCHAR background_imageW[] =
45 {'b','a','c','k','g','r','o','u','n','d','-','i','m','a','g','e',0};
46 static const WCHAR background_positionW[] =
47 {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n',0};
48 static const WCHAR background_position_xW[] =
49 {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n','-','x',0};
50 static const WCHAR background_position_yW[] =
51 {'b','a','c','k','g','r','o','u','n','d','-','p','o','s','i','t','i','o','n','-','y',0};
52 static const WCHAR background_repeatW[] =
53 {'b','a','c','k','g','r','o','u','n','d','-','r','e','p','e','a','t',0};
54 static const WCHAR borderW[] =
55 {'b','o','r','d','e','r',0};
56 static const WCHAR border_bottomW[] =
57 {'b','o','r','d','e','r','-','b','o','t','t','o','m',0};
58 static const WCHAR border_bottom_colorW[] =
59 {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','c','o','l','o','r',0};
60 static const WCHAR border_bottom_styleW[] =
61 {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','s','t','y','l','e',0};
62 static const WCHAR border_bottom_widthW[] =
63 {'b','o','r','d','e','r','-','b','o','t','t','o','m','-','w','i','d','t','h',0};
64 static const WCHAR border_colorW[] =
65 {'b','o','r','d','e','r','-','c','o','l','o','r',0};
66 static const WCHAR border_leftW[] =
67 {'b','o','r','d','e','r','-','l','e','f','t',0};
68 static const WCHAR border_left_colorW[] =
69 {'b','o','r','d','e','r','-','l','e','f','t','-','c','o','l','o','r',0};
70 static const WCHAR border_left_styleW[] =
71 {'b','o','r','d','e','r','-','l','e','f','t','-','s','t','y','l','e',0};
72 static const WCHAR border_left_widthW[] =
73 {'b','o','r','d','e','r','-','l','e','f','t','-','w','i','d','t','h',0};
74 static const WCHAR border_rightW[] =
75 {'b','o','r','d','e','r','-','r','i','g','h','t',0};
76 static const WCHAR border_right_colorW[] =
77 {'b','o','r','d','e','r','-','r','i','g','h','t','-','c','o','l','o','r',0};
78 static const WCHAR border_right_styleW[] =
79 {'b','o','r','d','e','r','-','r','i','g','h','t','-','s','t','y','l','e',0};
80 static const WCHAR border_right_widthW[] =
81 {'b','o','r','d','e','r','-','r','i','g','h','t','-','w','i','d','t','h',0};
82 static const WCHAR border_topW[] =
83 {'b','o','r','d','e','r','-','t','o','p',0};
84 static const WCHAR border_top_colorW[] =
85 {'b','o','r','d','e','r','-','t','o','p','-','c','o','l','o','r',0};
86 static const WCHAR border_styleW[] =
87 {'b','o','r','d','e','r','-','s','t','y','l','e',0};
88 static const WCHAR border_top_styleW[] =
89 {'b','o','r','d','e','r','-','t','o','p','-','s','t','y','l','e',0};
90 static const WCHAR border_top_widthW[] =
91 {'b','o','r','d','e','r','-','t','o','p','-','w','i','d','t','h',0};
92 static const WCHAR border_widthW[] =
93 {'b','o','r','d','e','r','-','w','i','d','t','h',0};
94 static const WCHAR bottomW[] =
95 {'b','o','t','t','o','m',0};
96 /* FIXME: Use unprefixed version (requires Gecko changes). */
97 static const WCHAR box_sizingW[] =
98 {'-','m','o','z','-','b','o','x','-','s','i','z','i','n','g',0};
99 static const WCHAR clearW[] =
100 {'c','l','e','a','r',0};
101 static const WCHAR clipW[] =
102 {'c','l','i','p',0};
103 static const WCHAR colorW[] =
104 {'c','o','l','o','r',0};
105 static const WCHAR cursorW[] =
106 {'c','u','r','s','o','r',0};
107 static const WCHAR directionW[] =
108 {'d','i','r','e','c','t','i','o','n',0};
109 static const WCHAR displayW[] =
110 {'d','i','s','p','l','a','y',0};
111 static const WCHAR filterW[] =
112 {'f','i','l','e','t','e','r',0};
113 static const WCHAR floatW[] =
114 {'f','l','o','a','t',0};
115 static const WCHAR font_familyW[] =
116 {'f','o','n','t','-','f','a','m','i','l','y',0};
117 static const WCHAR font_sizeW[] =
118 {'f','o','n','t','-','s','i','z','e',0};
119 static const WCHAR font_styleW[] =
120 {'f','o','n','t','-','s','t','y','l','e',0};
121 static const WCHAR font_variantW[] =
122 {'f','o','n','t','-','v','a','r','i','a','n','t',0};
123 static const WCHAR font_weightW[] =
124 {'f','o','n','t','-','w','e','i','g','h','t',0};
125 static const WCHAR heightW[] =
126 {'h','e','i','g','h','t',0};
127 static const WCHAR leftW[] =
128 {'l','e','f','t',0};
129 static const WCHAR letter_spacingW[] =
130 {'l','e','t','t','e','r','-','s','p','a','c','i','n','g',0};
131 static const WCHAR line_heightW[] =
132 {'l','i','n','e','-','h','e','i','g','h','t',0};
133 static const WCHAR list_styleW[] =
134 {'l','i','s','t','-','s','t','y','l','e',0};
135 static const WCHAR list_style_typeW[] =
136 {'l','i','s','t','-','s','t','y','l','e','-','t','y','p','e',0};
137 static const WCHAR list_style_positionW[] =
138 {'l','i','s','t','-','s','t','y','l','e','-','p','o','s','i','t','i','o','n',0};
139 static const WCHAR marginW[] =
140 {'m','a','r','g','i','n',0};
141 static const WCHAR margin_bottomW[] =
142 {'m','a','r','g','i','n','-','b','o','t','t','o','m',0};
143 static const WCHAR margin_leftW[] =
144 {'m','a','r','g','i','n','-','l','e','f','t',0};
145 static const WCHAR margin_rightW[] =
146 {'m','a','r','g','i','n','-','r','i','g','h','t',0};
147 static const WCHAR margin_topW[] =
148 {'m','a','r','g','i','n','-','t','o','p',0};
149 static const WCHAR max_heightW[] =
150 {'m','a','x','-','h','e','i','g','h','t',0};
151 static const WCHAR max_widthW[] =
152 {'m','a','x','-','w','i','d','t','h',0};
153 static const WCHAR min_heightW[] =
154 {'m','i','n','-','h','e','i','g','h','t',0};
155 static const WCHAR min_widthW[] =
156 {'m','i','n','-','w','i','d','t','h',0};
157 static const WCHAR outlineW[] =
158 {'o','u','t','l','i','n','e',0};
159 static const WCHAR overflowW[] =
160 {'o','v','e','r','f','l','o','w',0};
161 static const WCHAR overflow_xW[] =
162 {'o','v','e','r','f','l','o','w','-','x',0};
163 static const WCHAR overflow_yW[] =
164 {'o','v','e','r','f','l','o','w','-','y',0};
165 static const WCHAR paddingW[] =
166 {'p','a','d','d','i','n','g',0};
167 static const WCHAR padding_bottomW[] =
168 {'p','a','d','d','i','n','g','-','b','o','t','t','o','m',0};
169 static const WCHAR padding_leftW[] =
170 {'p','a','d','d','i','n','g','-','l','e','f','t',0};
171 static const WCHAR padding_rightW[] =
172 {'p','a','d','d','i','n','g','-','r','i','g','h','t',0};
173 static const WCHAR padding_topW[] =
174 {'p','a','d','d','i','n','g','-','t','o','p',0};
175 static const WCHAR page_break_afterW[] =
176 {'p','a','g','e','-','b','r','e','a','k','-','a','f','t','e','r',0};
177 static const WCHAR page_break_beforeW[] =
178 {'p','a','g','e','-','b','r','e','a','k','-','b','e','f','o','r','e',0};
179 static const WCHAR positionW[] =
180 {'p','o','s','i','t','i','o','n',0};
181 static const WCHAR rightW[] =
182 {'r','i','g','h','t',0};
183 static const WCHAR table_layoutW[] =
184 {'t','a','b','l','e','-','l','a','y','o','u','t',0};
185 static const WCHAR text_alignW[] =
186 {'t','e','x','t','-','a','l','i','g','n',0};
187 static const WCHAR text_decorationW[] =
188 {'t','e','x','t','-','d','e','c','o','r','a','t','i','o','n',0};
189 static const WCHAR text_indentW[] =
190 {'t','e','x','t','-','i','n','d','e','n','t',0};
191 static const WCHAR text_transformW[] =
192 {'t','e','x','t','-','t','r','a','n','s','f','o','r','m',0};
193 static const WCHAR topW[] =
194 {'t','o','p',0};
195 static const WCHAR vertical_alignW[] =
196 {'v','e','r','t','i','c','a','l','-','a','l','i','g','n',0};
197 static const WCHAR visibilityW[] =
198 {'v','i','s','i','b','i','l','i','t','y',0};
199 static const WCHAR white_spaceW[] =
200 {'w','h','i','t','e','-','s','p','a','c','e',0};
201 static const WCHAR widthW[] =
202 {'w','i','d','t','h',0};
203 static const WCHAR word_spacingW[] =
204 {'w','o','r','d','-','s','p','a','c','i','n','g',0};
205 static const WCHAR word_wrapW[] =
206 {'w','o','r','d','-','w','r','a','p',0};
207 static const WCHAR z_indexW[] =
208 {'z','-','i','n','d','e','x',0};
209
210
211 static const WCHAR pxW[] = {'p','x',0};
212
213 typedef struct {
214 const WCHAR *name;
215 DISPID dispid;
216 unsigned flags;
217 } style_tbl_entry_t;
218
219 static const style_tbl_entry_t style_tbl[] = {
220 {backgroundW, DISPID_IHTMLSTYLE_BACKGROUND},
221 {background_attachmentW, DISPID_IHTMLSTYLE_BACKGROUNDATTACHMENT},
222 {background_colorW, DISPID_IHTMLSTYLE_BACKGROUNDCOLOR, ATTR_HEX_INT},
223 {background_imageW, DISPID_IHTMLSTYLE_BACKGROUNDIMAGE, ATTR_FIX_URL},
224 {background_positionW, DISPID_IHTMLSTYLE_BACKGROUNDPOSITION},
225 {background_position_xW, DISPID_IHTMLSTYLE_BACKGROUNDPOSITIONX, ATTR_FIX_PX},
226 {background_position_yW, DISPID_IHTMLSTYLE_BACKGROUNDPOSITIONY, ATTR_FIX_PX},
227 {background_repeatW, DISPID_IHTMLSTYLE_BACKGROUNDREPEAT},
228 {borderW, DISPID_IHTMLSTYLE_BORDER},
229 {border_bottomW, DISPID_IHTMLSTYLE_BORDERBOTTOM, ATTR_FIX_PX},
230 {border_bottom_colorW, DISPID_IHTMLSTYLE_BORDERBOTTOMCOLOR, ATTR_HEX_INT},
231 {border_bottom_styleW, DISPID_IHTMLSTYLE_BORDERBOTTOMSTYLE},
232 {border_bottom_widthW, DISPID_IHTMLSTYLE_BORDERBOTTOMWIDTH, ATTR_FIX_PX},
233 {border_colorW, DISPID_IHTMLSTYLE_BORDERCOLOR},
234 {border_leftW, DISPID_IHTMLSTYLE_BORDERLEFT, ATTR_FIX_PX},
235 {border_left_colorW, DISPID_IHTMLSTYLE_BORDERLEFTCOLOR, ATTR_HEX_INT},
236 {border_left_styleW, DISPID_IHTMLSTYLE_BORDERLEFTSTYLE},
237 {border_left_widthW, DISPID_IHTMLSTYLE_BORDERLEFTWIDTH, ATTR_FIX_PX},
238 {border_rightW, DISPID_IHTMLSTYLE_BORDERRIGHT, ATTR_FIX_PX},
239 {border_right_colorW, DISPID_IHTMLSTYLE_BORDERRIGHTCOLOR, ATTR_HEX_INT},
240 {border_right_styleW, DISPID_IHTMLSTYLE_BORDERRIGHTSTYLE},
241 {border_right_widthW, DISPID_IHTMLSTYLE_BORDERRIGHTWIDTH, ATTR_FIX_PX},
242 {border_styleW, DISPID_IHTMLSTYLE_BORDERSTYLE},
243 {border_topW, DISPID_IHTMLSTYLE_BORDERTOP, ATTR_FIX_PX},
244 {border_top_colorW, DISPID_IHTMLSTYLE_BORDERTOPCOLOR, ATTR_HEX_INT},
245 {border_top_styleW, DISPID_IHTMLSTYLE_BORDERTOPSTYLE},
246 {border_top_widthW, DISPID_IHTMLSTYLE_BORDERTOPWIDTH},
247 {border_widthW, DISPID_IHTMLSTYLE_BORDERWIDTH},
248 {bottomW, DISPID_IHTMLSTYLE2_BOTTOM, ATTR_FIX_PX},
249 {box_sizingW, DISPID_IHTMLSTYLE6_BOXSIZING},
250 {clearW, DISPID_IHTMLSTYLE_CLEAR},
251 {clipW, DISPID_IHTMLSTYLE_CLIP, ATTR_REMOVE_COMMA},
252 {colorW, DISPID_IHTMLSTYLE_COLOR, ATTR_HEX_INT},
253 {cursorW, DISPID_IHTMLSTYLE_CURSOR},
254 {directionW, DISPID_IHTMLSTYLE2_DIRECTION},
255 {displayW, DISPID_IHTMLSTYLE_DISPLAY},
256 {filterW, DISPID_IHTMLSTYLE_FILTER},
257 {floatW, DISPID_IHTMLSTYLE_STYLEFLOAT},
258 {font_familyW, DISPID_IHTMLSTYLE_FONTFAMILY},
259 {font_sizeW, DISPID_IHTMLSTYLE_FONTSIZE, ATTR_FIX_PX},
260 {font_styleW, DISPID_IHTMLSTYLE_FONTSTYLE},
261 {font_variantW, DISPID_IHTMLSTYLE_FONTVARIANT},
262 {font_weightW, DISPID_IHTMLSTYLE_FONTWEIGHT, ATTR_STR_TO_INT},
263 {heightW, DISPID_IHTMLSTYLE_HEIGHT, ATTR_FIX_PX},
264 {leftW, DISPID_IHTMLSTYLE_LEFT},
265 {letter_spacingW, DISPID_IHTMLSTYLE_LETTERSPACING},
266 {line_heightW, DISPID_IHTMLSTYLE_LINEHEIGHT},
267 {list_styleW, DISPID_IHTMLSTYLE_LISTSTYLE},
268 {list_style_positionW, DISPID_IHTMLSTYLE_LISTSTYLEPOSITION},
269 {list_style_typeW, DISPID_IHTMLSTYLE_LISTSTYLETYPE},
270 {marginW, DISPID_IHTMLSTYLE_MARGIN},
271 {margin_bottomW, DISPID_IHTMLSTYLE_MARGINBOTTOM, ATTR_FIX_PX},
272 {margin_leftW, DISPID_IHTMLSTYLE_MARGINLEFT, ATTR_FIX_PX},
273 {margin_rightW, DISPID_IHTMLSTYLE_MARGINRIGHT, ATTR_FIX_PX},
274 {margin_topW, DISPID_IHTMLSTYLE_MARGINTOP, ATTR_FIX_PX},
275 {max_heightW, DISPID_IHTMLSTYLE5_MAXHEIGHT, ATTR_FIX_PX},
276 {max_widthW, DISPID_IHTMLSTYLE5_MAXWIDTH, ATTR_FIX_PX},
277 {min_heightW, DISPID_IHTMLSTYLE4_MINHEIGHT},
278 {min_widthW, DISPID_IHTMLSTYLE5_MINWIDTH, ATTR_FIX_PX},
279 {outlineW, DISPID_IHTMLSTYLE6_OUTLINE, ATTR_NO_NULL},
280 {overflowW, DISPID_IHTMLSTYLE_OVERFLOW},
281 {overflow_xW, DISPID_IHTMLSTYLE2_OVERFLOWX},
282 {overflow_yW, DISPID_IHTMLSTYLE2_OVERFLOWY},
283 {paddingW, DISPID_IHTMLSTYLE_PADDING},
284 {padding_bottomW, DISPID_IHTMLSTYLE_PADDINGBOTTOM, ATTR_FIX_PX},
285 {padding_leftW, DISPID_IHTMLSTYLE_PADDINGLEFT, ATTR_FIX_PX},
286 {padding_rightW, DISPID_IHTMLSTYLE_PADDINGRIGHT, ATTR_FIX_PX},
287 {padding_topW, DISPID_IHTMLSTYLE_PADDINGTOP, ATTR_FIX_PX},
288 {page_break_afterW, DISPID_IHTMLSTYLE_PAGEBREAKAFTER},
289 {page_break_beforeW, DISPID_IHTMLSTYLE_PAGEBREAKBEFORE},
290 {positionW, DISPID_IHTMLSTYLE2_POSITION},
291 {rightW, DISPID_IHTMLSTYLE2_RIGHT},
292 {table_layoutW, DISPID_IHTMLSTYLE2_TABLELAYOUT},
293 {text_alignW, DISPID_IHTMLSTYLE_TEXTALIGN},
294 {text_decorationW, DISPID_IHTMLSTYLE_TEXTDECORATION},
295 {text_indentW, DISPID_IHTMLSTYLE_TEXTINDENT, ATTR_FIX_PX},
296 {text_transformW, DISPID_IHTMLSTYLE_TEXTTRANSFORM},
297 {topW, DISPID_IHTMLSTYLE_TOP},
298 {vertical_alignW, DISPID_IHTMLSTYLE_VERTICALALIGN, ATTR_FIX_PX},
299 {visibilityW, DISPID_IHTMLSTYLE_VISIBILITY},
300 {white_spaceW, DISPID_IHTMLSTYLE_WHITESPACE},
301 {widthW, DISPID_IHTMLSTYLE_WIDTH, ATTR_FIX_PX},
302 {word_spacingW, DISPID_IHTMLSTYLE_WORDSPACING},
303 {word_wrapW, DISPID_IHTMLSTYLE3_WORDWRAP},
304 {z_indexW, DISPID_IHTMLSTYLE_ZINDEX, ATTR_STR_TO_INT}
305 };
306
307 C_ASSERT(ARRAY_SIZE(style_tbl) == STYLEID_MAX_VALUE);
308
309 static const WCHAR valLineThrough[] =
310 {'l','i','n','e','-','t','h','r','o','u','g','h',0};
311 static const WCHAR valUnderline[] =
312 {'u','n','d','e','r','l','i','n','e',0};
313 static const WCHAR szNormal[] =
314 {'n','o','r','m','a','l',0};
315 static const WCHAR styleNone[] =
316 {'n','o','n','e',0};
317 static const WCHAR valOverline[] =
318 {'o','v','e','r','l','i','n','e',0};
319 static const WCHAR valBlink[] =
320 {'b','l','i','n','k',0};
321
322 static const WCHAR px_formatW[] = {'%','d','p','x',0};
323 static const WCHAR emptyW[] = {0};
324
325 static const style_tbl_entry_t *lookup_style_tbl(const WCHAR *name)
326 {
327 int c, i, min = 0, max = ARRAY_SIZE(style_tbl)-1;
328
329 while(min <= max) {
330 i = (min+max)/2;
331
332 c = strcmpW(style_tbl[i].name, name);
333 if(!c)
334 return style_tbl+i;
335
336 if(c > 0)
337 max = i-1;
338 else
339 min = i+1;
340 }
341
342 return NULL;
343 }
344
345 static inline compat_mode_t get_style_compat_mode(HTMLStyle *style)
346 {
347 return style->elem && style->elem->node.doc ? style->elem->node.doc->document_mode : COMPAT_MODE_QUIRKS;
348 }
349
350 static LPWSTR fix_px_value(LPCWSTR val)
351 {
352 LPCWSTR ptr = val;
353
354 while(*ptr) {
355 while(*ptr && isspaceW(*ptr))
356 ptr++;
357 if(!*ptr)
358 break;
359
360 while(*ptr && isdigitW(*ptr))
361 ptr++;
362
363 if(!*ptr || isspaceW(*ptr)) {
364 LPWSTR ret, p;
365 int len = strlenW(val)+1;
366
367 ret = heap_alloc((len+2)*sizeof(WCHAR));
368 memcpy(ret, val, (ptr-val)*sizeof(WCHAR));
369 p = ret + (ptr-val);
370 *p++ = 'p';
371 *p++ = 'x';
372 strcpyW(p, ptr);
373
374 TRACE("fixed %s -> %s\n", debugstr_w(val), debugstr_w(ret));
375
376 return ret;
377 }
378
379 while(*ptr && !isspaceW(*ptr))
380 ptr++;
381 }
382
383 return NULL;
384 }
385
386 static LPWSTR fix_url_value(LPCWSTR val)
387 {
388 WCHAR *ret, *ptr;
389
390 static const WCHAR urlW[] = {'u','r','l','('};
391
392 if(strncmpW(val, urlW, ARRAY_SIZE(urlW)) || !strchrW(val, '\\'))
393 return NULL;
394
395 ret = heap_strdupW(val);
396
397 for(ptr = ret; *ptr; ptr++) {
398 if(*ptr == '\\')
399 *ptr = '/';
400 }
401
402 return ret;
403 }
404
405 static HRESULT set_nsstyle_attr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, const WCHAR *value, DWORD flags)
406 {
407 nsAString str_name, str_value, str_empty;
408 LPWSTR val = NULL;
409 nsresult nsres;
410
411 if(value) {
412 flags = style_tbl[sid].flags;
413 if(flags & ATTR_FIX_PX)
414 val = fix_px_value(value);
415 else if(flags & ATTR_FIX_URL)
416 val = fix_url_value(value);
417 }
418
419 nsAString_InitDepend(&str_name, style_tbl[sid].name);
420 nsAString_InitDepend(&str_value, val ? val : value);
421 nsAString_InitDepend(&str_empty, emptyW);
422
423 nsres = nsIDOMCSSStyleDeclaration_SetProperty(nsstyle, &str_name, &str_value, &str_empty);
424 if(NS_FAILED(nsres))
425 ERR("SetProperty failed: %08x\n", nsres);
426
427 nsAString_Finish(&str_name);
428 nsAString_Finish(&str_value);
429 nsAString_Finish(&str_empty);
430 heap_free(val);
431
432 return S_OK;
433 }
434
435 static HRESULT var_to_styleval(const VARIANT *v, WCHAR *buf, DWORD flags, const WCHAR **ret)
436 {
437 switch(V_VT(v)) {
438 case VT_NULL:
439 *ret = emptyW;
440 return S_OK;
441
442 case VT_BSTR:
443 *ret = V_BSTR(v);
444 return S_OK;
445
446 case VT_BSTR|VT_BYREF:
447 *ret = *V_BSTRREF(v);
448 return S_OK;
449
450 case VT_I4: {
451 static const WCHAR formatW[] = {'%','d',0};
452 static const WCHAR hex_formatW[] = {'#','%','0','6','x',0};
453
454 if(flags & ATTR_HEX_INT)
455 wsprintfW(buf, hex_formatW, V_I4(v));
456 else if(flags & ATTR_FIX_PX)
457 wsprintfW(buf, px_formatW, V_I4(v));
458 else
459 wsprintfW(buf, formatW, V_I4(v));
460
461 *ret = buf;
462 return S_OK;
463 }
464 default:
465 FIXME("not implemented for %s\n", debugstr_variant(v));
466 return E_NOTIMPL;
467
468 }
469 }
470
471 static HRESULT set_nsstyle_attr_var(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, VARIANT *value, DWORD flags)
472 {
473 const WCHAR *val;
474 WCHAR buf[14];
475 HRESULT hres;
476
477 hres = var_to_styleval(value, buf, flags, &val);
478 if(FAILED(hres))
479 return hres;
480
481 return set_nsstyle_attr(nsstyle, sid, val, flags);
482 }
483
484 static inline HRESULT set_style_attr(HTMLStyle *This, styleid_t sid, LPCWSTR value, DWORD flags)
485 {
486 return set_nsstyle_attr(This->nsstyle, sid, value, flags);
487 }
488
489 static HRESULT get_nsstyle_attr_nsval(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, nsAString *value)
490 {
491 nsAString str_name;
492 nsresult nsres;
493
494 nsAString_InitDepend(&str_name, style_tbl[sid].name);
495 nsres = nsIDOMCSSStyleDeclaration_GetPropertyValue(nsstyle, &str_name, value);
496 nsAString_Finish(&str_name);
497 if(NS_FAILED(nsres)) {
498 ERR("SetProperty failed: %08x\n", nsres);
499 return E_FAIL;
500 }
501
502 return S_OK;
503 }
504
505 static HRESULT nsstyle_to_bstr(const WCHAR *val, DWORD flags, BSTR *p)
506 {
507 BSTR ret;
508 DWORD len;
509
510 if(!*val) {
511 *p = (flags & ATTR_NO_NULL) ? SysAllocStringLen(NULL, 0) : NULL;
512 return S_OK;
513 }
514
515 ret = SysAllocString(val);
516 if(!ret)
517 return E_OUTOFMEMORY;
518
519 len = SysStringLen(ret);
520
521 if(flags & ATTR_REMOVE_COMMA) {
522 DWORD new_len = len;
523 WCHAR *ptr, *ptr2;
524
525 for(ptr = ret; (ptr = strchrW(ptr, ',')); ptr++)
526 new_len--;
527
528 if(new_len != len) {
529 BSTR new_ret;
530
531 new_ret = SysAllocStringLen(NULL, new_len);
532 if(!new_ret) {
533 SysFreeString(ret);
534 return E_OUTOFMEMORY;
535 }
536
537 for(ptr2 = new_ret, ptr = ret; *ptr; ptr++) {
538 if(*ptr != ',')
539 *ptr2++ = *ptr;
540 }
541
542 SysFreeString(ret);
543 ret = new_ret;
544 }
545 }
546
547 *p = ret;
548 return S_OK;
549 }
550
551 HRESULT get_nsstyle_attr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, BSTR *p, DWORD flags)
552 {
553 nsAString str_value;
554 const PRUnichar *value;
555 HRESULT hres;
556
557 nsAString_Init(&str_value, NULL);
558
559 get_nsstyle_attr_nsval(nsstyle, sid, &str_value);
560
561 nsAString_GetData(&str_value, &value);
562 hres = nsstyle_to_bstr(value, flags, p);
563 nsAString_Finish(&str_value);
564
565 TRACE("%s -> %s\n", debugstr_w(style_tbl[sid].name), debugstr_w(*p));
566 return hres;
567 }
568
569 HRESULT get_nsstyle_attr_var(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, VARIANT *p, DWORD flags)
570 {
571 nsAString str_value;
572 const PRUnichar *value;
573 BOOL set = FALSE;
574 HRESULT hres = S_OK;
575
576 flags = style_tbl[sid].flags;
577 nsAString_Init(&str_value, NULL);
578
579 get_nsstyle_attr_nsval(nsstyle, sid, &str_value);
580
581 nsAString_GetData(&str_value, &value);
582
583 if(flags & ATTR_STR_TO_INT) {
584 const PRUnichar *ptr = value;
585 BOOL neg = FALSE;
586 INT i = 0;
587
588 if(*ptr == '-') {
589 neg = TRUE;
590 ptr++;
591 }
592
593 while(isdigitW(*ptr))
594 i = i*10 + (*ptr++ - '0');
595
596 if(!*ptr) {
597 V_VT(p) = VT_I4;
598 V_I4(p) = neg ? -i : i;
599 set = TRUE;
600 }
601 }
602
603 if(!set) {
604 BSTR str;
605
606 hres = nsstyle_to_bstr(value, flags, &str);
607 if(SUCCEEDED(hres)) {
608 V_VT(p) = VT_BSTR;
609 V_BSTR(p) = str;
610 }
611 }
612
613 nsAString_Finish(&str_value);
614
615 TRACE("%s -> %s\n", debugstr_w(style_tbl[sid].name), debugstr_variant(p));
616 return S_OK;
617 }
618
619 static inline HRESULT get_style_attr(HTMLStyle *This, styleid_t sid, BSTR *p)
620 {
621 return get_nsstyle_attr(This->nsstyle, sid, p, 0);
622 }
623
624 static HRESULT check_style_attr_value(HTMLStyle *This, styleid_t sid, LPCWSTR exval, VARIANT_BOOL *p)
625 {
626 nsAString str_value;
627 const PRUnichar *value;
628
629 nsAString_Init(&str_value, NULL);
630
631 get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
632
633 nsAString_GetData(&str_value, &value);
634 *p = variant_bool(!strcmpW(value, exval));
635 nsAString_Finish(&str_value);
636
637 TRACE("%s -> %x\n", debugstr_w(style_tbl[sid].name), *p);
638 return S_OK;
639 }
640
641 static inline HRESULT set_style_pos(HTMLStyle *This, styleid_t sid, float value)
642 {
643 WCHAR szValue[25];
644 WCHAR szFormat[] = {'%','.','0','f','p','x',0};
645
646 value = floor(value);
647
648 sprintfW(szValue, szFormat, value);
649
650 return set_style_attr(This, sid, szValue, 0);
651 }
652
653 static HRESULT set_style_pxattr(nsIDOMCSSStyleDeclaration *nsstyle, styleid_t sid, LONG value)
654 {
655 WCHAR value_str[16];
656
657 sprintfW(value_str, px_formatW, value);
658
659 return set_nsstyle_attr(nsstyle, sid, value_str, 0);
660 }
661
662 static HRESULT get_nsstyle_pos(HTMLStyle *This, styleid_t sid, float *p)
663 {
664 nsAString str_value;
665 HRESULT hres;
666
667 TRACE("%p %d %p\n", This, sid, p);
668
669 *p = 0.0f;
670
671 nsAString_Init(&str_value, NULL);
672
673 hres = get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
674 if(hres == S_OK)
675 {
676 WCHAR *ptr;
677 const PRUnichar *value;
678
679 nsAString_GetData(&str_value, &value);
680 if(value)
681 {
682 *p = strtolW(value, &ptr, 10);
683
684 if(*ptr && strcmpW(ptr, pxW))
685 {
686 nsAString_Finish(&str_value);
687 FIXME("only px values are currently supported\n");
688 hres = E_FAIL;
689 }
690 }
691 }
692
693 TRACE("ret %f\n", *p);
694
695 nsAString_Finish(&str_value);
696 return hres;
697 }
698
699 static HRESULT get_nsstyle_pixel_val(HTMLStyle *This, styleid_t sid, LONG *p)
700 {
701 nsAString str_value;
702 HRESULT hres;
703
704 if(!p)
705 return E_POINTER;
706
707 nsAString_Init(&str_value, NULL);
708
709 hres = get_nsstyle_attr_nsval(This->nsstyle, sid, &str_value);
710 if(hres == S_OK) {
711 WCHAR *ptr = NULL;
712 const PRUnichar *value;
713
714 nsAString_GetData(&str_value, &value);
715 if(value) {
716 *p = strtolW(value, &ptr, 10);
717
718 if(*ptr == '.') {
719 /* Skip all digits. We have tests showing that we should not round the value. */
720 while(isdigitW(*++ptr));
721 }
722 }
723
724 if(!ptr || (*ptr && strcmpW(ptr, pxW)))
725 *p = 0;
726 }
727
728 nsAString_Finish(&str_value);
729 return hres;
730 }
731
732 static BOOL is_valid_border_style(BSTR v)
733 {
734 static const WCHAR styleDotted[] = {'d','o','t','t','e','d',0};
735 static const WCHAR styleDashed[] = {'d','a','s','h','e','d',0};
736 static const WCHAR styleSolid[] = {'s','o','l','i','d',0};
737 static const WCHAR styleDouble[] = {'d','o','u','b','l','e',0};
738 static const WCHAR styleGroove[] = {'g','r','o','o','v','e',0};
739 static const WCHAR styleRidge[] = {'r','i','d','g','e',0};
740 static const WCHAR styleInset[] = {'i','n','s','e','t',0};
741 static const WCHAR styleOutset[] = {'o','u','t','s','e','t',0};
742
743 TRACE("%s\n", debugstr_w(v));
744
745 if(!v || strcmpiW(v, styleNone) == 0 || strcmpiW(v, styleDotted) == 0 ||
746 strcmpiW(v, styleDashed) == 0 || strcmpiW(v, styleSolid) == 0 ||
747 strcmpiW(v, styleDouble) == 0 || strcmpiW(v, styleGroove) == 0 ||
748 strcmpiW(v, styleRidge) == 0 || strcmpiW(v, styleInset) == 0 ||
749 strcmpiW(v, styleOutset) == 0 )
750 {
751 return TRUE;
752 }
753
754 return FALSE;
755 }
756
757 static inline HTMLStyle *impl_from_IHTMLStyle(IHTMLStyle *iface)
758 {
759 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle_iface);
760 }
761
762 static HRESULT WINAPI HTMLStyle_QueryInterface(IHTMLStyle *iface, REFIID riid, void **ppv)
763 {
764 HTMLStyle *This = impl_from_IHTMLStyle(iface);
765
766 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
767
768 if(IsEqualGUID(&IID_IUnknown, riid)) {
769 *ppv = &This->IHTMLStyle_iface;
770 }else if(IsEqualGUID(&IID_IHTMLStyle, riid)) {
771 *ppv = &This->IHTMLStyle_iface;
772 }else if(IsEqualGUID(&IID_IHTMLStyle2, riid)) {
773 *ppv = &This->IHTMLStyle2_iface;
774 }else if(IsEqualGUID(&IID_IHTMLStyle3, riid)) {
775 *ppv = &This->IHTMLStyle3_iface;
776 }else if(IsEqualGUID(&IID_IHTMLStyle4, riid)) {
777 *ppv = &This->IHTMLStyle4_iface;
778 }else if(IsEqualGUID(&IID_IHTMLStyle5, riid)) {
779 *ppv = &This->IHTMLStyle5_iface;
780 }else if(IsEqualGUID(&IID_IHTMLStyle6, riid)) {
781 *ppv = &This->IHTMLStyle6_iface;
782 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
783 return *ppv ? S_OK : E_NOINTERFACE;
784 }else {
785 *ppv = NULL;
786 WARN("unsupported iface %s\n", debugstr_mshtml_guid(riid));
787 return E_NOINTERFACE;
788 }
789
790 IUnknown_AddRef((IUnknown*)*ppv);
791 return S_OK;
792 }
793
794 static ULONG WINAPI HTMLStyle_AddRef(IHTMLStyle *iface)
795 {
796 HTMLStyle *This = impl_from_IHTMLStyle(iface);
797 LONG ref = InterlockedIncrement(&This->ref);
798
799 TRACE("(%p) ref=%d\n", This, ref);
800
801 return ref;
802 }
803
804 static ULONG WINAPI HTMLStyle_Release(IHTMLStyle *iface)
805 {
806 HTMLStyle *This = impl_from_IHTMLStyle(iface);
807 LONG ref = InterlockedDecrement(&This->ref);
808
809 TRACE("(%p) ref=%d\n", This, ref);
810
811 if(!ref) {
812 assert(!This->elem);
813 if(This->nsstyle)
814 nsIDOMCSSStyleDeclaration_Release(This->nsstyle);
815 release_dispex(&This->dispex);
816 heap_free(This);
817 }
818
819 return ref;
820 }
821
822 static HRESULT WINAPI HTMLStyle_GetTypeInfoCount(IHTMLStyle *iface, UINT *pctinfo)
823 {
824 HTMLStyle *This = impl_from_IHTMLStyle(iface);
825 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
826 }
827
828 static HRESULT WINAPI HTMLStyle_GetTypeInfo(IHTMLStyle *iface, UINT iTInfo,
829 LCID lcid, ITypeInfo **ppTInfo)
830 {
831 HTMLStyle *This = impl_from_IHTMLStyle(iface);
832 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
833 }
834
835 static HRESULT WINAPI HTMLStyle_GetIDsOfNames(IHTMLStyle *iface, REFIID riid,
836 LPOLESTR *rgszNames, UINT cNames,
837 LCID lcid, DISPID *rgDispId)
838 {
839 HTMLStyle *This = impl_from_IHTMLStyle(iface);
840 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
841 lcid, rgDispId);
842 }
843
844 static HRESULT WINAPI HTMLStyle_Invoke(IHTMLStyle *iface, DISPID dispIdMember,
845 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
846 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
847 {
848 HTMLStyle *This = impl_from_IHTMLStyle(iface);
849 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
850 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
851 }
852
853 static HRESULT WINAPI HTMLStyle_put_fontFamily(IHTMLStyle *iface, BSTR v)
854 {
855 HTMLStyle *This = impl_from_IHTMLStyle(iface);
856
857 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
858
859 return set_style_attr(This, STYLEID_FONT_FAMILY, v, 0);
860 }
861
862 static HRESULT WINAPI HTMLStyle_get_fontFamily(IHTMLStyle *iface, BSTR *p)
863 {
864 HTMLStyle *This = impl_from_IHTMLStyle(iface);
865
866 TRACE("(%p)->(%p)\n", This, p);
867
868 return get_style_attr(This, STYLEID_FONT_FAMILY, p);
869 }
870
871 static HRESULT WINAPI HTMLStyle_put_fontStyle(IHTMLStyle *iface, BSTR v)
872 {
873 HTMLStyle *This = impl_from_IHTMLStyle(iface);
874 static const WCHAR szItalic[] = {'i','t','a','l','i','c',0};
875 static const WCHAR szOblique[] = {'o','b','l','i','q','u','e',0};
876
877 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
878
879 /* fontStyle can only be one of the follow values. */
880 if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szItalic, v) == 0 ||
881 strcmpiW(szOblique, v) == 0)
882 {
883 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_STYLE, v, 0);
884 }
885
886 return E_INVALIDARG;
887 }
888
889 static HRESULT WINAPI HTMLStyle_get_fontStyle(IHTMLStyle *iface, BSTR *p)
890 {
891 HTMLStyle *This = impl_from_IHTMLStyle(iface);
892
893 TRACE("(%p)->(%p)\n", This, p);
894
895 return get_style_attr(This, STYLEID_FONT_STYLE, p);
896 }
897
898 static HRESULT WINAPI HTMLStyle_put_fontVariant(IHTMLStyle *iface, BSTR v)
899 {
900 HTMLStyle *This = impl_from_IHTMLStyle(iface);
901 static const WCHAR szCaps[] = {'s','m','a','l','l','-','c','a','p','s',0};
902
903 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
904
905 /* fontVariant can only be one of the follow values. */
906 if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(szCaps, v) == 0)
907 {
908 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_VARIANT, v, 0);
909 }
910
911 return E_INVALIDARG;
912 }
913
914 static HRESULT WINAPI HTMLStyle_get_fontVariant(IHTMLStyle *iface, BSTR *p)
915 {
916 HTMLStyle *This = impl_from_IHTMLStyle(iface);
917 TRACE("(%p)->(%p)\n", This, p);
918
919 if(!p)
920 return E_INVALIDARG;
921
922 return get_style_attr(This, STYLEID_FONT_VARIANT, p);
923 }
924
925 static HRESULT WINAPI HTMLStyle_put_fontWeight(IHTMLStyle *iface, BSTR v)
926 {
927 HTMLStyle *This = impl_from_IHTMLStyle(iface);
928 static const WCHAR styleBold[] = {'b','o','l','d',0};
929 static const WCHAR styleBolder[] = {'b','o','l','d','e','r',0};
930 static const WCHAR styleLighter[] = {'l','i','g','h','t','e','r',0};
931 static const WCHAR style100[] = {'1','0','0',0};
932 static const WCHAR style200[] = {'2','0','0',0};
933 static const WCHAR style300[] = {'3','0','0',0};
934 static const WCHAR style400[] = {'4','0','0',0};
935 static const WCHAR style500[] = {'5','0','0',0};
936 static const WCHAR style600[] = {'6','0','0',0};
937 static const WCHAR style700[] = {'7','0','0',0};
938 static const WCHAR style800[] = {'8','0','0',0};
939 static const WCHAR style900[] = {'9','0','0',0};
940
941 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
942
943 /* fontWeight can only be one of the following */
944 if(v && *v && strcmpiW(szNormal, v) && strcmpiW(styleBold, v) && strcmpiW(styleBolder, v)
945 && strcmpiW(styleLighter, v) && strcmpiW(style100, v) && strcmpiW(style200, v)
946 && strcmpiW(style300, v) && strcmpiW(style400, v) && strcmpiW(style500, v) && strcmpiW(style600, v)
947 && strcmpiW(style700, v) && strcmpiW(style800, v) && strcmpiW(style900, v))
948 return E_INVALIDARG;
949
950 return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_WEIGHT, v, 0);
951 }
952
953 static HRESULT WINAPI HTMLStyle_get_fontWeight(IHTMLStyle *iface, BSTR *p)
954 {
955 HTMLStyle *This = impl_from_IHTMLStyle(iface);
956
957 TRACE("(%p)->(%p)\n", This, p);
958
959 return get_style_attr(This, STYLEID_FONT_WEIGHT, p);
960 }
961
962 static HRESULT WINAPI HTMLStyle_put_fontSize(IHTMLStyle *iface, VARIANT v)
963 {
964 HTMLStyle *This = impl_from_IHTMLStyle(iface);
965
966 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
967
968 return set_nsstyle_attr_var(This->nsstyle, STYLEID_FONT_SIZE, &v, ATTR_FIX_PX);
969 }
970
971 static HRESULT WINAPI HTMLStyle_get_fontSize(IHTMLStyle *iface, VARIANT *p)
972 {
973 HTMLStyle *This = impl_from_IHTMLStyle(iface);
974
975 TRACE("(%p)->(%p)\n", This, p);
976
977 return get_nsstyle_attr_var(This->nsstyle, STYLEID_FONT_SIZE, p, 0);
978 }
979
980 static HRESULT WINAPI HTMLStyle_put_font(IHTMLStyle *iface, BSTR v)
981 {
982 HTMLStyle *This = impl_from_IHTMLStyle(iface);
983 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
984 return E_NOTIMPL;
985 }
986
987 static HRESULT WINAPI HTMLStyle_get_font(IHTMLStyle *iface, BSTR *p)
988 {
989 HTMLStyle *This = impl_from_IHTMLStyle(iface);
990 FIXME("(%p)->(%p)\n", This, p);
991 return E_NOTIMPL;
992 }
993
994 static HRESULT WINAPI HTMLStyle_put_color(IHTMLStyle *iface, VARIANT v)
995 {
996 HTMLStyle *This = impl_from_IHTMLStyle(iface);
997
998 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
999
1000 return set_nsstyle_attr_var(This->nsstyle, STYLEID_COLOR, &v, ATTR_HEX_INT);
1001 }
1002
1003 static HRESULT WINAPI HTMLStyle_get_color(IHTMLStyle *iface, VARIANT *p)
1004 {
1005 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1006
1007 TRACE("(%p)->(%p)\n", This, p);
1008
1009 return get_nsstyle_attr_var(This->nsstyle, STYLEID_COLOR, p, 0);
1010 }
1011
1012 static HRESULT WINAPI HTMLStyle_put_background(IHTMLStyle *iface, BSTR v)
1013 {
1014 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1015
1016 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1017
1018 return set_style_attr(This, STYLEID_BACKGROUND, v, 0);
1019 }
1020
1021 static HRESULT WINAPI HTMLStyle_get_background(IHTMLStyle *iface, BSTR *p)
1022 {
1023 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1024
1025 TRACE("(%p)->(%p)\n", This, p);
1026
1027 return get_style_attr(This, STYLEID_BACKGROUND, p);
1028 }
1029
1030 static HRESULT WINAPI HTMLStyle_put_backgroundColor(IHTMLStyle *iface, VARIANT v)
1031 {
1032 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1033
1034 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1035
1036 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BACKGROUND_COLOR, &v, ATTR_HEX_INT);
1037 }
1038
1039 static HRESULT WINAPI HTMLStyle_get_backgroundColor(IHTMLStyle *iface, VARIANT *p)
1040 {
1041 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1042
1043 TRACE("(%p)->(%p)\n", This, p);
1044
1045 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BACKGROUND_COLOR, p, 0);
1046 }
1047
1048 static HRESULT WINAPI HTMLStyle_put_backgroundImage(IHTMLStyle *iface, BSTR v)
1049 {
1050 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1051
1052 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1053
1054 return set_style_attr(This, STYLEID_BACKGROUND_IMAGE, v, ATTR_FIX_URL);
1055 }
1056
1057 static HRESULT WINAPI HTMLStyle_get_backgroundImage(IHTMLStyle *iface, BSTR *p)
1058 {
1059 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1060
1061 TRACE("(%p)->(%p)\n", This, p);
1062
1063 return get_style_attr(This, STYLEID_BACKGROUND_IMAGE, p);
1064 }
1065
1066 static HRESULT WINAPI HTMLStyle_put_backgroundRepeat(IHTMLStyle *iface, BSTR v)
1067 {
1068 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1069 static const WCHAR styleRepeat[] = {'r','e','p','e','a','t',0};
1070 static const WCHAR styleNoRepeat[] = {'n','o','-','r','e','p','e','a','t',0};
1071 static const WCHAR styleRepeatX[] = {'r','e','p','e','a','t','-','x',0};
1072 static const WCHAR styleRepeatY[] = {'r','e','p','e','a','t','-','y',0};
1073
1074 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1075
1076 /* fontWeight can only be one of the following */
1077 if(!v || strcmpiW(styleRepeat, v) == 0 || strcmpiW(styleNoRepeat, v) == 0 ||
1078 strcmpiW(styleRepeatX, v) == 0 || strcmpiW(styleRepeatY, v) == 0 )
1079 {
1080 return set_style_attr(This, STYLEID_BACKGROUND_REPEAT , v, 0);
1081 }
1082
1083 return E_INVALIDARG;
1084 }
1085
1086 static HRESULT WINAPI HTMLStyle_get_backgroundRepeat(IHTMLStyle *iface, BSTR *p)
1087 {
1088 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1089
1090 TRACE("(%p)->(%p)\n", This, p);
1091
1092 return get_style_attr(This, STYLEID_BACKGROUND_REPEAT, p);
1093 }
1094
1095 static HRESULT WINAPI HTMLStyle_put_backgroundAttachment(IHTMLStyle *iface, BSTR v)
1096 {
1097 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1098
1099 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1100
1101 return set_style_attr(This, STYLEID_BACKGROUND_ATTACHMENT, v, 0);
1102 }
1103
1104 static HRESULT WINAPI HTMLStyle_get_backgroundAttachment(IHTMLStyle *iface, BSTR *p)
1105 {
1106 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1107
1108 TRACE("(%p)->(%p)\n", This, p);
1109
1110 return get_style_attr(This, STYLEID_BACKGROUND_ATTACHMENT, p);
1111 }
1112
1113 static HRESULT WINAPI HTMLStyle_put_backgroundPosition(IHTMLStyle *iface, BSTR v)
1114 {
1115 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1116
1117 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1118
1119 return set_style_attr(This, STYLEID_BACKGROUND_POSITION, v, 0);
1120 }
1121
1122 static HRESULT WINAPI HTMLStyle_get_backgroundPosition(IHTMLStyle *iface, BSTR *p)
1123 {
1124 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1125
1126 TRACE("(%p)->(%p)\n", This, p);
1127
1128 return get_style_attr(This, STYLEID_BACKGROUND_POSITION, p);
1129 }
1130
1131 static HRESULT WINAPI HTMLStyle_put_backgroundPositionX(IHTMLStyle *iface, VARIANT v)
1132 {
1133 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1134 WCHAR buf[14], *pos_val;
1135 nsAString pos_str;
1136 const WCHAR *val;
1137 DWORD val_len;
1138 HRESULT hres;
1139
1140 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1141
1142 hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1143 if(FAILED(hres))
1144 return hres;
1145
1146 val_len = val ? strlenW(val) : 0;
1147
1148 nsAString_Init(&pos_str, NULL);
1149 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1150 if(SUCCEEDED(hres)) {
1151 const PRUnichar *pos, *posy;
1152 DWORD posy_len;
1153
1154 nsAString_GetData(&pos_str, &pos);
1155 posy = strchrW(pos, ' ');
1156 if(!posy) {
1157 static const WCHAR zero_pxW[] = {' ','0','p','x',0};
1158
1159 TRACE("no space in %s\n", debugstr_w(pos));
1160 posy = zero_pxW;
1161 }
1162
1163 posy_len = strlenW(posy);
1164 pos_val = heap_alloc((val_len+posy_len+1)*sizeof(WCHAR));
1165 if(pos_val) {
1166 if(val_len)
1167 memcpy(pos_val, val, val_len*sizeof(WCHAR));
1168 if(posy_len)
1169 memcpy(pos_val+val_len, posy, posy_len*sizeof(WCHAR));
1170 pos_val[val_len+posy_len] = 0;
1171 }else {
1172 hres = E_OUTOFMEMORY;
1173 }
1174 }
1175 nsAString_Finish(&pos_str);
1176 if(FAILED(hres))
1177 return hres;
1178
1179 TRACE("setting position to %s\n", debugstr_w(pos_val));
1180 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1181 heap_free(pos_val);
1182 return hres;
1183 }
1184
1185 static HRESULT WINAPI HTMLStyle_get_backgroundPositionX(IHTMLStyle *iface, VARIANT *p)
1186 {
1187 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1188 nsAString pos_str;
1189 BSTR ret;
1190 HRESULT hres;
1191
1192 TRACE("(%p)->(%p)\n", This, p);
1193
1194 nsAString_Init(&pos_str, NULL);
1195 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1196 if(SUCCEEDED(hres)) {
1197 const PRUnichar *pos, *space;
1198
1199 nsAString_GetData(&pos_str, &pos);
1200 space = strchrW(pos, ' ');
1201 if(!space) {
1202 WARN("no space in %s\n", debugstr_w(pos));
1203 space = pos + strlenW(pos);
1204 }
1205
1206 if(space != pos) {
1207 ret = SysAllocStringLen(pos, space-pos);
1208 if(!ret)
1209 hres = E_OUTOFMEMORY;
1210 }else {
1211 ret = NULL;
1212 }
1213 }
1214 nsAString_Finish(&pos_str);
1215 if(FAILED(hres))
1216 return hres;
1217
1218 TRACE("returning %s\n", debugstr_w(ret));
1219 V_VT(p) = VT_BSTR;
1220 V_BSTR(p) = ret;
1221 return S_OK;
1222 }
1223
1224 static HRESULT WINAPI HTMLStyle_put_backgroundPositionY(IHTMLStyle *iface, VARIANT v)
1225 {
1226 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1227 WCHAR buf[14], *pos_val;
1228 nsAString pos_str;
1229 const WCHAR *val;
1230 DWORD val_len;
1231 HRESULT hres;
1232
1233 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1234
1235 hres = var_to_styleval(&v, buf, ATTR_FIX_PX, &val);
1236 if(FAILED(hres))
1237 return hres;
1238
1239 val_len = val ? strlenW(val) : 0;
1240
1241 nsAString_Init(&pos_str, NULL);
1242 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1243 if(SUCCEEDED(hres)) {
1244 const PRUnichar *pos, *space;
1245 DWORD posx_len;
1246
1247 nsAString_GetData(&pos_str, &pos);
1248 space = strchrW(pos, ' ');
1249 if(space) {
1250 space++;
1251 }else {
1252 static const WCHAR zero_pxW[] = {'0','p','x',' ',0};
1253
1254 TRACE("no space in %s\n", debugstr_w(pos));
1255 pos = zero_pxW;
1256 space = pos + ARRAY_SIZE(zero_pxW)-1;
1257 }
1258
1259 posx_len = space-pos;
1260
1261 pos_val = heap_alloc((posx_len+val_len+1)*sizeof(WCHAR));
1262 if(pos_val) {
1263 memcpy(pos_val, pos, posx_len*sizeof(WCHAR));
1264 if(val_len)
1265 memcpy(pos_val+posx_len, val, val_len*sizeof(WCHAR));
1266 pos_val[posx_len+val_len] = 0;
1267 }else {
1268 hres = E_OUTOFMEMORY;
1269 }
1270 }
1271 nsAString_Finish(&pos_str);
1272 if(FAILED(hres))
1273 return hres;
1274
1275 TRACE("setting position to %s\n", debugstr_w(pos_val));
1276 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BACKGROUND_POSITION, pos_val, ATTR_FIX_PX);
1277 heap_free(pos_val);
1278 return hres;
1279 }
1280
1281 static HRESULT WINAPI HTMLStyle_get_backgroundPositionY(IHTMLStyle *iface, VARIANT *p)
1282 {
1283 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1284 nsAString pos_str;
1285 BSTR ret;
1286 HRESULT hres;
1287
1288 TRACE("(%p)->(%p)\n", This, p);
1289
1290 nsAString_Init(&pos_str, NULL);
1291 hres = get_nsstyle_attr_nsval(This->nsstyle, STYLEID_BACKGROUND_POSITION, &pos_str);
1292 if(SUCCEEDED(hres)) {
1293 const PRUnichar *pos, *posy;
1294
1295 nsAString_GetData(&pos_str, &pos);
1296 posy = strchrW(pos, ' ');
1297 if(posy) {
1298 ret = SysAllocString(posy+1);
1299 if(!ret)
1300 hres = E_OUTOFMEMORY;
1301 }else {
1302 ret = NULL;
1303 }
1304 }
1305 nsAString_Finish(&pos_str);
1306 if(FAILED(hres))
1307 return hres;
1308
1309 TRACE("returning %s\n", debugstr_w(ret));
1310 V_VT(p) = VT_BSTR;
1311 V_BSTR(p) = ret;
1312 return S_OK;
1313 }
1314
1315 static HRESULT WINAPI HTMLStyle_put_wordSpacing(IHTMLStyle *iface, VARIANT v)
1316 {
1317 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1318
1319 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1320
1321 return set_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, &v, 0);
1322 }
1323
1324 static HRESULT WINAPI HTMLStyle_get_wordSpacing(IHTMLStyle *iface, VARIANT *p)
1325 {
1326 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1327 TRACE("(%p)->(%p)\n", This, p);
1328 return get_nsstyle_attr_var(This->nsstyle, STYLEID_WORD_SPACING, p, 0);
1329 }
1330
1331 static HRESULT WINAPI HTMLStyle_put_letterSpacing(IHTMLStyle *iface, VARIANT v)
1332 {
1333 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1334
1335 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1336
1337 return set_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, &v, 0);
1338 }
1339
1340 static HRESULT WINAPI HTMLStyle_get_letterSpacing(IHTMLStyle *iface, VARIANT *p)
1341 {
1342 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1343 TRACE("(%p)->(%p)\n", This, p);
1344 return get_nsstyle_attr_var(This->nsstyle, STYLEID_LETTER_SPACING, p, 0);
1345 }
1346
1347 static HRESULT WINAPI HTMLStyle_put_textDecoration(IHTMLStyle *iface, BSTR v)
1348 {
1349 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1350
1351 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1352
1353 /* textDecoration can only be one of the following */
1354 if(!v || strcmpiW(styleNone, v) == 0 || strcmpiW(valUnderline, v) == 0 ||
1355 strcmpiW(valOverline, v) == 0 || strcmpiW(valLineThrough, v) == 0 ||
1356 strcmpiW(valBlink, v) == 0)
1357 {
1358 return set_style_attr(This, STYLEID_TEXT_DECORATION , v, 0);
1359 }
1360
1361 return E_INVALIDARG;
1362 }
1363
1364 static HRESULT WINAPI HTMLStyle_get_textDecoration(IHTMLStyle *iface, BSTR *p)
1365 {
1366 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1367
1368 TRACE("(%p)->(%p)\n", This, p);
1369
1370 return get_style_attr(This, STYLEID_TEXT_DECORATION, p);
1371 }
1372
1373 static HRESULT WINAPI HTMLStyle_put_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL v)
1374 {
1375 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1376
1377 TRACE("(%p)->(%x)\n", This, v);
1378
1379 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? styleNone : emptyW, 0);
1380 }
1381
1382 static HRESULT WINAPI HTMLStyle_get_textDecorationNone(IHTMLStyle *iface, VARIANT_BOOL *p)
1383 {
1384 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1385
1386 TRACE("(%p)->(%p)\n", This, p);
1387
1388 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, styleNone, p);
1389 }
1390
1391 static HRESULT WINAPI HTMLStyle_put_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL v)
1392 {
1393 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1394
1395 TRACE("(%p)->(%x)\n", This, v);
1396
1397 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valUnderline : emptyW, 0);
1398 }
1399
1400 static HRESULT WINAPI HTMLStyle_get_textDecorationUnderline(IHTMLStyle *iface, VARIANT_BOOL *p)
1401 {
1402 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1403
1404 TRACE("(%p)->(%p)\n", This, p);
1405
1406 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valUnderline, p);
1407 }
1408
1409 static HRESULT WINAPI HTMLStyle_put_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL v)
1410 {
1411 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1412
1413 TRACE("(%p)->(%x)\n", This, v);
1414
1415 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valOverline : emptyW, 0);
1416 }
1417
1418 static HRESULT WINAPI HTMLStyle_get_textDecorationOverline(IHTMLStyle *iface, VARIANT_BOOL *p)
1419 {
1420 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1421
1422 TRACE("(%p)->(%p)\n", This, p);
1423
1424 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valOverline, p);
1425 }
1426
1427 static HRESULT WINAPI HTMLStyle_put_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL v)
1428 {
1429 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1430
1431 TRACE("(%p)->(%x)\n", This, v);
1432
1433 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valLineThrough : emptyW, 0);
1434 }
1435
1436 static HRESULT WINAPI HTMLStyle_get_textDecorationLineThrough(IHTMLStyle *iface, VARIANT_BOOL *p)
1437 {
1438 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1439
1440 TRACE("(%p)->(%p)\n", This, p);
1441
1442 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valLineThrough, p);
1443 }
1444
1445 static HRESULT WINAPI HTMLStyle_put_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL v)
1446 {
1447 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1448
1449 TRACE("(%p)->(%x)\n", This, v);
1450
1451 return set_style_attr(This, STYLEID_TEXT_DECORATION, v ? valBlink : emptyW, 0);
1452 }
1453
1454 static HRESULT WINAPI HTMLStyle_get_textDecorationBlink(IHTMLStyle *iface, VARIANT_BOOL *p)
1455 {
1456 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1457
1458 TRACE("(%p)->(%p)\n", This, p);
1459
1460 return check_style_attr_value(This, STYLEID_TEXT_DECORATION, valBlink, p);
1461 }
1462
1463 static HRESULT WINAPI HTMLStyle_put_verticalAlign(IHTMLStyle *iface, VARIANT v)
1464 {
1465 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1466
1467 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1468
1469 return set_nsstyle_attr_var(This->nsstyle, STYLEID_VERTICAL_ALIGN, &v, ATTR_FIX_PX);
1470 }
1471
1472 static HRESULT WINAPI HTMLStyle_get_verticalAlign(IHTMLStyle *iface, VARIANT *p)
1473 {
1474 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1475
1476 TRACE("(%p)->(%p)\n", This, p);
1477
1478 return get_nsstyle_attr_var(This->nsstyle, STYLEID_VERTICAL_ALIGN, p, 0);
1479 }
1480
1481 static HRESULT WINAPI HTMLStyle_put_textTransform(IHTMLStyle *iface, BSTR v)
1482 {
1483 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1484
1485 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1486
1487 return set_style_attr(This, STYLEID_TEXT_TRANSFORM, v, 0);
1488 }
1489
1490 static HRESULT WINAPI HTMLStyle_get_textTransform(IHTMLStyle *iface, BSTR *p)
1491 {
1492 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1493
1494 TRACE("(%p)->(%p)\n", This, p);
1495
1496 return get_style_attr(This, STYLEID_TEXT_TRANSFORM, p);
1497 }
1498
1499 static HRESULT WINAPI HTMLStyle_put_textAlign(IHTMLStyle *iface, BSTR v)
1500 {
1501 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1502
1503 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1504
1505 return set_style_attr(This, STYLEID_TEXT_ALIGN, v, 0);
1506 }
1507
1508 static HRESULT WINAPI HTMLStyle_get_textAlign(IHTMLStyle *iface, BSTR *p)
1509 {
1510 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1511
1512 TRACE("(%p)->(%p)\n", This, p);
1513
1514 return get_style_attr(This, STYLEID_TEXT_ALIGN, p);
1515 }
1516
1517 static HRESULT WINAPI HTMLStyle_put_textIndent(IHTMLStyle *iface, VARIANT v)
1518 {
1519 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1520
1521 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1522
1523 return set_nsstyle_attr_var(This->nsstyle, STYLEID_TEXT_INDENT, &v, ATTR_FIX_PX);
1524 }
1525
1526 static HRESULT WINAPI HTMLStyle_get_textIndent(IHTMLStyle *iface, VARIANT *p)
1527 {
1528 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1529
1530 TRACE("(%p)->(%p)\n", This, p);
1531
1532 return get_nsstyle_attr_var(This->nsstyle, STYLEID_TEXT_INDENT, p, 0);
1533 }
1534
1535 static HRESULT WINAPI HTMLStyle_put_lineHeight(IHTMLStyle *iface, VARIANT v)
1536 {
1537 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1538
1539 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1540
1541 return set_nsstyle_attr_var(This->nsstyle, STYLEID_LINE_HEIGHT, &v, 0);
1542 }
1543
1544 static HRESULT WINAPI HTMLStyle_get_lineHeight(IHTMLStyle *iface, VARIANT *p)
1545 {
1546 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1547
1548 TRACE("(%p)->(%p)\n", This, p);
1549
1550 return get_nsstyle_attr_var(This->nsstyle, STYLEID_LINE_HEIGHT, p, 0);
1551 }
1552
1553 static HRESULT WINAPI HTMLStyle_put_marginTop(IHTMLStyle *iface, VARIANT v)
1554 {
1555 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1556
1557 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1558
1559 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, &v, ATTR_FIX_PX);
1560 }
1561
1562 static HRESULT WINAPI HTMLStyle_get_marginTop(IHTMLStyle *iface, VARIANT *p)
1563 {
1564 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1565
1566 TRACE("(%p)->(%p)\n", This, p);
1567
1568 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_TOP, p, 0);
1569 }
1570
1571 static HRESULT WINAPI HTMLStyle_put_marginRight(IHTMLStyle *iface, VARIANT v)
1572 {
1573 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1574
1575 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1576
1577 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, &v, ATTR_FIX_PX);
1578 }
1579
1580 static HRESULT WINAPI HTMLStyle_get_marginRight(IHTMLStyle *iface, VARIANT *p)
1581 {
1582 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1583 TRACE("(%p)->(%p)\n", This, p);
1584 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_RIGHT, p, 0);
1585 }
1586
1587 static HRESULT WINAPI HTMLStyle_put_marginBottom(IHTMLStyle *iface, VARIANT v)
1588 {
1589 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1590
1591 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1592
1593 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, &v, ATTR_FIX_PX);
1594 }
1595
1596 static HRESULT WINAPI HTMLStyle_get_marginBottom(IHTMLStyle *iface, VARIANT *p)
1597 {
1598 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1599
1600 TRACE("(%p)->(%p)\n", This, p);
1601
1602 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_BOTTOM, p, 0);
1603 }
1604
1605 static HRESULT WINAPI HTMLStyle_put_marginLeft(IHTMLStyle *iface, VARIANT v)
1606 {
1607 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1608
1609 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1610
1611 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, &v, ATTR_FIX_PX);
1612 }
1613
1614 static HRESULT WINAPI HTMLStyle_put_margin(IHTMLStyle *iface, BSTR v)
1615 {
1616 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1617
1618 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1619
1620 return set_style_attr(This, STYLEID_MARGIN, v, 0);
1621 }
1622
1623 static HRESULT WINAPI HTMLStyle_get_margin(IHTMLStyle *iface, BSTR *p)
1624 {
1625 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1626
1627 TRACE("(%p)->(%p)\n", This, p);
1628
1629 return get_style_attr(This, STYLEID_MARGIN, p);
1630 }
1631
1632 static HRESULT WINAPI HTMLStyle_get_marginLeft(IHTMLStyle *iface, VARIANT *p)
1633 {
1634 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1635 TRACE("(%p)->(%p)\n", This, p);
1636 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MARGIN_LEFT, p, 0);
1637 }
1638
1639 static HRESULT WINAPI HTMLStyle_put_paddingTop(IHTMLStyle *iface, VARIANT v)
1640 {
1641 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1642
1643 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1644
1645 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, &v, ATTR_FIX_PX);
1646 }
1647
1648 static HRESULT WINAPI HTMLStyle_get_paddingTop(IHTMLStyle *iface, VARIANT *p)
1649 {
1650 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1651
1652 TRACE("(%p)->(%p)\n", This, p);
1653
1654 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_TOP, p, 0);
1655 }
1656
1657 static HRESULT WINAPI HTMLStyle_put_paddingRight(IHTMLStyle *iface, VARIANT v)
1658 {
1659 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1660
1661 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1662
1663 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, &v, ATTR_FIX_PX);
1664 }
1665
1666 static HRESULT WINAPI HTMLStyle_get_paddingRight(IHTMLStyle *iface, VARIANT *p)
1667 {
1668 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1669
1670 TRACE("(%p)->(%p)\n", This, p);
1671
1672 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_RIGHT, p, 0);
1673 }
1674
1675 static HRESULT WINAPI HTMLStyle_put_paddingBottom(IHTMLStyle *iface, VARIANT v)
1676 {
1677 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1678
1679 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1680
1681 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, &v, ATTR_FIX_PX);
1682 }
1683
1684 static HRESULT WINAPI HTMLStyle_get_paddingBottom(IHTMLStyle *iface, VARIANT *p)
1685 {
1686 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1687
1688 TRACE("(%p)->(%p)\n", This, p);
1689
1690 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_BOTTOM, p, 0);
1691 }
1692
1693 static HRESULT WINAPI HTMLStyle_put_paddingLeft(IHTMLStyle *iface, VARIANT v)
1694 {
1695 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1696
1697 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1698
1699 return set_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, &v, ATTR_FIX_PX);
1700 }
1701
1702 static HRESULT WINAPI HTMLStyle_get_paddingLeft(IHTMLStyle *iface, VARIANT *p)
1703 {
1704 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1705
1706 TRACE("(%p)->(%p)\n", This, p);
1707
1708 return get_nsstyle_attr_var(This->nsstyle, STYLEID_PADDING_LEFT, p, 0);
1709 }
1710
1711 static HRESULT WINAPI HTMLStyle_put_padding(IHTMLStyle *iface, BSTR v)
1712 {
1713 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1714
1715 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1716
1717 return set_style_attr(This, STYLEID_PADDING, v, 0);
1718 }
1719
1720 static HRESULT WINAPI HTMLStyle_get_padding(IHTMLStyle *iface, BSTR *p)
1721 {
1722 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1723
1724 TRACE("(%p)->(%p)\n", This, p);
1725
1726 return get_style_attr(This, STYLEID_PADDING, p);
1727 }
1728
1729 static HRESULT WINAPI HTMLStyle_put_border(IHTMLStyle *iface, BSTR v)
1730 {
1731 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1732
1733 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1734
1735 return set_style_attr(This, STYLEID_BORDER, v, 0);
1736 }
1737
1738 static HRESULT WINAPI HTMLStyle_get_border(IHTMLStyle *iface, BSTR *p)
1739 {
1740 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1741
1742 TRACE("(%p)->(%p)\n", This, p);
1743
1744 return get_style_attr(This, STYLEID_BORDER, p);
1745 }
1746
1747 static HRESULT WINAPI HTMLStyle_put_borderTop(IHTMLStyle *iface, BSTR v)
1748 {
1749 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1750 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1751 return set_style_attr(This, STYLEID_BORDER_TOP, v, ATTR_FIX_PX);
1752 }
1753
1754 static HRESULT WINAPI HTMLStyle_get_borderTop(IHTMLStyle *iface, BSTR *p)
1755 {
1756 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1757 TRACE("(%p)->(%p)\n", This, p);
1758 return get_style_attr(This, STYLEID_BORDER_TOP, p);
1759 }
1760
1761 static HRESULT WINAPI HTMLStyle_put_borderRight(IHTMLStyle *iface, BSTR v)
1762 {
1763 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1764 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1765 return set_style_attr(This, STYLEID_BORDER_RIGHT, v, ATTR_FIX_PX);
1766 }
1767
1768 static HRESULT WINAPI HTMLStyle_get_borderRight(IHTMLStyle *iface, BSTR *p)
1769 {
1770 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1771 TRACE("(%p)->(%p)\n", This, p);
1772 return get_style_attr(This, STYLEID_BORDER_RIGHT, p);
1773 }
1774
1775 static HRESULT WINAPI HTMLStyle_put_borderBottom(IHTMLStyle *iface, BSTR v)
1776 {
1777 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1778 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1779 return set_style_attr(This, STYLEID_BORDER_BOTTOM, v, ATTR_FIX_PX);
1780 }
1781
1782 static HRESULT WINAPI HTMLStyle_get_borderBottom(IHTMLStyle *iface, BSTR *p)
1783 {
1784 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1785 TRACE("(%p)->(%p)\n", This, p);
1786 return get_style_attr(This, STYLEID_BORDER_BOTTOM, p);
1787 }
1788
1789 static HRESULT WINAPI HTMLStyle_put_borderLeft(IHTMLStyle *iface, BSTR v)
1790 {
1791 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1792
1793 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1794
1795 return set_style_attr(This, STYLEID_BORDER_LEFT, v, ATTR_FIX_PX);
1796 }
1797
1798 static HRESULT WINAPI HTMLStyle_get_borderLeft(IHTMLStyle *iface, BSTR *p)
1799 {
1800 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1801
1802 TRACE("(%p)->(%p)\n", This, p);
1803
1804 return get_style_attr(This, STYLEID_BORDER_LEFT, p);
1805 }
1806
1807 static HRESULT WINAPI HTMLStyle_put_borderColor(IHTMLStyle *iface, BSTR v)
1808 {
1809 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1810
1811 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1812
1813 return set_style_attr(This, STYLEID_BORDER_COLOR, v, 0);
1814 }
1815
1816 static HRESULT WINAPI HTMLStyle_get_borderColor(IHTMLStyle *iface, BSTR *p)
1817 {
1818 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1819
1820 TRACE("(%p)->(%p)\n", This, p);
1821
1822 return get_style_attr(This, STYLEID_BORDER_COLOR, p);
1823 }
1824
1825 static HRESULT WINAPI HTMLStyle_put_borderTopColor(IHTMLStyle *iface, VARIANT v)
1826 {
1827 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1828
1829 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1830
1831 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, &v, ATTR_HEX_INT);
1832 }
1833
1834 static HRESULT WINAPI HTMLStyle_get_borderTopColor(IHTMLStyle *iface, VARIANT *p)
1835 {
1836 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1837
1838 TRACE("(%p)->(%p)\n", This, p);
1839
1840 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_COLOR, p, 0);
1841 }
1842
1843 static HRESULT WINAPI HTMLStyle_put_borderRightColor(IHTMLStyle *iface, VARIANT v)
1844 {
1845 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1846
1847 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1848
1849 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, &v, ATTR_HEX_INT);
1850 }
1851
1852 static HRESULT WINAPI HTMLStyle_get_borderRightColor(IHTMLStyle *iface, VARIANT *p)
1853 {
1854 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1855
1856 TRACE("(%p)->(%p)\n", This, p);
1857
1858 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_COLOR, p, 0);
1859 }
1860
1861 static HRESULT WINAPI HTMLStyle_put_borderBottomColor(IHTMLStyle *iface, VARIANT v)
1862 {
1863 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1864
1865 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1866
1867 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, &v, ATTR_HEX_INT);
1868 }
1869
1870 static HRESULT WINAPI HTMLStyle_get_borderBottomColor(IHTMLStyle *iface, VARIANT *p)
1871 {
1872 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1873
1874 TRACE("(%p)->(%p)\n", This, p);
1875
1876 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_COLOR, p, 0);
1877 }
1878
1879 static HRESULT WINAPI HTMLStyle_put_borderLeftColor(IHTMLStyle *iface, VARIANT v)
1880 {
1881 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1882
1883 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1884
1885 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, &v, ATTR_HEX_INT);
1886 }
1887
1888 static HRESULT WINAPI HTMLStyle_get_borderLeftColor(IHTMLStyle *iface, VARIANT *p)
1889 {
1890 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1891
1892 TRACE("(%p)->(%p)\n", This, p);
1893
1894 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_COLOR, p, 0);
1895 }
1896
1897 static HRESULT WINAPI HTMLStyle_put_borderWidth(IHTMLStyle *iface, BSTR v)
1898 {
1899 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1900 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1901 return set_style_attr(This, STYLEID_BORDER_WIDTH, v, ATTR_FIX_PX);
1902 }
1903
1904 static HRESULT WINAPI HTMLStyle_get_borderWidth(IHTMLStyle *iface, BSTR *p)
1905 {
1906 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1907 TRACE("(%p)->(%p)\n", This, p);
1908 return get_style_attr(This, STYLEID_BORDER_WIDTH, p);
1909 }
1910
1911 static HRESULT WINAPI HTMLStyle_put_borderTopWidth(IHTMLStyle *iface, VARIANT v)
1912 {
1913 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1914
1915 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1916
1917 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, &v, 0);
1918 }
1919
1920 static HRESULT WINAPI HTMLStyle_get_borderTopWidth(IHTMLStyle *iface, VARIANT *p)
1921 {
1922 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1923
1924 TRACE("(%p)->(%p)\n", This, p);
1925
1926 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_TOP_WIDTH, p, 0);
1927 }
1928
1929 static HRESULT WINAPI HTMLStyle_put_borderRightWidth(IHTMLStyle *iface, VARIANT v)
1930 {
1931 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1932
1933 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1934
1935 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, &v, 0);
1936 }
1937
1938 static HRESULT WINAPI HTMLStyle_get_borderRightWidth(IHTMLStyle *iface, VARIANT *p)
1939 {
1940 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1941
1942 TRACE("(%p)->(%p)\n", This, p);
1943
1944 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_RIGHT_WIDTH, p, 0);
1945 }
1946
1947 static HRESULT WINAPI HTMLStyle_put_borderBottomWidth(IHTMLStyle *iface, VARIANT v)
1948 {
1949 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1950
1951 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1952
1953 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, &v, 0);
1954 }
1955
1956 static HRESULT WINAPI HTMLStyle_get_borderBottomWidth(IHTMLStyle *iface, VARIANT *p)
1957 {
1958 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1959 TRACE("(%p)->(%p)\n", This, p);
1960 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_BOTTOM_WIDTH, p, 0);
1961 }
1962
1963 static HRESULT WINAPI HTMLStyle_put_borderLeftWidth(IHTMLStyle *iface, VARIANT v)
1964 {
1965 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1966
1967 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1968
1969 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, &v, 0);
1970 }
1971
1972 static HRESULT WINAPI HTMLStyle_get_borderLeftWidth(IHTMLStyle *iface, VARIANT *p)
1973 {
1974 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1975 TRACE("(%p)->(%p)\n", This, p);
1976 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BORDER_LEFT_WIDTH, p, 0);
1977 }
1978
1979 static HRESULT WINAPI HTMLStyle_put_borderStyle(IHTMLStyle *iface, BSTR v)
1980 {
1981 HTMLStyle *This = impl_from_IHTMLStyle(iface);
1982 static const WCHAR styleWindowInset[] = {'w','i','n','d','o','w','-','i','n','s','e','t',0};
1983 HRESULT hres = S_OK;
1984 BSTR pstyle;
1985 int i=0;
1986 int last = 0;
1987
1988 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1989
1990 while(v[i] && hres == S_OK)
1991 {
1992 if(v[i] == (WCHAR)' ')
1993 {
1994 pstyle = SysAllocStringLen(&v[last], (i-last));
1995 if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
1996 {
1997 TRACE("1. Invalid style (%s)\n", debugstr_w(pstyle));
1998 hres = E_INVALIDARG;
1999 }
2000 SysFreeString(pstyle);
2001 last = i+1;
2002 }
2003 i++;
2004 }
2005
2006 if(hres == S_OK)
2007 {
2008 pstyle = SysAllocStringLen(&v[last], i-last);
2009 if( !(is_valid_border_style(pstyle) || strcmpiW(styleWindowInset, pstyle) == 0))
2010 {
2011 TRACE("2. Invalid style (%s)\n", debugstr_w(pstyle));
2012 hres = E_INVALIDARG;
2013 }
2014 SysFreeString(pstyle);
2015 }
2016
2017 if(hres == S_OK)
2018 hres = set_nsstyle_attr(This->nsstyle, STYLEID_BORDER_STYLE, v, 0);
2019
2020 return hres;
2021 }
2022
2023 static HRESULT WINAPI HTMLStyle_get_borderStyle(IHTMLStyle *iface, BSTR *p)
2024 {
2025 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2026 TRACE("(%p)->(%p)\n", This, p);
2027 return get_style_attr(This, STYLEID_BORDER_STYLE, p);
2028 }
2029
2030 static HRESULT WINAPI HTMLStyle_put_borderTopStyle(IHTMLStyle *iface, BSTR v)
2031 {
2032 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2033 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2034
2035 if(!is_valid_border_style(v))
2036 return E_INVALIDARG;
2037
2038 return set_style_attr(This, STYLEID_BORDER_TOP_STYLE, v, 0);
2039 }
2040
2041 static HRESULT WINAPI HTMLStyle_get_borderTopStyle(IHTMLStyle *iface, BSTR *p)
2042 {
2043 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2044 TRACE("(%p)->(%p)\n", This, p);
2045 return get_style_attr(This, STYLEID_BORDER_TOP_STYLE, p);
2046 }
2047
2048 static HRESULT WINAPI HTMLStyle_put_borderRightStyle(IHTMLStyle *iface, BSTR v)
2049 {
2050 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2051 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2052
2053 if(!is_valid_border_style(v))
2054 return E_INVALIDARG;
2055
2056 return set_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, v, 0);
2057 }
2058
2059 static HRESULT WINAPI HTMLStyle_get_borderRightStyle(IHTMLStyle *iface, BSTR *p)
2060 {
2061 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2062 TRACE("(%p)->(%p)\n", This, p);
2063 return get_style_attr(This, STYLEID_BORDER_RIGHT_STYLE, p);
2064 }
2065
2066 static HRESULT WINAPI HTMLStyle_put_borderBottomStyle(IHTMLStyle *iface, BSTR v)
2067 {
2068 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2069 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2070
2071 if(!is_valid_border_style(v))
2072 return E_INVALIDARG;
2073
2074 return set_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, v, 0);
2075 }
2076
2077 static HRESULT WINAPI HTMLStyle_get_borderBottomStyle(IHTMLStyle *iface, BSTR *p)
2078 {
2079 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2080 TRACE("(%p)->(%p)\n", This, p);
2081 return get_style_attr(This, STYLEID_BORDER_BOTTOM_STYLE, p);
2082 }
2083
2084 static HRESULT WINAPI HTMLStyle_put_borderLeftStyle(IHTMLStyle *iface, BSTR v)
2085 {
2086 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2087 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2088
2089 if(!is_valid_border_style(v))
2090 return E_INVALIDARG;
2091
2092 return set_style_attr(This, STYLEID_BORDER_LEFT_STYLE, v, 0);
2093 }
2094
2095 static HRESULT WINAPI HTMLStyle_get_borderLeftStyle(IHTMLStyle *iface, BSTR *p)
2096 {
2097 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2098 TRACE("(%p)->(%p)\n", This, p);
2099 return get_style_attr(This, STYLEID_BORDER_LEFT_STYLE, p);
2100 }
2101
2102 static HRESULT WINAPI HTMLStyle_put_width(IHTMLStyle *iface, VARIANT v)
2103 {
2104 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2105
2106 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2107
2108 return set_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, &v, ATTR_FIX_PX);
2109 }
2110
2111 static HRESULT WINAPI HTMLStyle_get_width(IHTMLStyle *iface, VARIANT *p)
2112 {
2113 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2114
2115 TRACE("(%p)->(%p)\n", This, p);
2116
2117 return get_nsstyle_attr_var(This->nsstyle, STYLEID_WIDTH, p, 0);
2118 }
2119
2120 static HRESULT WINAPI HTMLStyle_put_height(IHTMLStyle *iface, VARIANT v)
2121 {
2122 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2123
2124 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2125
2126 return set_nsstyle_attr_var(This->nsstyle, STYLEID_HEIGHT, &v, ATTR_FIX_PX);
2127 }
2128
2129 static HRESULT WINAPI HTMLStyle_get_height(IHTMLStyle *iface, VARIANT *p)
2130 {
2131 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2132
2133 TRACE("(%p)->(%p)\n", This, p);
2134
2135 return get_nsstyle_attr_var(This->nsstyle, STYLEID_HEIGHT, p, 0);
2136 }
2137
2138 static HRESULT WINAPI HTMLStyle_put_styleFloat(IHTMLStyle *iface, BSTR v)
2139 {
2140 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2141
2142 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2143
2144 return set_style_attr(This, STYLEID_FLOAT, v, 0);
2145 }
2146
2147 static HRESULT WINAPI HTMLStyle_get_styleFloat(IHTMLStyle *iface, BSTR *p)
2148 {
2149 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2150
2151 TRACE("(%p)->(%p)\n", This, p);
2152
2153 return get_style_attr(This, STYLEID_FLOAT, p);
2154 }
2155
2156 static HRESULT WINAPI HTMLStyle_put_clear(IHTMLStyle *iface, BSTR v)
2157 {
2158 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2159
2160 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2161
2162 return set_style_attr(This, STYLEID_CLEAR, v, 0);
2163 }
2164
2165 static HRESULT WINAPI HTMLStyle_get_clear(IHTMLStyle *iface, BSTR *p)
2166 {
2167 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2168
2169 TRACE("(%p)->(%p)\n", This, p);
2170
2171 return get_style_attr(This, STYLEID_CLEAR, p);
2172 }
2173
2174 static HRESULT WINAPI HTMLStyle_put_display(IHTMLStyle *iface, BSTR v)
2175 {
2176 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2177
2178 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2179
2180 return set_style_attr(This, STYLEID_DISPLAY, v, 0);
2181 }
2182
2183 static HRESULT WINAPI HTMLStyle_get_display(IHTMLStyle *iface, BSTR *p)
2184 {
2185 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2186
2187 TRACE("(%p)->(%p)\n", This, p);
2188
2189 return get_style_attr(This, STYLEID_DISPLAY, p);
2190 }
2191
2192 static HRESULT WINAPI HTMLStyle_put_visibility(IHTMLStyle *iface, BSTR v)
2193 {
2194 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2195
2196 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2197
2198 return set_style_attr(This, STYLEID_VISIBILITY, v, 0);
2199 }
2200
2201 static HRESULT WINAPI HTMLStyle_get_visibility(IHTMLStyle *iface, BSTR *p)
2202 {
2203 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2204
2205 TRACE("(%p)->(%p)\n", This, p);
2206
2207 return get_style_attr(This, STYLEID_VISIBILITY, p);
2208 }
2209
2210 static HRESULT WINAPI HTMLStyle_put_listStyleType(IHTMLStyle *iface, BSTR v)
2211 {
2212 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2213
2214 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2215
2216 return set_style_attr(This, STYLEID_LISTSTYLETYPE, v, 0);
2217 }
2218
2219 static HRESULT WINAPI HTMLStyle_get_listStyleType(IHTMLStyle *iface, BSTR *p)
2220 {
2221 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2222
2223 TRACE("(%p)->(%p)\n", This, p);
2224
2225 return get_style_attr(This, STYLEID_LISTSTYLETYPE, p);
2226 }
2227
2228 static HRESULT WINAPI HTMLStyle_put_listStylePosition(IHTMLStyle *iface, BSTR v)
2229 {
2230 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2231
2232 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2233
2234 return set_style_attr(This, STYLEID_LISTSTYLEPOSITION, v, 0);
2235 }
2236
2237 static HRESULT WINAPI HTMLStyle_get_listStylePosition(IHTMLStyle *iface, BSTR *p)
2238 {
2239 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2240
2241 TRACE("(%p)->(%p)\n", This, p);
2242
2243 return get_style_attr(This, STYLEID_LISTSTYLEPOSITION, p);
2244 }
2245
2246 static HRESULT WINAPI HTMLStyle_put_listStyleImage(IHTMLStyle *iface, BSTR v)
2247 {
2248 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2249 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2250 return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI HTMLStyle_get_listStyleImage(IHTMLStyle *iface, BSTR *p)
2254 {
2255 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2256 FIXME("(%p)->(%p)\n", This, p);
2257 return E_NOTIMPL;
2258 }
2259
2260 static HRESULT WINAPI HTMLStyle_put_listStyle(IHTMLStyle *iface, BSTR v)
2261 {
2262 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2263
2264 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2265
2266 return set_style_attr(This, STYLEID_LIST_STYLE, v, 0);
2267 }
2268
2269 static HRESULT WINAPI HTMLStyle_get_listStyle(IHTMLStyle *iface, BSTR *p)
2270 {
2271 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2272
2273 TRACE("(%p)->(%p)\n", This, p);
2274
2275 return get_style_attr(This, STYLEID_LIST_STYLE, p);
2276 }
2277
2278 static HRESULT WINAPI HTMLStyle_put_whiteSpace(IHTMLStyle *iface, BSTR v)
2279 {
2280 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2281
2282 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2283
2284 return set_nsstyle_attr(This->nsstyle, STYLEID_WHITE_SPACE, v, 0);
2285 }
2286
2287 static HRESULT WINAPI HTMLStyle_get_whiteSpace(IHTMLStyle *iface, BSTR *p)
2288 {
2289 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2290
2291 TRACE("(%p)->(%p)\n", This, p);
2292
2293 return get_nsstyle_attr(This->nsstyle, STYLEID_WHITE_SPACE, p, 0);
2294 }
2295
2296 static HRESULT WINAPI HTMLStyle_put_top(IHTMLStyle *iface, VARIANT v)
2297 {
2298 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2299
2300 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2301
2302 return set_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, &v, 0);
2303 }
2304
2305 static HRESULT WINAPI HTMLStyle_get_top(IHTMLStyle *iface, VARIANT *p)
2306 {
2307 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2308
2309 TRACE("(%p)->(%p)\n", This, p);
2310
2311 return get_nsstyle_attr_var(This->nsstyle, STYLEID_TOP, p, 0);
2312 }
2313
2314 static HRESULT WINAPI HTMLStyle_put_left(IHTMLStyle *iface, VARIANT v)
2315 {
2316 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2317
2318 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2319
2320 return set_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, &v, 0);
2321 }
2322
2323 static HRESULT WINAPI HTMLStyle_get_left(IHTMLStyle *iface, VARIANT *p)
2324 {
2325 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2326
2327 TRACE("(%p)->(%p)\n", This, p);
2328
2329 return get_nsstyle_attr_var(This->nsstyle, STYLEID_LEFT, p, 0);
2330 }
2331
2332 static HRESULT WINAPI HTMLStyle_get_position(IHTMLStyle *iface, BSTR *p)
2333 {
2334 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2335 TRACE("(%p)->(%p)\n", This, p);
2336 return IHTMLStyle2_get_position(&This->IHTMLStyle2_iface, p);
2337 }
2338
2339 static HRESULT WINAPI HTMLStyle_put_zIndex(IHTMLStyle *iface, VARIANT v)
2340 {
2341 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2342
2343 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2344
2345 return set_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, &v, 0);
2346 }
2347
2348 static HRESULT WINAPI HTMLStyle_get_zIndex(IHTMLStyle *iface, VARIANT *p)
2349 {
2350 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2351
2352 TRACE("(%p)->(%p)\n", This, p);
2353
2354 return get_nsstyle_attr_var(This->nsstyle, STYLEID_Z_INDEX, p, ATTR_STR_TO_INT);
2355 }
2356
2357 static HRESULT WINAPI HTMLStyle_put_overflow(IHTMLStyle *iface, BSTR v)
2358 {
2359 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2360 static const WCHAR szVisible[] = {'v','i','s','i','b','l','e',0};
2361 static const WCHAR szScroll[] = {'s','c','r','o','l','l',0};
2362 static const WCHAR szHidden[] = {'h','i','d','d','e','n',0};
2363 static const WCHAR szAuto[] = {'a','u','t','o',0};
2364
2365 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2366
2367 /* overflow can only be one of the follow values. */
2368 if(!v || !*v || strcmpiW(szVisible, v) == 0 || strcmpiW(szScroll, v) == 0 ||
2369 strcmpiW(szHidden, v) == 0 || strcmpiW(szAuto, v) == 0)
2370 {
2371 return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW, v, 0);
2372 }
2373
2374 return E_INVALIDARG;
2375 }
2376
2377
2378 static HRESULT WINAPI HTMLStyle_get_overflow(IHTMLStyle *iface, BSTR *p)
2379 {
2380 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2381
2382 TRACE("(%p)->(%p)\n", This, p);
2383
2384 if(!p)
2385 return E_INVALIDARG;
2386
2387 return get_style_attr(This, STYLEID_OVERFLOW, p);
2388 }
2389
2390 static HRESULT WINAPI HTMLStyle_put_pageBreakBefore(IHTMLStyle *iface, BSTR v)
2391 {
2392 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2393
2394 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2395
2396 return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, v, 0);
2397 }
2398
2399 static HRESULT WINAPI HTMLStyle_get_pageBreakBefore(IHTMLStyle *iface, BSTR *p)
2400 {
2401 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2402
2403 TRACE("(%p)->(%p)\n", This, p);
2404
2405 return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_BEFORE, p, 0);
2406 }
2407
2408 static HRESULT WINAPI HTMLStyle_put_pageBreakAfter(IHTMLStyle *iface, BSTR v)
2409 {
2410 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2411
2412 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2413
2414 return set_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, v, 0);
2415 }
2416
2417 static HRESULT WINAPI HTMLStyle_get_pageBreakAfter(IHTMLStyle *iface, BSTR *p)
2418 {
2419 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2420
2421 TRACE("(%p)->(%p)\n", This, p);
2422
2423 return get_nsstyle_attr(This->nsstyle, STYLEID_PAGE_BREAK_AFTER, p, 0);
2424 }
2425
2426 static HRESULT WINAPI HTMLStyle_put_cssText(IHTMLStyle *iface, BSTR v)
2427 {
2428 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2429 nsAString text_str;
2430 nsresult nsres;
2431
2432 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2433
2434 nsAString_InitDepend(&text_str, v);
2435 nsres = nsIDOMCSSStyleDeclaration_SetCssText(This->nsstyle, &text_str);
2436 nsAString_Finish(&text_str);
2437 if(NS_FAILED(nsres)) {
2438 FIXME("SetCssStyle failed: %08x\n", nsres);
2439 return E_FAIL;
2440 }
2441
2442 return S_OK;
2443 }
2444
2445 static HRESULT WINAPI HTMLStyle_get_cssText(IHTMLStyle *iface, BSTR *p)
2446 {
2447 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2448 nsAString text_str;
2449 nsresult nsres;
2450
2451 TRACE("(%p)->(%p)\n", This, p);
2452
2453 /* FIXME: Gecko style formatting is different than IE (uppercase). */
2454 nsAString_Init(&text_str, NULL);
2455 nsres = nsIDOMCSSStyleDeclaration_GetCssText(This->nsstyle, &text_str);
2456 if(NS_SUCCEEDED(nsres)) {
2457 const PRUnichar *text;
2458
2459 nsAString_GetData(&text_str, &text);
2460 *p = *text ? SysAllocString(text) : NULL;
2461 }else {
2462 FIXME("GetCssStyle failed: %08x\n", nsres);
2463 *p = NULL;
2464 }
2465
2466 nsAString_Finish(&text_str);
2467 return S_OK;
2468 }
2469
2470 static HRESULT WINAPI HTMLStyle_put_pixelTop(IHTMLStyle *iface, LONG v)
2471 {
2472 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2473
2474 TRACE("(%p)->(%d)\n", This, v);
2475
2476 return set_style_pxattr(This->nsstyle, STYLEID_TOP, v);
2477 }
2478
2479 static HRESULT WINAPI HTMLStyle_get_pixelTop(IHTMLStyle *iface, LONG *p)
2480 {
2481 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2482
2483 TRACE("(%p)->(%p)\n", This, p);
2484
2485 return get_nsstyle_pixel_val(This, STYLEID_TOP, p);
2486 }
2487
2488 static HRESULT WINAPI HTMLStyle_put_pixelLeft(IHTMLStyle *iface, LONG v)
2489 {
2490 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2491
2492 TRACE("(%p)->(%d)\n", This, v);
2493
2494 return set_style_pxattr(This->nsstyle, STYLEID_LEFT, v);
2495 }
2496
2497 static HRESULT WINAPI HTMLStyle_get_pixelLeft(IHTMLStyle *iface, LONG *p)
2498 {
2499 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2500
2501 TRACE("(%p)->(%p)\n", This, p);
2502
2503 return get_nsstyle_pixel_val(This, STYLEID_LEFT, p);
2504 }
2505
2506 static HRESULT WINAPI HTMLStyle_put_pixelWidth(IHTMLStyle *iface, LONG v)
2507 {
2508 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2509
2510 TRACE("(%p)->()\n", This);
2511
2512 return set_style_pxattr(This->nsstyle, STYLEID_WIDTH, v);
2513 }
2514
2515 static HRESULT WINAPI HTMLStyle_get_pixelWidth(IHTMLStyle *iface, LONG *p)
2516 {
2517 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2518
2519 TRACE("(%p)->(%p)\n", This, p);
2520
2521 return get_nsstyle_pixel_val(This, STYLEID_WIDTH, p);
2522 }
2523
2524 static HRESULT WINAPI HTMLStyle_put_pixelHeight(IHTMLStyle *iface, LONG v)
2525 {
2526 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2527
2528 TRACE("(%p)->(%d)\n", This, v);
2529
2530 return set_style_pxattr(This->nsstyle, STYLEID_HEIGHT, v);
2531 }
2532
2533 static HRESULT WINAPI HTMLStyle_get_pixelHeight(IHTMLStyle *iface, LONG *p)
2534 {
2535 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2536
2537 TRACE("(%p)->(%p)\n", This, p);
2538
2539 return get_nsstyle_pixel_val(This, STYLEID_HEIGHT, p);
2540 }
2541
2542 static HRESULT WINAPI HTMLStyle_put_posTop(IHTMLStyle *iface, float v)
2543 {
2544 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2545
2546 TRACE("(%p)->(%f)\n", This, v);
2547
2548 return set_style_pos(This, STYLEID_TOP, v);
2549 }
2550
2551 static HRESULT WINAPI HTMLStyle_get_posTop(IHTMLStyle *iface, float *p)
2552 {
2553 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2554
2555 TRACE("(%p)->(%p)\n", This, p);
2556
2557 if(!p)
2558 return E_POINTER;
2559
2560 return get_nsstyle_pos(This, STYLEID_TOP, p);
2561 }
2562
2563 static HRESULT WINAPI HTMLStyle_put_posLeft(IHTMLStyle *iface, float v)
2564 {
2565 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2566
2567 TRACE("(%p)->(%f)\n", This, v);
2568
2569 return set_style_pos(This, STYLEID_LEFT, v);
2570 }
2571
2572 static HRESULT WINAPI HTMLStyle_get_posLeft(IHTMLStyle *iface, float *p)
2573 {
2574 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2575
2576 TRACE("(%p)->(%p)\n", This, p);
2577
2578 if(!p)
2579 return E_POINTER;
2580
2581 return get_nsstyle_pos(This, STYLEID_LEFT, p);
2582 }
2583
2584 static HRESULT WINAPI HTMLStyle_put_posWidth(IHTMLStyle *iface, float v)
2585 {
2586 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2587
2588 TRACE("(%p)->(%f)\n", This, v);
2589
2590 return set_style_pos(This, STYLEID_WIDTH, v);
2591 }
2592
2593 static HRESULT WINAPI HTMLStyle_get_posWidth(IHTMLStyle *iface, float *p)
2594 {
2595 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2596
2597 TRACE("(%p)->(%p)\n", This, p);
2598
2599 if(!p)
2600 return E_POINTER;
2601
2602 if(get_nsstyle_pos(This, STYLEID_WIDTH, p) != S_OK)
2603 *p = 0.0f;
2604
2605 return S_OK;
2606 }
2607
2608 static HRESULT WINAPI HTMLStyle_put_posHeight(IHTMLStyle *iface, float v)
2609 {
2610 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2611
2612 TRACE("(%p)->(%f)\n", This, v);
2613
2614 return set_style_pos(This, STYLEID_HEIGHT, v);
2615 }
2616
2617 static HRESULT WINAPI HTMLStyle_get_posHeight(IHTMLStyle *iface, float *p)
2618 {
2619 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2620
2621 TRACE("(%p)->(%p)\n", This, p);
2622
2623 if(!p)
2624 return E_POINTER;
2625
2626 if(get_nsstyle_pos(This, STYLEID_HEIGHT, p) != S_OK)
2627 *p = 0.0f;
2628
2629 return S_OK;
2630 }
2631
2632 static HRESULT WINAPI HTMLStyle_put_cursor(IHTMLStyle *iface, BSTR v)
2633 {
2634 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2635
2636 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2637
2638 return set_style_attr(This, STYLEID_CURSOR, v, 0);
2639 }
2640
2641 static HRESULT WINAPI HTMLStyle_get_cursor(IHTMLStyle *iface, BSTR *p)
2642 {
2643 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2644
2645 TRACE("(%p)->(%p)\n", This, p);
2646
2647 return get_style_attr(This, STYLEID_CURSOR, p);
2648 }
2649
2650 static HRESULT WINAPI HTMLStyle_put_clip(IHTMLStyle *iface, BSTR v)
2651 {
2652 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2653
2654 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2655
2656 return set_style_attr(This, STYLEID_CLIP, v, 0);
2657 }
2658
2659 static HRESULT WINAPI HTMLStyle_get_clip(IHTMLStyle *iface, BSTR *p)
2660 {
2661 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2662
2663 TRACE("(%p)->(%p)\n", This, p);
2664
2665 return get_nsstyle_attr(This->nsstyle, STYLEID_CLIP, p, ATTR_REMOVE_COMMA);
2666 }
2667
2668 static void set_opacity(HTMLStyle *This, const WCHAR *val)
2669 {
2670 nsAString name_str, val_str, empty_str;
2671 nsresult nsres;
2672
2673 static const WCHAR opacityW[] = {'o','p','a','c','i','t','y',0};
2674
2675 TRACE("%s\n", debugstr_w(val));
2676
2677 nsAString_InitDepend(&name_str, opacityW);
2678 nsAString_InitDepend(&val_str, val);
2679 nsAString_InitDepend(&empty_str, emptyW);
2680
2681 nsres = nsIDOMCSSStyleDeclaration_SetProperty(This->nsstyle, &name_str, &val_str, &empty_str);
2682 if(NS_FAILED(nsres))
2683 ERR("SetProperty failed: %08x\n", nsres);
2684
2685 nsAString_Finish(&name_str);
2686 nsAString_Finish(&val_str);
2687 nsAString_Finish(&empty_str);
2688 }
2689
2690 static void update_filter(HTMLStyle *This)
2691 {
2692 const WCHAR *ptr, *ptr2;
2693
2694 static const WCHAR alphaW[] = {'a','l','p','h','a'};
2695
2696 if(get_style_compat_mode(This) >= COMPAT_MODE_IE10)
2697 return;
2698
2699 ptr = This->elem->filter;
2700 TRACE("%s\n", debugstr_w(ptr));
2701 if(!ptr) {
2702 set_opacity(This, emptyW);
2703 return;
2704 }
2705
2706 while(1) {
2707 while(isspaceW(*ptr))
2708 ptr++;
2709 if(!*ptr)
2710 break;
2711
2712 ptr2 = ptr;
2713 while(isalnumW(*ptr))
2714 ptr++;
2715 if(ptr == ptr2) {
2716 WARN("unexpected char '%c'\n", *ptr);
2717 break;
2718 }
2719 if(*ptr != '(') {
2720 WARN("expected '('\n");
2721 continue;
2722 }
2723
2724 if(ptr2 + ARRAY_SIZE(alphaW) == ptr && !memcmp(ptr2, alphaW, sizeof(alphaW))) {
2725 static const WCHAR formatW[] = {'%','f',0};
2726 static const WCHAR opacityW[] = {'o','p','a','c','i','t','y','='};
2727
2728 ptr++;
2729 do {
2730 while(isspaceW(*ptr))
2731 ptr++;
2732
2733 ptr2 = ptr;
2734 while(*ptr && *ptr != ',' && *ptr != ')')
2735 ptr++;
2736 if(!*ptr) {
2737 WARN("unexpected end of string\n");
2738 break;
2739 }
2740
2741 if(ptr-ptr2 > ARRAY_SIZE(opacityW) && !memcmp(ptr2, opacityW, sizeof(opacityW))) {
2742 float fval = 0.0f, e = 0.1f;
2743 WCHAR buf[32];
2744
2745 ptr2 += ARRAY_SIZE(opacityW);
2746
2747 while(isdigitW(*ptr2))
2748 fval = fval*10.0f + (float)(*ptr2++ - '0');
2749
2750 if(*ptr2 == '.') {
2751 while(isdigitW(*++ptr2)) {
2752 fval += e * (float)(*ptr2++ - '0');
2753 e *= 0.1f;
2754 }
2755 }
2756
2757 sprintfW(buf, formatW, fval * 0.01f);
2758 set_opacity(This, buf);
2759 }else {
2760 FIXME("unknown param %s\n", debugstr_wn(ptr2, ptr-ptr2));
2761 }
2762
2763 if(*ptr == ',')
2764 ptr++;
2765 }while(*ptr != ')');
2766 }else {
2767 FIXME("unknown filter %s\n", debugstr_wn(ptr2, ptr-ptr2));
2768 ptr = strchrW(ptr, ')');
2769 if(!ptr)
2770 break;
2771 ptr++;
2772 }
2773 }
2774 }
2775
2776 static HRESULT WINAPI HTMLStyle_put_filter(IHTMLStyle *iface, BSTR v)
2777 {
2778 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2779 WCHAR *new_filter = NULL;
2780
2781 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2782
2783 if(!This->elem) {
2784 FIXME("Element already destroyed\n");
2785 return E_UNEXPECTED;
2786 }
2787
2788 if(v) {
2789 new_filter = heap_strdupW(v);
2790 if(!new_filter)
2791 return E_OUTOFMEMORY;
2792 }
2793
2794 heap_free(This->elem->filter);
2795 This->elem->filter = new_filter;
2796
2797 update_filter(This);
2798 return S_OK;
2799 }
2800
2801 static HRESULT WINAPI HTMLStyle_get_filter(IHTMLStyle *iface, BSTR *p)
2802 {
2803 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2804
2805 TRACE("(%p)->(%p)\n", This, p);
2806
2807 if(!This->elem) {
2808 FIXME("Element already destroyed\n");
2809 return E_UNEXPECTED;
2810 }
2811
2812 if(This->elem->filter) {
2813 *p = SysAllocString(This->elem->filter);
2814 if(!*p)
2815 return E_OUTOFMEMORY;
2816 }else {
2817 *p = NULL;
2818 }
2819
2820 return S_OK;
2821 }
2822
2823 static HRESULT WINAPI HTMLStyle_setAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2824 VARIANT AttributeValue, LONG lFlags)
2825 {
2826 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2827 HRESULT hres;
2828 DISPID dispid;
2829
2830 TRACE("(%p)->(%s %s %08x)\n", This, debugstr_w(strAttributeName),
2831 debugstr_variant(&AttributeValue), lFlags);
2832
2833 if(!strAttributeName)
2834 return E_INVALIDARG;
2835
2836 if(lFlags == 1)
2837 FIXME("Parameter lFlags ignored\n");
2838
2839 hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2840 LOCALE_USER_DEFAULT, &dispid);
2841 if(hres == S_OK)
2842 {
2843 VARIANT ret;
2844 DISPID dispidNamed = DISPID_PROPERTYPUT;
2845 DISPPARAMS params;
2846
2847 params.cArgs = 1;
2848 params.rgvarg = &AttributeValue;
2849 params.cNamedArgs = 1;
2850 params.rgdispidNamedArgs = &dispidNamed;
2851
2852 hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2853 DISPATCH_PROPERTYPUT, &params, &ret, NULL, NULL);
2854 }
2855 else
2856 {
2857 FIXME("Custom attributes not supported.\n");
2858 }
2859
2860 TRACE("ret: %08x\n", hres);
2861
2862 return hres;
2863 }
2864
2865 static HRESULT WINAPI HTMLStyle_getAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2866 LONG lFlags, VARIANT *AttributeValue)
2867 {
2868 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2869 HRESULT hres;
2870 DISPID dispid;
2871
2872 TRACE("(%p)->(%s v%p %08x)\n", This, debugstr_w(strAttributeName),
2873 AttributeValue, lFlags);
2874
2875 if(!AttributeValue || !strAttributeName)
2876 return E_INVALIDARG;
2877
2878 if(lFlags == 1)
2879 FIXME("Parameter lFlags ignored\n");
2880
2881 hres = HTMLStyle_GetIDsOfNames(iface, &IID_NULL, &strAttributeName, 1,
2882 LOCALE_USER_DEFAULT, &dispid);
2883 if(hres == S_OK)
2884 {
2885 DISPPARAMS params = {NULL, NULL, 0, 0 };
2886
2887 hres = HTMLStyle_Invoke(iface, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,
2888 DISPATCH_PROPERTYGET, &params, AttributeValue, NULL, NULL);
2889 }
2890 else
2891 {
2892 FIXME("Custom attributes not supported.\n");
2893 }
2894
2895 return hres;
2896 }
2897
2898 static HRESULT WINAPI HTMLStyle_removeAttribute(IHTMLStyle *iface, BSTR strAttributeName,
2899 LONG lFlags, VARIANT_BOOL *pfSuccess)
2900 {
2901 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2902 const style_tbl_entry_t *style_entry;
2903 nsAString name_str, ret_str;
2904 nsresult nsres;
2905 HRESULT hres;
2906
2907 TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
2908
2909 style_entry = lookup_style_tbl(strAttributeName);
2910 if(!style_entry) {
2911 DISPID dispid;
2912 unsigned i;
2913
2914 hres = IDispatchEx_GetDispID(&This->dispex.IDispatchEx_iface, strAttributeName,
2915 (lFlags&1) ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &dispid);
2916 if(hres != S_OK) {
2917 *pfSuccess = VARIANT_FALSE;
2918 return S_OK;
2919 }
2920
2921 for(i=0; i < ARRAY_SIZE(style_tbl); i++) {
2922 if(dispid == style_tbl[i].dispid)
2923 break;
2924 }
2925
2926 if(i == ARRAY_SIZE(style_tbl))
2927 return remove_attribute(&This->dispex, dispid, pfSuccess);
2928 style_entry = style_tbl+i;
2929 }
2930
2931 /* filter property is a special case */
2932 if(style_entry->dispid == DISPID_IHTMLSTYLE_FILTER) {
2933 *pfSuccess = variant_bool(This->elem->filter && *This->elem->filter);
2934 heap_free(This->elem->filter);
2935 This->elem->filter = NULL;
2936 update_filter(This);
2937 return S_OK;
2938 }
2939
2940 nsAString_InitDepend(&name_str, style_entry->name);
2941 nsAString_Init(&ret_str, NULL);
2942 nsres = nsIDOMCSSStyleDeclaration_RemoveProperty(This->nsstyle, &name_str, &ret_str);
2943 if(NS_SUCCEEDED(nsres)) {
2944 const PRUnichar *ret;
2945 nsAString_GetData(&ret_str, &ret);
2946 *pfSuccess = variant_bool(*ret);
2947 }else {
2948 ERR("RemoveProperty failed: %08x\n", nsres);
2949 }
2950 nsAString_Finish(&name_str);
2951 nsAString_Finish(&ret_str);
2952 return NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
2953 }
2954
2955 static HRESULT WINAPI HTMLStyle_toString(IHTMLStyle *iface, BSTR *String)
2956 {
2957 HTMLStyle *This = impl_from_IHTMLStyle(iface);
2958 FIXME("(%p)->(%p)\n", This, String);
2959 return E_NOTIMPL;
2960 }
2961
2962 static const IHTMLStyleVtbl HTMLStyleVtbl = {
2963 HTMLStyle_QueryInterface,
2964 HTMLStyle_AddRef,
2965 HTMLStyle_Release,
2966 HTMLStyle_GetTypeInfoCount,
2967 HTMLStyle_GetTypeInfo,
2968 HTMLStyle_GetIDsOfNames,
2969 HTMLStyle_Invoke,
2970 HTMLStyle_put_fontFamily,
2971 HTMLStyle_get_fontFamily,
2972 HTMLStyle_put_fontStyle,
2973 HTMLStyle_get_fontStyle,
2974 HTMLStyle_put_fontVariant,
2975 HTMLStyle_get_fontVariant,
2976 HTMLStyle_put_fontWeight,
2977 HTMLStyle_get_fontWeight,
2978 HTMLStyle_put_fontSize,
2979 HTMLStyle_get_fontSize,
2980 HTMLStyle_put_font,
2981 HTMLStyle_get_font,
2982 HTMLStyle_put_color,
2983 HTMLStyle_get_color,
2984 HTMLStyle_put_background,
2985 HTMLStyle_get_background,
2986 HTMLStyle_put_backgroundColor,
2987 HTMLStyle_get_backgroundColor,
2988 HTMLStyle_put_backgroundImage,
2989 HTMLStyle_get_backgroundImage,
2990 HTMLStyle_put_backgroundRepeat,
2991 HTMLStyle_get_backgroundRepeat,
2992 HTMLStyle_put_backgroundAttachment,
2993 HTMLStyle_get_backgroundAttachment,
2994 HTMLStyle_put_backgroundPosition,
2995 HTMLStyle_get_backgroundPosition,
2996 HTMLStyle_put_backgroundPositionX,
2997 HTMLStyle_get_backgroundPositionX,
2998 HTMLStyle_put_backgroundPositionY,
2999 HTMLStyle_get_backgroundPositionY,
3000 HTMLStyle_put_wordSpacing,
3001 HTMLStyle_get_wordSpacing,
3002 HTMLStyle_put_letterSpacing,
3003 HTMLStyle_get_letterSpacing,
3004 HTMLStyle_put_textDecoration,
3005 HTMLStyle_get_textDecoration,
3006 HTMLStyle_put_textDecorationNone,
3007 HTMLStyle_get_textDecorationNone,
3008 HTMLStyle_put_textDecorationUnderline,
3009 HTMLStyle_get_textDecorationUnderline,
3010 HTMLStyle_put_textDecorationOverline,
3011 HTMLStyle_get_textDecorationOverline,
3012 HTMLStyle_put_textDecorationLineThrough,
3013 HTMLStyle_get_textDecorationLineThrough,
3014 HTMLStyle_put_textDecorationBlink,
3015 HTMLStyle_get_textDecorationBlink,
3016 HTMLStyle_put_verticalAlign,
3017 HTMLStyle_get_verticalAlign,
3018 HTMLStyle_put_textTransform,
3019 HTMLStyle_get_textTransform,
3020 HTMLStyle_put_textAlign,
3021 HTMLStyle_get_textAlign,
3022 HTMLStyle_put_textIndent,
3023 HTMLStyle_get_textIndent,
3024 HTMLStyle_put_lineHeight,
3025 HTMLStyle_get_lineHeight,
3026 HTMLStyle_put_marginTop,
3027 HTMLStyle_get_marginTop,
3028 HTMLStyle_put_marginRight,
3029 HTMLStyle_get_marginRight,
3030 HTMLStyle_put_marginBottom,
3031 HTMLStyle_get_marginBottom,
3032 HTMLStyle_put_marginLeft,
3033 HTMLStyle_get_marginLeft,
3034 HTMLStyle_put_margin,
3035 HTMLStyle_get_margin,
3036 HTMLStyle_put_paddingTop,
3037 HTMLStyle_get_paddingTop,
3038 HTMLStyle_put_paddingRight,
3039 HTMLStyle_get_paddingRight,
3040 HTMLStyle_put_paddingBottom,
3041 HTMLStyle_get_paddingBottom,
3042 HTMLStyle_put_paddingLeft,
3043 HTMLStyle_get_paddingLeft,
3044 HTMLStyle_put_padding,
3045 HTMLStyle_get_padding,
3046 HTMLStyle_put_border,
3047 HTMLStyle_get_border,
3048 HTMLStyle_put_borderTop,
3049 HTMLStyle_get_borderTop,
3050 HTMLStyle_put_borderRight,
3051 HTMLStyle_get_borderRight,
3052 HTMLStyle_put_borderBottom,
3053 HTMLStyle_get_borderBottom,
3054 HTMLStyle_put_borderLeft,
3055 HTMLStyle_get_borderLeft,
3056 HTMLStyle_put_borderColor,
3057 HTMLStyle_get_borderColor,
3058 HTMLStyle_put_borderTopColor,
3059 HTMLStyle_get_borderTopColor,
3060 HTMLStyle_put_borderRightColor,
3061 HTMLStyle_get_borderRightColor,
3062 HTMLStyle_put_borderBottomColor,
3063 HTMLStyle_get_borderBottomColor,
3064 HTMLStyle_put_borderLeftColor,
3065 HTMLStyle_get_borderLeftColor,
3066 HTMLStyle_put_borderWidth,
3067 HTMLStyle_get_borderWidth,
3068 HTMLStyle_put_borderTopWidth,
3069 HTMLStyle_get_borderTopWidth,
3070 HTMLStyle_put_borderRightWidth,
3071 HTMLStyle_get_borderRightWidth,
3072 HTMLStyle_put_borderBottomWidth,
3073 HTMLStyle_get_borderBottomWidth,
3074 HTMLStyle_put_borderLeftWidth,
3075 HTMLStyle_get_borderLeftWidth,
3076 HTMLStyle_put_borderStyle,
3077 HTMLStyle_get_borderStyle,
3078 HTMLStyle_put_borderTopStyle,
3079 HTMLStyle_get_borderTopStyle,
3080 HTMLStyle_put_borderRightStyle,
3081 HTMLStyle_get_borderRightStyle,
3082 HTMLStyle_put_borderBottomStyle,
3083 HTMLStyle_get_borderBottomStyle,
3084 HTMLStyle_put_borderLeftStyle,
3085 HTMLStyle_get_borderLeftStyle,
3086 HTMLStyle_put_width,
3087 HTMLStyle_get_width,
3088 HTMLStyle_put_height,
3089 HTMLStyle_get_height,
3090 HTMLStyle_put_styleFloat,
3091 HTMLStyle_get_styleFloat,
3092 HTMLStyle_put_clear,
3093 HTMLStyle_get_clear,
3094 HTMLStyle_put_display,
3095 HTMLStyle_get_display,
3096 HTMLStyle_put_visibility,
3097 HTMLStyle_get_visibility,
3098 HTMLStyle_put_listStyleType,
3099 HTMLStyle_get_listStyleType,
3100 HTMLStyle_put_listStylePosition,
3101 HTMLStyle_get_listStylePosition,
3102 HTMLStyle_put_listStyleImage,
3103 HTMLStyle_get_listStyleImage,
3104 HTMLStyle_put_listStyle,
3105 HTMLStyle_get_listStyle,
3106 HTMLStyle_put_whiteSpace,
3107 HTMLStyle_get_whiteSpace,
3108 HTMLStyle_put_top,
3109 HTMLStyle_get_top,
3110 HTMLStyle_put_left,
3111 HTMLStyle_get_left,
3112 HTMLStyle_get_position,
3113 HTMLStyle_put_zIndex,
3114 HTMLStyle_get_zIndex,
3115 HTMLStyle_put_overflow,
3116 HTMLStyle_get_overflow,
3117 HTMLStyle_put_pageBreakBefore,
3118 HTMLStyle_get_pageBreakBefore,
3119 HTMLStyle_put_pageBreakAfter,
3120 HTMLStyle_get_pageBreakAfter,
3121 HTMLStyle_put_cssText,
3122 HTMLStyle_get_cssText,
3123 HTMLStyle_put_pixelTop,
3124 HTMLStyle_get_pixelTop,
3125 HTMLStyle_put_pixelLeft,
3126 HTMLStyle_get_pixelLeft,
3127 HTMLStyle_put_pixelWidth,
3128 HTMLStyle_get_pixelWidth,
3129 HTMLStyle_put_pixelHeight,
3130 HTMLStyle_get_pixelHeight,
3131 HTMLStyle_put_posTop,
3132 HTMLStyle_get_posTop,
3133 HTMLStyle_put_posLeft,
3134 HTMLStyle_get_posLeft,
3135 HTMLStyle_put_posWidth,
3136 HTMLStyle_get_posWidth,
3137 HTMLStyle_put_posHeight,
3138 HTMLStyle_get_posHeight,
3139 HTMLStyle_put_cursor,
3140 HTMLStyle_get_cursor,
3141 HTMLStyle_put_clip,
3142 HTMLStyle_get_clip,
3143 HTMLStyle_put_filter,
3144 HTMLStyle_get_filter,
3145 HTMLStyle_setAttribute,
3146 HTMLStyle_getAttribute,
3147 HTMLStyle_removeAttribute,
3148 HTMLStyle_toString
3149 };
3150
3151 static inline HTMLStyle *impl_from_IHTMLStyle2(IHTMLStyle2 *iface)
3152 {
3153 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle2_iface);
3154 }
3155
3156 static HRESULT WINAPI HTMLStyle2_QueryInterface(IHTMLStyle2 *iface, REFIID riid, void **ppv)
3157 {
3158 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3159
3160 return IHTMLStyle_QueryInterface(&This->IHTMLStyle_iface, riid, ppv);
3161 }
3162
3163 static ULONG WINAPI HTMLStyle2_AddRef(IHTMLStyle2 *iface)
3164 {
3165 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3166
3167 return IHTMLStyle_AddRef(&This->IHTMLStyle_iface);
3168 }
3169
3170 static ULONG WINAPI HTMLStyle2_Release(IHTMLStyle2 *iface)
3171 {
3172 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3173
3174 return IHTMLStyle_Release(&This->IHTMLStyle_iface);
3175 }
3176
3177 static HRESULT WINAPI HTMLStyle2_GetTypeInfoCount(IHTMLStyle2 *iface, UINT *pctinfo)
3178 {
3179 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3180 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
3181 }
3182
3183 static HRESULT WINAPI HTMLStyle2_GetTypeInfo(IHTMLStyle2 *iface, UINT iTInfo,
3184 LCID lcid, ITypeInfo **ppTInfo)
3185 {
3186 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3187 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3188 }
3189
3190 static HRESULT WINAPI HTMLStyle2_GetIDsOfNames(IHTMLStyle2 *iface, REFIID riid,
3191 LPOLESTR *rgszNames, UINT cNames,
3192 LCID lcid, DISPID *rgDispId)
3193 {
3194 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3195 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3196 lcid, rgDispId);
3197 }
3198
3199 static HRESULT WINAPI HTMLStyle2_Invoke(IHTMLStyle2 *iface, DISPID dispIdMember,
3200 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3201 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3202 {
3203 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3204 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3205 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3206 }
3207
3208 static HRESULT WINAPI HTMLStyle2_put_tableLayout(IHTMLStyle2 *iface, BSTR v)
3209 {
3210 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3211
3212 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3213
3214 return set_nsstyle_attr(This->nsstyle, STYLEID_TABLE_LAYOUT, v, 0);
3215 }
3216
3217 static HRESULT WINAPI HTMLStyle2_get_tableLayout(IHTMLStyle2 *iface, BSTR *p)
3218 {
3219 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3220
3221 TRACE("(%p)->(%p)\n", This, p);
3222
3223 return get_nsstyle_attr(This->nsstyle, STYLEID_TABLE_LAYOUT, p, 0);
3224 }
3225
3226 static HRESULT WINAPI HTMLStyle2_put_borderCollapse(IHTMLStyle2 *iface, BSTR v)
3227 {
3228 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3229 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3230 return E_NOTIMPL;
3231 }
3232
3233 static HRESULT WINAPI HTMLStyle2_get_borderCollapse(IHTMLStyle2 *iface, BSTR *p)
3234 {
3235 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3236 FIXME("(%p)->(%p)\n", This, p);
3237 return E_NOTIMPL;
3238 }
3239
3240 static HRESULT WINAPI HTMLStyle2_put_direction(IHTMLStyle2 *iface, BSTR v)
3241 {
3242 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3243
3244 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3245
3246 return set_nsstyle_attr(This->nsstyle, STYLEID_DIRECTION, v, 0);
3247 }
3248
3249 static HRESULT WINAPI HTMLStyle2_get_direction(IHTMLStyle2 *iface, BSTR *p)
3250 {
3251 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3252
3253 TRACE("(%p)->(%p)\n", This, p);
3254
3255 return get_nsstyle_attr(This->nsstyle, STYLEID_DIRECTION, p, 0);
3256 }
3257
3258 static HRESULT WINAPI HTMLStyle2_put_behavior(IHTMLStyle2 *iface, BSTR v)
3259 {
3260 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3261 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3262 return S_OK;
3263 }
3264
3265 static HRESULT WINAPI HTMLStyle2_get_behavior(IHTMLStyle2 *iface, BSTR *p)
3266 {
3267 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3268 FIXME("(%p)->(%p)\n", This, p);
3269 return E_NOTIMPL;
3270 }
3271
3272 static HRESULT WINAPI HTMLStyle2_setExpression(IHTMLStyle2 *iface, BSTR propname, BSTR expression, BSTR language)
3273 {
3274 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3275 FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(propname), debugstr_w(expression), debugstr_w(language));
3276 return E_NOTIMPL;
3277 }
3278
3279 static HRESULT WINAPI HTMLStyle2_getExpression(IHTMLStyle2 *iface, BSTR propname, VARIANT *expression)
3280 {
3281 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3282 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), expression);
3283 return E_NOTIMPL;
3284 }
3285
3286 static HRESULT WINAPI HTMLStyle2_removeExpression(IHTMLStyle2 *iface, BSTR propname, VARIANT_BOOL *pfSuccess)
3287 {
3288 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3289 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), pfSuccess);
3290 return E_NOTIMPL;
3291 }
3292
3293 static HRESULT WINAPI HTMLStyle2_put_position(IHTMLStyle2 *iface, BSTR v)
3294 {
3295 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3296
3297 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3298
3299 return set_nsstyle_attr(This->nsstyle, STYLEID_POSITION, v, 0);
3300 }
3301
3302 static HRESULT WINAPI HTMLStyle2_get_position(IHTMLStyle2 *iface, BSTR *p)
3303 {
3304 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3305
3306 TRACE("(%p)->(%p)\n", This, p);
3307
3308 return get_nsstyle_attr(This->nsstyle, STYLEID_POSITION, p, 0);
3309 }
3310
3311 static HRESULT WINAPI HTMLStyle2_put_unicodeBidi(IHTMLStyle2 *iface, BSTR v)
3312 {
3313 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3314 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3315 return E_NOTIMPL;
3316 }
3317
3318 static HRESULT WINAPI HTMLStyle2_get_unicodeBidi(IHTMLStyle2 *iface, BSTR *p)
3319 {
3320 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3321 FIXME("(%p)->(%p)\n", This, p);
3322 return E_NOTIMPL;
3323 }
3324
3325 static HRESULT WINAPI HTMLStyle2_put_bottom(IHTMLStyle2 *iface, VARIANT v)
3326 {
3327 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3328
3329 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3330
3331 return set_nsstyle_attr_var(This->nsstyle, STYLEID_BOTTOM, &v, ATTR_FIX_PX);
3332 }
3333
3334 static HRESULT WINAPI HTMLStyle2_get_bottom(IHTMLStyle2 *iface, VARIANT *p)
3335 {
3336 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3337
3338 TRACE("(%p)->(%p)\n", This, p);
3339
3340 return get_nsstyle_attr_var(This->nsstyle, STYLEID_BOTTOM, p, 0);
3341 }
3342
3343 static HRESULT WINAPI HTMLStyle2_put_right(IHTMLStyle2 *iface, VARIANT v)
3344 {
3345 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3346
3347 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3348
3349 return set_nsstyle_attr_var(This->nsstyle, STYLEID_RIGHT, &v, 0);
3350 }
3351
3352 static HRESULT WINAPI HTMLStyle2_get_right(IHTMLStyle2 *iface, VARIANT *p)
3353 {
3354 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3355
3356 TRACE("(%p)->(%p)\n", This, p);
3357
3358 return get_nsstyle_attr_var(This->nsstyle, STYLEID_RIGHT, p, 0);
3359 }
3360
3361 static HRESULT WINAPI HTMLStyle2_put_pixelBottom(IHTMLStyle2 *iface, LONG v)
3362 {
3363 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3364 FIXME("(%p)->(%d)\n", This, v);
3365 return E_NOTIMPL;
3366 }
3367
3368 static HRESULT WINAPI HTMLStyle2_get_pixelBottom(IHTMLStyle2 *iface, LONG *p)
3369 {
3370 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3371 FIXME("(%p)->(%p)\n", This, p);
3372 return E_NOTIMPL;
3373 }
3374
3375 static HRESULT WINAPI HTMLStyle2_put_pixelRight(IHTMLStyle2 *iface, LONG v)
3376 {
3377 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3378 FIXME("(%p)->(%d)\n", This, v);
3379 return E_NOTIMPL;
3380 }
3381
3382 static HRESULT WINAPI HTMLStyle2_get_pixelRight(IHTMLStyle2 *iface, LONG *p)
3383 {
3384 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3385 FIXME("(%p)->(%p)\n", This, p);
3386 return E_NOTIMPL;
3387 }
3388
3389 static HRESULT WINAPI HTMLStyle2_put_posBottom(IHTMLStyle2 *iface, float v)
3390 {
3391 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3392 FIXME("(%p)->(%f)\n", This, v);
3393 return E_NOTIMPL;
3394 }
3395
3396 static HRESULT WINAPI HTMLStyle2_get_posBottom(IHTMLStyle2 *iface, float *p)
3397 {
3398 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3399 FIXME("(%p)->(%p)\n", This, p);
3400 return E_NOTIMPL;
3401 }
3402
3403 static HRESULT WINAPI HTMLStyle2_put_posRight(IHTMLStyle2 *iface, float v)
3404 {
3405 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3406 FIXME("(%p)->(%f)\n", This, v);
3407 return E_NOTIMPL;
3408 }
3409
3410 static HRESULT WINAPI HTMLStyle2_get_posRight(IHTMLStyle2 *iface, float *p)
3411 {
3412 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3413 FIXME("(%p)->(%p)\n", This, p);
3414 return E_NOTIMPL;
3415 }
3416
3417 static HRESULT WINAPI HTMLStyle2_put_imeMode(IHTMLStyle2 *iface, BSTR v)
3418 {
3419 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3420 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3421 return E_NOTIMPL;
3422 }
3423
3424 static HRESULT WINAPI HTMLStyle2_get_imeMode(IHTMLStyle2 *iface, BSTR *p)
3425 {
3426 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3427 FIXME("(%p)->(%p)\n", This, p);
3428 return E_NOTIMPL;
3429 }
3430
3431 static HRESULT WINAPI HTMLStyle2_put_rubyAlign(IHTMLStyle2 *iface, BSTR v)
3432 {
3433 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3434 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3435 return E_NOTIMPL;
3436 }
3437
3438 static HRESULT WINAPI HTMLStyle2_get_rubyAlign(IHTMLStyle2 *iface, BSTR *p)
3439 {
3440 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3441 FIXME("(%p)->(%p)\n", This, p);
3442 return E_NOTIMPL;
3443 }
3444
3445 static HRESULT WINAPI HTMLStyle2_put_rubyPosition(IHTMLStyle2 *iface, BSTR v)
3446 {
3447 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3448 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3449 return E_NOTIMPL;
3450 }
3451
3452 static HRESULT WINAPI HTMLStyle2_get_rubyPosition(IHTMLStyle2 *iface, BSTR *p)
3453 {
3454 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3455 FIXME("(%p)->(%p)\n", This, p);
3456 return E_NOTIMPL;
3457 }
3458
3459 static HRESULT WINAPI HTMLStyle2_put_rubyOverhang(IHTMLStyle2 *iface, BSTR v)
3460 {
3461 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3462 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3463 return E_NOTIMPL;
3464 }
3465
3466 static HRESULT WINAPI HTMLStyle2_get_rubyOverhang(IHTMLStyle2 *iface, BSTR *p)
3467 {
3468 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3469 FIXME("(%p)->(%p)\n", This, p);
3470 return E_NOTIMPL;
3471 }
3472
3473 static HRESULT WINAPI HTMLStyle2_put_layoutGridChar(IHTMLStyle2 *iface, VARIANT v)
3474 {
3475 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3476 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3477 return E_NOTIMPL;
3478 }
3479
3480 static HRESULT WINAPI HTMLStyle2_get_layoutGridChar(IHTMLStyle2 *iface, VARIANT *p)
3481 {
3482 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3483 FIXME("(%p)->(%p)\n", This, p);
3484 return E_NOTIMPL;
3485 }
3486
3487 static HRESULT WINAPI HTMLStyle2_put_layoutGridLine(IHTMLStyle2 *iface, VARIANT v)
3488 {
3489 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3490 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3491 return E_NOTIMPL;
3492 }
3493
3494 static HRESULT WINAPI HTMLStyle2_get_layoutGridLine(IHTMLStyle2 *iface, VARIANT *p)
3495 {
3496 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3497 FIXME("(%p)->(%p)\n", This, p);
3498 return E_NOTIMPL;
3499 }
3500
3501 static HRESULT WINAPI HTMLStyle2_put_layoutGridMode(IHTMLStyle2 *iface, BSTR v)
3502 {
3503 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3504 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3505 return E_NOTIMPL;
3506 }
3507
3508 static HRESULT WINAPI HTMLStyle2_get_layoutGridMode(IHTMLStyle2 *iface, BSTR *p)
3509 {
3510 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3511 FIXME("(%p)->(%p)\n", This, p);
3512 return E_NOTIMPL;
3513 }
3514
3515 static HRESULT WINAPI HTMLStyle2_put_layoutGridType(IHTMLStyle2 *iface, BSTR v)
3516 {
3517 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3518 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3519 return E_NOTIMPL;
3520 }
3521
3522 static HRESULT WINAPI HTMLStyle2_get_layoutGridType(IHTMLStyle2 *iface, BSTR *p)
3523 {
3524 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3525 FIXME("(%p)->(%p)\n", This, p);
3526 return E_NOTIMPL;
3527 }
3528
3529 static HRESULT WINAPI HTMLStyle2_put_layoutGrid(IHTMLStyle2 *iface, BSTR v)
3530 {
3531 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3532 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3533 return E_NOTIMPL;
3534 }
3535
3536 static HRESULT WINAPI HTMLStyle2_get_layoutGrid(IHTMLStyle2 *iface, BSTR *p)
3537 {
3538 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3539 FIXME("(%p)->(%p)\n", This, p);
3540 return E_NOTIMPL;
3541 }
3542
3543 static HRESULT WINAPI HTMLStyle2_put_wordBreak(IHTMLStyle2 *iface, BSTR v)
3544 {
3545 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3546 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3547 return E_NOTIMPL;
3548 }
3549
3550 static HRESULT WINAPI HTMLStyle2_get_wordBreak(IHTMLStyle2 *iface, BSTR *p)
3551 {
3552 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3553 FIXME("(%p)->(%p)\n", This, p);
3554 return E_NOTIMPL;
3555 }
3556
3557 static HRESULT WINAPI HTMLStyle2_put_lineBreak(IHTMLStyle2 *iface, BSTR v)
3558 {
3559 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3560 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3561 return E_NOTIMPL;
3562 }
3563
3564 static HRESULT WINAPI HTMLStyle2_get_lineBreak(IHTMLStyle2 *iface, BSTR *p)
3565 {
3566 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3567 FIXME("(%p)->(%p)\n", This, p);
3568 return E_NOTIMPL;
3569 }
3570
3571 static HRESULT WINAPI HTMLStyle2_put_textJustify(IHTMLStyle2 *iface, BSTR v)
3572 {
3573 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3574 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3575 return E_NOTIMPL;
3576 }
3577
3578 static HRESULT WINAPI HTMLStyle2_get_textJustify(IHTMLStyle2 *iface, BSTR *p)
3579 {
3580 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3581 FIXME("(%p)->(%p)\n", This, p);
3582 return E_NOTIMPL;
3583 }
3584
3585 static HRESULT WINAPI HTMLStyle2_put_textJustifyTrim(IHTMLStyle2 *iface, BSTR v)
3586 {
3587 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3588 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3589 return E_NOTIMPL;
3590 }
3591
3592 static HRESULT WINAPI HTMLStyle2_get_textJustifyTrim(IHTMLStyle2 *iface, BSTR *p)
3593 {
3594 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3595 FIXME("(%p)->(%p)\n", This, p);
3596 return E_NOTIMPL;
3597 }
3598
3599 static HRESULT WINAPI HTMLStyle2_put_textKashida(IHTMLStyle2 *iface, VARIANT v)
3600 {
3601 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3602 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3603 return E_NOTIMPL;
3604 }
3605
3606 static HRESULT WINAPI HTMLStyle2_get_textKashida(IHTMLStyle2 *iface, VARIANT *p)
3607 {
3608 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3609 FIXME("(%p)->(%p)\n", This, p);
3610 return E_NOTIMPL;
3611 }
3612
3613 static HRESULT WINAPI HTMLStyle2_put_textAutospace(IHTMLStyle2 *iface, BSTR v)
3614 {
3615 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3616 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3617 return E_NOTIMPL;
3618 }
3619
3620 static HRESULT WINAPI HTMLStyle2_get_textAutospace(IHTMLStyle2 *iface, BSTR *p)
3621 {
3622 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3623 FIXME("(%p)->(%p)\n", This, p);
3624 return E_NOTIMPL;
3625 }
3626
3627 static HRESULT WINAPI HTMLStyle2_put_overflowX(IHTMLStyle2 *iface, BSTR v)
3628 {
3629 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3630
3631 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3632
3633 return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW_X, v, 0);
3634 }
3635
3636 static HRESULT WINAPI HTMLStyle2_get_overflowX(IHTMLStyle2 *iface, BSTR *p)
3637 {
3638 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3639
3640 TRACE("(%p)->(%p)\n", This, p);
3641
3642 return get_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW_X, p, 0);
3643 }
3644
3645 static HRESULT WINAPI HTMLStyle2_put_overflowY(IHTMLStyle2 *iface, BSTR v)
3646 {
3647 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3648
3649 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3650
3651 return set_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW_Y, v, 0);
3652 }
3653
3654 static HRESULT WINAPI HTMLStyle2_get_overflowY(IHTMLStyle2 *iface, BSTR *p)
3655 {
3656 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3657
3658 TRACE("(%p)->(%p)\n", This, p);
3659
3660 return get_nsstyle_attr(This->nsstyle, STYLEID_OVERFLOW_Y, p, 0);
3661 }
3662
3663 static HRESULT WINAPI HTMLStyle2_put_accelerator(IHTMLStyle2 *iface, BSTR v)
3664 {
3665 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3666 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3667 return E_NOTIMPL;
3668 }
3669
3670 static HRESULT WINAPI HTMLStyle2_get_accelerator(IHTMLStyle2 *iface, BSTR *p)
3671 {
3672 HTMLStyle *This = impl_from_IHTMLStyle2(iface);
3673 FIXME("(%p)->(%p)\n", This, p);
3674 return E_NOTIMPL;
3675 }
3676
3677 static const IHTMLStyle2Vtbl HTMLStyle2Vtbl = {
3678 HTMLStyle2_QueryInterface,
3679 HTMLStyle2_AddRef,
3680 HTMLStyle2_Release,
3681 HTMLStyle2_GetTypeInfoCount,
3682 HTMLStyle2_GetTypeInfo,
3683 HTMLStyle2_GetIDsOfNames,
3684 HTMLStyle2_Invoke,
3685 HTMLStyle2_put_tableLayout,
3686 HTMLStyle2_get_tableLayout,
3687 HTMLStyle2_put_borderCollapse,
3688 HTMLStyle2_get_borderCollapse,
3689 HTMLStyle2_put_direction,
3690 HTMLStyle2_get_direction,
3691 HTMLStyle2_put_behavior,
3692 HTMLStyle2_get_behavior,
3693 HTMLStyle2_setExpression,
3694 HTMLStyle2_getExpression,
3695 HTMLStyle2_removeExpression,
3696 HTMLStyle2_put_position,
3697 HTMLStyle2_get_position,
3698 HTMLStyle2_put_unicodeBidi,
3699 HTMLStyle2_get_unicodeBidi,
3700 HTMLStyle2_put_bottom,
3701 HTMLStyle2_get_bottom,
3702 HTMLStyle2_put_right,
3703 HTMLStyle2_get_right,
3704 HTMLStyle2_put_pixelBottom,
3705 HTMLStyle2_get_pixelBottom,
3706 HTMLStyle2_put_pixelRight,
3707 HTMLStyle2_get_pixelRight,
3708 HTMLStyle2_put_posBottom,
3709 HTMLStyle2_get_posBottom,
3710 HTMLStyle2_put_posRight,
3711 HTMLStyle2_get_posRight,
3712 HTMLStyle2_put_imeMode,
3713 HTMLStyle2_get_imeMode,
3714 HTMLStyle2_put_rubyAlign,
3715 HTMLStyle2_get_rubyAlign,
3716 HTMLStyle2_put_rubyPosition,
3717 HTMLStyle2_get_rubyPosition,
3718 HTMLStyle2_put_rubyOverhang,
3719 HTMLStyle2_get_rubyOverhang,
3720 HTMLStyle2_put_layoutGridChar,
3721 HTMLStyle2_get_layoutGridChar,
3722 HTMLStyle2_put_layoutGridLine,
3723 HTMLStyle2_get_layoutGridLine,
3724 HTMLStyle2_put_layoutGridMode,
3725 HTMLStyle2_get_layoutGridMode,
3726 HTMLStyle2_put_layoutGridType,
3727 HTMLStyle2_get_layoutGridType,
3728 HTMLStyle2_put_layoutGrid,
3729 HTMLStyle2_get_layoutGrid,
3730 HTMLStyle2_put_wordBreak,
3731 HTMLStyle2_get_wordBreak,
3732 HTMLStyle2_put_lineBreak,
3733 HTMLStyle2_get_lineBreak,
3734 HTMLStyle2_put_textJustify,
3735 HTMLStyle2_get_textJustify,
3736 HTMLStyle2_put_textJustifyTrim,
3737 HTMLStyle2_get_textJustifyTrim,
3738 HTMLStyle2_put_textKashida,
3739 HTMLStyle2_get_textKashida,
3740 HTMLStyle2_put_textAutospace,
3741 HTMLStyle2_get_textAutospace,
3742 HTMLStyle2_put_overflowX,
3743 HTMLStyle2_get_overflowX,
3744 HTMLStyle2_put_overflowY,
3745 HTMLStyle2_get_overflowY,
3746 HTMLStyle2_put_accelerator,
3747 HTMLStyle2_get_accelerator
3748 };
3749
3750 static inline HTMLStyle *impl_from_IHTMLStyle3(IHTMLStyle3 *iface)
3751 {
3752 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle3_iface);
3753 }
3754
3755 static HRESULT WINAPI HTMLStyle3_QueryInterface(IHTMLStyle3 *iface, REFIID riid, void **ppv)
3756 {
3757 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3758
3759 return IHTMLStyle_QueryInterface(&This->IHTMLStyle_iface, riid, ppv);
3760 }
3761
3762 static ULONG WINAPI HTMLStyle3_AddRef(IHTMLStyle3 *iface)
3763 {
3764 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3765
3766 return IHTMLStyle_AddRef(&This->IHTMLStyle_iface);
3767 }
3768
3769 static ULONG WINAPI HTMLStyle3_Release(IHTMLStyle3 *iface)
3770 {
3771 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3772
3773 return IHTMLStyle_Release(&This->IHTMLStyle_iface);
3774 }
3775
3776 static HRESULT WINAPI HTMLStyle3_GetTypeInfoCount(IHTMLStyle3 *iface, UINT *pctinfo)
3777 {
3778 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3779 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
3780 }
3781
3782 static HRESULT WINAPI HTMLStyle3_GetTypeInfo(IHTMLStyle3 *iface, UINT iTInfo,
3783 LCID lcid, ITypeInfo **ppTInfo)
3784 {
3785 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3786 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3787 }
3788
3789 static HRESULT WINAPI HTMLStyle3_GetIDsOfNames(IHTMLStyle3 *iface, REFIID riid,
3790 LPOLESTR *rgszNames, UINT cNames,
3791 LCID lcid, DISPID *rgDispId)
3792 {
3793 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3794 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3795 lcid, rgDispId);
3796 }
3797
3798 static HRESULT WINAPI HTMLStyle3_Invoke(IHTMLStyle3 *iface, DISPID dispIdMember,
3799 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3800 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3801 {
3802 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3803 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3804 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3805 }
3806
3807 static HRESULT WINAPI HTMLStyle3_put_layoutFlow(IHTMLStyle3 *iface, BSTR v)
3808 {
3809 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3810 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3811 return E_NOTIMPL;
3812 }
3813
3814 static HRESULT WINAPI HTMLStyle3_get_layoutFlow(IHTMLStyle3 *iface, BSTR *p)
3815 {
3816 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3817 FIXME("(%p)->(%p)\n", This, p);
3818 return E_NOTIMPL;
3819 }
3820
3821 static const WCHAR zoomW[] = {'z','o','o','m',0};
3822
3823 static HRESULT WINAPI HTMLStyle3_put_zoom(IHTMLStyle3 *iface, VARIANT v)
3824 {
3825 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3826 VARIANT *var;
3827 HRESULT hres;
3828
3829 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3830
3831 /* zoom property is IE CSS extension that is mostly used as a hack to workaround IE bugs.
3832 * The value is set to 1 then. We can safely ignore setting zoom to 1. */
3833 if(V_VT(&v) != VT_I4 || V_I4(&v) != 1)
3834 WARN("stub for %s\n", debugstr_variant(&v));
3835
3836 hres = dispex_get_dprop_ref(&This->dispex, zoomW, TRUE, &var);
3837 if(FAILED(hres))
3838 return hres;
3839
3840 return VariantChangeType(var, &v, 0, VT_BSTR);
3841 }
3842
3843 static HRESULT WINAPI HTMLStyle3_get_zoom(IHTMLStyle3 *iface, VARIANT *p)
3844 {
3845 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3846 VARIANT *var;
3847 HRESULT hres;
3848
3849 TRACE("(%p)->(%p)\n", This, p);
3850
3851 hres = dispex_get_dprop_ref(&This->dispex, zoomW, FALSE, &var);
3852 if(hres == DISP_E_UNKNOWNNAME) {
3853 V_VT(p) = VT_BSTR;
3854 V_BSTR(p) = NULL;
3855 return S_OK;
3856 }
3857 if(FAILED(hres))
3858 return hres;
3859
3860 return VariantCopy(p, var);
3861 }
3862
3863 static HRESULT WINAPI HTMLStyle3_put_wordWrap(IHTMLStyle3 *iface, BSTR v)
3864 {
3865 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3866
3867 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3868
3869 return set_nsstyle_attr(This->nsstyle, STYLEID_WORD_WRAP, v, 0);
3870 }
3871
3872 static HRESULT WINAPI HTMLStyle3_get_wordWrap(IHTMLStyle3 *iface, BSTR *p)
3873 {
3874 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3875
3876 TRACE("(%p)->(%p)\n", This, p);
3877
3878 return get_nsstyle_attr(This->nsstyle, STYLEID_WORD_WRAP, p, 0);
3879 }
3880
3881 static HRESULT WINAPI HTMLStyle3_put_textUnderlinePosition(IHTMLStyle3 *iface, BSTR v)
3882 {
3883 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3884 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3885 return E_NOTIMPL;
3886 }
3887
3888 static HRESULT WINAPI HTMLStyle3_get_textUnderlinePosition(IHTMLStyle3 *iface, BSTR *p)
3889 {
3890 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3891 FIXME("(%p)->(%p)\n", This, p);
3892 return E_NOTIMPL;
3893 }
3894
3895 static HRESULT WINAPI HTMLStyle3_put_scrollbarBaseColor(IHTMLStyle3 *iface, VARIANT v)
3896 {
3897 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3898 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3899 return E_NOTIMPL;
3900 }
3901
3902 static HRESULT WINAPI HTMLStyle3_get_scrollbarBaseColor(IHTMLStyle3 *iface, VARIANT *p)
3903 {
3904 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3905 FIXME("(%p)->(%p)\n", This, p);
3906 return E_NOTIMPL;
3907 }
3908
3909 static HRESULT WINAPI HTMLStyle3_put_scrollbarFaceColor(IHTMLStyle3 *iface, VARIANT v)
3910 {
3911 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3912 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3913 return E_NOTIMPL;
3914 }
3915
3916 static HRESULT WINAPI HTMLStyle3_get_scrollbarFaceColor(IHTMLStyle3 *iface, VARIANT *p)
3917 {
3918 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3919 FIXME("(%p)->(%p)\n", This, p);
3920 return E_NOTIMPL;
3921 }
3922
3923 static HRESULT WINAPI HTMLStyle3_put_scrollbar3dLightColor(IHTMLStyle3 *iface, VARIANT v)
3924 {
3925 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3926 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3927 return E_NOTIMPL;
3928 }
3929
3930 static HRESULT WINAPI HTMLStyle3_get_scrollbar3dLightColor(IHTMLStyle3 *iface, VARIANT *p)
3931 {
3932 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3933 FIXME("(%p)->(%p)\n", This, p);
3934 return E_NOTIMPL;
3935 }
3936
3937 static HRESULT WINAPI HTMLStyle3_put_scrollbarShadowColor(IHTMLStyle3 *iface, VARIANT v)
3938 {
3939 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3940 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3941 return E_NOTIMPL;
3942 }
3943
3944 static HRESULT WINAPI HTMLStyle3_get_scrollbarShadowColor(IHTMLStyle3 *iface, VARIANT *p)
3945 {
3946 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3947 FIXME("(%p)->(%p)\n", This, p);
3948 return E_NOTIMPL;
3949 }
3950
3951 static HRESULT WINAPI HTMLStyle3_put_scrollbarHighlightColor(IHTMLStyle3 *iface, VARIANT v)
3952 {
3953 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3954 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3955 return E_NOTIMPL;
3956 }
3957
3958 static HRESULT WINAPI HTMLStyle3_get_scrollbarHighlightColor(IHTMLStyle3 *iface, VARIANT *p)
3959 {
3960 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3961 FIXME("(%p)->(%p)\n", This, p);
3962 return E_NOTIMPL;
3963 }
3964
3965 static HRESULT WINAPI HTMLStyle3_put_scrollbarDarkShadowColor(IHTMLStyle3 *iface, VARIANT v)
3966 {
3967 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3968 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3969 return E_NOTIMPL;
3970 }
3971
3972 static HRESULT WINAPI HTMLStyle3_get_scrollbarDarkShadowColor(IHTMLStyle3 *iface, VARIANT *p)
3973 {
3974 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3975 FIXME("(%p)->(%p)\n", This, p);
3976 return E_NOTIMPL;
3977 }
3978
3979 static HRESULT WINAPI HTMLStyle3_put_scrollbarArrowColor(IHTMLStyle3 *iface, VARIANT v)
3980 {
3981 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3982 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3983 return E_NOTIMPL;
3984 }
3985
3986 static HRESULT WINAPI HTMLStyle3_get_scrollbarArrowColor(IHTMLStyle3 *iface, VARIANT *p)
3987 {
3988 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3989 FIXME("(%p)->(%p)\n", This, p);
3990 return E_NOTIMPL;
3991 }
3992
3993 static HRESULT WINAPI HTMLStyle3_put_scrollbarTrackColor(IHTMLStyle3 *iface, VARIANT v)
3994 {
3995 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
3996 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3997 return E_NOTIMPL;
3998 }
3999
4000 static HRESULT WINAPI HTMLStyle3_get_scrollbarTrackColor(IHTMLStyle3 *iface, VARIANT *p)
4001 {
4002 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4003 FIXME("(%p)->(%p)\n", This, p);
4004 return E_NOTIMPL;
4005 }
4006
4007 static HRESULT WINAPI HTMLStyle3_put_writingMode(IHTMLStyle3 *iface, BSTR v)
4008 {
4009 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4010 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4011 return E_NOTIMPL;
4012 }
4013
4014 static HRESULT WINAPI HTMLStyle3_get_writingMode(IHTMLStyle3 *iface, BSTR *p)
4015 {
4016 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4017 FIXME("(%p)->(%p)\n", This, p);
4018 return E_NOTIMPL;
4019 }
4020
4021 static HRESULT WINAPI HTMLStyle3_put_textAlignLast(IHTMLStyle3 *iface, BSTR v)
4022 {
4023 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4024 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4025 return E_NOTIMPL;
4026 }
4027
4028 static HRESULT WINAPI HTMLStyle3_get_textAlignLast(IHTMLStyle3 *iface, BSTR *p)
4029 {
4030 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4031 FIXME("(%p)->(%p)\n", This, p);
4032 return E_NOTIMPL;
4033 }
4034
4035 static HRESULT WINAPI HTMLStyle3_put_textKashidaSpace(IHTMLStyle3 *iface, VARIANT v)
4036 {
4037 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4038 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4039 return E_NOTIMPL;
4040 }
4041
4042 static HRESULT WINAPI HTMLStyle3_get_textKashidaSpace(IHTMLStyle3 *iface, VARIANT *p)
4043 {
4044 HTMLStyle *This = impl_from_IHTMLStyle3(iface);
4045 FIXME("(%p)->(%p)\n", This, p);
4046 return E_NOTIMPL;
4047 }
4048
4049 static const IHTMLStyle3Vtbl HTMLStyle3Vtbl = {
4050 HTMLStyle3_QueryInterface,
4051 HTMLStyle3_AddRef,
4052 HTMLStyle3_Release,
4053 HTMLStyle3_GetTypeInfoCount,
4054 HTMLStyle3_GetTypeInfo,
4055 HTMLStyle3_GetIDsOfNames,
4056 HTMLStyle3_Invoke,
4057 HTMLStyle3_put_layoutFlow,
4058 HTMLStyle3_get_layoutFlow,
4059 HTMLStyle3_put_zoom,
4060 HTMLStyle3_get_zoom,
4061 HTMLStyle3_put_wordWrap,
4062 HTMLStyle3_get_wordWrap,
4063 HTMLStyle3_put_textUnderlinePosition,
4064 HTMLStyle3_get_textUnderlinePosition,
4065 HTMLStyle3_put_scrollbarBaseColor,
4066 HTMLStyle3_get_scrollbarBaseColor,
4067 HTMLStyle3_put_scrollbarFaceColor,
4068 HTMLStyle3_get_scrollbarFaceColor,
4069 HTMLStyle3_put_scrollbar3dLightColor,
4070 HTMLStyle3_get_scrollbar3dLightColor,
4071 HTMLStyle3_put_scrollbarShadowColor,
4072 HTMLStyle3_get_scrollbarShadowColor,
4073 HTMLStyle3_put_scrollbarHighlightColor,
4074 HTMLStyle3_get_scrollbarHighlightColor,
4075 HTMLStyle3_put_scrollbarDarkShadowColor,
4076 HTMLStyle3_get_scrollbarDarkShadowColor,
4077 HTMLStyle3_put_scrollbarArrowColor,
4078 HTMLStyle3_get_scrollbarArrowColor,
4079 HTMLStyle3_put_scrollbarTrackColor,
4080 HTMLStyle3_get_scrollbarTrackColor,
4081 HTMLStyle3_put_writingMode,
4082 HTMLStyle3_get_writingMode,
4083 HTMLStyle3_put_textAlignLast,
4084 HTMLStyle3_get_textAlignLast,
4085 HTMLStyle3_put_textKashidaSpace,
4086 HTMLStyle3_get_textKashidaSpace
4087 };
4088
4089 /*
4090 * IHTMLStyle4 Interface
4091 */
4092 static inline HTMLStyle *impl_from_IHTMLStyle4(IHTMLStyle4 *iface)
4093 {
4094 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle4_iface);
4095 }
4096
4097 static HRESULT WINAPI HTMLStyle4_QueryInterface(IHTMLStyle4 *iface, REFIID riid, void **ppv)
4098 {
4099 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4100
4101 return IHTMLStyle_QueryInterface(&This->IHTMLStyle_iface, riid, ppv);
4102 }
4103
4104 static ULONG WINAPI HTMLStyle4_AddRef(IHTMLStyle4 *iface)
4105 {
4106 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4107
4108 return IHTMLStyle_AddRef(&This->IHTMLStyle_iface);
4109 }
4110
4111 static ULONG WINAPI HTMLStyle4_Release(IHTMLStyle4 *iface)
4112 {
4113 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4114
4115 return IHTMLStyle_Release(&This->IHTMLStyle_iface);
4116 }
4117
4118 static HRESULT WINAPI HTMLStyle4_GetTypeInfoCount(IHTMLStyle4 *iface, UINT *pctinfo)
4119 {
4120 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4121 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4122 }
4123
4124 static HRESULT WINAPI HTMLStyle4_GetTypeInfo(IHTMLStyle4 *iface, UINT iTInfo,
4125 LCID lcid, ITypeInfo **ppTInfo)
4126 {
4127 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4128 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4129 }
4130
4131 static HRESULT WINAPI HTMLStyle4_GetIDsOfNames(IHTMLStyle4 *iface, REFIID riid,
4132 LPOLESTR *rgszNames, UINT cNames,
4133 LCID lcid, DISPID *rgDispId)
4134 {
4135 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4136 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4137 lcid, rgDispId);
4138 }
4139
4140 static HRESULT WINAPI HTMLStyle4_Invoke(IHTMLStyle4 *iface, DISPID dispIdMember,
4141 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4142 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4143 {
4144 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4145 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4146 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4147 }
4148
4149 static HRESULT WINAPI HTMLStyle4_put_textOverflow(IHTMLStyle4 *iface, BSTR v)
4150 {
4151 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4152 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4153 return E_NOTIMPL;
4154 }
4155
4156 static HRESULT WINAPI HTMLStyle4_get_textOverflow(IHTMLStyle4 *iface, BSTR *p)
4157 {
4158 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4159 FIXME("(%p)->(%p)\n", This, p);
4160 return E_NOTIMPL;
4161 }
4162
4163 static HRESULT WINAPI HTMLStyle4_put_minHeight(IHTMLStyle4 *iface, VARIANT v)
4164 {
4165 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4166
4167 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4168
4169 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MIN_HEIGHT, &v, 0);
4170 }
4171
4172 static HRESULT WINAPI HTMLStyle4_get_minHeight(IHTMLStyle4 *iface, VARIANT *p)
4173 {
4174 HTMLStyle *This = impl_from_IHTMLStyle4(iface);
4175
4176 TRACE("(%p)->(%p)\n", This, p);
4177
4178 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MIN_HEIGHT, p, 0);
4179 }
4180
4181 static const IHTMLStyle4Vtbl HTMLStyle4Vtbl = {
4182 HTMLStyle4_QueryInterface,
4183 HTMLStyle4_AddRef,
4184 HTMLStyle4_Release,
4185 HTMLStyle4_GetTypeInfoCount,
4186 HTMLStyle4_GetTypeInfo,
4187 HTMLStyle4_GetIDsOfNames,
4188 HTMLStyle4_Invoke,
4189 HTMLStyle4_put_textOverflow,
4190 HTMLStyle4_get_textOverflow,
4191 HTMLStyle4_put_minHeight,
4192 HTMLStyle4_get_minHeight
4193 };
4194
4195 static inline HTMLStyle *impl_from_IHTMLStyle5(IHTMLStyle5 *iface)
4196 {
4197 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle5_iface);
4198 }
4199
4200 static HRESULT WINAPI HTMLStyle5_QueryInterface(IHTMLStyle5 *iface, REFIID riid, void **ppv)
4201 {
4202 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4203
4204 return IHTMLStyle_QueryInterface(&This->IHTMLStyle_iface, riid, ppv);
4205 }
4206
4207 static ULONG WINAPI HTMLStyle5_AddRef(IHTMLStyle5 *iface)
4208 {
4209 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4210
4211 return IHTMLStyle_AddRef(&This->IHTMLStyle_iface);
4212 }
4213
4214 static ULONG WINAPI HTMLStyle5_Release(IHTMLStyle5 *iface)
4215 {
4216 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4217
4218 return IHTMLStyle_Release(&This->IHTMLStyle_iface);
4219 }
4220
4221 static HRESULT WINAPI HTMLStyle5_GetTypeInfoCount(IHTMLStyle5 *iface, UINT *pctinfo)
4222 {
4223 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4224 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4225 }
4226
4227 static HRESULT WINAPI HTMLStyle5_GetTypeInfo(IHTMLStyle5 *iface, UINT iTInfo,
4228 LCID lcid, ITypeInfo **ppTInfo)
4229 {
4230 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4231 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4232 }
4233
4234 static HRESULT WINAPI HTMLStyle5_GetIDsOfNames(IHTMLStyle5 *iface, REFIID riid,
4235 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4236 {
4237 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4238 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4239 lcid, rgDispId);
4240 }
4241
4242 static HRESULT WINAPI HTMLStyle5_Invoke(IHTMLStyle5 *iface, DISPID dispIdMember,
4243 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4244 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4245 {
4246 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4247 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4248 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4249 }
4250
4251 static HRESULT WINAPI HTMLStyle5_put_msInterpolationMode(IHTMLStyle5 *iface, BSTR v)
4252 {
4253 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4254 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4255 return E_NOTIMPL;
4256 }
4257
4258 static HRESULT WINAPI HTMLStyle5_get_msInterpolationMode(IHTMLStyle5 *iface, BSTR *p)
4259 {
4260 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4261 FIXME("(%p)->(%p)\n", This, p);
4262 return E_NOTIMPL;
4263 }
4264
4265 static HRESULT WINAPI HTMLStyle5_put_maxHeight(IHTMLStyle5 *iface, VARIANT v)
4266 {
4267 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4268
4269 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4270
4271 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_HEIGHT, &v, ATTR_FIX_PX);
4272 }
4273
4274 static HRESULT WINAPI HTMLStyle5_get_maxHeight(IHTMLStyle5 *iface, VARIANT *p)
4275 {
4276 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4277
4278 TRACE("(%p)->(%s)\n", This, debugstr_variant(p));
4279
4280 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_HEIGHT, p, 0);
4281 }
4282
4283 static HRESULT WINAPI HTMLStyle5_put_minWidth(IHTMLStyle5 *iface, VARIANT v)
4284 {
4285 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4286
4287 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4288
4289 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MIN_WIDTH, &v, ATTR_FIX_PX);
4290 }
4291
4292 static HRESULT WINAPI HTMLStyle5_get_minWidth(IHTMLStyle5 *iface, VARIANT *p)
4293 {
4294 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4295
4296 TRACE("(%p)->(%p)\n", This, p);
4297
4298 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MIN_WIDTH, p, 0);
4299 }
4300
4301 static HRESULT WINAPI HTMLStyle5_put_maxWidth(IHTMLStyle5 *iface, VARIANT v)
4302 {
4303 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4304
4305 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4306
4307 return set_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_WIDTH, &v, ATTR_FIX_PX);
4308 }
4309
4310 static HRESULT WINAPI HTMLStyle5_get_maxWidth(IHTMLStyle5 *iface, VARIANT *p)
4311 {
4312 HTMLStyle *This = impl_from_IHTMLStyle5(iface);
4313
4314 TRACE("(%p)->(%p)\n", This, p);
4315
4316 return get_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_WIDTH, p, 0);
4317 }
4318
4319 static const IHTMLStyle5Vtbl HTMLStyle5Vtbl = {
4320 HTMLStyle5_QueryInterface,
4321 HTMLStyle5_AddRef,
4322 HTMLStyle5_Release,
4323 HTMLStyle5_GetTypeInfoCount,
4324 HTMLStyle5_GetTypeInfo,
4325 HTMLStyle5_GetIDsOfNames,
4326 HTMLStyle5_Invoke,
4327 HTMLStyle5_put_msInterpolationMode,
4328 HTMLStyle5_get_msInterpolationMode,
4329 HTMLStyle5_put_maxHeight,
4330 HTMLStyle5_get_maxHeight,
4331 HTMLStyle5_put_minWidth,
4332 HTMLStyle5_get_minWidth,
4333 HTMLStyle5_put_maxWidth,
4334 HTMLStyle5_get_maxWidth
4335 };
4336
4337 static inline HTMLStyle *impl_from_IHTMLStyle6(IHTMLStyle6 *iface)
4338 {
4339 return CONTAINING_RECORD(iface, HTMLStyle, IHTMLStyle6_iface);
4340 }
4341
4342 static HRESULT WINAPI HTMLStyle6_QueryInterface(IHTMLStyle6 *iface, REFIID riid, void **ppv)
4343 {
4344 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4345
4346 return IHTMLStyle_QueryInterface(&This->IHTMLStyle_iface, riid, ppv);
4347 }
4348
4349 static ULONG WINAPI HTMLStyle6_AddRef(IHTMLStyle6 *iface)
4350 {
4351 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4352
4353 return IHTMLStyle_AddRef(&This->IHTMLStyle_iface);
4354 }
4355
4356 static ULONG WINAPI HTMLStyle6_Release(IHTMLStyle6 *iface)
4357 {
4358 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4359
4360 return IHTMLStyle_Release(&This->IHTMLStyle_iface);
4361 }
4362
4363 static HRESULT WINAPI HTMLStyle6_GetTypeInfoCount(IHTMLStyle6 *iface, UINT *pctinfo)
4364 {
4365 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4366 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4367 }
4368
4369 static HRESULT WINAPI HTMLStyle6_GetTypeInfo(IHTMLStyle6 *iface, UINT iTInfo,
4370 LCID lcid, ITypeInfo **ppTInfo)
4371 {
4372 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4373 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4374 }
4375
4376 static HRESULT WINAPI HTMLStyle6_GetIDsOfNames(IHTMLStyle6 *iface, REFIID riid,
4377 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4378 {
4379 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4380 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4381 lcid, rgDispId);
4382 }
4383
4384 static HRESULT WINAPI HTMLStyle6_Invoke(IHTMLStyle6 *iface, DISPID dispIdMember,
4385 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4386 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4387 {
4388 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4389 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4390 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4391 }
4392
4393 static HRESULT WINAPI HTMLStyle6_put_content(IHTMLStyle6 *iface, BSTR v)
4394 {
4395 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4396 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4397 return E_NOTIMPL;
4398 }
4399
4400 static HRESULT WINAPI HTMLStyle6_get_content(IHTMLStyle6 *iface, BSTR *p)
4401 {
4402 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4403 FIXME("(%p)->(%p)\n", This, p);
4404 return E_NOTIMPL;
4405 }
4406
4407 static HRESULT WINAPI HTMLStyle6_put_contentSide(IHTMLStyle6 *iface, BSTR v)
4408 {
4409 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4410 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4411 return E_NOTIMPL;
4412 }
4413
4414 static HRESULT WINAPI HTMLStyle6_get_contentSide(IHTMLStyle6 *iface, BSTR *p)
4415 {
4416 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4417 FIXME("(%p)->(%p)\n", This, p);
4418 return E_NOTIMPL;
4419 }
4420
4421 static HRESULT WINAPI HTMLStyle6_put_counterIncrement(IHTMLStyle6 *iface, BSTR v)
4422 {
4423 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4424 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4425 return E_NOTIMPL;
4426 }
4427
4428 static HRESULT WINAPI HTMLStyle6_get_counterIncrement(IHTMLStyle6 *iface, BSTR *p)
4429 {
4430 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4431 FIXME("(%p)->(%p)\n", This, p);
4432 return E_NOTIMPL;
4433 }
4434
4435 static HRESULT WINAPI HTMLStyle6_put_counterReset(IHTMLStyle6 *iface, BSTR v)
4436 {
4437 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4438 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4439 return E_NOTIMPL;
4440 }
4441
4442 static HRESULT WINAPI HTMLStyle6_get_counterReset(IHTMLStyle6 *iface, BSTR *p)
4443 {
4444 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4445 FIXME("(%p)->(%p)\n", This, p);
4446 return E_NOTIMPL;
4447 }
4448
4449 static HRESULT WINAPI HTMLStyle6_put_outline(IHTMLStyle6 *iface, BSTR v)
4450 {
4451 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4452
4453 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
4454
4455 return set_nsstyle_attr(This->nsstyle, STYLEID_OUTLINE, v, 0);
4456 }
4457
4458 static HRESULT WINAPI HTMLStyle6_get_outline(IHTMLStyle6 *iface, BSTR *p)
4459 {
4460 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4461
4462 TRACE("(%p)->(%p)\n", This, p);
4463
4464 return get_nsstyle_attr(This->nsstyle, STYLEID_OUTLINE, p, ATTR_NO_NULL);
4465 }
4466
4467 static HRESULT WINAPI HTMLStyle6_put_outlineWidth(IHTMLStyle6 *iface, VARIANT v)
4468 {
4469 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4470 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4471 return E_NOTIMPL;
4472 }
4473
4474 static HRESULT WINAPI HTMLStyle6_get_outlineWidth(IHTMLStyle6 *iface, VARIANT *p)
4475 {
4476 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4477 FIXME("(%p)->(%p)\n", This, p);
4478 return E_NOTIMPL;
4479 }
4480
4481 static HRESULT WINAPI HTMLStyle6_put_outlineStyle(IHTMLStyle6 *iface, BSTR v)
4482 {
4483 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4484 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4485 return E_NOTIMPL;
4486 }
4487
4488 static HRESULT WINAPI HTMLStyle6_get_outlineStyle(IHTMLStyle6 *iface, BSTR *p)
4489 {
4490 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4491 FIXME("(%p)->(%p)\n", This, p);
4492 return E_NOTIMPL;
4493 }
4494
4495 static HRESULT WINAPI HTMLStyle6_put_outlineColor(IHTMLStyle6 *iface, VARIANT v)
4496 {
4497 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4498 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4499 return E_NOTIMPL;
4500 }
4501
4502 static HRESULT WINAPI HTMLStyle6_get_outlineColor(IHTMLStyle6 *iface, VARIANT *p)
4503 {
4504 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4505 FIXME("(%p)->(%p)\n", This, p);
4506 return E_NOTIMPL;
4507 }
4508
4509 static HRESULT WINAPI HTMLStyle6_put_boxSizing(IHTMLStyle6 *iface, BSTR v)
4510 {
4511 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4512
4513 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
4514
4515 return set_nsstyle_attr(This->nsstyle, STYLEID_BOX_SIZING, v, 0);
4516 }
4517
4518 static HRESULT WINAPI HTMLStyle6_get_boxSizing(IHTMLStyle6 *iface, BSTR *p)
4519 {
4520 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4521
4522 TRACE("(%p)->(%p)\n", This, p);
4523
4524 return get_nsstyle_attr(This->nsstyle, STYLEID_BOX_SIZING, p, 0);
4525 }
4526
4527 static HRESULT WINAPI HTMLStyle6_put_boxSpacing(IHTMLStyle6 *iface, BSTR v)
4528 {
4529 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4530 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4531 return E_NOTIMPL;
4532 }
4533
4534 static HRESULT WINAPI HTMLStyle6_get_boxSpacing(IHTMLStyle6 *iface, BSTR *p)
4535 {
4536 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4537 FIXME("(%p)->(%p)\n", This, p);
4538 return E_NOTIMPL;
4539 }
4540
4541 static HRESULT WINAPI HTMLStyle6_put_orphans(IHTMLStyle6 *iface, VARIANT v)
4542 {
4543 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4544 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4545 return E_NOTIMPL;
4546 }
4547
4548 static HRESULT WINAPI HTMLStyle6_get_orphans(IHTMLStyle6 *iface, VARIANT *p)
4549 {
4550 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4551 FIXME("(%p)->(%p)\n", This, p);
4552 return E_NOTIMPL;
4553 }
4554
4555 static HRESULT WINAPI HTMLStyle6_put_windows(IHTMLStyle6 *iface, VARIANT v)
4556 {
4557 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4558 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4559 return E_NOTIMPL;
4560 }
4561
4562 static HRESULT WINAPI HTMLStyle6_get_windows(IHTMLStyle6 *iface, VARIANT *p)
4563 {
4564 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4565 FIXME("(%p)->(%p)\n", This, p);
4566 return E_NOTIMPL;
4567 }
4568
4569 static HRESULT WINAPI HTMLStyle6_put_pageBreakInside(IHTMLStyle6 *iface, BSTR v)
4570 {
4571 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4572 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4573 return E_NOTIMPL;
4574 }
4575
4576 static HRESULT WINAPI HTMLStyle6_get_pageBreakInside(IHTMLStyle6 *iface, BSTR *p)
4577 {
4578 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4579 FIXME("(%p)->(%p)\n", This, p);
4580 return E_NOTIMPL;
4581 }
4582
4583 static HRESULT WINAPI HTMLStyle6_put_emptyCells(IHTMLStyle6 *iface, BSTR v)
4584 {
4585 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4586 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4587 return E_NOTIMPL;
4588 }
4589
4590 static HRESULT WINAPI HTMLStyle6_get_emptyCells(IHTMLStyle6 *iface, BSTR *p)
4591 {
4592 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4593 FIXME("(%p)->(%p)\n", This, p);
4594 return E_NOTIMPL;
4595 }
4596
4597 static HRESULT WINAPI HTMLStyle6_put_msBlockProgression(IHTMLStyle6 *iface, BSTR v)
4598 {
4599 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4600 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4601 return E_NOTIMPL;
4602 }
4603
4604 static HRESULT WINAPI HTMLStyle6_get_msBlockProgression(IHTMLStyle6 *iface, BSTR *p)
4605 {
4606 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4607 FIXME("(%p)->(%p)\n", This, p);
4608 return E_NOTIMPL;
4609 }
4610
4611 static HRESULT WINAPI HTMLStyle6_put_quotes(IHTMLStyle6 *iface, BSTR v)
4612 {
4613 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4614 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
4615 return E_NOTIMPL;
4616 }
4617
4618 static HRESULT WINAPI HTMLStyle6_get_quotes(IHTMLStyle6 *iface, BSTR *p)
4619 {
4620 HTMLStyle *This = impl_from_IHTMLStyle6(iface);
4621 FIXME("(%p)->(%p)\n", This, p);
4622 return E_NOTIMPL;
4623 }
4624
4625 static const IHTMLStyle6Vtbl HTMLStyle6Vtbl = {
4626 HTMLStyle6_QueryInterface,
4627 HTMLStyle6_AddRef,
4628 HTMLStyle6_Release,
4629 HTMLStyle6_GetTypeInfoCount,
4630 HTMLStyle6_GetTypeInfo,
4631 HTMLStyle6_GetIDsOfNames,
4632 HTMLStyle6_Invoke,
4633 HTMLStyle6_put_content,
4634 HTMLStyle6_get_content,
4635 HTMLStyle6_put_contentSide,
4636 HTMLStyle6_get_contentSide,
4637 HTMLStyle6_put_counterIncrement,
4638 HTMLStyle6_get_counterIncrement,
4639 HTMLStyle6_put_counterReset,
4640 HTMLStyle6_get_counterReset,
4641 HTMLStyle6_put_outline,
4642 HTMLStyle6_get_outline,
4643 HTMLStyle6_put_outlineWidth,
4644 HTMLStyle6_get_outlineWidth,
4645 HTMLStyle6_put_outlineStyle,
4646 HTMLStyle6_get_outlineStyle,
4647 HTMLStyle6_put_outlineColor,
4648 HTMLStyle6_get_outlineColor,
4649 HTMLStyle6_put_boxSizing,
4650 HTMLStyle6_get_boxSizing,
4651 HTMLStyle6_put_boxSpacing,
4652 HTMLStyle6_get_boxSpacing,
4653 HTMLStyle6_put_orphans,
4654 HTMLStyle6_get_orphans,
4655 HTMLStyle6_put_windows,
4656 HTMLStyle6_get_windows,
4657 HTMLStyle6_put_pageBreakInside,
4658 HTMLStyle6_get_pageBreakInside,
4659 HTMLStyle6_put_emptyCells,
4660 HTMLStyle6_get_emptyCells,
4661 HTMLStyle6_put_msBlockProgression,
4662 HTMLStyle6_get_msBlockProgression,
4663 HTMLStyle6_put_quotes,
4664 HTMLStyle6_get_quotes
4665 };
4666
4667 static HRESULT HTMLStyle_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
4668 {
4669 const style_tbl_entry_t *style_entry;
4670
4671 style_entry = lookup_style_tbl(name);
4672 if(style_entry) {
4673 *dispid = style_entry->dispid;
4674 return S_OK;
4675 }
4676
4677 return DISP_E_UNKNOWNNAME;
4678 }
4679
4680 static const dispex_static_data_vtbl_t HTMLStyle_dispex_vtbl = {
4681 NULL,
4682 HTMLStyle_get_dispid,
4683 NULL,
4684 NULL
4685 };
4686
4687 static const tid_t HTMLStyle_iface_tids[] = {
4688 IHTMLStyle6_tid,
4689 IHTMLStyle5_tid,
4690 IHTMLStyle4_tid,
4691 IHTMLStyle3_tid,
4692 IHTMLStyle2_tid,
4693 IHTMLStyle_tid,
4694 0
4695 };
4696 static dispex_static_data_t HTMLStyle_dispex = {
4697 &HTMLStyle_dispex_vtbl,
4698 DispHTMLStyle_tid,
4699 HTMLStyle_iface_tids
4700 };
4701
4702 static HRESULT get_style_from_elem(HTMLElement *elem, nsIDOMCSSStyleDeclaration **ret)
4703 {
4704 nsIDOMElementCSSInlineStyle *nselemstyle;
4705 nsresult nsres;
4706
4707 if(!elem->dom_element) {
4708 FIXME("comment element\n");
4709 return E_NOTIMPL;
4710 }
4711
4712 nsres = nsIDOMElement_QueryInterface(elem->dom_element, &IID_nsIDOMElementCSSInlineStyle,
4713 (void**)&nselemstyle);
4714 assert(nsres == NS_OK);
4715
4716 nsres = nsIDOMElementCSSInlineStyle_GetStyle(nselemstyle, ret);
4717 nsIDOMElementCSSInlineStyle_Release(nselemstyle);
4718 if(NS_FAILED(nsres)) {
4719 ERR("GetStyle failed: %08x\n", nsres);
4720 return E_FAIL;
4721 }
4722
4723 return S_OK;
4724 }
4725
4726 HRESULT HTMLStyle_Create(HTMLElement *elem, HTMLStyle **ret)
4727 {
4728 nsIDOMCSSStyleDeclaration *nsstyle;
4729 HTMLStyle *style;
4730 HRESULT hres;
4731
4732 hres = get_style_from_elem(elem, &nsstyle);
4733 if(FAILED(hres))
4734 return hres;
4735
4736 style = heap_alloc_zero(sizeof(HTMLStyle));
4737 if(!style) {
4738 nsIDOMCSSStyleDeclaration_Release(nsstyle);
4739 return E_OUTOFMEMORY;
4740 }
4741
4742 style->IHTMLStyle_iface.lpVtbl = &HTMLStyleVtbl;
4743 style->IHTMLStyle2_iface.lpVtbl = &HTMLStyle2Vtbl;
4744 style->IHTMLStyle3_iface.lpVtbl = &HTMLStyle3Vtbl;
4745 style->IHTMLStyle4_iface.lpVtbl = &HTMLStyle4Vtbl;
4746 style->IHTMLStyle5_iface.lpVtbl = &HTMLStyle5Vtbl;
4747 style->IHTMLStyle6_iface.lpVtbl = &HTMLStyle6Vtbl;
4748
4749 style->ref = 1;
4750 style->nsstyle = nsstyle;
4751 style->elem = elem;
4752
4753 nsIDOMCSSStyleDeclaration_AddRef(nsstyle);
4754
4755 init_dispex(&style->dispex, (IUnknown*)&style->IHTMLStyle_iface, &HTMLStyle_dispex);
4756
4757 *ret = style;
4758 return S_OK;
4759 }
4760
4761 HRESULT get_elem_style(HTMLElement *elem, styleid_t styleid, BSTR *ret)
4762 {
4763 nsIDOMCSSStyleDeclaration *style;
4764 HRESULT hres;
4765
4766 hres = get_style_from_elem(elem, &style);
4767 if(FAILED(hres))
4768 return hres;
4769
4770 hres = get_nsstyle_attr(style, styleid, ret, 0);
4771 nsIDOMCSSStyleDeclaration_Release(style);
4772 return hres;
4773 }
4774
4775 HRESULT set_elem_style(HTMLElement *elem, styleid_t styleid, const WCHAR *val)
4776 {
4777 nsIDOMCSSStyleDeclaration *style;
4778 HRESULT hres;
4779
4780 hres = get_style_from_elem(elem, &style);
4781 if(FAILED(hres))
4782 return hres;
4783
4784 hres = set_nsstyle_attr(style, styleid, val, 0);
4785 nsIDOMCSSStyleDeclaration_Release(style);
4786 return hres;
4787 }
Windows API implementation