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