Back to index

lightning-sunbird  0.9+nobinonly
Public Member Functions | Private Member Functions | Private Attributes
nsDrawingSurfaceWin Class Reference

#include <nsDrawingSurfaceWin.h>

Inheritance diagram for nsDrawingSurfaceWin:
Inheritance graph
[legend]
Collaboration diagram for nsDrawingSurfaceWin:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 nsDrawingSurfaceWin ()
NS_DECL_ISUPPORTS NS_IMETHOD Lock (PRInt32 aX, PRInt32 aY, PRUint32 aWidth, PRUint32 aHeight, void **aBits, PRInt32 *aStride, PRInt32 *aWidthBytes, PRUint32 aFlags)
 Lock a rect of a drawing surface and return a pointer to the upper left hand corner of the bitmap.
NS_IMETHOD Unlock (void)
 Unlock a rect of a drawing surface.
NS_IMETHOD GetDimensions (PRUint32 *aWidth, PRUint32 *aHeight)
 Get the dimensions of a drawing surface.
NS_IMETHOD IsOffscreen (PRBool *aOffScreen)
 Get the offscreen status of the drawing surface.
NS_IMETHOD IsPixelAddressable (PRBool *aAddressable)
 Get the pixel addressability status of the drawing surface.
NS_IMETHOD GetPixelFormat (nsPixelFormat *aFormat)
 Get the pixel format of a drawing surface.
NS_IMETHOD Init (HDC aDC)
 Initialize a drawing surface using a windows DC.
NS_IMETHOD Init (HDC aDC, PRUint32 aWidth, PRUint32 aHeight, PRUint32 aFlags)
 Initialize an offscreen drawing surface using a windows DC.
NS_IMETHOD GetDC (HDC *aDC)
 Get a windows DC that represents the drawing surface.
NS_IMETHOD GetTECHNOLOGY (PRInt32 *aTechnology)
NS_IMETHOD ReleaseDC (void)
 Release a windows DC obtained by GetDC().
NS_IMETHOD IsReleaseDCDestructive (PRBool *aDestructive)
 If ReleaseDC() truly destroys the state in the DC this will return PR_TRUE.

Private Member Functions

 ~nsDrawingSurfaceWin ()
BITMAPINFO * CreateBitmapInfo (PRInt32 aWidth, PRInt32 aHeight, PRInt32 aDepth, void **aBits=nsnull)

Private Attributes

HDC mDC
HBITMAP mOrigBitmap
HBITMAP mSelectedBitmap
PRBool mKillDC
BITMAPINFO * mBitmapInfo
PRUint8mDIBits
BITMAP mBitmap
nsPixelFormat mPixFormat
HBITMAP mLockedBitmap
PRUint32 mWidth
PRUint32 mHeight
PRInt32 mLockOffset
PRInt32 mLockHeight
PRUint32 mLockFlags
PRInt32 mTechnology

Detailed Description

Definition at line 48 of file nsDrawingSurfaceWin.h.


Constructor & Destructor Documentation

Definition at line 69 of file nsDrawingSurfaceWin.cpp.

{
  mDC = NULL;
  mOrigBitmap = nsnull;
  mSelectedBitmap = nsnull;
  mKillDC = PR_FALSE;
  mBitmapInfo = nsnull;
  mDIBits = nsnull;
  mLockedBitmap = nsnull;
  mWidth = mHeight = 0;
  mLockOffset = mLockHeight = 0;
  mLockFlags = 0;

#ifdef NGLAYOUT_DDRAW

  CreateDDraw();

  mSurface = NULL;
  mSurfLockCnt = 0;

#endif
}

Definition at line 92 of file nsDrawingSurfaceWin.cpp.

