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