?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut32: FONTDESC size field value is not important for OleCreateFontIndirect.
[wine/multimedia.git] / dlls / oleaut32 / olefont.c
blob222e20d740da7bc984616ee81d2573d027f15e01
1 /*
2 * OLE Font encapsulation implementation
3 *
4 * This file contains an implementation of the IFont
5 * interface and the OleCreateFontIndirect API call.
6 *
7 * Copyright 1999 Francis Beaudet
8 * Copyright 2006 (Google) Benjamin Arai
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <string.h>
27
28 #define COBJMACROS
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
31
32 #include "winerror.h"
33 #include "windef.h"
34 #include "winbase.h"
35 #include "wingdi.h"
36 #include "winuser.h"
37 #include "wine/list.h"
38 #include "wine/unicode.h"
39 #include "objbase.h"
40 #include "oleauto.h" /* for SysAllocString(....) */
41 #include "ole2.h"
42 #include "olectl.h"
43 #include "wine/debug.h"
44 #include "connpt.h" /* for CreateConnectionPoint */
45 #include "oaidl.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(ole);
48
49 /***********************************************************************
50 * Declaration of constants used when serializing the font object.
51 */
52 #define FONTPERSIST_ITALIC 0x02
53 #define FONTPERSIST_UNDERLINE 0x04
54 #define FONTPERSIST_STRIKETHROUGH 0x08
55
56 static HDC olefont_hdc;
57
58 /***********************************************************************
59 * List of the HFONTs it has given out, with each one having a separate
60 * ref count.
61 */
62 typedef struct _HFONTItem
63 {
64 struct list entry;
65
66 /* Reference count of any IFont objects that own this hfont */
67 LONG int_refs;
68
69 /* Total reference count of any refs held by the application obtained by AddRefHfont plus any internal refs */
70 LONG total_refs;
71
72 /* The font associated with this object. */
73 HFONT gdiFont;
74
75 } HFONTItem, *PHFONTItem;
76
77 static struct list OLEFontImpl_hFontList = LIST_INIT(OLEFontImpl_hFontList);
78
79 /* Counts how many fonts contain at least one lock */
80 static LONG ifont_cnt = 0;
81
82 /***********************************************************************
83 * Critical section for OLEFontImpl_hFontList
84 */
85 static CRITICAL_SECTION OLEFontImpl_csHFONTLIST;
86 static CRITICAL_SECTION_DEBUG OLEFontImpl_csHFONTLIST_debug =
87 {
88 0, 0, &OLEFontImpl_csHFONTLIST,
89 { &OLEFontImpl_csHFONTLIST_debug.ProcessLocksList,
90 &OLEFontImpl_csHFONTLIST_debug.ProcessLocksList },
91 0, 0, { (DWORD_PTR)(__FILE__ ": OLEFontImpl_csHFONTLIST") }
92 };
93 static CRITICAL_SECTION OLEFontImpl_csHFONTLIST = { &OLEFontImpl_csHFONTLIST_debug, -1, 0, 0, 0, 0 };
94
95 static HDC get_dc(void)
96 {
97 HDC hdc;
98 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
99 if(!olefont_hdc)
100 olefont_hdc = CreateCompatibleDC(NULL);
101 hdc = olefont_hdc;
102 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
103 return hdc;
104 }
105
106 static void delete_dc(void)
107 {
108 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
109 if(olefont_hdc)
110 {
111 DeleteDC(olefont_hdc);
112 olefont_hdc = NULL;
113 }
114 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
115 }
116
117 static void HFONTItem_Delete(PHFONTItem item)
118 {
119 DeleteObject(item->gdiFont);
120 list_remove(&item->entry);
121 HeapFree(GetProcessHeap(), 0, item);
122 }
123
124 /* Find hfont item entry in the list. Should be called while holding the crit sect */
125 static HFONTItem *find_hfontitem(HFONT hfont)
126 {
127 HFONTItem *item;
128
129 LIST_FOR_EACH_ENTRY(item, &OLEFontImpl_hFontList, HFONTItem, entry)
130 {
131 if (item->gdiFont == hfont)
132 return item;
133 }
134 return NULL;
135 }
136
137 /* Add an item to the list with one internal reference */
138 static HRESULT add_hfontitem(HFONT hfont)
139 {
140 HFONTItem *new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_item));
141
142 if(!new_item) return E_OUTOFMEMORY;
143
144 new_item->int_refs = 1;
145 new_item->total_refs = 1;
146 new_item->gdiFont = hfont;
147 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
148 list_add_tail(&OLEFontImpl_hFontList,&new_item->entry);
149 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
150 return S_OK;
151 }
152
153 static HRESULT inc_int_ref(HFONT hfont)
154 {
155 HFONTItem *item;
156 HRESULT hr = S_FALSE;
157
158 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
159 item = find_hfontitem(hfont);
160
161 if(item)
162 {
163 item->int_refs++;
164 item->total_refs++;
165 hr = S_OK;
166 }
167 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
168
169 return hr;
170 }
171
172 /* decrements the internal ref of a hfont item. If both refs are zero it'll
173 remove the item from the list and delete the hfont */
174 static HRESULT dec_int_ref(HFONT hfont)
175 {
176 HFONTItem *item;
177 HRESULT hr = S_FALSE;
178
179 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
180 item = find_hfontitem(hfont);
181
182 if(item)
183 {
184 item->int_refs--;
185 item->total_refs--;
186 if(item->int_refs == 0 && item->total_refs == 0)
187 HFONTItem_Delete(item);
188 hr = S_OK;
189 }
190 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
191
192 return hr;
193 }
194
195 static HRESULT inc_ext_ref(HFONT hfont)
196 {
197 HFONTItem *item;
198 HRESULT hr = S_FALSE;
199
200 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
201
202 item = find_hfontitem(hfont);
203 if(item)
204 {
205 item->total_refs++;
206 hr = S_OK;
207 }
208 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
209
210 return hr;
211 }
212
213 static HRESULT dec_ext_ref(HFONT hfont)
214 {
215 HFONTItem *item;
216 HRESULT hr = S_FALSE;
217
218 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
219
220 item = find_hfontitem(hfont);
221 if(item)
222 {
223 if(--item->total_refs >= 0) hr = S_OK;
224 }
225 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
226
227 return hr;
228 }
229
230 static WCHAR *strdupW(const WCHAR* str)
231 {
232 WCHAR *ret;
233 DWORD size = (strlenW(str) + 1) * sizeof(WCHAR);
234
235 ret = HeapAlloc(GetProcessHeap(), 0, size);
236 if(ret)
237 memcpy(ret, str, size);
238 return ret;
239 }
240
241 /***********************************************************************
242 * Declaration of the implementation class for the IFont interface
243 */
244 typedef struct OLEFontImpl OLEFontImpl;
245
246 struct OLEFontImpl
247 {
248 /*
249 * This class supports many interfaces. IUnknown, IFont,
250 * IDispatch, IDispFont IPersistStream and IConnectionPointContainer.
251 * The first two are supported by the first vtable, the next two are
252 * supported by the second table and the last two have their own.
253 */
254 IFont IFont_iface;
255 IDispatch IDispatch_iface;
256 IPersistStream IPersistStream_iface;
257 IConnectionPointContainer IConnectionPointContainer_iface;
258 IPersistPropertyBag IPersistPropertyBag_iface;
259 IPersistStreamInit IPersistStreamInit_iface;
260 /*
261 * Reference count for that instance of the class.
262 */
263 LONG ref;
264
265 /*
266 * This structure contains the description of the class.
267 */
268 FONTDESC description;
269
270 /*
271 * Contain the font associated with this object.
272 */
273 HFONT gdiFont;
274 BOOL dirty;
275 /*
276 * Size ratio
277 */
278 LONG cyLogical;
279 LONG cyHimetric;
280
281 /*
282 * Stash realized height (pixels) from TEXTMETRIC - used in get_Size()
283 */
284 LONG nRealHeight;
285
286 IConnectionPoint *pPropertyNotifyCP;
287 IConnectionPoint *pFontEventsCP;
288 };
289
290 /*
291 * Here, I define utility macros to help with the casting of the
292 * "this" parameter.
293 * There is a version to accommodate all of the VTables implemented
294 * by this object.
295 */
296
297 static inline OLEFontImpl *impl_from_IFont(IFont *iface)
298 {
299 return CONTAINING_RECORD(iface, OLEFontImpl, IFont_iface);
300 }
301
302 static inline OLEFontImpl *impl_from_IDispatch( IDispatch *iface )
303 {
304 return CONTAINING_RECORD(iface, OLEFontImpl, IDispatch_iface);
305 }
306
307 static inline OLEFontImpl *impl_from_IPersistStream( IPersistStream *iface )
308 {
309 return CONTAINING_RECORD(iface, OLEFontImpl, IPersistStream_iface);
310 }
311
312 static inline OLEFontImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
313 {
314 return CONTAINING_RECORD(iface, OLEFontImpl, IConnectionPointContainer_iface);
315 }
316
317 static inline OLEFontImpl *impl_from_IPersistPropertyBag( IPersistPropertyBag *iface )
318 {
319 return CONTAINING_RECORD(iface, OLEFontImpl, IPersistPropertyBag_iface);
320 }
321
322 static inline OLEFontImpl *impl_from_IPersistStreamInit( IPersistStreamInit *iface )
323 {
324 return CONTAINING_RECORD(iface, OLEFontImpl, IPersistStreamInit_iface);
325 }
326
327
328 /***********************************************************************
329 * Prototypes for the implementation functions for the IFont
330 * interface
331 */
332 static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc);
333 static void OLEFontImpl_Destroy(OLEFontImpl* fontDesc);
334 static ULONG WINAPI OLEFontImpl_AddRef(IFont* iface);
335
336 /******************************************************************************
337 * OleCreateFontIndirect [OLEAUT32.420]
338 */
339 HRESULT WINAPI OleCreateFontIndirect(
340 LPFONTDESC lpFontDesc,
341 REFIID riid,
342 LPVOID* ppvObj)
343 {
344 OLEFontImpl* newFont;
345 HRESULT hr;
346 FONTDESC fd;
347
348 TRACE("(%p, %s, %p)\n", lpFontDesc, debugstr_guid(riid), ppvObj);
349
350 if (!ppvObj) return E_POINTER;
351
352 *ppvObj = 0;
353
354 if (!lpFontDesc) {
355 static WCHAR fname[] = { 'S','y','s','t','e','m',0 };
356
357 fd.cbSizeofstruct = sizeof(fd);
358 fd.lpstrName = fname;
359 fd.cySize.s.Lo = 80000;
360 fd.cySize.s.Hi = 0;
361 fd.sWeight = 0;
362 fd.sCharset = 0;
363 fd.fItalic = 0;
364 fd.fUnderline = 0;
365 fd.fStrikethrough = 0;
366 lpFontDesc = &fd;
367 }
368
369 newFont = OLEFontImpl_Construct(lpFontDesc);
370 if (!newFont) return E_OUTOFMEMORY;
371
372 hr = IFont_QueryInterface(&newFont->IFont_iface, riid, ppvObj);
373 IFont_Release(&newFont->IFont_iface);
374
375 return hr;
376 }
377
378
379 /***********************************************************************
380 * Implementation of the OLEFontImpl class.
381 */
382
383 /***********************************************************************
384 * OLEFont_SendNotify (internal)
385 *
386 * Sends notification messages of changed properties to any interested
387 * connections.
388 */
389 static void OLEFont_SendNotify(OLEFontImpl* this, DISPID dispID)
390 {
391 static const WCHAR wszName[] = {'N','a','m','e',0};
392 static const WCHAR wszSize[] = {'S','i','z','e',0};
393 static const WCHAR wszBold[] = {'B','o','l','d',0};
394 static const WCHAR wszItalic[] = {'I','t','a','l','i','c',0};
395 static const WCHAR wszUnder[] = {'U','n','d','e','r','l','i','n','e',0};
396 static const WCHAR wszStrike[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
397 static const WCHAR wszWeight[] = {'W','e','i','g','h','t',0};
398 static const WCHAR wszCharset[] = {'C','h','a','r','s','s','e','t',0};
399 static const LPCWSTR dispid_mapping[] =
400 {
401 wszName,
402 NULL,
403 wszSize,
404 wszBold,
405 wszItalic,
406 wszUnder,
407 wszStrike,
408 wszWeight,
409 wszCharset
410 };
411
412 IEnumConnections *pEnum;
413 CONNECTDATA CD;
414 HRESULT hres;
415
416 this->dirty = TRUE;
417
418 hres = IConnectionPoint_EnumConnections(this->pPropertyNotifyCP, &pEnum);
419 if (SUCCEEDED(hres))
420 {
421 while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
422 IPropertyNotifySink *sink;
423
424 IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
425 IPropertyNotifySink_OnChanged(sink, dispID);
426 IPropertyNotifySink_Release(sink);
427 IUnknown_Release(CD.pUnk);
428 }
429 IEnumConnections_Release(pEnum);
430 }
431
432 hres = IConnectionPoint_EnumConnections(this->pFontEventsCP, &pEnum);
433 if (SUCCEEDED(hres))
434 {
435 DISPPARAMS dispparams;
436 VARIANTARG vararg;
437
438 VariantInit(&vararg);
439 V_VT(&vararg) = VT_BSTR;
440 V_BSTR(&vararg) = SysAllocString(dispid_mapping[dispID]);
441
442 dispparams.cArgs = 1;
443 dispparams.cNamedArgs = 0;
444 dispparams.rgdispidNamedArgs = NULL;
445 dispparams.rgvarg = &vararg;
446
447 while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
448 IFontEventsDisp *disp;
449
450 IUnknown_QueryInterface(CD.pUnk, &IID_IFontEventsDisp, (LPVOID)&disp);
451 IDispatch_Invoke(disp, DISPID_FONT_CHANGED, &IID_NULL,
452 LOCALE_NEUTRAL, INVOKE_FUNC, &dispparams, NULL,
453 NULL, NULL);
454
455 IDispatch_Release(disp);
456 IUnknown_Release(CD.pUnk);
457 }
458 VariantClear(&vararg);
459 IEnumConnections_Release(pEnum);
460 }
461 }
462
463 /************************************************************************
464 * OLEFontImpl_QueryInterface (IUnknown)
465 *
466 * See Windows documentation for more details on IUnknown methods.
467 */
468 static HRESULT WINAPI OLEFontImpl_QueryInterface(
469 IFont* iface,
470 REFIID riid,
471 void** ppvObject)
472 {
473 OLEFontImpl *this = impl_from_IFont(iface);
474
475 TRACE("(%p)->(%s, %p)\n", this, debugstr_guid(riid), ppvObject);
476
477 *ppvObject = 0;
478
479 if (IsEqualGUID(&IID_IUnknown, riid) ||
480 IsEqualGUID(&IID_IFont, riid))
481 {
482 *ppvObject = this;
483 }
484 else if (IsEqualGUID(&IID_IDispatch, riid) ||
485 IsEqualGUID(&IID_IFontDisp, riid))
486 {
487 *ppvObject = &this->IDispatch_iface;
488 }
489 else if (IsEqualGUID(&IID_IPersist, riid) ||
490 IsEqualGUID(&IID_IPersistStream, riid))
491 {
492 *ppvObject = &this->IPersistStream_iface;
493 }
494 else if (IsEqualGUID(&IID_IConnectionPointContainer, riid))
495 {
496 *ppvObject = &this->IConnectionPointContainer_iface;
497 }
498 else if (IsEqualGUID(&IID_IPersistPropertyBag, riid))
499 {
500 *ppvObject = &this->IPersistPropertyBag_iface;
501 }
502 else if (IsEqualGUID(&IID_IPersistStreamInit, riid))
503 {
504 *ppvObject = &this->IPersistStreamInit_iface;
505 }
506
507 if (!*ppvObject)
508 {
509 FIXME("() : asking for unsupported interface %s\n", debugstr_guid(riid));
510 return E_NOINTERFACE;
511 }
512
513 IFont_AddRef(iface);
514
515 return S_OK;
516 }
517
518 /************************************************************************
519 * OLEFontImpl_AddRef (IUnknown)
520 */
521 static ULONG WINAPI OLEFontImpl_AddRef(
522 IFont* iface)
523 {
524 OLEFontImpl *this = impl_from_IFont(iface);
525 TRACE("(%p)->(ref=%d)\n", this, this->ref);
526 return InterlockedIncrement(&this->ref);
527 }
528
529 /************************************************************************
530 * OLEFontImpl_Release (IUnknown)
531 */
532 static ULONG WINAPI OLEFontImpl_Release(IFont* iface)
533 {
534 OLEFontImpl *this = impl_from_IFont(iface);
535 ULONG ref;
536
537 TRACE("(%p)->(ref=%d)\n", this, this->ref);
538
539 ref = InterlockedDecrement(&this->ref);
540
541 if (ref == 0)
542 {
543 ULONG fontlist_refs = InterlockedDecrement(&ifont_cnt);
544
545 /* Final IFont object so destroy font cache */
546 if (fontlist_refs == 0)
547 {
548 HFONTItem *item, *cursor2;
549
550 EnterCriticalSection(&OLEFontImpl_csHFONTLIST);
551 LIST_FOR_EACH_ENTRY_SAFE(item, cursor2, &OLEFontImpl_hFontList, HFONTItem, entry)
552 HFONTItem_Delete(item);
553 LeaveCriticalSection(&OLEFontImpl_csHFONTLIST);
554 delete_dc();
555 }
556 else
557 {
558 dec_int_ref(this->gdiFont);
559 }
560 OLEFontImpl_Destroy(this);
561 }
562
563 return ref;
564 }
565
566 typedef struct
567 {
568 short orig_cs;
569 short avail_cs;
570 } enum_data;
571
572 static int CALLBACK font_enum_proc(const LOGFONTW *elf, const TEXTMETRICW *ntm, DWORD type, LPARAM lp)
573 {
574 enum_data *data = (enum_data*)lp;
575
576 if(elf->lfCharSet == data->orig_cs)
577 {
578 data->avail_cs = data->orig_cs;
579 return 0;
580 }
581 if(data->avail_cs == -1) data->avail_cs = elf->lfCharSet;
582 return 1;
583 }
584
585 static void realize_font(OLEFontImpl *This)
586 {
587 LOGFONTW logFont;
588 INT fontHeight;
589 WCHAR text_face[LF_FACESIZE];
590 HDC hdc = get_dc();
591 HFONT old_font;
592 TEXTMETRICW tm;
593
594 if (!This->dirty) return;
595
596 text_face[0] = 0;
597
598 if(This->gdiFont)
599 {
600 old_font = SelectObject(hdc, This->gdiFont);
601 GetTextFaceW(hdc, sizeof(text_face) / sizeof(text_face[0]), text_face);
602 SelectObject(hdc, old_font);
603 dec_int_ref(This->gdiFont);
604 This->gdiFont = 0;
605 }
606
607 memset(&logFont, 0, sizeof(LOGFONTW));
608
609 lstrcpynW(logFont.lfFaceName, This->description.lpstrName, LF_FACESIZE);
610 logFont.lfCharSet = This->description.sCharset;
611
612 /* If the font name has been changed then enumerate all charsets
613 and pick one that'll result in the font specified being selected */
614 if(text_face[0] && lstrcmpiW(text_face, This->description.lpstrName))
615 {
616 enum_data data;
617 data.orig_cs = This->description.sCharset;
618 data.avail_cs = -1;
619 logFont.lfCharSet = DEFAULT_CHARSET;
620 EnumFontFamiliesExW(get_dc(), &logFont, font_enum_proc, (LPARAM)&data, 0);
621 if(data.avail_cs != -1) logFont.lfCharSet = data.avail_cs;
622 }
623
624 /*
625 * The height of the font returned by the get_Size property is the
626 * height of the font in points multiplied by 10000... Using some
627 * simple conversions and the ratio given by the application, it can
628 * be converted to a height in pixels.
629 *
630 * Standard ratio is 72 / 2540, or 18 / 635 in lowest terms.
631 * Ratio is applied here relative to the standard.
632 */
633
634 fontHeight = MulDiv( This->description.cySize.s.Lo, This->cyLogical*635, This->cyHimetric*18 );
635
636 logFont.lfHeight = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L) - 1 :
637 (-fontHeight/10000L);
638 logFont.lfItalic = This->description.fItalic;
639 logFont.lfUnderline = This->description.fUnderline;
640 logFont.lfStrikeOut = This->description.fStrikethrough;
641 logFont.lfWeight = This->description.sWeight;
642 logFont.lfOutPrecision = OUT_CHARACTER_PRECIS;
643 logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
644 logFont.lfQuality = DEFAULT_QUALITY;
645 logFont.lfPitchAndFamily = DEFAULT_PITCH;
646
647 This->gdiFont = CreateFontIndirectW(&logFont);
648 This->dirty = FALSE;
649
650 add_hfontitem(This->gdiFont);
651
652 /* Fixup the name and charset properties so that they match the
653 selected font */
654 old_font = SelectObject(get_dc(), This->gdiFont);
655 GetTextFaceW(hdc, sizeof(text_face) / sizeof(text_face[0]), text_face);
656 if(lstrcmpiW(text_face, This->description.lpstrName))
657 {
658 HeapFree(GetProcessHeap(), 0, This->description.lpstrName);
659 This->description.lpstrName = strdupW(text_face);
660 }
661 GetTextMetricsW(hdc, &tm);
662 This->description.sCharset = tm.tmCharSet;
663 /* While we have it handy, stash the realized font height for use by get_Size() */
664 This->nRealHeight = tm.tmHeight - tm.tmInternalLeading; /* corresponds to LOGFONT lfHeight */
665 SelectObject(hdc, old_font);
666 }
667
668 /************************************************************************
669 * OLEFontImpl_get_Name (IFont)
670 *
671 * See Windows documentation for more details on IFont methods.
672 */
673 static HRESULT WINAPI OLEFontImpl_get_Name(
674 IFont* iface,
675 BSTR* pname)
676 {
677 OLEFontImpl *this = impl_from_IFont(iface);
678 TRACE("(%p)->(%p)\n", this, pname);
679
680 if (pname==0)
681 return E_POINTER;
682
683 realize_font(this);
684
685 if (this->description.lpstrName!=0)
686 *pname = SysAllocString(this->description.lpstrName);
687 else
688 *pname = 0;
689
690 return S_OK;
691 }
692
693 /************************************************************************
694 * OLEFontImpl_put_Name (IFont)
695 */
696 static HRESULT WINAPI OLEFontImpl_put_Name(
697 IFont* iface,
698 BSTR name)
699 {
700 OLEFontImpl *this = impl_from_IFont(iface);
701 TRACE("(%p)->(%p)\n", this, name);
702
703 if (!name)
704 return CTL_E_INVALIDPROPERTYVALUE;
705
706 if (this->description.lpstrName==0)
707 {
708 this->description.lpstrName = HeapAlloc(GetProcessHeap(),
709 0,
710 (lstrlenW(name)+1) * sizeof(WCHAR));
711 }
712 else
713 {
714 this->description.lpstrName = HeapReAlloc(GetProcessHeap(),
715 0,
716 this->description.lpstrName,
717 (lstrlenW(name)+1) * sizeof(WCHAR));
718 }
719
720 if (this->description.lpstrName==0)
721 return E_OUTOFMEMORY;
722
723 strcpyW(this->description.lpstrName, name);
724 TRACE("new name %s\n", debugstr_w(this->description.lpstrName));
725 OLEFont_SendNotify(this, DISPID_FONT_NAME);
726 return S_OK;
727 }
728
729 /************************************************************************
730 * OLEFontImpl_get_Size (IFont)
731 */
732 static HRESULT WINAPI OLEFontImpl_get_Size(
733 IFont* iface,
734 CY* psize)
735 {
736 OLEFontImpl *this = impl_from_IFont(iface);
737 TRACE("(%p)->(%p)\n", this, psize);
738
739 if (!psize) return E_POINTER;
740
741 realize_font(this);
742
743 /*
744 * Convert realized font height in pixels to points descaled by current
745 * scaling ratio then scaled up by 10000.
746 */
747 psize->s.Lo = MulDiv(this->nRealHeight,
748 this->cyHimetric * 72 * 10000,
749 this->cyLogical * 2540);
750 psize->s.Hi = 0;
751
752 return S_OK;
753 }
754
755 /************************************************************************
756 * OLEFontImpl_put_Size (IFont)
757 */
758 static HRESULT WINAPI OLEFontImpl_put_Size(
759 IFont* iface,
760 CY size)
761 {
762 OLEFontImpl *this = impl_from_IFont(iface);
763 TRACE("(%p)->(%d)\n", this, size.s.Lo);
764 this->description.cySize.s.Hi = 0;
765 this->description.cySize.s.Lo = size.s.Lo;
766 OLEFont_SendNotify(this, DISPID_FONT_SIZE);
767
768 return S_OK;
769 }
770
771 /************************************************************************
772 * OLEFontImpl_get_Bold (IFont)
773 *
774 * See Windows documentation for more details on IFont methods.
775 */
776 static HRESULT WINAPI OLEFontImpl_get_Bold(
777 IFont* iface,
778 BOOL* pbold)
779 {
780 OLEFontImpl *this = impl_from_IFont(iface);
781 TRACE("(%p)->(%p)\n", this, pbold);
782
783 if (!pbold) return E_POINTER;
784
785 realize_font(this);
786
787 *pbold = this->description.sWeight > 550;
788
789 return S_OK;
790 }
791
792 /************************************************************************
793 * OLEFontImpl_put_Bold (IFont)
794 */
795 static HRESULT WINAPI OLEFontImpl_put_Bold(
796 IFont* iface,
797 BOOL bold)
798 {
799 OLEFontImpl *this = impl_from_IFont(iface);
800 TRACE("(%p)->(%d)\n", this, bold);
801 this->description.sWeight = bold ? FW_BOLD : FW_NORMAL;
802 OLEFont_SendNotify(this, DISPID_FONT_BOLD);
803
804 return S_OK;
805 }
806
807 /************************************************************************
808 * OLEFontImpl_get_Italic (IFont)
809 */
810 static HRESULT WINAPI OLEFontImpl_get_Italic(
811 IFont* iface,
812 BOOL* pitalic)
813 {
814 OLEFontImpl *this = impl_from_IFont(iface);
815 TRACE("(%p)->(%p)\n", this, pitalic);
816
817 if (pitalic==0)
818 return E_POINTER;
819
820 realize_font(this);
821
822 *pitalic = this->description.fItalic;
823
824 return S_OK;
825 }
826
827 /************************************************************************
828 * OLEFontImpl_put_Italic (IFont)
829 */
830 static HRESULT WINAPI OLEFontImpl_put_Italic(
831 IFont* iface,
832 BOOL italic)
833 {
834 OLEFontImpl *this = impl_from_IFont(iface);
835 TRACE("(%p)->(%d)\n", this, italic);
836
837 this->description.fItalic = italic;
838
839 OLEFont_SendNotify(this, DISPID_FONT_ITALIC);
840 return S_OK;
841 }
842
843 /************************************************************************
844 * OLEFontImpl_get_Underline (IFont)
845 */
846 static HRESULT WINAPI OLEFontImpl_get_Underline(
847 IFont* iface,
848 BOOL* punderline)
849 {
850 OLEFontImpl *this = impl_from_IFont(iface);
851 TRACE("(%p)->(%p)\n", this, punderline);
852
853 if (punderline==0)
854 return E_POINTER;
855
856 realize_font(this);
857
858 *punderline = this->description.fUnderline;
859
860 return S_OK;
861 }
862
863 /************************************************************************
864 * OLEFontImpl_put_Underline (IFont)
865 */
866 static HRESULT WINAPI OLEFontImpl_put_Underline(
867 IFont* iface,
868 BOOL underline)
869 {
870 OLEFontImpl *this = impl_from_IFont(iface);
871 TRACE("(%p)->(%d)\n", this, underline);
872
873 this->description.fUnderline = underline;
874
875 OLEFont_SendNotify(this, DISPID_FONT_UNDER);
876 return S_OK;
877 }
878
879 /************************************************************************
880 * OLEFontImpl_get_Strikethrough (IFont)
881 */
882 static HRESULT WINAPI OLEFontImpl_get_Strikethrough(
883 IFont* iface,
884 BOOL* pstrikethrough)
885 {
886 OLEFontImpl *this = impl_from_IFont(iface);
887 TRACE("(%p)->(%p)\n", this, pstrikethrough);
888
889 if (pstrikethrough==0)
890 return E_POINTER;
891
892 realize_font(this);
893
894 *pstrikethrough = this->description.fStrikethrough;
895
896 return S_OK;
897 }
898
899 /************************************************************************
900 * OLEFontImpl_put_Strikethrough (IFont)
901 */
902 static HRESULT WINAPI OLEFontImpl_put_Strikethrough(
903 IFont* iface,
904 BOOL strikethrough)
905 {
906 OLEFontImpl *this = impl_from_IFont(iface);
907 TRACE("(%p)->(%d)\n", this, strikethrough);
908
909 this->description.fStrikethrough = strikethrough;
910 OLEFont_SendNotify(this, DISPID_FONT_STRIKE);
911
912 return S_OK;
913 }
914
915 /************************************************************************
916 * OLEFontImpl_get_Weight (IFont)
917 */
918 static HRESULT WINAPI OLEFontImpl_get_Weight(
919 IFont* iface,
920 short* pweight)
921 {
922 OLEFontImpl *this = impl_from_IFont(iface);
923 TRACE("(%p)->(%p)\n", this, pweight);
924
925 if (pweight==0)
926 return E_POINTER;
927
928 realize_font(this);
929
930 *pweight = this->description.sWeight;
931
932 return S_OK;
933 }
934
935 /************************************************************************
936 * OLEFontImpl_put_Weight (IFont)
937 */
938 static HRESULT WINAPI OLEFontImpl_put_Weight(
939 IFont* iface,
940 short weight)
941 {
942 OLEFontImpl *this = impl_from_IFont(iface);
943 TRACE("(%p)->(%d)\n", this, weight);
944
945 this->description.sWeight = weight;
946
947 OLEFont_SendNotify(this, DISPID_FONT_WEIGHT);
948 return S_OK;
949 }
950
951 /************************************************************************
952 * OLEFontImpl_get_Charset (IFont)
953 */
954 static HRESULT WINAPI OLEFontImpl_get_Charset(
955 IFont* iface,
956 short* pcharset)
957 {
958 OLEFontImpl *this = impl_from_IFont(iface);
959 TRACE("(%p)->(%p)\n", this, pcharset);
960
961 if (pcharset==0)
962 return E_POINTER;
963
964 realize_font(this);
965
966 *pcharset = this->description.sCharset;
967
968 return S_OK;
969 }
970
971 /************************************************************************
972 * OLEFontImpl_put_Charset (IFont)
973 */
974 static HRESULT WINAPI OLEFontImpl_put_Charset(
975 IFont* iface,
976 short charset)
977 {
978 OLEFontImpl *this = impl_from_IFont(iface);
979 TRACE("(%p)->(%d)\n", this, charset);
980
981 this->description.sCharset = charset;
982 OLEFont_SendNotify(this, DISPID_FONT_CHARSET);
983
984 return S_OK;
985 }
986
987 /************************************************************************
988 * OLEFontImpl_get_hFont (IFont)
989 */
990 static HRESULT WINAPI OLEFontImpl_get_hFont(
991 IFont* iface,
992 HFONT* phfont)
993 {
994 OLEFontImpl *this = impl_from_IFont(iface);
995 TRACE("(%p)->(%p)\n", this, phfont);
996 if (phfont==NULL)
997 return E_POINTER;
998
999 realize_font(this);
1000
1001 *phfont = this->gdiFont;
1002 TRACE("Returning %p\n", *phfont);
1003 return S_OK;
1004 }
1005
1006 /************************************************************************
1007 * OLEFontImpl_Clone (IFont)
1008 */
1009 static HRESULT WINAPI OLEFontImpl_Clone(
1010 IFont* iface,
1011 IFont** ppfont)
1012 {
1013 OLEFontImpl *this = impl_from_IFont(iface);
1014 OLEFontImpl* newObject;
1015
1016 TRACE("(%p)->(%p)\n", this, ppfont);
1017
1018 if (ppfont == NULL)
1019 return E_POINTER;
1020
1021 *ppfont = NULL;
1022
1023 newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
1024 if (newObject==NULL)
1025 return E_OUTOFMEMORY;
1026
1027 *newObject = *this;
1028
1029 /* We need to alloc new memory for the string, otherwise
1030 * we free memory twice.
1031 */
1032 newObject->description.lpstrName = HeapAlloc(
1033 GetProcessHeap(),0,
1034 (1+strlenW(this->description.lpstrName))*2
1035 );
1036 strcpyW(newObject->description.lpstrName, this->description.lpstrName);
1037
1038 /* Increment internal ref in hfont item list */
1039 if(newObject->gdiFont) inc_int_ref(newObject->gdiFont);
1040
1041 InterlockedIncrement(&ifont_cnt);
1042
1043 newObject->pPropertyNotifyCP = NULL;
1044 newObject->pFontEventsCP = NULL;
1045 CreateConnectionPoint((IUnknown*)newObject, &IID_IPropertyNotifySink, &newObject->pPropertyNotifyCP);
1046 CreateConnectionPoint((IUnknown*)newObject, &IID_IFontEventsDisp, &newObject->pFontEventsCP);
1047
1048 if (!newObject->pPropertyNotifyCP || !newObject->pFontEventsCP)
1049 {
1050 OLEFontImpl_Destroy(newObject);
1051 return E_OUTOFMEMORY;
1052 }
1053
1054 /* The cloned object starts with a reference count of 1 */
1055 newObject->ref = 1;
1056
1057 *ppfont = &newObject->IFont_iface;
1058
1059 return S_OK;
1060 }
1061
1062 /************************************************************************
1063 * OLEFontImpl_IsEqual (IFont)
1064 */
1065 static HRESULT WINAPI OLEFontImpl_IsEqual(
1066 IFont* iface,
1067 IFont* pFontOther)
1068 {
1069 OLEFontImpl *left = impl_from_IFont(iface);
1070 OLEFontImpl *right = impl_from_IFont(pFontOther);
1071 INT ret;
1072 INT left_len,right_len;
1073
1074 if(pFontOther == NULL)
1075 return E_POINTER;
1076 else if (left->description.cySize.s.Lo != right->description.cySize.s.Lo)
1077 return S_FALSE;
1078 else if (left->description.cySize.s.Hi != right->description.cySize.s.Hi)
1079 return S_FALSE;
1080 else if (left->description.sWeight != right->description.sWeight)
1081 return S_FALSE;
1082 else if (left->description.sCharset != right->description.sCharset)
1083 return S_FALSE;
1084 else if (left->description.fItalic != right->description.fItalic)
1085 return S_FALSE;
1086 else if (left->description.fUnderline != right->description.fUnderline)
1087 return S_FALSE;
1088 else if (left->description.fStrikethrough != right->description.fStrikethrough)
1089 return S_FALSE;
1090
1091 /* Check from string */
1092 left_len = strlenW(left->description.lpstrName);
1093 right_len = strlenW(right->description.lpstrName);
1094 ret = CompareStringW(0,0,left->description.lpstrName, left_len,
1095 right->description.lpstrName, right_len);
1096 if (ret != CSTR_EQUAL)
1097 return S_FALSE;
1098
1099 return S_OK;
1100 }
1101
1102 /************************************************************************
1103 * OLEFontImpl_SetRatio (IFont)
1104 */
1105 static HRESULT WINAPI OLEFontImpl_SetRatio(
1106 IFont* iface,
1107 LONG cyLogical,
1108 LONG cyHimetric)
1109 {
1110 OLEFontImpl *this = impl_from_IFont(iface);
1111 TRACE("(%p)->(%d, %d)\n", this, cyLogical, cyHimetric);
1112
1113 if(cyLogical == 0 || cyHimetric == 0)
1114 return E_INVALIDARG;
1115
1116 this->cyLogical = cyLogical;
1117 this->cyHimetric = cyHimetric;
1118 this->dirty = TRUE;
1119
1120 return S_OK;
1121 }
1122
1123 /************************************************************************
1124 * OLEFontImpl_QueryTextMetrics (IFont)
1125 */
1126 static HRESULT WINAPI OLEFontImpl_QueryTextMetrics(
1127 IFont* iface,
1128 TEXTMETRICOLE* ptm)
1129 {
1130 HDC hdcRef;
1131 HFONT hOldFont, hNewFont;
1132
1133 hdcRef = GetDC(0);
1134 IFont_get_hFont(iface, &hNewFont);
1135 hOldFont = SelectObject(hdcRef, hNewFont);
1136 GetTextMetricsW(hdcRef, ptm);
1137 SelectObject(hdcRef, hOldFont);
1138 ReleaseDC(0, hdcRef);
1139 return S_OK;
1140 }
1141
1142 /************************************************************************
1143 * OLEFontImpl_AddRefHfont (IFont)
1144 */
1145 static HRESULT WINAPI OLEFontImpl_AddRefHfont(
1146 IFont* iface,
1147 HFONT hfont)
1148 {
1149 OLEFontImpl *this = impl_from_IFont(iface);
1150
1151 TRACE("(%p)->(%p)\n", this, hfont);
1152
1153 if (!hfont) return E_INVALIDARG;
1154
1155 return inc_ext_ref(hfont);
1156 }
1157
1158 /************************************************************************
1159 * OLEFontImpl_ReleaseHfont (IFont)
1160 */
1161 static HRESULT WINAPI OLEFontImpl_ReleaseHfont(
1162 IFont* iface,
1163 HFONT hfont)
1164 {
1165 OLEFontImpl *this = impl_from_IFont(iface);
1166
1167 TRACE("(%p)->(%p)\n", this, hfont);
1168
1169 if (!hfont) return E_INVALIDARG;
1170
1171 return dec_ext_ref(hfont);
1172 }
1173
1174 /************************************************************************
1175 * OLEFontImpl_SetHdc (IFont)
1176 */
1177 static HRESULT WINAPI OLEFontImpl_SetHdc(
1178 IFont* iface,
1179 HDC hdc)
1180 {
1181 OLEFontImpl *this = impl_from_IFont(iface);
1182 FIXME("(%p)->(%p): Stub\n", this, hdc);
1183 return E_NOTIMPL;
1184 }
1185
1186 static const IFontVtbl OLEFontImpl_VTable =
1187 {
1188 OLEFontImpl_QueryInterface,
1189 OLEFontImpl_AddRef,
1190 OLEFontImpl_Release,
1191 OLEFontImpl_get_Name,
1192 OLEFontImpl_put_Name,
1193 OLEFontImpl_get_Size,
1194 OLEFontImpl_put_Size,
1195 OLEFontImpl_get_Bold,
1196 OLEFontImpl_put_Bold,
1197 OLEFontImpl_get_Italic,
1198 OLEFontImpl_put_Italic,
1199 OLEFontImpl_get_Underline,
1200 OLEFontImpl_put_Underline,
1201 OLEFontImpl_get_Strikethrough,
1202 OLEFontImpl_put_Strikethrough,
1203 OLEFontImpl_get_Weight,
1204 OLEFontImpl_put_Weight,
1205 OLEFontImpl_get_Charset,
1206 OLEFontImpl_put_Charset,
1207 OLEFontImpl_get_hFont,
1208 OLEFontImpl_Clone,
1209 OLEFontImpl_IsEqual,
1210 OLEFontImpl_SetRatio,
1211 OLEFontImpl_QueryTextMetrics,
1212 OLEFontImpl_AddRefHfont,
1213 OLEFontImpl_ReleaseHfont,
1214 OLEFontImpl_SetHdc
1215 };
1216
1217 /************************************************************************
1218 * OLEFontImpl_IDispatch_QueryInterface (IUnknown)
1219 */
1220 static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(
1221 IDispatch* iface,
1222 REFIID riid,
1223 VOID** ppvoid)
1224 {
1225 OLEFontImpl *this = impl_from_IDispatch(iface);
1226 return IFont_QueryInterface(&this->IFont_iface, riid, ppvoid);
1227 }
1228
1229 /************************************************************************
1230 * OLEFontImpl_IDispatch_Release (IUnknown)
1231 */
1232 static ULONG WINAPI OLEFontImpl_IDispatch_Release(
1233 IDispatch* iface)
1234 {
1235 OLEFontImpl *this = impl_from_IDispatch(iface);
1236 return IFont_Release(&this->IFont_iface);
1237 }
1238
1239 /************************************************************************
1240 * OLEFontImpl_IDispatch_AddRef (IUnknown)
1241 */
1242 static ULONG WINAPI OLEFontImpl_IDispatch_AddRef(
1243 IDispatch* iface)
1244 {
1245 OLEFontImpl *this = impl_from_IDispatch(iface);
1246 return IFont_AddRef(&this->IFont_iface);
1247 }
1248
1249 /************************************************************************
1250 * OLEFontImpl_GetTypeInfoCount (IDispatch)
1251 */
1252 static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(
1253 IDispatch* iface,
1254 unsigned int* pctinfo)
1255 {
1256 OLEFontImpl *this = impl_from_IDispatch(iface);
1257 TRACE("(%p)->(%p)\n", this, pctinfo);
1258 *pctinfo = 1;
1259
1260 return S_OK;
1261 }
1262
1263 /************************************************************************
1264 * OLEFontImpl_GetTypeInfo (IDispatch)
1265 */
1266 static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
1267 IDispatch* iface,
1268 UINT iTInfo,
1269 LCID lcid,
1270 ITypeInfo** ppTInfo)
1271 {
1272 static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
1273 ITypeLib *tl;
1274 HRESULT hres;
1275
1276 OLEFontImpl *this = impl_from_IDispatch(iface);
1277 TRACE("(%p, iTInfo=%d, lcid=%04x, %p)\n", this, iTInfo, (int)lcid, ppTInfo);
1278 if (iTInfo != 0)
1279 return E_FAIL;
1280 hres = LoadTypeLib(stdole2tlb, &tl);
1281 if (FAILED(hres)) {
1282 ERR("Could not load the stdole2.tlb?\n");
1283 return hres;
1284 }
1285 hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IFontDisp, ppTInfo);
1286 ITypeLib_Release(tl);
1287 if (FAILED(hres)) {
1288 FIXME("Did not IDispatch typeinfo from typelib, hres %x\n",hres);
1289 }
1290 return hres;
1291 }
1292
1293 /************************************************************************
1294 * OLEFontImpl_GetIDsOfNames (IDispatch)
1295 */
1296 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(
1297 IDispatch* iface,
1298 REFIID riid,
1299 LPOLESTR* rgszNames,
1300 UINT cNames,
1301 LCID lcid,
1302 DISPID* rgDispId)
1303 {
1304 ITypeInfo * pTInfo;
1305 HRESULT hres;
1306
1307 OLEFontImpl *this = impl_from_IDispatch(iface);
1308
1309 TRACE("(%p,%s,%p,cNames=%d,lcid=%04x,%p)\n", this, debugstr_guid(riid),
1310 rgszNames, cNames, (int)lcid, rgDispId);
1311
1312 if (cNames == 0) return E_INVALIDARG;
1313
1314 hres = IDispatch_GetTypeInfo(iface, 0, lcid, &pTInfo);
1315 if (FAILED(hres))
1316 {
1317 ERR("GetTypeInfo failed.\n");
1318 return hres;
1319 }
1320
1321 /* convert names to DISPIDs */
1322 hres = DispGetIDsOfNames (pTInfo, rgszNames, cNames, rgDispId);
1323 ITypeInfo_Release(pTInfo);
1324
1325 return hres;
1326 }
1327
1328 /************************************************************************
1329 * OLEFontImpl_Invoke (IDispatch)
1330 *
1331 * Note: Do not call _put_Xxx methods, since setting things here
1332 * should not call notify functions as I found out debugging the generic
1333 * MS VB5 installer.
1334 */
1335 static HRESULT WINAPI OLEFontImpl_Invoke(
1336 IDispatch* iface,
1337 DISPID dispIdMember,
1338 REFIID riid,
1339 LCID lcid,
1340 WORD wFlags,
1341 DISPPARAMS* pDispParams,
1342 VARIANT* pVarResult,
1343 EXCEPINFO* pExepInfo,
1344 UINT* puArgErr)
1345 {
1346 OLEFontImpl *this = impl_from_IDispatch(iface);
1347 HRESULT hr;
1348
1349 TRACE("%p->(%d,%s,0x%x,0x%x,%p,%p,%p,%p)\n", this, dispIdMember,
1350 debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo,
1351 puArgErr);
1352
1353 /* validate parameters */
1354
1355 if (!IsEqualIID(riid, &IID_NULL))
1356 {
1357 ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
1358 return DISP_E_UNKNOWNINTERFACE;
1359 }
1360
1361 if (wFlags & DISPATCH_PROPERTYGET)
1362 {
1363 if (!pVarResult)
1364 {
1365 ERR("null pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
1366 return DISP_E_PARAMNOTOPTIONAL;
1367 }
1368 }
1369 else if (wFlags & DISPATCH_PROPERTYPUT)
1370 {
1371 if (!pDispParams)
1372 {
1373 ERR("null pDispParams not allowed when DISPATCH_PROPERTYPUT specified\n");
1374 return DISP_E_PARAMNOTOPTIONAL;
1375 }
1376 if (pDispParams->cArgs != 1)
1377 {
1378 ERR("param count for DISPATCH_PROPERTYPUT was %d instead of 1\n", pDispParams->cArgs);
1379 return DISP_E_BADPARAMCOUNT;
1380 }
1381 }
1382 else
1383 {
1384 ERR("one of DISPATCH_PROPERTYGET or DISPATCH_PROPERTYPUT must be specified\n");
1385 return DISP_E_MEMBERNOTFOUND;
1386 }
1387
1388 switch (dispIdMember) {
1389 case DISPID_FONT_NAME:
1390 if (wFlags & DISPATCH_PROPERTYGET) {
1391 V_VT(pVarResult) = VT_BSTR;
1392 return IFont_get_Name(&this->IFont_iface, &V_BSTR(pVarResult));
1393 } else {
1394 VARIANTARG vararg;
1395
1396 VariantInit(&vararg);
1397 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_BSTR);
1398 if (FAILED(hr))
1399 return hr;
1400
1401 hr = IFont_put_Name(&this->IFont_iface, V_BSTR(&vararg));
1402
1403 VariantClear(&vararg);
1404 return hr;
1405 }
1406 break;
1407 case DISPID_FONT_BOLD:
1408 if (wFlags & DISPATCH_PROPERTYGET) {
1409 BOOL value;
1410 hr = IFont_get_Bold(&this->IFont_iface, &value);
1411 V_VT(pVarResult) = VT_BOOL;
1412 V_BOOL(pVarResult) = value ? VARIANT_TRUE : VARIANT_FALSE;
1413 return hr;
1414 } else {
1415 VARIANTARG vararg;
1416
1417 VariantInit(&vararg);
1418 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_BOOL);
1419 if (FAILED(hr))
1420 return hr;
1421
1422 hr = IFont_put_Bold(&this->IFont_iface, V_BOOL(&vararg));
1423
1424 VariantClear(&vararg);
1425 return hr;
1426 }
1427 break;
1428 case DISPID_FONT_ITALIC:
1429 if (wFlags & DISPATCH_PROPERTYGET) {
1430 BOOL value;
1431 hr = IFont_get_Italic(&this->IFont_iface, &value);
1432 V_VT(pVarResult) = VT_BOOL;
1433 V_BOOL(pVarResult) = value ? VARIANT_TRUE : VARIANT_FALSE;
1434 return hr;
1435 } else {
1436 VARIANTARG vararg;
1437
1438 VariantInit(&vararg);
1439 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_BOOL);
1440 if (FAILED(hr))
1441 return hr;
1442
1443 hr = IFont_put_Italic(&this->IFont_iface, V_BOOL(&vararg));
1444
1445 VariantClear(&vararg);
1446 return hr;
1447 }
1448 break;
1449 case DISPID_FONT_UNDER:
1450 if (wFlags & DISPATCH_PROPERTYGET) {
1451 BOOL value;
1452 hr = IFont_get_Underline(&this->IFont_iface, &value);
1453 V_VT(pVarResult) = VT_BOOL;
1454 V_BOOL(pVarResult) = value ? VARIANT_TRUE : VARIANT_FALSE;
1455 return hr;
1456 } else {
1457 VARIANTARG vararg;
1458
1459 VariantInit(&vararg);
1460 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_BOOL);
1461 if (FAILED(hr))
1462 return hr;
1463
1464 hr = IFont_put_Underline(&this->IFont_iface, V_BOOL(&vararg));
1465
1466 VariantClear(&vararg);
1467 return hr;
1468 }
1469 break;
1470 case DISPID_FONT_STRIKE:
1471 if (wFlags & DISPATCH_PROPERTYGET) {
1472 BOOL value;
1473 hr = IFont_get_Strikethrough(&this->IFont_iface, &value);
1474 V_VT(pVarResult) = VT_BOOL;
1475 V_BOOL(pVarResult) = value ? VARIANT_TRUE : VARIANT_FALSE;
1476 return hr;
1477 } else {
1478 VARIANTARG vararg;
1479
1480 VariantInit(&vararg);
1481 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_BOOL);
1482 if (FAILED(hr))
1483 return hr;
1484
1485 hr = IFont_put_Strikethrough(&this->IFont_iface, V_BOOL(&vararg));
1486
1487 VariantClear(&vararg);
1488 return hr;
1489 }
1490 break;
1491 case DISPID_FONT_SIZE:
1492 if (wFlags & DISPATCH_PROPERTYGET) {
1493 V_VT(pVarResult) = VT_CY;
1494 return IFont_get_Size(&this->IFont_iface, &V_CY(pVarResult));
1495 } else {
1496 VARIANTARG vararg;
1497
1498 VariantInit(&vararg);
1499 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_CY);
1500 if (FAILED(hr))
1501 return hr;
1502
1503 hr = IFont_put_Size(&this->IFont_iface, V_CY(&vararg));
1504
1505 VariantClear(&vararg);
1506 return hr;
1507 }
1508 break;
1509 case DISPID_FONT_WEIGHT:
1510 if (wFlags & DISPATCH_PROPERTYGET) {
1511 V_VT(pVarResult) = VT_I2;
1512 return IFont_get_Weight(&this->IFont_iface, &V_I2(pVarResult));
1513 } else {
1514 VARIANTARG vararg;
1515
1516 VariantInit(&vararg);
1517 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I2);
1518 if (FAILED(hr))
1519 return hr;
1520
1521 hr = IFont_put_Weight(&this->IFont_iface, V_I2(&vararg));
1522
1523 VariantClear(&vararg);
1524 return hr;
1525 }
1526 break;
1527 case DISPID_FONT_CHARSET:
1528 if (wFlags & DISPATCH_PROPERTYGET) {
1529 V_VT(pVarResult) = VT_I2;
1530 return OLEFontImpl_get_Charset(&this->IFont_iface, &V_I2(pVarResult));
1531 } else {
1532 VARIANTARG vararg;
1533
1534 VariantInit(&vararg);
1535 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I2);
1536 if (FAILED(hr))
1537 return hr;
1538
1539 hr = IFont_put_Charset(&this->IFont_iface, V_I2(&vararg));
1540
1541 VariantClear(&vararg);
1542 return hr;
1543 }
1544 break;
1545 default:
1546 ERR("member not found for dispid 0x%x\n", dispIdMember);
1547 return DISP_E_MEMBERNOTFOUND;
1548 }
1549 }
1550
1551 static const IDispatchVtbl OLEFontImpl_IDispatch_VTable =
1552 {
1553 OLEFontImpl_IDispatch_QueryInterface,
1554 OLEFontImpl_IDispatch_AddRef,
1555 OLEFontImpl_IDispatch_Release,
1556 OLEFontImpl_GetTypeInfoCount,
1557 OLEFontImpl_GetTypeInfo,
1558 OLEFontImpl_GetIDsOfNames,
1559 OLEFontImpl_Invoke
1560 };
1561
1562 /************************************************************************
1563 * OLEFontImpl_IPersistStream_QueryInterface (IUnknown)
1564 */
1565 static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(
1566 IPersistStream* iface,
1567 REFIID riid,
1568 VOID** ppvoid)
1569 {
1570 OLEFontImpl *this = impl_from_IPersistStream(iface);
1571
1572 return IFont_QueryInterface(&this->IFont_iface, riid, ppvoid);
1573 }
1574
1575 /************************************************************************
1576 * OLEFontImpl_IPersistStream_Release (IUnknown)
1577 */
1578 static ULONG WINAPI OLEFontImpl_IPersistStream_Release(
1579 IPersistStream* iface)
1580 {
1581 OLEFontImpl *this = impl_from_IPersistStream(iface);
1582
1583 return IFont_Release(&this->IFont_iface);
1584 }
1585
1586 /************************************************************************
1587 * OLEFontImpl_IPersistStream_AddRef (IUnknown)
1588 */
1589 static ULONG WINAPI OLEFontImpl_IPersistStream_AddRef(
1590 IPersistStream* iface)
1591 {
1592 OLEFontImpl *this = impl_from_IPersistStream(iface);
1593
1594 return IFont_AddRef(&this->IFont_iface);
1595 }
1596
1597 /************************************************************************
1598 * OLEFontImpl_GetClassID (IPersistStream)
1599 */
1600 static HRESULT WINAPI OLEFontImpl_GetClassID(
1601 IPersistStream* iface,
1602 CLSID* pClassID)
1603 {
1604 TRACE("(%p,%p)\n",iface,pClassID);
1605 if (pClassID==0)
1606 return E_POINTER;
1607
1608 *pClassID = CLSID_StdFont;
1609
1610 return S_OK;
1611 }
1612
1613 /************************************************************************
1614 * OLEFontImpl_IsDirty (IPersistStream)
1615 *
1616 * See Windows documentation for more details on IPersistStream methods.
1617 */
1618 static HRESULT WINAPI OLEFontImpl_IsDirty(
1619 IPersistStream* iface)
1620 {
1621 TRACE("(%p)\n",iface);
1622 return S_OK;
1623 }
1624
1625 /************************************************************************
1626 * OLEFontImpl_Load (IPersistStream)
1627 *
1628 * See Windows documentation for more details on IPersistStream methods.
1629 *
1630 * This is the format of the standard font serialization as far as I
1631 * know
1632 *
1633 * Offset Type Value Comment
1634 * 0x0000 Byte Unknown Probably a version number, contains 0x01
1635 * 0x0001 Short Charset Charset value from the FONTDESC structure
1636 * 0x0003 Byte Attributes Flags defined as follows:
1637 * 00000010 - Italic
1638 * 00000100 - Underline
1639 * 00001000 - Strikethrough
1640 * 0x0004 Short Weight Weight value from FONTDESC structure
1641 * 0x0006 DWORD size "Low" portion of the cySize member of the FONTDESC
1642 * structure/
1643 * 0x000A Byte name length Length of the font name string (no null character)
1644 * 0x000B String name Name of the font (ASCII, no nul character)
1645 */
1646 static HRESULT WINAPI OLEFontImpl_Load(
1647 IPersistStream* iface,
1648 IStream* pLoadStream)
1649 {
1650 char readBuffer[0x100];
1651 ULONG cbRead;
1652 BYTE bVersion;
1653 BYTE bAttributes;
1654 BYTE bStringSize;
1655 INT len;
1656
1657 OLEFontImpl *this = impl_from_IPersistStream(iface);
1658
1659 /*
1660 * Read the version byte
1661 */
1662 IStream_Read(pLoadStream, &bVersion, 1, &cbRead);
1663
1664 if ( (cbRead!=1) ||
1665 (bVersion!=0x01) )
1666 return E_FAIL;
1667
1668 /*
1669 * Charset
1670 */
1671 IStream_Read(pLoadStream, &this->description.sCharset, 2, &cbRead);
1672
1673 if (cbRead!=2)
1674 return E_FAIL;
1675
1676 /*
1677 * Attributes
1678 */
1679 IStream_Read(pLoadStream, &bAttributes, 1, &cbRead);
1680
1681 if (cbRead!=1)
1682 return E_FAIL;
1683
1684 this->description.fItalic = (bAttributes & FONTPERSIST_ITALIC) != 0;
1685 this->description.fStrikethrough = (bAttributes & FONTPERSIST_STRIKETHROUGH) != 0;
1686 this->description.fUnderline = (bAttributes & FONTPERSIST_UNDERLINE) != 0;
1687
1688 /*
1689 * Weight
1690 */
1691 IStream_Read(pLoadStream, &this->description.sWeight, 2, &cbRead);
1692
1693 if (cbRead!=2)
1694 return E_FAIL;
1695
1696 /*
1697 * Size
1698 */
1699 IStream_Read(pLoadStream, &this->description.cySize.s.Lo, 4, &cbRead);
1700
1701 if (cbRead!=4)
1702 return E_FAIL;
1703
1704 this->description.cySize.s.Hi = 0;
1705
1706 /*
1707 * FontName
1708 */
1709 IStream_Read(pLoadStream, &bStringSize, 1, &cbRead);
1710
1711 if (cbRead!=1)
1712 return E_FAIL;
1713
1714 IStream_Read(pLoadStream, readBuffer, bStringSize, &cbRead);
1715
1716 if (cbRead!=bStringSize)
1717 return E_FAIL;
1718
1719 HeapFree(GetProcessHeap(), 0, this->description.lpstrName);
1720
1721 len = MultiByteToWideChar( CP_ACP, 0, readBuffer, bStringSize, NULL, 0 );
1722 this->description.lpstrName = HeapAlloc( GetProcessHeap(), 0, (len+1) * sizeof(WCHAR) );
1723 MultiByteToWideChar( CP_ACP, 0, readBuffer, bStringSize, this->description.lpstrName, len );
1724 this->description.lpstrName[len] = 0;
1725
1726 /* Ensure use of this font causes a new one to be created */
1727 dec_int_ref(this->gdiFont);
1728 this->gdiFont = 0;
1729 this->dirty = TRUE;
1730
1731 return S_OK;
1732 }
1733
1734 /************************************************************************
1735 * OLEFontImpl_Save (IPersistStream)
1736 */
1737 static HRESULT WINAPI OLEFontImpl_Save(
1738 IPersistStream* iface,
1739 IStream* pOutStream,
1740 BOOL fClearDirty)
1741 {
1742 char* writeBuffer = NULL;
1743 ULONG cbWritten;
1744 BYTE bVersion = 0x01;
1745 BYTE bAttributes;
1746 BYTE bStringSize;
1747
1748 OLEFontImpl *this = impl_from_IPersistStream(iface);
1749
1750 /*
1751 * Read the version byte
1752 */
1753 IStream_Write(pOutStream, &bVersion, 1, &cbWritten);
1754
1755 if (cbWritten!=1)
1756 return E_FAIL;
1757
1758 /*
1759 * Charset
1760 */
1761 IStream_Write(pOutStream, &this->description.sCharset, 2, &cbWritten);
1762
1763 if (cbWritten!=2)
1764 return E_FAIL;
1765
1766 /*
1767 * Attributes
1768 */
1769 bAttributes = 0;
1770
1771 if (this->description.fItalic)
1772 bAttributes |= FONTPERSIST_ITALIC;
1773
1774 if (this->description.fStrikethrough)
1775 bAttributes |= FONTPERSIST_STRIKETHROUGH;
1776
1777 if (this->description.fUnderline)
1778 bAttributes |= FONTPERSIST_UNDERLINE;
1779
1780 IStream_Write(pOutStream, &bAttributes, 1, &cbWritten);
1781
1782 if (cbWritten!=1)
1783 return E_FAIL;
1784
1785 /*
1786 * Weight
1787 */
1788 IStream_Write(pOutStream, &this->description.sWeight, 2, &cbWritten);
1789
1790 if (cbWritten!=2)
1791 return E_FAIL;
1792
1793 /*
1794 * Size
1795 */
1796 IStream_Write(pOutStream, &this->description.cySize.s.Lo, 4, &cbWritten);
1797
1798 if (cbWritten!=4)
1799 return E_FAIL;
1800
1801 /*
1802 * FontName
1803 */
1804 if (this->description.lpstrName!=0)
1805 bStringSize = WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
1806 strlenW(this->description.lpstrName), NULL, 0, NULL, NULL );
1807 else
1808 bStringSize = 0;
1809
1810 IStream_Write(pOutStream, &bStringSize, 1, &cbWritten);
1811
1812 if (cbWritten!=1)
1813 return E_FAIL;
1814
1815 if (bStringSize!=0)
1816 {
1817 if (!(writeBuffer = HeapAlloc( GetProcessHeap(), 0, bStringSize ))) return E_OUTOFMEMORY;
1818 WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
1819 strlenW(this->description.lpstrName),
1820 writeBuffer, bStringSize, NULL, NULL );
1821
1822 IStream_Write(pOutStream, writeBuffer, bStringSize, &cbWritten);
1823 HeapFree(GetProcessHeap(), 0, writeBuffer);
1824
1825 if (cbWritten!=bStringSize)
1826 return E_FAIL;
1827 }
1828
1829 return S_OK;
1830 }
1831
1832 /************************************************************************
1833 * OLEFontImpl_GetSizeMax (IPersistStream)
1834 */
1835 static HRESULT WINAPI OLEFontImpl_GetSizeMax(
1836 IPersistStream* iface,
1837 ULARGE_INTEGER* pcbSize)
1838 {
1839 OLEFontImpl *this = impl_from_IPersistStream(iface);
1840
1841 if (pcbSize==NULL)
1842 return E_POINTER;
1843
1844 pcbSize->u.HighPart = 0;
1845 pcbSize->u.LowPart = 0;
1846
1847 pcbSize->u.LowPart += sizeof(BYTE); /* Version */
1848 pcbSize->u.LowPart += sizeof(WORD); /* Lang code */
1849 pcbSize->u.LowPart += sizeof(BYTE); /* Flags */
1850 pcbSize->u.LowPart += sizeof(WORD); /* Weight */
1851 pcbSize->u.LowPart += sizeof(DWORD); /* Size */
1852 pcbSize->u.LowPart += sizeof(BYTE); /* StrLength */
1853
1854 if (this->description.lpstrName!=0)
1855 pcbSize->u.LowPart += WideCharToMultiByte( CP_ACP, 0, this->description.lpstrName,
1856 strlenW(this->description.lpstrName),
1857 NULL, 0, NULL, NULL );
1858
1859 return S_OK;
1860 }
1861
1862 static const IPersistStreamVtbl OLEFontImpl_IPersistStream_VTable =
1863 {
1864 OLEFontImpl_IPersistStream_QueryInterface,
1865 OLEFontImpl_IPersistStream_AddRef,
1866 OLEFontImpl_IPersistStream_Release,
1867 OLEFontImpl_GetClassID,
1868 OLEFontImpl_IsDirty,
1869 OLEFontImpl_Load,
1870 OLEFontImpl_Save,
1871 OLEFontImpl_GetSizeMax
1872 };
1873
1874 /************************************************************************
1875 * OLEFontImpl_IConnectionPointContainer_QueryInterface (IUnknown)
1876 */
1877 static HRESULT WINAPI OLEFontImpl_IConnectionPointContainer_QueryInterface(
1878 IConnectionPointContainer* iface,
1879 REFIID riid,
1880 VOID** ppvoid)
1881 {
1882 OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
1883
1884 return IFont_QueryInterface(&this->IFont_iface, riid, ppvoid);
1885 }
1886
1887 /************************************************************************
1888 * OLEFontImpl_IConnectionPointContainer_Release (IUnknown)
1889 */
1890 static ULONG WINAPI OLEFontImpl_IConnectionPointContainer_Release(
1891 IConnectionPointContainer* iface)
1892 {
1893 OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
1894
1895 return IFont_Release(&this->IFont_iface);
1896 }
1897
1898 /************************************************************************
1899 * OLEFontImpl_IConnectionPointContainer_AddRef (IUnknown)
1900 */
1901 static ULONG WINAPI OLEFontImpl_IConnectionPointContainer_AddRef(
1902 IConnectionPointContainer* iface)
1903 {
1904 OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
1905
1906 return IFont_AddRef(&this->IFont_iface);
1907 }
1908
1909 /************************************************************************
1910 * OLEFontImpl_EnumConnectionPoints (IConnectionPointContainer)
1911 */
1912 static HRESULT WINAPI OLEFontImpl_EnumConnectionPoints(
1913 IConnectionPointContainer* iface,
1914 IEnumConnectionPoints **ppEnum)
1915 {
1916 OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
1917
1918 FIXME("(%p)->(%p): stub\n", this, ppEnum);
1919 return E_NOTIMPL;
1920 }
1921
1922 /************************************************************************
1923 * OLEFontImpl_FindConnectionPoint (IConnectionPointContainer)
1924 */
1925 static HRESULT WINAPI OLEFontImpl_FindConnectionPoint(
1926 IConnectionPointContainer* iface,
1927 REFIID riid,
1928 IConnectionPoint **ppCp)
1929 {
1930 OLEFontImpl *this = impl_from_IConnectionPointContainer(iface);
1931 TRACE("(%p)->(%s, %p)\n", this, debugstr_guid(riid), ppCp);
1932
1933 if(IsEqualIID(riid, &IID_IPropertyNotifySink)) {
1934 return IConnectionPoint_QueryInterface(this->pPropertyNotifyCP,
1935 &IID_IConnectionPoint,
1936 (LPVOID)ppCp);
1937 } else if(IsEqualIID(riid, &IID_IFontEventsDisp)) {
1938 return IConnectionPoint_QueryInterface(this->pFontEventsCP,
1939 &IID_IConnectionPoint,
1940 (LPVOID)ppCp);
1941 } else {
1942 FIXME("no connection point for %s\n", debugstr_guid(riid));
1943 return CONNECT_E_NOCONNECTION;
1944 }
1945 }
1946
1947 static const IConnectionPointContainerVtbl
1948 OLEFontImpl_IConnectionPointContainer_VTable =
1949 {
1950 OLEFontImpl_IConnectionPointContainer_QueryInterface,
1951 OLEFontImpl_IConnectionPointContainer_AddRef,
1952 OLEFontImpl_IConnectionPointContainer_Release,
1953 OLEFontImpl_EnumConnectionPoints,
1954 OLEFontImpl_FindConnectionPoint
1955 };
1956
1957 /************************************************************************
1958 * OLEFontImpl implementation of IPersistPropertyBag.
1959 */
1960 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_QueryInterface(
1961 IPersistPropertyBag *iface, REFIID riid, LPVOID *ppvObj
1962 ) {
1963 OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
1964 return IFont_QueryInterface(&this->IFont_iface,riid,ppvObj);
1965 }
1966
1967 static ULONG WINAPI OLEFontImpl_IPersistPropertyBag_AddRef(
1968 IPersistPropertyBag *iface
1969 ) {
1970 OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
1971 return IFont_AddRef(&this->IFont_iface);
1972 }
1973
1974 static ULONG WINAPI OLEFontImpl_IPersistPropertyBag_Release(
1975 IPersistPropertyBag *iface
1976 ) {
1977 OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
1978 return IFont_Release(&this->IFont_iface);
1979 }
1980
1981 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_GetClassID(
1982 IPersistPropertyBag *iface, CLSID *classid
1983 ) {
1984 FIXME("(%p,%p), stub!\n", iface, classid);
1985 return E_FAIL;
1986 }
1987
1988 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_InitNew(
1989 IPersistPropertyBag *iface
1990 ) {
1991 FIXME("(%p), stub!\n", iface);
1992 return S_OK;
1993 }
1994
1995 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Load(
1996 IPersistPropertyBag *iface, IPropertyBag* pPropBag, IErrorLog* pErrorLog
1997 ) {
1998 /* (from Visual Basic 6 property bag)
1999 Name = "MS Sans Serif"
2000 Size = 13.8
2001 Charset = 0
2002 Weight = 400
2003 Underline = 0 'False
2004 Italic = 0 'False
2005 Strikethrough = 0 'False
2006 */
2007 static const WCHAR sAttrName[] = {'N','a','m','e',0};
2008 static const WCHAR sAttrSize[] = {'S','i','z','e',0};
2009 static const WCHAR sAttrCharset[] = {'C','h','a','r','s','e','t',0};
2010 static const WCHAR sAttrWeight[] = {'W','e','i','g','h','t',0};
2011 static const WCHAR sAttrUnderline[] = {'U','n','d','e','r','l','i','n','e',0};
2012 static const WCHAR sAttrItalic[] = {'I','t','a','l','i','c',0};
2013 static const WCHAR sAttrStrikethrough[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
2014 OLEFontImpl *this = impl_from_IPersistPropertyBag(iface);
2015 VARIANT value;
2016 HRESULT iRes;
2017
2018 VariantInit(&value);
2019
2020 iRes = IPropertyBag_Read(pPropBag, sAttrName, &value, pErrorLog);
2021 if (iRes == S_OK)
2022 {
2023 iRes = VariantChangeType(&value, &value, 0, VT_BSTR);
2024 if (iRes == S_OK)
2025 iRes = IFont_put_Name(&this->IFont_iface, V_BSTR(&value));
2026 }
2027 else if (iRes == E_INVALIDARG)
2028 iRes = S_OK;
2029
2030 VariantClear(&value);
2031
2032 if (iRes == S_OK) {
2033 iRes = IPropertyBag_Read(pPropBag, sAttrSize, &value, pErrorLog);
2034 if (iRes == S_OK)
2035 {
2036 iRes = VariantChangeType(&value, &value, 0, VT_CY);
2037 if (iRes == S_OK)
2038 iRes = IFont_put_Size(&this->IFont_iface, V_CY(&value));
2039 }
2040 else if (iRes == E_INVALIDARG)
2041 iRes = S_OK;
2042
2043 VariantClear(&value);
2044 }
2045
2046 if (iRes == S_OK) {
2047 iRes = IPropertyBag_Read(pPropBag, sAttrCharset, &value, pErrorLog);
2048 if (iRes == S_OK)
2049 {
2050 iRes = VariantChangeType(&value, &value, 0, VT_I2);
2051 if (iRes == S_OK)
2052 iRes = IFont_put_Charset(&this->IFont_iface, V_I2(&value));
2053 }
2054 else if (iRes == E_INVALIDARG)
2055 iRes = S_OK;
2056
2057 VariantClear(&value);
2058 }
2059
2060 if (iRes == S_OK) {
2061 iRes = IPropertyBag_Read(pPropBag, sAttrWeight, &value, pErrorLog);
2062 if (iRes == S_OK)
2063 {
2064 iRes = VariantChangeType(&value, &value, 0, VT_I2);
2065 if (iRes == S_OK)
2066 iRes = IFont_put_Weight(&this->IFont_iface, V_I2(&value));
2067 }
2068 else if (iRes == E_INVALIDARG)
2069 iRes = S_OK;
2070
2071 VariantClear(&value);
2072 }
2073
2074 if (iRes == S_OK) {
2075 iRes = IPropertyBag_Read(pPropBag, sAttrUnderline, &value, pErrorLog);
2076 if (iRes == S_OK)
2077 {
2078 iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
2079 if (iRes == S_OK)
2080 iRes = IFont_put_Underline(&this->IFont_iface, V_BOOL(&value));
2081 }
2082 else if (iRes == E_INVALIDARG)
2083 iRes = S_OK;
2084
2085 VariantClear(&value);
2086 }
2087
2088 if (iRes == S_OK) {
2089 iRes = IPropertyBag_Read(pPropBag, sAttrItalic, &value, pErrorLog);
2090 if (iRes == S_OK)
2091 {
2092 iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
2093 if (iRes == S_OK)
2094 iRes = IFont_put_Italic(&this->IFont_iface, V_BOOL(&value));
2095 }
2096 else if (iRes == E_INVALIDARG)
2097 iRes = S_OK;
2098
2099 VariantClear(&value);
2100 }
2101
2102 if (iRes == S_OK) {
2103 iRes = IPropertyBag_Read(pPropBag, sAttrStrikethrough, &value, pErrorLog);
2104 if (iRes == S_OK)
2105 {
2106 iRes = VariantChangeType(&value, &value, 0, VT_BOOL);
2107 if (iRes == S_OK)
2108 IFont_put_Strikethrough(&this->IFont_iface, V_BOOL(&value));
2109 }
2110 else if (iRes == E_INVALIDARG)
2111 iRes = S_OK;
2112
2113 VariantClear(&value);
2114 }
2115
2116 if (FAILED(iRes))
2117 WARN("-- 0x%08x\n", iRes);
2118 return iRes;
2119 }
2120
2121 static HRESULT WINAPI OLEFontImpl_IPersistPropertyBag_Save(
2122 IPersistPropertyBag *iface, IPropertyBag* pPropBag, BOOL fClearDirty,
2123 BOOL fSaveAllProperties
2124 ) {
2125 FIXME("(%p,%p,%d,%d), stub!\n", iface, pPropBag, fClearDirty, fSaveAllProperties);
2126 return E_FAIL;
2127 }
2128
2129 static const IPersistPropertyBagVtbl OLEFontImpl_IPersistPropertyBag_VTable =
2130 {
2131 OLEFontImpl_IPersistPropertyBag_QueryInterface,
2132 OLEFontImpl_IPersistPropertyBag_AddRef,
2133 OLEFontImpl_IPersistPropertyBag_Release,
2134
2135 OLEFontImpl_IPersistPropertyBag_GetClassID,
2136 OLEFontImpl_IPersistPropertyBag_InitNew,
2137 OLEFontImpl_IPersistPropertyBag_Load,
2138 OLEFontImpl_IPersistPropertyBag_Save
2139 };
2140
2141 /************************************************************************
2142 * OLEFontImpl implementation of IPersistStreamInit.
2143 */
2144 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_QueryInterface(
2145 IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj
2146 ) {
2147 OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
2148 return IFont_QueryInterface(&this->IFont_iface,riid,ppvObj);
2149 }
2150
2151 static ULONG WINAPI OLEFontImpl_IPersistStreamInit_AddRef(
2152 IPersistStreamInit *iface
2153 ) {
2154 OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
2155 return IFont_AddRef(&this->IFont_iface);
2156 }
2157
2158 static ULONG WINAPI OLEFontImpl_IPersistStreamInit_Release(
2159 IPersistStreamInit *iface
2160 ) {
2161 OLEFontImpl *this = impl_from_IPersistStreamInit(iface);
2162 return IFont_Release(&this->IFont_iface);
2163 }
2164
2165 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetClassID(
2166 IPersistStreamInit *iface, CLSID *classid
2167 ) {
2168 FIXME("(%p,%p), stub!\n", iface, classid);
2169 return E_FAIL;
2170 }
2171
2172 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_IsDirty(
2173 IPersistStreamInit *iface
2174 ) {
2175 FIXME("(%p), stub!\n", iface);
2176 return E_FAIL;
2177 }
2178
2179 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Load(
2180 IPersistStreamInit *iface, LPSTREAM pStm
2181 ) {
2182 FIXME("(%p,%p), stub!\n", iface, pStm);
2183 return E_FAIL;
2184 }
2185
2186 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_Save(
2187 IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty
2188 ) {
2189 FIXME("(%p,%p,%d), stub!\n", iface, pStm, fClearDirty);
2190 return E_FAIL;
2191 }
2192
2193 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_GetSizeMax(
2194 IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize
2195 ) {
2196 FIXME("(%p,%p), stub!\n", iface, pcbSize);
2197 return E_FAIL;
2198 }
2199
2200 static HRESULT WINAPI OLEFontImpl_IPersistStreamInit_InitNew(
2201 IPersistStreamInit *iface
2202 ) {
2203 FIXME("(%p), stub!\n", iface);
2204 return S_OK;
2205 }
2206
2207 static const IPersistStreamInitVtbl OLEFontImpl_IPersistStreamInit_VTable =
2208 {
2209 OLEFontImpl_IPersistStreamInit_QueryInterface,
2210 OLEFontImpl_IPersistStreamInit_AddRef,
2211 OLEFontImpl_IPersistStreamInit_Release,
2212
2213 OLEFontImpl_IPersistStreamInit_GetClassID,
2214 OLEFontImpl_IPersistStreamInit_IsDirty,
2215 OLEFontImpl_IPersistStreamInit_Load,
2216 OLEFontImpl_IPersistStreamInit_Save,
2217 OLEFontImpl_IPersistStreamInit_GetSizeMax,
2218 OLEFontImpl_IPersistStreamInit_InitNew
2219 };
2220
2221 /************************************************************************
2222 * OLEFontImpl_Construct
2223 *
2224 * This method will construct a new instance of the OLEFontImpl
2225 * class.
2226 *
2227 * The caller of this method must release the object when it's
2228 * done with it.
2229 */
2230 static OLEFontImpl* OLEFontImpl_Construct(const FONTDESC *fontDesc)
2231 {
2232 OLEFontImpl* newObject;
2233
2234 newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
2235
2236 if (newObject==0)
2237 return newObject;
2238
2239 newObject->IFont_iface.lpVtbl = &OLEFontImpl_VTable;
2240 newObject->IDispatch_iface.lpVtbl = &OLEFontImpl_IDispatch_VTable;
2241 newObject->IPersistStream_iface.lpVtbl = &OLEFontImpl_IPersistStream_VTable;
2242 newObject->IConnectionPointContainer_iface.lpVtbl = &OLEFontImpl_IConnectionPointContainer_VTable;
2243 newObject->IPersistPropertyBag_iface.lpVtbl = &OLEFontImpl_IPersistPropertyBag_VTable;
2244 newObject->IPersistStreamInit_iface.lpVtbl = &OLEFontImpl_IPersistStreamInit_VTable;
2245
2246 newObject->ref = 1;
2247
2248 newObject->description.cbSizeofstruct = sizeof(FONTDESC);
2249 newObject->description.lpstrName = HeapAlloc(GetProcessHeap(),
2250 0,
2251 (lstrlenW(fontDesc->lpstrName)+1) * sizeof(WCHAR));
2252 strcpyW(newObject->description.lpstrName, fontDesc->lpstrName);
2253 newObject->description.cySize = fontDesc->cySize;
2254 newObject->description.sWeight = fontDesc->sWeight;
2255 newObject->description.sCharset = fontDesc->sCharset;
2256 newObject->description.fItalic = fontDesc->fItalic;
2257 newObject->description.fUnderline = fontDesc->fUnderline;
2258 newObject->description.fStrikethrough = fontDesc->fStrikethrough;
2259
2260 newObject->gdiFont = 0;
2261 newObject->dirty = TRUE;
2262 newObject->cyLogical = GetDeviceCaps(get_dc(), LOGPIXELSY);
2263 newObject->cyHimetric = 2540L;
2264 newObject->pPropertyNotifyCP = NULL;
2265 newObject->pFontEventsCP = NULL;
2266
2267 CreateConnectionPoint((IUnknown*)newObject, &IID_IPropertyNotifySink, &newObject->pPropertyNotifyCP);
2268 CreateConnectionPoint((IUnknown*)newObject, &IID_IFontEventsDisp, &newObject->pFontEventsCP);
2269
2270 if (!newObject->pPropertyNotifyCP || !newObject->pFontEventsCP)
2271 {
2272 OLEFontImpl_Destroy(newObject);
2273 return NULL;
2274 }
2275
2276 InterlockedIncrement(&ifont_cnt);
2277
2278 TRACE("returning %p\n", newObject);
2279 return newObject;
2280 }
2281
2282 /************************************************************************
2283 * OLEFontImpl_Destroy
2284 *
2285 * This method is called by the Release method when the reference
2286 * count goes down to 0. It will free all resources used by
2287 * this object.
2288 */
2289 static void OLEFontImpl_Destroy(OLEFontImpl* fontDesc)
2290 {
2291 TRACE("(%p)\n", fontDesc);
2292
2293 HeapFree(GetProcessHeap(), 0, fontDesc->description.lpstrName);
2294
2295 if (fontDesc->pPropertyNotifyCP)
2296 IConnectionPoint_Release(fontDesc->pPropertyNotifyCP);
2297 if (fontDesc->pFontEventsCP)
2298 IConnectionPoint_Release(fontDesc->pFontEventsCP);
2299
2300 HeapFree(GetProcessHeap(), 0, fontDesc);
2301 }
2302
2303 /*******************************************************************************
2304 * StdFont ClassFactory
2305 */
2306 typedef struct
2307 {
2308 /* IUnknown fields */
2309 IClassFactory IClassFactory_iface;
2310 LONG ref;
2311 } IClassFactoryImpl;
2312
2313 static inline IClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
2314 {
2315 return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
2316 }
2317
2318 static HRESULT WINAPI
2319 SFCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
2320 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2321
2322 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
2323 return E_NOINTERFACE;
2324 }
2325
2326 static ULONG WINAPI
2327 SFCF_AddRef(LPCLASSFACTORY iface) {
2328 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2329 return InterlockedIncrement(&This->ref);
2330 }
2331
2332 static ULONG WINAPI SFCF_Release(LPCLASSFACTORY iface) {
2333 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2334 /* static class, won't be freed */
2335 return InterlockedDecrement(&This->ref);
2336 }
2337
2338 static HRESULT WINAPI SFCF_CreateInstance(
2339 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
2340 ) {
2341 return OleCreateFontIndirect(NULL,riid,ppobj);
2342
2343 }
2344
2345 static HRESULT WINAPI SFCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
2346 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2347 FIXME("(%p)->(%d),stub!\n",This,dolock);
2348 return S_OK;
2349 }
2350
2351 static const IClassFactoryVtbl SFCF_Vtbl = {
2352 SFCF_QueryInterface,
2353 SFCF_AddRef,
2354 SFCF_Release,
2355 SFCF_CreateInstance,
2356 SFCF_LockServer
2357 };
2358 static IClassFactoryImpl STDFONT_CF = {{&SFCF_Vtbl}, 1 };
2359
2360 void _get_STDFONT_CF(LPVOID *ppv) { *ppv = &STDFONT_CF; }
Maarten's multimedia branch