{
  if ((nsnull != mDC) && (nsnull != mOrigBitmap))
  {
    HBITMAP tbits = (HBITMAP)::SelectObject(mDC, mOrigBitmap);

    if (nsnull != tbits)
      VERIFY(::DeleteObject(tbits));

    mOrigBitmap = nsnull;
  }

  if (nsnull != mBitmapInfo)
  {
    PR_Free(mBitmapInfo);
    mBitmapInfo = nsnull;
  }

  if ((nsnull != mDIBits) && (nsnull == mSelectedBitmap))
    PR_Free(mDIBits);

  mDIBits = nsnull;
  mSelectedBitmap = nsnull;

#ifdef NGLAYOUT_DDRAW
  if (NULL != mSurface)
  {
    if (NULL != mDC)
    {
      mSurface->ReleaseDC(mDC);
      mDC = NULL;
    }

    NS_RELEASE(mSurface);
    mSurface = NULL;
  }
  else
#endif
  {
    if (NULL != mDC)
    {
      if (PR_TRUE == mKillDC)
        ::DeleteDC(mDC);

      mDC = NULL;
    }
  }
}

Member Function Documentation

BITMAPINFO * nsDrawingSurfaceWin::CreateBitmapInfo ( PRInt32  aWidth,
PRInt32  aHeight,
PRInt32  aDepth,
void **  aBits = nsnull 
) [private]

Definition at line 547 of file nsDrawingSurfaceWin.cpp.

{
  NS_ASSERTION(aDepth == 24 || aDepth == 32, "Unsupported bitmap depth");

  PRInt32 palsize, imagesize, spanbytes, allocsize;
  PRUint8 *colortable;
  DWORD   bicomp, masks[3];
  BITMAPINFO  *rv = nsnull;

  switch (aDepth)
  {
    case 24:
      palsize = 0;
      allocsize = 0;
      bicomp = BI_RGB;

      mPixFormat.mRedZeroMask = 0xff;
      mPixFormat.mGreenZeroMask = 0xff;
      mPixFormat.mBlueZeroMask = 0xff;
      mPixFormat.mAlphaZeroMask = 0;
      mPixFormat.mRedMask = 0xff0000;
      mPixFormat.mGreenMask = 0xff00;
      mPixFormat.mBlueMask = 0xff;
      mPixFormat.mAlphaMask = 0;
      mPixFormat.mRedCount = 8;
      mPixFormat.mGreenCount = 8;
      mPixFormat.mBlueCount = 8;
      mPixFormat.mAlphaCount = 0;
      mPixFormat.mRedShift = 16;
      mPixFormat.mGreenShift = 8;
      mPixFormat.mBlueShift = 0;
      mPixFormat.mAlphaShift = 0;
      
      break;

    case 32:
      palsize = 0;
      allocsize = 3;
      bicomp = BI_BITFIELDS;
      masks[0] = 0xff0000;
      masks[1] = 0x00ff00;
      masks[2] = 0x0000ff;
     
      mPixFormat.mRedZeroMask = 0xff;
      mPixFormat.mGreenZeroMask = 0xff;
      mPixFormat.mBlueZeroMask = 0xff;
      mPixFormat.mAlphaZeroMask = 0xff;
      mPixFormat.mRedMask = masks[0];
      mPixFormat.mGreenMask = masks[1];
      mPixFormat.mBlueMask = masks[2];
      mPixFormat.mAlphaMask = 0xff000000;
      mPixFormat.mRedCount = 8;
      mPixFormat.mGreenCount = 8;
      mPixFormat.mBlueCount = 8;
      mPixFormat.mAlphaCount = 8;
      mPixFormat.mRedShift = 16;
      mPixFormat.mGreenShift = 8;
      mPixFormat.mBlueShift = 0;
      mPixFormat.mAlphaShift = 24;

      break;

    default:
      palsize = -1;
      break;
  }

  if (palsize >= 0)
  {
    spanbytes = RASWIDTH(aWidth, aDepth);
    imagesize = spanbytes * aHeight;

    rv = (BITMAPINFO *)PR_Malloc(sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD) * allocsize));

    if (nsnull != rv)
    {
      rv->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
      rv->bmiHeader.biWidth = aWidth;
      rv->bmiHeader.biHeight = -aHeight;
      rv->bmiHeader.biPlanes = 1;
      rv->bmiHeader.biBitCount = (unsigned short)aDepth;
      rv->bmiHeader.biCompression = bicomp;
      rv->bmiHeader.biSizeImage = imagesize;
      rv->bmiHeader.biXPelsPerMeter = 0;
      rv->bmiHeader.biYPelsPerMeter = 0;
      rv->bmiHeader.biClrUsed = palsize;
      rv->bmiHeader.biClrImportant = palsize;

      // set the color table in the info header
      colortable = (PRUint8 *)rv + sizeof(BITMAPINFOHEADER);

      if ((aDepth == 16) || (aDepth == 32))
        memcpy(colortable, masks, sizeof(DWORD) * allocsize);
      else
        memset(colortable, 0, sizeof(RGBQUAD) * palsize);

      if (nsnull != aBits) {
        *aBits = PR_Malloc(imagesize);
        if ( nsnull == *aBits ) {
          PR_Free(rv);
          rv = nsnull;
        }
      }
    }
  }

  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NS_IMETHODIMP nsDrawingSurfaceWin::GetDC ( HDC *  aDC) [virtual]

