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