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