Get a windows DC that represents the drawing surface.

GetDC() must be paired with ReleaseDC(). Getting a DC and Lock()ing are mutually exclusive operations.

Parameters:
aDCout parameter for HDC
Returns:
error status

Implements nsIDrawingSurfaceWin.

Definition at line 489 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  if (nsnull != mSurface)
  {
    if (0 == mSurfLockCnt)
      mSurface->GetDC(&mDC);

    mSurfLockCnt++;
  }
#endif

  *aDC = mDC;

  return NS_OK;
}

Here is the caller graph for this function:

NS_IMETHODIMP nsDrawingSurfaceWin::GetDimensions ( PRUint32 aWidth,
PRUint32 aHeight 
) [virtual]

Get the dimensions of a drawing surface.

Parameters:
aWidthout parameter for width of drawing surface
aHeightout parameter for height of drawing surface
Returns:
error status

Implements nsIDrawingSurface.

Definition at line 338 of file nsDrawingSurfaceWin.cpp.

{
  *aWidth = mWidth;
  *aHeight = mHeight;

  return NS_OK;
}

Get the pixel format of a drawing surface.

Parameters:
aOffscreenout parameter filled in with pixel format information.
Returns:
error status

Implements nsIDrawingSurface.

Definition at line 368 of file nsDrawingSurfaceWin.cpp.

{
  *aFormat = mPixFormat;

  return NS_OK;
}

Definition at line 508 of file nsDrawingSurfaceWin.cpp.

{ 
  
  *aTechnology = mTechnology;
  return NS_OK;
}
NS_IMETHODIMP nsDrawingSurfaceWin::Init ( HDC  aDC) [virtual]

Initialize a drawing surface using a windows DC.

aDC is "owned" by the drawing surface until the drawing surface is destroyed.

Parameters:
aDCHDC to initialize drawing surface with
Returns:
error status

Implements nsIDrawingSurfaceWin.

Definition at line 375 of file nsDrawingSurfaceWin.cpp.

{
  mDC = aDC;

  mTechnology = ::GetDeviceCaps(mDC, TECHNOLOGY);

  return NS_OK;
}

Here is the caller graph for this function:

NS_IMETHODIMP nsDrawingSurfaceWin::Init ( HDC  aDC,
PRUint32  aWidth,
PRUint32  aHeight,
PRUint32  aFlags 
) [virtual]

Initialize an offscreen drawing surface using a windows DC.

aDC is not "owned" by this drawing surface, instead it is used to create a drawing surface compatible with aDC. if width or height are less than zero, aDC will be created with no offscreen bitmap installed.

Parameters:
aDCHDC to initialize drawing surface with
aWidthwidth of drawing surface
aHeightheight of drawing surface
aFlagsflags used to control type of drawing surface created
Returns:
error status

Implements nsIDrawingSurfaceWin.

Definition at line 384 of file nsDrawingSurfaceWin.cpp.

