ole/olefont.c

   1 /*
   2  * OLE Font encapsulation implementation
   3  *
   4  * This file contains an implementation of the IFont
   5  * interface and the OleCreateFontIndirect API call.
   6  *
   7  * Copyright 1999 Francis Beaudet
   8  */
   9 #include <assert.h>
  10 #include <string.h>
  11 #include "winerror.h"
  12 #include "oleauto.h"
  13 #include "ocidl.h"
  14 #include "olectl.h"
  15 #include "debug.h"
  16 #include "heap.h"
  17
  18 DEFAULT_DEBUG_CHANNEL(ole)
  19
  20 /***********************************************************************
  21  * Declaration of constants used when serializing the font object.
  22  */
  23 #define FONTPERSIST_ITALIC        0x02
  24 #define FONTPERSIST_UNDERLINE     0x04
  25 #define FONTPERSIST_STRIKETHROUGH 0x08
  26
  27 /***********************************************************************
  28  * Declaration of the implementation class for the IFont interface
  29  */
  30 typedef struct OLEFontImpl OLEFontImpl;
  31
  32 struct OLEFontImpl
  33 {
  34   /*
  35    * This class supports many interfaces. IUnknown, IFont,
  36    * IDispatch, IDispFont and IPersistStream. The first two are
  37    * supported by the first vtablem the next two are supported by
  38    * the second table and the last one has it's own.
  39    */
  40   ICOM_VTABLE(IFont)*     lpvtbl1;
  41   ICOM_VTABLE(IDispatch)* lpvtbl2;
  42   ICOM_VTABLE(IPersistStream)*            lpvtbl3;
  43
  44   /*
  45    * Reference count for that instance of the class.
  46    */
  47   ULONG ref;
  48
  49   /*
  50    * This structure contains the description of the class.
  51    */
  52   FONTDESC description;
  53
  54   /*
  55    * Contain the font associated with this object.
  56    */
  57   HFONT gdiFont;
  58
  59   /*
  60    * Font lock count.
  61    */
  62   DWORD fontLock;
  63
  64   /*
  65    * Size ratio
  66    */
  67   long cyLogical;
  68   long cyHimetric;
  69 };
  70
  71 /*
  72  * Here, I define utility macros to help with the casting of the
  73  * "this" parameter.
  74  * There is a version to accomodate all of the VTables implemented
  75  * by this object.
  76  */
  77 #define _ICOM_THIS(class,name) class* this = (class*)name;
  78 #define _ICOM_THIS_From_IDispatch(class, name) class* this = (class*)(((char*)name)-sizeof(void*));
  79 #define _ICOM_THIS_From_IPersistStream(class, name) class* this = (class*)(((char*)name)-2*sizeof(void*));
  80
  81 /***********************************************************************
  82  * Prototypes for the implementation functions for the IFont
  83  * interface
  84  */
  85 static OLEFontImpl* OLEFontImpl_Construct(LPFONTDESC fontDesc);
  86 static void         OLEFontImpl_Destroy(OLEFontImpl* fontDesc);
  87 static HRESULT      WINAPI OLEFontImpl_QueryInterface(IFont* iface, REFIID riid, VOID** ppvoid);
  88 static ULONG        WINAPI OLEFontImpl_AddRef(IFont* iface);
  89 static ULONG        WINAPI OLEFontImpl_Release(IFont* iface);
  90 static HRESULT      WINAPI OLEFontImpl_get_Name(IFont* iface, BSTR* pname);
  91 static HRESULT      WINAPI OLEFontImpl_put_Name(IFont* iface, BSTR name);
  92 static HRESULT      WINAPI OLEFontImpl_get_Size(IFont* iface, CY* psize);
  93 static HRESULT      WINAPI OLEFontImpl_put_Size(IFont* iface, CY size);
  94 static HRESULT      WINAPI OLEFontImpl_get_Bold(IFont* iface, BOOL* pbold);
  95 static HRESULT      WINAPI OLEFontImpl_put_Bold(IFont* iface, BOOL bold);
  96 static HRESULT      WINAPI OLEFontImpl_get_Italic(IFont* iface, BOOL* pitalic);
  97 static HRESULT      WINAPI OLEFontImpl_put_Italic(IFont* iface, BOOL italic);
  98 static HRESULT      WINAPI OLEFontImpl_get_Underline(IFont* iface, BOOL* punderline);
  99 static HRESULT      WINAPI OLEFontImpl_put_Underline(IFont* iface, BOOL underline);
 100 static HRESULT      WINAPI OLEFontImpl_get_Strikethrough(IFont* iface, BOOL* pstrikethrough);
 101 static HRESULT      WINAPI OLEFontImpl_put_Strikethrough(IFont* iface, BOOL strikethrough);
 102 static HRESULT      WINAPI OLEFontImpl_get_Weight(IFont* iface, short* pweight);
 103 static HRESULT      WINAPI OLEFontImpl_put_Weight(IFont* iface, short weight);
 104 static HRESULT      WINAPI OLEFontImpl_get_Charset(IFont* iface, short* pcharset);
 105 static HRESULT      WINAPI OLEFontImpl_put_Charset(IFont* iface, short charset);
 106 static HRESULT      WINAPI OLEFontImpl_get_hFont(IFont* iface, HFONT* phfont);
 107 static HRESULT      WINAPI OLEFontImpl_Clone(IFont* iface, IFont** ppfont);
 108 static HRESULT      WINAPI OLEFontImpl_IsEqual(IFont* iface, IFont* pFontOther);
 109 static HRESULT      WINAPI OLEFontImpl_SetRatio(IFont* iface, long cyLogical, long cyHimetric);
 110 static HRESULT      WINAPI OLEFontImpl_QueryTextMetrics(IFont* iface, TEXTMETRICOLE* ptm);
 111 static HRESULT      WINAPI OLEFontImpl_AddRefHfont(IFont* iface, HFONT hfont);
 112 static HRESULT      WINAPI OLEFontImpl_ReleaseHfont(IFont* iface, HFONT hfont);
 113 static HRESULT      WINAPI OLEFontImpl_SetHdc(IFont* iface, HDC hdc);
 114
 115 /***********************************************************************
 116  * Prototypes for the implementation functions for the IDispatch
 117  * interface
 118  */
 119 static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(IDispatch* iface,
 120                                                     REFIID     riid,
 121                                                     VOID**     ppvoid);
 122 static ULONG   WINAPI OLEFontImpl_IDispatch_AddRef(IDispatch* iface);
 123 static ULONG   WINAPI OLEFontImpl_IDispatch_Release(IDispatch* iface);
 124 static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(IDispatch*    iface,
 125                                                    unsigned int* pctinfo);
 126 static HRESULT WINAPI OLEFontImpl_GetTypeInfo(IDispatch*  iface,
 127                                               UINT      iTInfo,
 128                                               LCID        lcid,
 129                                               ITypeInfo** ppTInfo);
 130 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(IDispatch*  iface,
 131                                                 REFIID      riid,
 132                                                 LPOLESTR* rgszNames,
 133                                                 UINT      cNames,
 134                                                 LCID        lcid,
 135                                                 DISPID*     rgDispId);
 136 static HRESULT WINAPI OLEFontImpl_Invoke(IDispatch*  iface,
 137                                          DISPID      dispIdMember,
 138                                          REFIID      riid,
 139                                          LCID        lcid,
 140                                          WORD        wFlags,
 141                                          DISPPARAMS* pDispParams,
 142                                          VARIANT*    pVarResult,
 143                                          EXCEPINFO*  pExepInfo,
 144                                          UINT*     puArgErr);
 145
 146 /***********************************************************************
 147  * Prototypes for the implementation functions for the IPersistStream
 148  * interface
 149  */
 150 static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(IPersistStream* iface,
 151                                                     REFIID     riid,
 152                                                     VOID**     ppvoid);
 153 static ULONG   WINAPI OLEFontImpl_IPersistStream_AddRef(IPersistStream* iface);
 154 static ULONG   WINAPI OLEFontImpl_IPersistStream_Release(IPersistStream* iface);
 155 static HRESULT WINAPI OLEFontImpl_GetClassID(const IPersistStream* iface,
 156                                              CLSID*                pClassID);
 157 static HRESULT WINAPI OLEFontImpl_IsDirty(IPersistStream*  iface);
 158 static HRESULT WINAPI OLEFontImpl_Load(IPersistStream*  iface,
 159                                        IStream*         pLoadStream);
 160 static HRESULT WINAPI OLEFontImpl_Save(IPersistStream*  iface,
 161                                        IStream*         pOutStream,
 162                                        BOOL             fClearDirty);
 163 static HRESULT WINAPI OLEFontImpl_GetSizeMax(IPersistStream*  iface,
 164                                              ULARGE_INTEGER*  pcbSize);
 165
 166 /*
 167  * Virtual function tables for the OLEFontImpl class.
 168  */
 169 static ICOM_VTABLE(IFont) OLEFontImpl_VTable =
 170 {
 171   OLEFontImpl_QueryInterface,
 172   OLEFontImpl_AddRef,
 173   OLEFontImpl_Release,
 174   OLEFontImpl_get_Name,
 175   OLEFontImpl_put_Name,
 176   OLEFontImpl_get_Size,
 177   OLEFontImpl_put_Size,
 178   OLEFontImpl_get_Bold,
 179   OLEFontImpl_put_Bold,
 180   OLEFontImpl_get_Italic,
 181   OLEFontImpl_put_Italic,
 182   OLEFontImpl_get_Underline,
 183   OLEFontImpl_put_Underline,
 184   OLEFontImpl_get_Strikethrough,
 185   OLEFontImpl_put_Strikethrough,
 186   OLEFontImpl_get_Weight,
 187   OLEFontImpl_put_Weight,
 188   OLEFontImpl_get_Charset,
 189   OLEFontImpl_put_Charset,
 190   OLEFontImpl_get_hFont,
 191   OLEFontImpl_Clone,
 192   OLEFontImpl_IsEqual,
 193   OLEFontImpl_SetRatio,
 194   OLEFontImpl_QueryTextMetrics,
 195   OLEFontImpl_AddRefHfont,
 196   OLEFontImpl_ReleaseHfont,
 197   OLEFontImpl_SetHdc
 198 };
 199
 200 static ICOM_VTABLE(IDispatch) OLEFontImpl_IDispatch_VTable =
 201 {
 202   OLEFontImpl_IDispatch_QueryInterface,
 203   OLEFontImpl_IDispatch_AddRef,
 204   OLEFontImpl_IDispatch_Release,
 205   OLEFontImpl_GetTypeInfoCount,
 206   OLEFontImpl_GetTypeInfo,
 207   OLEFontImpl_GetIDsOfNames,
 208   OLEFontImpl_Invoke
 209 };
 210
 211 static ICOM_VTABLE(IPersistStream) OLEFontImpl_IPersistStream_VTable =
 212 {
 213   OLEFontImpl_IPersistStream_QueryInterface,
 214   OLEFontImpl_IPersistStream_AddRef,
 215   OLEFontImpl_IPersistStream_Release,
 216   OLEFontImpl_GetClassID,
 217   OLEFontImpl_IsDirty,
 218   OLEFontImpl_Load,
 219   OLEFontImpl_Save,
 220   OLEFontImpl_GetSizeMax
 221 };
 222
 223 /******************************************************************************
 224  *              OleCreateFontIndirect   [OLEAUT32.420]
 225  */
 226 WINOLECTLAPI OleCreateFontIndirect(
 227   LPFONTDESC lpFontDesc,
 228   REFIID     riid,
 229   VOID**     ppvObj)
 230 {
 231   OLEFontImpl* newFont = 0;
 232   HRESULT      hr      = S_OK;
 233
 234   /*
 235    * Sanity check
 236    */
 237   if (ppvObj==0)
 238     return E_POINTER;
 239
 240   *ppvObj = 0;
 241
 242   /*
 243    * Try to construct a new instance of the class.
 244    */
 245   newFont = OLEFontImpl_Construct(lpFontDesc);
 246
 247   if (newFont == 0)
 248     return E_OUTOFMEMORY;
 249
 250   /*
 251    * Make sure it supports the interface required by the caller.
 252    */
 253   hr = IFont_QueryInterface((IFont*)newFont, riid, ppvObj);
 254
 255   /*
 256    * Release the reference obtained in the constructor. If
 257    * the QueryInterface was unsuccessful, it will free the class.
 258    */
 259   IFont_Release((IFont*)newFont);
 260
 261   return hr;
 262 }
 263
 264
 265 /***********************************************************************
 266  * Implementation of the OLEFontImpl class.
 267  */
 268
 269 /************************************************************************
 270  * OLEFontImpl_Construct
 271  *
 272  * This method will construct a new instance of the OLEFontImpl
 273  * class.
 274  *
 275  * The caller of this method must release the object when it's
 276  * done with it.
 277  */
 278 static OLEFontImpl* OLEFontImpl_Construct(LPFONTDESC fontDesc)
 279 {
 280   OLEFontImpl* newObject = 0;
 281
 282   /*
 283    * Allocate space for the object.
 284    */
 285   newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
 286
 287   if (newObject==0)
 288     return newObject;
 289
 290   /*
 291    * Initialize the virtual function table.
 292    */
 293   newObject->lpvtbl1 = &OLEFontImpl_VTable;
 294   newObject->lpvtbl2 = &OLEFontImpl_IDispatch_VTable;
 295   newObject->lpvtbl3 = &OLEFontImpl_IPersistStream_VTable;
 296
 297   /*
 298    * Start with one reference count. The caller of this function
 299    * must release the interface pointer when it is done.
 300    */
 301   newObject->ref = 1;
 302
 303   /*
 304    * Copy the description of the font in the object.
 305    */
 306   assert(fontDesc->cbSizeofstruct >= sizeof(FONTDESC));
 307
 308   newObject->description.cbSizeofstruct = sizeof(FONTDESC);
 309   newObject->description.lpstrName = HeapAlloc(GetProcessHeap(),
 310                                                0,
 311                                                (lstrlenW(fontDesc->lpstrName)+1) * sizeof(WCHAR));
 312   lstrcpyW(newObject->description.lpstrName, fontDesc->lpstrName);
 313   newObject->description.cySize         = fontDesc->cySize;
 314   newObject->description.sWeight        = fontDesc->sWeight;
 315   newObject->description.sCharset       = fontDesc->sCharset;
 316   newObject->description.fItalic        = fontDesc->fItalic;
 317   newObject->description.fUnderline     = fontDesc->fUnderline;
 318   newObject->description.fStrikethrough = fontDesc->fStrikethrough;
 319
 320   /*
 321    * Initializing all the other members.
 322    */
 323   newObject->gdiFont  = 0;
 324   newObject->fontLock = 0;
 325   newObject->cyHimetric = 1;
 326   newObject->cyLogical  = 1;
 327
 328   return newObject;
 329 }
 330
 331 /************************************************************************
 332  * OLEFontImpl_Construct
 333  *
 334  * This method is called by the Release method when the reference
 335  * count goes doen to 0. it will free all resources used by
 336  * this object.
 337  */
 338 static void OLEFontImpl_Destroy(OLEFontImpl* fontDesc)
 339 {
 340   if (fontDesc->description.lpstrName!=0)
 341     HeapFree(GetProcessHeap(), 0, fontDesc->description.lpstrName);
 342
 343   if (fontDesc->gdiFont!=0)
 344     DeleteObject(fontDesc->gdiFont);
 345
 346   HeapFree(GetProcessHeap(), 0, fontDesc);
 347 }
 348
 349 /************************************************************************
 350  * OLEFontImpl_QueryInterface (IUnknown)
 351  *
 352  * See Windows documentation for more details on IUnknown methods.
 353  */
 354 HRESULT WINAPI OLEFontImpl_QueryInterface(
 355   IFont*  iface,
 356   REFIID  riid,
 357   void**  ppvObject)
 358 {
 359   _ICOM_THIS(OLEFontImpl, iface);
 360
 361   /*
 362    * Perform a sanity check on the parameters.
 363    */
 364   if ( (this==0) || (ppvObject==0) )
 365     return E_INVALIDARG;
 366
 367   /*
 368    * Initialize the return parameter.
 369    */
 370   *ppvObject = 0;
 371
 372   /*
 373    * Compare the riid with the interface IDs implemented by this object.
 374    */
 375   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 376   {
 377     *ppvObject = (IFont*)this;
 378   }
 379   else if (memcmp(&IID_IFont, riid, sizeof(IID_IFont)) == 0)
 380   {
 381     *ppvObject = (IFont*)this;
 382   }
 383   else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
 384   {
 385     *ppvObject = (IDispatch*)&(this->lpvtbl2);
 386   }
 387   else if (memcmp(&IID_IFontDisp, riid, sizeof(IID_IFontDisp)) == 0)
 388   {
 389     *ppvObject = (IDispatch*)&(this->lpvtbl2);
 390   }
 391   else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
 392   {
 393     *ppvObject = (IPersistStream*)&(this->lpvtbl3);
 394   }
 395
 396   /*
 397    * Check that we obtained an interface.
 398    */
 399   if ((*ppvObject)==0)
 400   {
 401     char clsid[50];
 402
 403     WINE_StringFromCLSID((LPCLSID)riid,clsid);
 404
 405     WARN(ole,
 406          "() : asking for un supported interface %s\n",
 407          clsid);
 408
 409     return E_NOINTERFACE;
 410   }
 411
 412   /*
 413    * Query Interface always increases the reference count by one when it is
 414    * successful
 415    */
 416   OLEFontImpl_AddRef((IFont*)this);
 417
 418   return S_OK;;
 419 }
 420
 421 /************************************************************************
 422  * OLEFontImpl_AddRef (IUnknown)
 423  *
 424  * See Windows documentation for more details on IUnknown methods.
 425  */
 426 ULONG WINAPI OLEFontImpl_AddRef(
 427   IFont* iface)
 428 {
 429   _ICOM_THIS(OLEFontImpl, iface);
 430
 431   this->ref++;
 432
 433   return this->ref;
 434 }
 435
 436 /************************************************************************
 437  * OLEFontImpl_Release (IUnknown)
 438  *
 439  * See Windows documentation for more details on IUnknown methods.
 440  */
 441 ULONG WINAPI OLEFontImpl_Release(
 442       IFont* iface)
 443 {
 444   _ICOM_THIS(OLEFontImpl, iface);
 445
 446   /*
 447    * Decrease the reference count on this object.
 448    */
 449   this->ref--;
 450
 451   /*
 452    * If the reference count goes down to 0, perform suicide.
 453    */
 454   if (this->ref==0)
 455   {
 456     OLEFontImpl_Destroy(this);
 457
 458     return 0;
 459   }
 460
 461   return this->ref;
 462 }
 463
 464 /************************************************************************
 465  * OLEFontImpl_get_Name (IFont)
 466  *
 467  * See Windows documentation for more details on IFont methods.
 468  */
 469 static HRESULT WINAPI OLEFontImpl_get_Name(
 470   IFont*  iface,
 471   BSTR* pname)
 472 {
 473   _ICOM_THIS(OLEFontImpl, iface);
 474
 475   /*
 476    * Sanity check.
 477    */
 478   if (pname==0)
 479     return E_POINTER;
 480
 481   if (this->description.lpstrName!=0)
 482     *pname = SysAllocString(this->description.lpstrName);
 483   else
 484     *pname = 0;
 485
 486   return S_OK;
 487 }
 488
 489 /************************************************************************
 490  * OLEFontImpl_put_Name (IFont)
 491  *
 492  * See Windows documentation for more details on IFont methods.
 493  */
 494 static HRESULT WINAPI OLEFontImpl_put_Name(
 495   IFont* iface,
 496   BSTR name)
 497 {
 498   _ICOM_THIS(OLEFontImpl, iface);
 499
 500   if (this->description.lpstrName==0)
 501   {
 502     this->description.lpstrName = HeapAlloc(GetProcessHeap(),
 503                                             0,
 504                                             (lstrlenW(name)+1) * sizeof(WCHAR));
 505   }
 506   else
 507   {
 508     this->description.lpstrName = HeapReAlloc(GetProcessHeap(),
 509                                               0,
 510                                               this->description.lpstrName,
 511                                               (lstrlenW(name)+1) * sizeof(WCHAR));
 512   }
 513
 514   if (this->description.lpstrName==0)
 515     return E_OUTOFMEMORY;
 516
 517   lstrcpyW(this->description.lpstrName, name);
 518
 519   return S_OK;
 520 }
 521
 522 /************************************************************************
 523  * OLEFontImpl_get_Size (IFont)
 524  *
 525  * See Windows documentation for more details on IFont methods.
 526  */
 527 static HRESULT WINAPI OLEFontImpl_get_Size(
 528   IFont* iface,
 529   CY*    psize)
 530 {
 531   _ICOM_THIS(OLEFontImpl, iface);
 532
 533   /*
 534    * Sanity check
 535    */
 536   if (psize==0)
 537     return E_POINTER;
 538
 539   psize->u.Hi = 0;
 540   psize->u.Lo = this->description.cySize.u.Lo;
 541
 542   return S_OK;
 543 }
 544
 545 /************************************************************************
 546  * OLEFontImpl_put_Size (IFont)
 547  *
 548  * See Windows documentation for more details on IFont methods.
 549  */
 550 static HRESULT WINAPI OLEFontImpl_put_Size(
 551   IFont* iface,
 552   CY     size)
 553 {
 554   _ICOM_THIS(OLEFontImpl, iface);
 555
 556   this->description.cySize.u.Hi = 0;
 557   this->description.cySize.u.Lo = this->description.cySize.u.Lo;
 558
 559   return S_OK;
 560 }
 561
 562 /************************************************************************
 563  * OLEFontImpl_get_Bold (IFont)
 564  *
 565  * See Windows documentation for more details on IFont methods.
 566  */
 567 static HRESULT WINAPI OLEFontImpl_get_Bold(
 568   IFont*  iface,
 569   BOOL* pbold)
 570 {
 571   FIXME(ole,"():Stub\n");
 572   return E_NOTIMPL;
 573 }
 574
 575 /************************************************************************
 576  * OLEFontImpl_put_Bold (IFont)
 577  *
 578  * See Windows documentation for more details on IFont methods.
 579  */
 580 static HRESULT WINAPI OLEFontImpl_put_Bold(
 581   IFont* iface,
 582   BOOL bold)
 583 {
 584   FIXME(ole,"():Stub\n");
 585   return E_NOTIMPL;
 586 }
 587
 588 /************************************************************************
 589  * OLEFontImpl_get_Italic (IFont)
 590  *
 591  * See Windows documentation for more details on IFont methods.
 592  */
 593 static HRESULT WINAPI OLEFontImpl_get_Italic(
 594   IFont*  iface,
 595   BOOL* pitalic)
 596 {
 597   _ICOM_THIS(OLEFontImpl, iface);
 598
 599   /*
 600    * Sanity check
 601    */
 602   if (pitalic==0)
 603     return E_POINTER;
 604
 605   *pitalic = this->description.fItalic;
 606
 607   return S_OK;
 608 }
 609
 610 /************************************************************************
 611  * OLEFontImpl_put_Italic (IFont)
 612  *
 613  * See Windows documentation for more details on IFont methods.
 614  */
 615 static HRESULT WINAPI OLEFontImpl_put_Italic(
 616   IFont* iface,
 617   BOOL italic)
 618 {
 619   _ICOM_THIS(OLEFontImpl, iface);
 620
 621   this->description.fItalic = italic;
 622
 623   return S_OK;
 624 }
 625
 626 /************************************************************************
 627  * OLEFontImpl_get_Underline (IFont)
 628  *
 629  * See Windows documentation for more details on IFont methods.
 630  */
 631 static HRESULT WINAPI OLEFontImpl_get_Underline(
 632   IFont*  iface,
 633   BOOL* punderline)
 634 {
 635   _ICOM_THIS(OLEFontImpl, iface);
 636
 637   /*
 638    * Sanity check
 639    */
 640   if (punderline==0)
 641     return E_POINTER;
 642
 643   *punderline = this->description.fUnderline;
 644
 645   return S_OK;
 646 }
 647
 648 /************************************************************************
 649  * OLEFontImpl_put_Underline (IFont)
 650  *
 651  * See Windows documentation for more details on IFont methods.
 652  */
 653 static HRESULT WINAPI OLEFontImpl_put_Underline(
 654   IFont* iface,
 655   BOOL underline)
 656 {
 657   _ICOM_THIS(OLEFontImpl, iface);
 658
 659   this->description.fUnderline = underline;
 660
 661   return S_OK;
 662 }
 663
 664 /************************************************************************
 665  * OLEFontImpl_get_Strikethrough (IFont)
 666  *
 667  * See Windows documentation for more details on IFont methods.
 668  */
 669 static HRESULT WINAPI OLEFontImpl_get_Strikethrough(
 670   IFont*  iface,
 671   BOOL* pstrikethrough)
 672 {
 673   _ICOM_THIS(OLEFontImpl, iface);
 674
 675   /*
 676    * Sanity check
 677    */
 678   if (pstrikethrough==0)
 679     return E_POINTER;
 680
 681   *pstrikethrough = this->description.fStrikethrough;
 682
 683   return S_OK;
 684 }
 685
 686 /************************************************************************
 687  * OLEFontImpl_put_Strikethrough (IFont)
 688  *
 689  * See Windows documentation for more details on IFont methods.
 690  */
 691 static HRESULT WINAPI OLEFontImpl_put_Strikethrough(
 692  IFont* iface,
 693  BOOL strikethrough)
 694 {
 695   _ICOM_THIS(OLEFontImpl, iface);
 696
 697   this->description.fStrikethrough = strikethrough;
 698
 699   return S_OK;
 700 }
 701
 702 /************************************************************************
 703  * OLEFontImpl_get_Weight (IFont)
 704  *
 705  * See Windows documentation for more details on IFont methods.
 706  */
 707 static HRESULT WINAPI OLEFontImpl_get_Weight(
 708   IFont* iface,
 709   short* pweight)
 710 {
 711   _ICOM_THIS(OLEFontImpl, iface);
 712
 713   /*
 714    * Sanity check
 715    */
 716   if (pweight==0)
 717     return E_POINTER;
 718
 719   *pweight = this->description.sWeight;
 720
 721   return S_OK;
 722 }
 723
 724 /************************************************************************
 725  * OLEFontImpl_put_Weight (IFont)
 726  *
 727  * See Windows documentation for more details on IFont methods.
 728  */
 729 static HRESULT WINAPI OLEFontImpl_put_Weight(
 730   IFont* iface,
 731   short  weight)
 732 {
 733   _ICOM_THIS(OLEFontImpl, iface);
 734
 735   this->description.sWeight = weight;
 736
 737   return S_OK;
 738 }
 739
 740 /************************************************************************
 741  * OLEFontImpl_get_Charset (IFont)
 742  *
 743  * See Windows documentation for more details on IFont methods.
 744  */
 745 static HRESULT WINAPI OLEFontImpl_get_Charset(
 746   IFont* iface,
 747   short* pcharset)
 748 {
 749   _ICOM_THIS(OLEFontImpl, iface);
 750
 751   /*
 752    * Sanity check
 753    */
 754   if (pcharset==0)
 755     return E_POINTER;
 756
 757   *pcharset = this->description.sCharset;
 758
 759   return S_OK;
 760 }
 761
 762 /************************************************************************
 763  * OLEFontImpl_put_Charset (IFont)
 764  *
 765  * See Windows documentation for more details on IFont methods.
 766  */
 767 static HRESULT WINAPI OLEFontImpl_put_Charset(
 768   IFont* iface,
 769   short charset)
 770 {
 771   _ICOM_THIS(OLEFontImpl, iface);
 772
 773   this->description.sCharset = charset;
 774
 775   return S_OK;
 776 }
 777
 778 /************************************************************************
 779  * OLEFontImpl_get_hFont (IFont)
 780  *
 781  * See Windows documentation for more details on IFont methods.
 782  */
 783 static HRESULT WINAPI OLEFontImpl_get_hFont(
 784   IFont*   iface,
 785   HFONT* phfont)
 786 {
 787   _ICOM_THIS(OLEFontImpl, iface);
 788
 789   if (phfont==NULL)
 790     return E_POINTER;
 791
 792   /*
 793    * Realize the font if necessary
 794  */
 795   if (this->gdiFont==0)
 796 {
 797     LOGFONTW logFont;
 798     INT      fontHeight;
 799     CY       cySize;
 800
 801     /*
 802      * The height of the font returned by the get_Size property is the
 803      * height of the font in points multiplied by 10000... Using some
 804      * simple conversions and the ratio given by the application, it can
 805      * be converted to a height in pixels.
 806      */
 807     IFont_get_Size(iface, &cySize);
 808
 809     fontHeight = MulDiv(cySize.u.Lo, 2540L, 72L);
 810     fontHeight = MulDiv(fontHeight, this->cyLogical,this->cyHimetric);
 811
 812     memset(&logFont, 0, sizeof(LOGFONTW));
 813
 814     logFont.lfHeight          = ((fontHeight%10000L)>5000L) ? (-fontHeight/10000L)-1 :
 815                                                               (-fontHeight/10000L);
 816     logFont.lfItalic          = this->description.fItalic;
 817     logFont.lfUnderline       = this->description.fUnderline;
 818     logFont.lfStrikeOut       = this->description.fStrikethrough;
 819     logFont.lfWeight          = this->description.sWeight;
 820     logFont.lfCharSet         = this->description.sCharset;
 821     logFont.lfOutPrecision    = OUT_CHARACTER_PRECIS;
 822     logFont.lfClipPrecision   = CLIP_DEFAULT_PRECIS;
 823     logFont.lfQuality         = DEFAULT_QUALITY;
 824     logFont.lfPitchAndFamily  = DEFAULT_PITCH;
 825     lstrcpyW(logFont.lfFaceName,this->description.lpstrName);
 826
 827     this->gdiFont = CreateFontIndirectW(&logFont);
 828   }
 829
 830   *phfont = this->gdiFont;
 831
 832   return S_OK;
 833 }
 834
 835 /************************************************************************
 836  * OLEFontImpl_Clone (IFont)
 837  *
 838  * See Windows documentation for more details on IFont methods.
 839  */
 840 static HRESULT WINAPI OLEFontImpl_Clone(
 841   IFont*  iface,
 842   IFont** ppfont)
 843 {
 844   OLEFontImpl* newObject = 0;
 845
 846   _ICOM_THIS(OLEFontImpl, iface);
 847
 848   if (ppfont == NULL)
 849     return E_POINTER;
 850
 851   *ppfont = NULL;
 852
 853   /*
 854    * Allocate space for the object.
 855    */
 856   newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(OLEFontImpl));
 857
 858   if (newObject==NULL)
 859     return E_OUTOFMEMORY;
 860
 861   *newObject = *this;
 862
 863   /*
 864    * That new object starts with a reference count of 1
 865    */
 866   newObject->ref          = 1;
 867
 868   *ppfont = (IFont*)newObject;
 869
 870   return S_OK;
 871 }
 872
 873 /************************************************************************
 874  * OLEFontImpl_IsEqual (IFont)
 875  *
 876  * See Windows documentation for more details on IFont methods.
 877  */
 878 static HRESULT WINAPI OLEFontImpl_IsEqual(
 879   IFont* iface,
 880   IFont* pFontOther)
 881 {
 882   FIXME(ole,"():Stub\n");
 883   return E_NOTIMPL;
 884 }
 885
 886 /************************************************************************
 887  * OLEFontImpl_SetRatio (IFont)
 888  *
 889  * See Windows documentation for more details on IFont methods.
 890  */
 891 static HRESULT WINAPI OLEFontImpl_SetRatio(
 892   IFont* iface,
 893   long   cyLogical,
 894   long   cyHimetric)
 895 {
 896   _ICOM_THIS(OLEFontImpl, iface);
 897
 898   this->cyLogical  = cyLogical;
 899   this->cyHimetric = cyHimetric;
 900
 901   return S_OK;
 902 }
 903
 904 /************************************************************************
 905  * OLEFontImpl_QueryTextMetrics (IFont)
 906  *
 907  * See Windows documentation for more details on IFont methods.
 908  */
 909 static HRESULT      WINAPI OLEFontImpl_QueryTextMetrics(
 910   IFont*         iface,
 911   TEXTMETRICOLE* ptm)
 912 {
 913   FIXME(ole,"():Stub\n");
 914   return E_NOTIMPL;
 915 }
 916
 917 /************************************************************************
 918  * OLEFontImpl_AddRefHfont (IFont)
 919  *
 920  * See Windows documentation for more details on IFont methods.
 921  */
 922 static HRESULT WINAPI OLEFontImpl_AddRefHfont(
 923   IFont*  iface,
 924   HFONT hfont)
 925 {
 926   _ICOM_THIS(OLEFontImpl, iface);
 927
 928   if ( (hfont == 0) ||
 929        (hfont != this->gdiFont) )
 930     return E_INVALIDARG;
 931
 932   this->fontLock++;
 933
 934   return S_OK;
 935 }
 936
 937 /************************************************************************
 938  * OLEFontImpl_ReleaseHfont (IFont)
 939  *
 940  * See Windows documentation for more details on IFont methods.
 941  */
 942 static HRESULT WINAPI OLEFontImpl_ReleaseHfont(
 943   IFont*  iface,
 944   HFONT hfont)
 945 {
 946   _ICOM_THIS(OLEFontImpl, iface);
 947
 948   if ( (hfont == 0) ||
 949        (hfont != this->gdiFont) )
 950     return E_INVALIDARG;
 951
 952   this->fontLock--;
 953
 954   /*
 955    * If we just released our last font reference, destroy it.
 956    */
 957   if (this->fontLock==0)
 958   {
 959     DeleteObject(this->gdiFont);
 960     this->gdiFont = 0;
 961 }
 962
 963   return S_OK;
 964 }
 965
 966 /************************************************************************
 967  * OLEFontImpl_SetHdc (IFont)
 968  *
 969  * See Windows documentation for more details on IFont methods.
 970  */
 971 static HRESULT WINAPI OLEFontImpl_SetHdc(
 972   IFont* iface,
 973   HDC  hdc)
 974 {
 975   FIXME(ole,"():Stub\n");
 976   return E_NOTIMPL;
 977 }
 978
 979 /************************************************************************
 980  * OLEFontImpl_IDispatch_QueryInterface (IUnknown)
 981  *
 982  * See Windows documentation for more details on IUnknown methods.
 983  */
 984 static HRESULT WINAPI OLEFontImpl_IDispatch_QueryInterface(
 985   IDispatch* iface,
 986   REFIID     riid,
 987   VOID**     ppvoid)
 988 {
 989   _ICOM_THIS_From_IDispatch(IFont, iface);
 990
 991   return IFont_QueryInterface(this, riid, ppvoid);
 992 }
 993
 994 /************************************************************************
 995  * OLEFontImpl_IDispatch_Release (IUnknown)
 996  *
 997  * See Windows documentation for more details on IUnknown methods.
 998  */
 999 static ULONG WINAPI OLEFontImpl_IDispatch_Release(
1000   IDispatch* iface)
1001 {
1002   _ICOM_THIS_From_IDispatch(IFont, iface);
1003
1004   return IFont_Release(this);
1005 }
1006
1007 /************************************************************************
1008  * OLEFontImpl_IDispatch_AddRef (IUnknown)
1009  *
1010  * See Windows documentation for more details on IUnknown methods.
1011  */
1012 static ULONG WINAPI OLEFontImpl_IDispatch_AddRef(
1013   IDispatch* iface)
1014 {
1015   _ICOM_THIS_From_IDispatch(IFont, iface);
1016
1017   return IFont_AddRef(this);
1018 }
1019
1020 /************************************************************************
1021  * OLEFontImpl_GetTypeInfoCount (IDispatch)
1022  *
1023  * See Windows documentation for more details on IDispatch methods.
1024  */
1025 static HRESULT WINAPI OLEFontImpl_GetTypeInfoCount(
1026   IDispatch*    iface,
1027   unsigned int* pctinfo)
1028 {
1029   FIXME(ole,"():Stub\n");
1030
1031   return E_NOTIMPL;
1032 }
1033
1034 /************************************************************************
1035  * OLEFontImpl_GetTypeInfo (IDispatch)
1036  *
1037  * See Windows documentation for more details on IDispatch methods.
1038  */
1039 static HRESULT WINAPI OLEFontImpl_GetTypeInfo(
1040   IDispatch*  iface,
1041   UINT      iTInfo,
1042   LCID        lcid,
1043   ITypeInfo** ppTInfo)
1044 {
1045   FIXME(ole,"():Stub\n");
1046
1047   return E_NOTIMPL;
1048 }
1049
1050 /************************************************************************
1051  * OLEFontImpl_GetIDsOfNames (IDispatch)
1052  *
1053  * See Windows documentation for more details on IDispatch methods.
1054  */
1055 static HRESULT WINAPI OLEFontImpl_GetIDsOfNames(
1056   IDispatch*  iface,
1057   REFIID      riid,
1058   LPOLESTR* rgszNames,
1059   UINT      cNames,
1060   LCID        lcid,
1061   DISPID*     rgDispId)
1062 {
1063   FIXME(ole,"():Stub\n");
1064
1065   return E_NOTIMPL;
1066 }
1067
1068 /************************************************************************
1069  * OLEFontImpl_Invoke (IDispatch)
1070  *
1071  * See Windows documentation for more details on IDispatch methods.
1072  */
1073 static HRESULT WINAPI OLEFontImpl_Invoke(
1074   IDispatch*  iface,
1075   DISPID      dispIdMember,
1076   REFIID      riid,
1077   LCID        lcid,
1078   WORD        wFlags,
1079   DISPPARAMS* pDispParams,
1080   VARIANT*    pVarResult,
1081   EXCEPINFO*  pExepInfo,
1082   UINT*     puArgErr)
1083 {
1084   FIXME(ole,"():Stub\n");
1085
1086   return E_NOTIMPL;
1087 }
1088
1089 /************************************************************************
1090  * OLEFontImpl_IPersistStream_QueryInterface (IUnknown)
1091  *
1092  * See Windows documentation for more details on IUnknown methods.
1093  */
1094 static HRESULT WINAPI OLEFontImpl_IPersistStream_QueryInterface(
1095   IPersistStream* iface,
1096   REFIID     riid,
1097   VOID**     ppvoid)
1098 {
1099   _ICOM_THIS_From_IPersistStream(IFont, iface);
1100
1101   return IFont_QueryInterface(this, riid, ppvoid);
1102 }
1103
1104 /************************************************************************
1105  * OLEFontImpl_IPersistStream_Release (IUnknown)
1106  *
1107  * See Windows documentation for more details on IUnknown methods.
1108  */
1109 static ULONG WINAPI OLEFontImpl_IPersistStream_Release(
1110   IPersistStream* iface)
1111 {
1112   _ICOM_THIS_From_IPersistStream(IFont, iface);
1113
1114   return IFont_Release(this);
1115 }
1116
1117 /************************************************************************
1118  * OLEFontImpl_IPersistStream_AddRef (IUnknown)
1119  *
1120  * See Windows documentation for more details on IUnknown methods.
1121  */
1122 static ULONG WINAPI OLEFontImpl_IPersistStream_AddRef(
1123   IPersistStream* iface)
1124 {
1125   _ICOM_THIS_From_IPersistStream(IFont, iface);
1126
1127   return IFont_AddRef(this);
1128 }
1129
1130 /************************************************************************
1131  * OLEFontImpl_GetClassID (IPersistStream)
1132  *
1133  * See Windows documentation for more details on IPersistStream methods.
1134  */
1135 static HRESULT WINAPI OLEFontImpl_GetClassID(
1136   const IPersistStream* iface,
1137   CLSID*                pClassID)
1138 {
1139   if (pClassID==0)
1140     return E_POINTER;
1141
1142   memcpy(pClassID, &CLSID_StdFont, sizeof(CLSID_StdFont));
1143
1144   return S_OK;
1145 }
1146
1147 /************************************************************************
1148  * OLEFontImpl_IsDirty (IPersistStream)
1149  *
1150  * See Windows documentation for more details on IPersistStream methods.
1151  */
1152 static HRESULT WINAPI OLEFontImpl_IsDirty(
1153   IPersistStream*  iface)
1154 {
1155   return S_OK;
1156 }
1157
1158 /************************************************************************
1159  * OLEFontImpl_Load (IPersistStream)
1160  *
1161  * See Windows documentation for more details on IPersistStream methods.
1162  *
1163  * This is the format of the standard font serialization as far as I
1164  * know
1165  *
1166  * Offset   Type   Value           Comment
1167  * 0x0000   Byte   Unknown         Probably a version number, contains 0x01
1168  * 0x0001   Short  Charset         Charset value from the FONTDESC structure
1169  * 0x0003   Byte   Attributes      Flags defined as follows:
1170  *                                     00000010 - Italic
1171  *                                     00000100 - Underline
1172  *                                     00001000 - Strikethrough
1173  * 0x0004   Short  Weight          Weight value from FONTDESC structure
1174  * 0x0006   DWORD  size            "Low" portion of the cySize member of the FONTDESC
1175  *                                 structure/
1176  * 0x000A   Byte   name length     Length of the font name string (no null character)
1177  * 0x000B   String name            Name of the font (ASCII, no nul character)
1178  */
1179 static HRESULT WINAPI OLEFontImpl_Load(
1180   IPersistStream*  iface,
1181   IStream*         pLoadStream)
1182 {
1183   char  readBuffer[0x100];
1184   ULONG cbRead;
1185   BYTE  bVersion;
1186   BYTE  bAttributes;
1187   BYTE  bStringSize;
1188
1189   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
1190
1191   /*
1192    * Read the version byte
1193    */
1194   IStream_Read(pLoadStream, &bVersion, 1, &cbRead);
1195
1196   if ( (cbRead!=1) ||
1197        (bVersion!=0x01) )
1198     return E_FAIL;
1199
1200   /*
1201    * Charset
1202    */
1203   IStream_Read(pLoadStream, &this->description.sCharset, 2, &cbRead);
1204
1205   if (cbRead!=2)
1206     return E_FAIL;
1207
1208   /*
1209    * Attributes
1210    */
1211   IStream_Read(pLoadStream, &bAttributes, 1, &cbRead);
1212
1213   if (cbRead!=1)
1214     return E_FAIL;
1215
1216   this->description.fItalic        = (bAttributes & FONTPERSIST_ITALIC) != 0;
1217   this->description.fStrikethrough = (bAttributes & FONTPERSIST_STRIKETHROUGH) != 0;
1218   this->description.fUnderline     = (bAttributes & FONTPERSIST_UNDERLINE) != 0;
1219
1220   /*
1221    * Weight
1222    */
1223   IStream_Read(pLoadStream, &this->description.sWeight, 2, &cbRead);
1224
1225   if (cbRead!=2)
1226     return E_FAIL;
1227
1228   /*
1229    * Size
1230    */
1231   IStream_Read(pLoadStream, &this->description.cySize.u.Lo, 4, &cbRead);
1232
1233   if (cbRead!=4)
1234     return E_FAIL;
1235
1236   this->description.cySize.u.Hi = 0;
1237
1238   /*
1239    * FontName
1240    */
1241   IStream_Read(pLoadStream, &bStringSize, 1, &cbRead);
1242
1243   if (cbRead!=1)
1244     return E_FAIL;
1245
1246   memset(readBuffer, 0, 0x100);
1247   IStream_Read(pLoadStream, readBuffer, bStringSize, &cbRead);
1248
1249   if (cbRead!=bStringSize)
1250     return E_FAIL;
1251
1252   if (this->description.lpstrName!=0)
1253     HeapFree(GetProcessHeap(), 0, this->description.lpstrName);
1254
1255   this->description.lpstrName = HEAP_strdupAtoW(GetProcessHeap(),
1256                                                     HEAP_ZERO_MEMORY,
1257                                                     readBuffer);
1258
1259   return S_OK;
1260 }
1261
1262 /************************************************************************
1263  * OLEFontImpl_Save (IPersistStream)
1264  *
1265  * See Windows documentation for more details on IPersistStream methods.
1266  */
1267 static HRESULT WINAPI OLEFontImpl_Save(
1268   IPersistStream*  iface,
1269   IStream*         pOutStream,
1270   BOOL             fClearDirty)
1271 {
1272   char* writeBuffer = NULL;
1273   ULONG cbWritten;
1274   BYTE  bVersion = 0x01;
1275   BYTE  bAttributes;
1276   BYTE  bStringSize;
1277
1278   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
1279
1280   /*
1281    * Read the version byte
1282    */
1283   IStream_Write(pOutStream, &bVersion, 1, &cbWritten);
1284
1285   if (cbWritten!=1)
1286     return E_FAIL;
1287
1288   /*
1289    * Charset
1290    */
1291   IStream_Write(pOutStream, &this->description.sCharset, 2, &cbWritten);
1292
1293   if (cbWritten!=2)
1294     return E_FAIL;
1295
1296   /*
1297    * Attributes
1298    */
1299   bAttributes = 0;
1300
1301   if (this->description.fItalic)
1302     bAttributes |= FONTPERSIST_ITALIC;
1303
1304   if (this->description.fStrikethrough)
1305     bAttributes |= FONTPERSIST_STRIKETHROUGH;
1306
1307   if (this->description.fUnderline)
1308     bAttributes |= FONTPERSIST_UNDERLINE;
1309
1310   IStream_Write(pOutStream, &bAttributes, 1, &cbWritten);
1311
1312   if (cbWritten!=1)
1313     return E_FAIL;
1314
1315   /*
1316    * Weight
1317    */
1318   IStream_Write(pOutStream, &this->description.sWeight, 2, &cbWritten);
1319
1320   if (cbWritten!=2)
1321     return E_FAIL;
1322
1323   /*
1324    * Size
1325    */
1326   IStream_Write(pOutStream, &this->description.cySize.u.Lo, 4, &cbWritten);
1327
1328   if (cbWritten!=4)
1329     return E_FAIL;
1330
1331   /*
1332    * FontName
1333    */
1334   if (this->description.lpstrName!=0)
1335     bStringSize = lstrlenW(this->description.lpstrName);
1336   else
1337     bStringSize = 0;
1338
1339   IStream_Write(pOutStream, &bStringSize, 1, &cbWritten);
1340
1341   if (cbWritten!=1)
1342     return E_FAIL;
1343
1344   if (bStringSize!=0)
1345   {
1346     writeBuffer = HEAP_strdupWtoA(GetProcessHeap(),
1347                                   HEAP_ZERO_MEMORY,
1348                                   this->description.lpstrName);
1349
1350     if (writeBuffer==0)
1351       return E_OUTOFMEMORY;
1352
1353     IStream_Write(pOutStream, writeBuffer, bStringSize, &cbWritten);
1354
1355     HeapFree(GetProcessHeap(), 0, writeBuffer);
1356
1357     if (cbWritten!=bStringSize)
1358       return E_FAIL;
1359   }
1360
1361   return S_OK;
1362 }
1363
1364 /************************************************************************
1365  * OLEFontImpl_GetSizeMax (IPersistStream)
1366  *
1367  * See Windows documentation for more details on IPersistStream methods.
1368  */
1369 static HRESULT WINAPI OLEFontImpl_GetSizeMax(
1370   IPersistStream*  iface,
1371   ULARGE_INTEGER*  pcbSize)
1372 {
1373   _ICOM_THIS_From_IPersistStream(OLEFontImpl, iface);
1374
1375   if (pcbSize==NULL)
1376     return E_POINTER;
1377
1378   pcbSize->HighPart = 0;
1379   pcbSize->LowPart = 0;
1380
1381   pcbSize->LowPart += sizeof(BYTE);  /* Version */
1382   pcbSize->LowPart += sizeof(WORD);  /* Lang code */
1383   pcbSize->LowPart += sizeof(BYTE);  /* Flags */
1384   pcbSize->LowPart += sizeof(WORD);  /* Weight */
1385   pcbSize->LowPart += sizeof(DWORD); /* Size */
1386   pcbSize->LowPart += sizeof(BYTE);  /* StrLength */
1387
1388   if (this->description.lpstrName!=0)
1389     pcbSize->LowPart += lstrlenW(this->description.lpstrName);
1390
1391   return S_OK;
1392 }