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