{
  NS_ASSERTION(!(aDC == nsnull), "null DC");

#if defined(MOZ_SVG) && defined(SVG_FORCE_PIXEL_ACCESS_SURFACES)
  // force pixel access on all surfaces. Improves gdi+ performance
  aFlags |= NS_CREATEDRAWINGSURFACE_FOR_PIXEL_ACCESS;
#endif
  
#ifdef NGLAYOUT_DDRAW
  if (aFlags & NS_CREATEDRAWINGSURFACE_FOR_PIXEL_ACCESS)
  {
    LPDIRECTDRAWSURFACE ddsurf = nsnull;

    if ((NULL != mDDraw2) && (aWidth > 0) && (aHeight > 0))
    {
      DDSURFACEDESC ddsd;

      ddsd.dwSize = sizeof(ddsd);
      ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
      ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
                            ((aFlags & NS_CREATEDRAWINGSURFACE_FOR_PIXEL_ACCESS) ?
                            DDSCAPS_SYSTEMMEMORY : 0);
      ddsd.dwWidth = aWidth;
      ddsd.dwHeight = aHeight;

      mDDraw2->CreateSurface(&ddsd, &ddsurf, NULL);
    }

    if (NULL != ddsurf)
      mSurface = ddsurf;
    else
    {
      mDC = ::CreateCompatibleDC(aDC);
      mKillDC = PR_TRUE;
    }
  }
  else
#endif
  {
    mDC = ::CreateCompatibleDC(aDC);
    mTechnology = ::GetDeviceCaps(mDC, TECHNOLOGY);
    mKillDC = PR_TRUE;
  }

#ifdef NGLAYOUT_DDRAW
  if (nsnull == mSurface)
#endif
  {
    HBITMAP tbits = nsnull;

    if (aWidth > 0 && aHeight > 0)
    {
      if ((aFlags & NS_CREATEDRAWINGSURFACE_FOR_PIXEL_ACCESS) == 0)
        tbits = ::CreateCompatibleBitmap(aDC, aWidth, aHeight);

      // Create a DIB if we need Pixel Access, or if DDB creation failed
      if (nsnull == tbits)
      {
        void        *bits;
        BITMAPINFO  *binfo;
        int         depth;

        depth = ::GetDeviceCaps(aDC, BITSPIXEL);
        // Always use at least 24-bit bitmaps regardless of the device context.
        // See bug 228399 for more information.
        if (depth < 24)
          depth = 24;

        binfo = CreateBitmapInfo(aWidth, aHeight, depth);

        if (nsnull == binfo)
          return NS_ERROR_FAILURE;

        mSelectedBitmap = tbits = ::CreateDIBSection(aDC, binfo, DIB_RGB_COLORS, &bits, NULL, 0);

        if (NULL == mSelectedBitmap)
          return NS_ERROR_FAILURE;

        mBitmapInfo = binfo;
        mDIBits = (PRUint8 *)bits;
        mBitmap.bmWidthBytes = RASWIDTH(aWidth, depth);
        mBitmap.bmBitsPixel = depth;
      }
    }
    else
    {
      //we do this to make sure that the memory DC knows what the
      //bitmap format of the original DC was. this way, later
      //operations to create bitmaps from the memory DC will create
      //bitmaps with the correct properties.

      tbits = ::CreateCompatibleBitmap(aDC, 2, 2);
    }

    mOrigBitmap = (HBITMAP)::SelectObject(mDC, tbits);
  }

  mWidth = aWidth;
  mHeight = aHeight;

  return NS_OK;
}

Here is the call graph for this function:

Get the offscreen status of the drawing surface.

Parameters:
aOffscreenout parameter for offscreen status of drawing surface. if PR_TRUE, then modifying the drawing surface does not immediately reflect the changes on the output device
Returns:
error status

Implements nsIDrawingSurface.

Definition at line 346 of file nsDrawingSurfaceWin.cpp.

{
  *aOffScreen = mKillDC;

  return NS_OK;
}

Get the pixel addressability status of the drawing surface.

Parameters:
aAddressableout parameter for pixel addressability status of drawing surface. if PR_TRUE, then the drawing surface is optimized for pixel addressability (i.e. the Lock() method has very low overhead). All drawing surfaces support Lock()ing, but doing so on drawing surfaces that do not return PR_TRUE here may impose significant overhead.
Returns:
error status

Implements nsIDrawingSurface.

Definition at line 353 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  if (nsnull != mSurface)
    *aAddressable = PR_TRUE;
  else
#endif
  if (nsnull != mSelectedBitmap)
    *aAddressable = PR_TRUE;
  else
    *aAddressable = PR_FALSE;

  return NS_OK;
}

If ReleaseDC() truly destroys the state in the DC this will return PR_TRUE.

Parameters:
aDestructiveout parameter for destructiveness
Returns:
error status

Implements nsIDrawingSurfaceWin.

Definition at line 535 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  if (nsnull != mSurface)
    *aDestructive = PR_TRUE;
  else
#endif
    *aDestructive = PR_FALSE;

  return NS_OK;
}

Here is the caller graph for this function:

NS_IMETHODIMP nsDrawingSurfaceWin::Lock ( PRInt32  aX,
PRInt32  aY,
PRUint32  aWidth,
PRUint32  aHeight,
void **  aBits,
PRInt32 aStride,
PRInt32 aWidthBytes,
PRUint32  aFlags 
) [virtual]

Lock a rect of a drawing surface and return a pointer to the upper left hand corner of the bitmap.

Parameters:
aXx position of subrect of bitmap
aYy position of subrect of bitmap
aWidthwidth of subrect of bitmap
aHeightheight of subrect of bitmap
aBitsout parameter for upper left hand corner of bitmap
aStrideout parameter for number of bytes to add to aBits to go from scanline to scanline
aWidthBytesout parameter for number of bytes per line in aBits to process aWidth pixels
Returns:
error status

Implements nsIDrawingSurface.

Definition at line 179 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  if (mSurfLockCnt == 0)
  {
    RECT  srect;
    DWORD lockflags = 0;

    srect.left = aX;
    srect.top = aY;
    srect.right = aX + aWidth;
    srect.bottom = aY + aHeight;

    if (aFlags & NS_LOCK_SURFACE_READ_ONLY)
      lockflags |= DDLOCK_READONLY;

    if (aFlags & NS_LOCK_SURFACE_WRITE_ONLY)
      lockflags |= DDLOCK_WRITEONLY;

    if (PR_TRUE == LockSurface(mSurface, &mSurfDesc, &mBitmap, &srect, lockflags, &mPixFormat))
      mSurfLockCnt++;
  }
  else
  {
    NS_ASSERTION(0, "nested lock attempt");
    return NS_ERROR_FAILURE;
  }

  if (mSurfLockCnt == 0)
#endif
  {
    if (nsnull == mLockedBitmap)
    {
      if (nsnull == mSelectedBitmap)
      {
        HBITMAP tbits = ::CreateCompatibleBitmap(mDC, 2, 2);
        if ( tbits != nsnull )
        {
          mLockedBitmap = (HBITMAP)::SelectObject(mDC, tbits);

          // if the SelectObject fails, or there was no bitmap returned from this DC
          if ( mLockedBitmap != nsnull ) 
          {
            ::GetObject(mLockedBitmap, sizeof(BITMAP), &mBitmap);
            // Always use at least 24-bit bitmaps regardless of the device context.
            // See bug 228399 for more information.
            if (mBitmap.bmBitsPixel < 24)
              mBitmap.bmBitsPixel = 24;
            // Note the width of the DIB-bits rows. DIB rows are DWORD-aligned,
            // the original bitmap's rows may not have been DWORD-aligned.
            mBitmap.bmWidthBytes = RASWIDTH(mBitmap.bmWidth, mBitmap.bmBitsPixel);

            if (aY < 0 || aY + aHeight > mBitmap.bmHeight) {
              ::DeleteObject(tbits);
              return NS_ERROR_FAILURE;
            }
            
            // GetDIBits always seems to interpret the scanlines as bottom-to-top.
            mLockHeight = (PRInt32)aHeight;
            mLockOffset = mBitmap.bmHeight - (aY + aHeight);

            mBitmapInfo = CreateBitmapInfo(mBitmap.bmWidth, mBitmap.bmHeight, mBitmap.bmBitsPixel, (void **)&mDIBits);

            if ( mBitmapInfo != nsnull ) {
              if (!(aFlags & NS_LOCK_SURFACE_WRITE_ONLY))
                ::GetDIBits(mDC, mLockedBitmap, mLockOffset, mLockHeight, mDIBits, mBitmapInfo, DIB_RGB_COLORS);

              mBitmap.bmBits = mDIBits;
            } else {
              ::DeleteObject(tbits);
              return NS_ERROR_FAILURE;
            }
          } 
          else 
          {      
            ::DeleteObject(tbits);
            return NS_ERROR_FAILURE;
          }
        }
        else
        {
          return NS_ERROR_FAILURE;
        }
      }
      else
      {
        if (!(aFlags & NS_LOCK_SURFACE_WRITE_ONLY))
          ::GdiFlush();
        mLockedBitmap = mSelectedBitmap;
        mBitmap.bmBits = mDIBits + mBitmap.bmWidthBytes * aY;
      }
    }
    else
    {
      NS_ASSERTION(0, "nested lock attempt");
      return NS_ERROR_FAILURE;
    }
  }

  *aBits = (PRUint8 *)mBitmap.bmBits + (aX * (mBitmap.bmBitsPixel >> 3));
  *aStride = mBitmap.bmWidthBytes;
  *aWidthBytes = aWidth * (mBitmap.bmBitsPixel >> 3);
  mLockFlags = aFlags;

  return NS_OK;
}

Here is the caller graph for this function:

Release a windows DC obtained by GetDC().

ReleaseDC() must be preceded by a call to ReleaseDC().

Returns:
error status

Implements nsIDrawingSurfaceWin.

Definition at line 517 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  if (nsnull != mSurface)
  {
    --mSurfLockCnt;

    if ((nsnull != mDC) && (mSurfLockCnt == 0))
    {
      mSurface->ReleaseDC(mDC);
      mDC = nsnull;
    }
  }
#endif

  return NS_OK;
}

Here is the caller graph for this function:

Unlock a rect of a drawing surface.

must be preceded by a call to Lock(). Lock()/Unlock() pairs do not nest.

Returns:
error status

Implements nsIDrawingSurface.

Definition at line 289 of file nsDrawingSurfaceWin.cpp.

{
#ifdef NGLAYOUT_DDRAW
  NS_ASSERTION(!(mDC != nsnull), "attempt to unlock with dc");

  if (nsnull == mDC)
  {
    mSurfLockCnt--;

    NS_ASSERTION(!(mSurfLockCnt != 0), "nested surface locks");

    if (mSurfLockCnt == 0)
      mSurface->Unlock(mSurfDesc.lpSurface);
  }
  else
#endif
  {
    if (nsnull != mLockedBitmap)
    {
      if (nsnull == mSelectedBitmap)
      {
        HBITMAP tbits;

        if (!(mLockFlags & NS_LOCK_SURFACE_READ_ONLY))
          ::SetDIBits(mDC, mLockedBitmap, mLockOffset, mLockHeight, mDIBits, mBitmapInfo, DIB_RGB_COLORS);

        tbits = (HBITMAP)::SelectObject(mDC, mLockedBitmap);
        ::DeleteObject(tbits);

        if (nsnull != mBitmapInfo)
        {
          PR_Free(mBitmapInfo);
          mBitmapInfo = nsnull;
        }

        if (nsnull != mDIBits)
        {
          PR_Free(mDIBits);
          mDIBits = nsnull;
        }
      }

      mLockedBitmap = nsnull;
    }
  }

  return NS_OK;
}

Here is the caller graph for this function:


Member Data Documentation

Definition at line 100 of file nsDrawingSurfaceWin.h.

BITMAPINFO* nsDrawingSurfaceWin::mBitmapInfo [private]

Definition at line 98 of file nsDrawingSurfaceWin.h.

HDC nsDrawingSurfaceWin::mDC [private]

Definition at line 94 of file nsDrawingSurfaceWin.h.

Definition at line 99 of file nsDrawingSurfaceWin.h.

Definition at line 104 of file nsDrawingSurfaceWin.h.

Definition at line 97 of file nsDrawingSurfaceWin.h.

Definition at line 102 of file nsDrawingSurfaceWin.h.

Definition at line 107 of file nsDrawingSurfaceWin.h.

Definition at line 106 of file nsDrawingSurfaceWin.h.

Definition at line 105 of file nsDrawingSurfaceWin.h.

Definition at line 95 of file nsDrawingSurfaceWin.h.

Definition at line 101 of file nsDrawingSurfaceWin.h.

Definition at line 96 of file nsDrawingSurfaceWin.h.

Definition at line 108 of file nsDrawingSurfaceWin.h.

Definition at line 103 of file nsDrawingSurfaceWin.h.


The documentation for this class was generated from the following files: