windows-xp/Source/XPSP1/NT/printscan/ui/photowiz/item.cpp

/*****************************************************************************
 *
 *  (C) COPYRIGHT MICROSOFT CORPORATION, 2000
 *
 *  TITLE:       item.cpp
 *
 *  VERSION:     1.0
 *
 *  AUTHOR:      RickTu
 *
 *  DATE:        10/18/00
 *
 *  DESCRIPTION: Implements an item class that encapsulates the photos
 *               we are dealing with.
 *
 *****************************************************************************/

#include <precomp.h>
#pragma hdrstop


/*****************************************************************************

   _ScaleImage

   Scales src rect to fit into dest rect while preserving aspect ratio

 *****************************************************************************/

HRESULT _ScaleImage( Gdiplus::Rect * pSrc, Gdiplus::Rect * pDest )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("_ScaleImage()")));

    if (!pDest || !pSrc)
    {
        WIA_ERROR((TEXT("_ScaleImage: bad params, exiting early!")));
        return E_INVALIDARG;
    }


    WIA_TRACE((TEXT("_ScaleImage: src before scaling:  (%d, %d) @ (%d, %d)"), pSrc->Width, pSrc->Height, pSrc->X, pSrc->Y));

    //
    // Scale without any crop
    //

    SIZE sizeNew;
    INT  NewX = pDest->X, NewY = pDest->Y;

    WIA_TRACE((TEXT("_ScaleImage: dest before scaling: (%d, %d) @ (%d, %d)"),pDest->Width, pDest->Height, pDest->X, pDest->Y));

    sizeNew = PrintScanUtil::ScalePreserveAspectRatio( pDest->Width, pDest->Height, pSrc->Width, pSrc->Height );

    NewX += ((pDest->Width  - sizeNew.cx) / 2);
    NewY += ((pDest->Height - sizeNew.cy) / 2);

    pDest->X      = NewX;
    pDest->Y      = NewY;
    pDest->Width  = sizeNew.cx;
    pDest->Height = sizeNew.cy;

    WIA_TRACE((TEXT("_ScaleImage: dest after scaling:  (%d, %d) @ (%d, %d)"),pDest->Width, pDest->Height, pDest->X, pDest->Y));

    return S_OK;
}

/*****************************************************************************

   _CropImage

   Scales src rect to fit into dest rect while preserving aspect ratio

 *****************************************************************************/

HRESULT _CropImage( Gdiplus::Rect * pSrc, Gdiplus::Rect * pDest )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("_CropImage()")));

    if (!pDest || !pSrc)
    {
        WIA_ERROR((TEXT("_CropImage: bad params, exiting early!")));
        return E_INVALIDARG;
    }


    WIA_TRACE((TEXT("_CropImage: pDest before cropping:  (%d, %d) @ (%d, %d)"), pDest->Width, pDest->Height, pDest->X, pDest->Y));

    //
    // Scale without any crop
    //

    SIZE sizeNew;
    INT  NewX = pSrc->X, NewY = pSrc->Y;

    WIA_TRACE((TEXT("_CropImage: pSrc before cropping: (%d, %d) @ (%d, %d)"),pSrc->Width, pSrc->Height, pSrc->X, pSrc->Y));

    sizeNew = PrintScanUtil::ScalePreserveAspectRatio( pSrc->Width, pSrc->Height, pDest->Width, pDest->Height );

    NewX += ((pSrc->Width  - sizeNew.cx) / 2);
    NewY += ((pSrc->Height - sizeNew.cy) / 2);

    pSrc->X      = NewX;
    pSrc->Y      = NewY;
    pSrc->Width  = sizeNew.cx;
    pSrc->Height = sizeNew.cy;

    WIA_TRACE((TEXT("_CropImage: pSrc after cropping:  (%d, %d) @ (%d, %d)"),pSrc->Width, pSrc->Height, pSrc->X, pSrc->Y));

    return S_OK;
}


/*****************************************************************************

   _GetImageDimensions

   Given a GDI+ image object, return the dimensions in the given
   rectangle...


 *****************************************************************************/

HRESULT _GetImageDimensions( Gdiplus::Image * pImage, Gdiplus::RectF &rect, Gdiplus::REAL &scalingFactorForY )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("_GetImageDimensions()")));

    if (!pImage)
    {
        WIA_ERROR((TEXT("_GetImageDimensions: bad params, exiting early!")));
        return E_INVALIDARG;
    }

    Gdiplus::Unit Unit;

    HRESULT hr = Gdiplus2HRESULT( pImage->GetBounds( &rect, &Unit ) );

    if (FAILED(hr))
    {
        //
        // Try the old fashioned way...
        //

        rect.X = (Gdiplus::REAL)0.0;
        rect.Y = (Gdiplus::REAL)0.0;

        rect.Width = (Gdiplus::REAL)pImage->GetWidth();
        hr = Gdiplus2HRESULT( pImage->GetLastStatus() );
        WIA_CHECK_HR(hr,"_GetImageDimensions: GetWidth failed!");
        if (SUCCEEDED(hr))
        {
            rect.Height = (Gdiplus::REAL)pImage->GetHeight();
            hr = Gdiplus2HRESULT( pImage->GetLastStatus() );
            WIA_CHECK_HR(hr,"_GetImageDimensions: GetHeight failed!");
        }
    }
    else
    {
        if (Unit != Gdiplus::UnitPixel)
        {
            hr = S_FALSE;
        }
    }

    Gdiplus::REAL xDPI = pImage->GetHorizontalResolution();
    Gdiplus::REAL yDPI = pImage->GetVerticalResolution();

    if (yDPI)
    {
        scalingFactorForY = xDPI / yDPI;
    }
    else
    {
        scalingFactorForY = (Gdiplus::REAL)1.0;
    }


    WIA_RETURN_HR(hr);
}


/*****************************************************************************

   CPhotoItem -- constructors/desctructor

   <Notes>

 *****************************************************************************/

CPhotoItem::CPhotoItem( LPITEMIDLIST pidlFull )
  : _pidlFull(NULL),
    _pImage(NULL),
    _lFrameCount(-1),
    _bTimeFrames(FALSE),
    _pAnnotations(NULL),
    _pAnnotBits(NULL),
    _bWeKnowAnnotationsDontExist(FALSE),
    _pThumbnails(NULL),
    _cRef(0),
    _llFileSize(0),
    _uImageType(DontKnowImageType),
    _DPIx((Gdiplus::REAL)0.0),
    _DPIy((Gdiplus::REAL)0.0)
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM, TEXT("CPhotoItem::CPhotoItem( fully qualified pidl )")));

    if (pidlFull)
    {
        _pidlFull = ILClone( pidlFull );
        WIA_TRACE((TEXT("_pidlFull = 0x%x"),_pidlFull));
    }

    *_szFileName = 0;

    //
    // Get just file name from the pidl
    //

    SHFILEINFO fi = {0};

    if (SHGetFileInfo( (LPCTSTR)pidlFull, 0, &fi, sizeof(fi), SHGFI_DISPLAYNAME| SHGFI_PIDL ))
    {
        lstrcpyn( _szFileName, fi.szDisplayName, ARRAYSIZE(_szFileName) );
    }

}

CPhotoItem::~CPhotoItem()
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM, TEXT("CPhotoItem::~CPhotoItem()")));

    CAutoCriticalSection lock( _csItem );

    //
    // Free pidl for item
    //

    if (_pidlFull)
    {
        WIA_TRACE((TEXT("_pidlFull = 0x%x"),_pidlFull));
        ILFree( _pidlFull );
        _pidlFull = NULL;
    }

    //
    // Free GDI+ icon
    //

    if (_pClassBitmap)
    {
        delete _pClassBitmap;
        _pClassBitmap = NULL;
    }

    //
    // Free bitmaps of thumbnails
    //

    if (_pThumbnails)
    {
        for (INT i=0; i < _lFrameCount; i++)
        {
            if (_pThumbnails[i])
            {
                DeleteObject( _pThumbnails[i] );
            }
        }

        delete _pThumbnails;
        _pThumbnails = NULL;
    }

    //
    // Destroy GDI+ backing images.  This also destroys any
    // annotation data we have...
    //

    _DiscardGdiPlusImages();

}

/*****************************************************************************

   CPhotoItem IUnknown methods

   <Notes>

 *****************************************************************************/

ULONG CPhotoItem::AddRef()
{
    LONG l = InterlockedIncrement(&_cRef);

    WIA_PUSH_FUNCTION_MASK((TRACE_REF_COUNTS,TEXT("CPhotoItem(0x%x)::AddRef( new count is %d )"),this,l));

    if (l < 0)
    {
        return 0;
    }

    return (ULONG)l;
}

ULONG CPhotoItem::Release()
{
    LONG l = InterlockedDecrement(&_cRef);

    WIA_PUSH_FUNCTION_MASK((TRACE_REF_COUNTS,TEXT("CPhotoItem(0x%x)::Release( new count is %d )"),this,l));

    if (l > 0)
        return (ULONG)l;

    WIA_TRACE((TEXT("deleting object ( this == 0x%x ) because ref count is zero."),this));
    delete this;
    return 0;
}

ULONG CPhotoItem::ReleaseWithoutDeleting()
{
    LONG l = InterlockedDecrement(&_cRef);

    WIA_PUSH_FUNCTION_MASK((TRACE_REF_COUNTS,TEXT("CPhotoItem(0x%x)::Release( new count is %d )"),this,l));

    return (ULONG)l;
}


/*****************************************************************************

   CPhotoItem::GetImageFrameCount

   returns the number of frames (pages) in this image

 *****************************************************************************/

HRESULT CPhotoItem::GetImageFrameCount(LONG * pFrameCount)
{

    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::GetImageFrameCount(%s)"),_szFileName));


    if (!pFrameCount)
    {
        return E_INVALIDARG;
    }

    HRESULT hr = S_OK;

    //
    // Protect us as we go get info about the item...
    //

    CAutoCriticalSection lock(_csItem);

    if (_lFrameCount == -1)
    {
        _lFrameCount = 1;

        //
        // Ensure the GDI+ image object has been created...this will also
        // update the frame count...
        //

        hr = _CreateGdiPlusImage();

        if (SUCCEEDED(hr) && _pImage)
        {
            LONG lPageFrames;
            LONG lTimeFrames;

            lPageFrames = _pImage->GetFrameCount(&Gdiplus::FrameDimensionPage);
            lTimeFrames = _pImage->GetFrameCount(&Gdiplus::FrameDimensionTime);

            if ((lPageFrames > 0) && (lTimeFrames <= 1))
            {
                _lFrameCount = lPageFrames;
            }
            else if (lTimeFrames > 0)
            {
                //
                // This is an animated GIF, report only 1 frame...
                //

                _lFrameCount = 1;
                _bTimeFrames = TRUE;
            }
            else
            {
                _lFrameCount = 1;
            }

        }

    }

    *pFrameCount = ((_lFrameCount == -1) ? 0 : _lFrameCount);

    WIA_TRACE((TEXT("%s: returning _FrameCount = %d"),_szFileName,*pFrameCount));

    return hr;
}


/*****************************************************************************

   CPhotoItem::GetClassBitmap

   Returns default icon for class (.jpg, .bmp, etc) for this item...

 *****************************************************************************/

HBITMAP CPhotoItem::GetClassBitmap( const SIZE &sizeDesired )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::GetClassBitmap( %s, size = %d,%d "),_szFileName,sizeDesired.cx, sizeDesired.cy ));

    HBITMAP hbmReturn = NULL;

    CAutoCriticalSection lock(_csItem);

    if (!_pClassBitmap)
    {
        //
        // Get icon from shell
        //

        SHFILEINFO fi = {0};

        if (SHGetFileInfo( (LPCTSTR)_pidlFull, 0, &fi, sizeof(fi), SHGFI_PIDL | SHGFI_SYSICONINDEX ))
        {
            //
            // Get large (48 x 48) icon image list
            //

            IImageList * piml = NULL;
            if (SUCCEEDED(SHGetImageList( SHIL_EXTRALARGE, IID_IImageList, (void **)&piml )) && piml)
            {

                HICON hIcon = NULL;

                if (SUCCEEDED(piml->GetIcon( fi.iIcon, 0, &hIcon )) && hIcon)
                {
                    //
                    // Got the ICON, create a bitmap for it...
                    //

                    hbmReturn = WiaUiUtil::CreateIconThumbnail( (HWND)NULL, 50, 60, hIcon, NULL );

                    if (hbmReturn)
                    {
                        _pClassBitmap = new Gdiplus::Bitmap( hbmReturn, NULL );
                        DeleteObject( hbmReturn );
                        hbmReturn = NULL;
                    }

                    DestroyIcon( hIcon );
                }
                piml->Release();
            }
        }
    }


    if (_pClassBitmap)
    {
        SIZE sizeDrawSize = {0};

        //
        // Scale image to fill thumbnail space while preserving
        // aspect ratio...
        //

        sizeDrawSize = PrintScanUtil::ScalePreserveAspectRatio( sizeDesired.cx,
                                                                sizeDesired.cy,
                                                                _pClassBitmap->GetWidth(),
                                                                _pClassBitmap->GetHeight()
                                                               );

        WIA_TRACE((TEXT("CPhotoItem::GetClassBitmap(%s) - _pClassBitmap( %d, %d )"),_szFileName,_pClassBitmap->GetWidth(), _pClassBitmap->GetHeight()));
        WIA_TRACE((TEXT("CPhotoItem::GetClassBitmap(%s) - sizeDesired(   %d, %d )"),_szFileName,sizeDesired.cx, sizeDesired.cy));
        WIA_TRACE((TEXT("CPhotoItem::GetClassBitmap(%s) - sizeDrawsize(  %d, %d )"),_szFileName,sizeDrawSize.cx, sizeDrawSize.cy));

        Gdiplus::Bitmap * pImage = new Gdiplus::Bitmap( sizeDesired.cx, sizeDesired.cy );
        if (pImage)
        {
            HRESULT hr = Gdiplus2HRESULT(pImage->GetLastStatus());
            if (SUCCEEDED(hr))
            {
                //
                // Get a graphics to render to
                //

                Graphics *pGraphics = Gdiplus::Graphics::FromImage((Gdiplus::Image *)pImage);

                if (pGraphics)
                {
                    hr = Gdiplus2HRESULT(pGraphics->GetLastStatus());

                    //
                    // Make sure it is valid
                    //

                    if (SUCCEEDED(hr))
                    {
                        //
                        // erase the background of the image
                        //

                        pGraphics->Clear( g_wndColor );

                        //
                        // Set the interpolation mode to high quality
                        //

                        pGraphics->SetInterpolationMode( Gdiplus::InterpolationModeHighQualityBicubic );

                        //
                        // Set the smoothing (anti-aliasing) mode to high quality as well
                        //

                        pGraphics->SetSmoothingMode( Gdiplus::SmoothingModeHighQuality );

                        //
                        // Draw scaled image
                        //

                        WIA_TRACE((TEXT("CPhotoItem::GetClassBitmap(%s) - calling pGraphics->DrawImage( _pClassBitmap, %d, %d, %d, %d )"),_szFileName,0 + ((sizeDesired.cx - sizeDrawSize.cx) / 2),0 + ((sizeDesired.cy - sizeDrawSize.cy) / 2),sizeDrawSize.cx,sizeDrawSize.cy));

                        hr = Gdiplus2HRESULT(pGraphics->DrawImage( _pClassBitmap,
                                                                   0 + ((sizeDesired.cx - sizeDrawSize.cx) / 2),
                                                                   0 + ((sizeDesired.cy - sizeDrawSize.cy) / 2),
                                                                   sizeDrawSize.cx,
                                                                   sizeDrawSize.cy
                                                                  ));

                        WIA_CHECK_HR(hr,"CPhotoItem::GetClassBitmap() - pGraphics->DrawImage( _pClassBitmap ) failed!");

                        if (SUCCEEDED(hr))
                        {
                            pImage->GetHBITMAP( g_wndColor, &hbmReturn );
                        }

                    }

                    //
                    // Clean up our dynamically allocated graphics
                    //

                    delete pGraphics;

                }
                else
                {
                    WIA_ERROR((TEXT("CPhotoItem::GetClassBitmap(%s) - pGraphics was NULL!"),_szFileName));
                    hr = E_OUTOFMEMORY;
                }
            }
            else
            {
                WIA_ERROR((TEXT("CPhotoItem::GetClassBitmap(%s) - pImage failed to be created, hr = 0x%x"),hr));
            }

            delete pImage;
        }

    }

    return hbmReturn;

}



/*****************************************************************************

   CPhotoItem::GetThumbnailBitmap

   Given a DC and a desired size, return an HBITMAP of the thumbnail
   for a this item. The caller MUST free the HBITMAP returned
   from this function.

 *****************************************************************************/

HBITMAP CPhotoItem::GetThumbnailBitmap( const SIZE &sizeDesired, LONG lFrame )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::GetThumbnailBitmap( %s, size = %d,%d "),_szFileName,sizeDesired.cx, sizeDesired.cy ));

    HBITMAP hbmReturn = NULL;
    Gdiplus::Image * pImageToUse = NULL;

    CAutoCriticalSection lock(_csItem);

    //
    // Make sure we have a thumbnail image for our photo...
    //

    _CreateGdiPlusThumbnail( sizeDesired, lFrame );

    if (_pThumbnails && (lFrame < _lFrameCount) && _pThumbnails[lFrame])
    {
        //
        // Use bitmap to draw with instead of going to the file...
        //

        pImageToUse = (Gdiplus::Image *)(Gdiplus::Bitmap::FromHBITMAP( _pThumbnails[lFrame], NULL ));
    }


    if (pImageToUse)
    {
        WIA_TRACE((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - pImageToUse is (%d x %d)"),_szFileName,pImageToUse->GetWidth(),pImageToUse->GetHeight()));

        Gdiplus::Bitmap * pImage = new Gdiplus::Bitmap( sizeDesired.cx, sizeDesired.cy );
        if (pImage)
        {
            HRESULT hr = Gdiplus2HRESULT(pImage->GetLastStatus());
            if (SUCCEEDED(hr))
            {
                //
                // Get a graphics to render to
                //

                Graphics *pGraphics = Gdiplus::Graphics::FromImage((Gdiplus::Image *)pImage);

                if (pGraphics)
                {
                    hr = Gdiplus2HRESULT(pGraphics->GetLastStatus());

                    //
                    // Make sure it is valid
                    //

                    if (SUCCEEDED(hr))
                    {
                        //
                        // compute how to scale the thumbnail image
                        //

                        SIZE sizeDrawSize = {0};
                        sizeDrawSize = PrintScanUtil::ScalePreserveAspectRatio( sizeDesired.cx,
                                                                                sizeDesired.cy,
                                                                                pImageToUse->GetWidth(),
                                                                                pImageToUse->GetHeight()
                                                                               );

                        //
                        // erase the background of the image
                        //

                        pGraphics->Clear( g_wndColor );

                        //
                        // Set the interpolation mode to high quality
                        //

                        pGraphics->SetInterpolationMode( Gdiplus::InterpolationModeHighQualityBilinear );

                        //
                        // Draw scaled image
                        //

                        WIA_TRACE((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - calling pGraphics->DrawImage( pImageToUse, %d, %d, %d, %d )"),_szFileName,0 + ((sizeDesired.cx - sizeDrawSize.cx) / 2),0 + ((sizeDesired.cy - sizeDrawSize.cy) / 2),sizeDrawSize.cx,sizeDrawSize.cy));

                        hr = Gdiplus2HRESULT(pGraphics->DrawImage( pImageToUse,
                                                                   0 + ((sizeDesired.cx - sizeDrawSize.cx) / 2),
                                                                   0 + ((sizeDesired.cy - sizeDrawSize.cy) / 2),
                                                                   sizeDrawSize.cx,
                                                                   sizeDrawSize.cy
                                                                  ));

                        WIA_CHECK_HR(hr,"CPhotoItem::GetThumbnailBitmap() - pGraphics->DrawImage( pImageToUse ) failed!");

                        if (SUCCEEDED(hr))
                        {
                            pImage->GetHBITMAP( g_wndColor, &hbmReturn );
                        }

                    }

                    //
                    // Clean up our dynamically allocated graphics
                    //

                    delete pGraphics;

                }
                else
                {
                    WIA_ERROR((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - pGraphics was NULL!"),_szFileName));
                    hr = E_OUTOFMEMORY;
                }
            }
            else
            {
                WIA_ERROR((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - pImage failed to be created, hr = 0x%x"),hr));
            }

            delete pImage;
        }

        //
        // If we created an image to wrap the bitmap bits, then delete it...
        //

        if (pImageToUse)
        {
            delete pImageToUse;
        }

    }
    else
    {
        WIA_ERROR((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - don't have stored thumbnail bitmap for this image!"),_szFileName));
    }

    return hbmReturn;
}


/*****************************************************************************

   CPhotoItem::_DoRotateAnnotations

   This function requires that the annotation data be already set up
   and initialized. This is true for the _pImage object as well.  This
   function will not initialize on the fly.

 *****************************************************************************/


HRESULT CPhotoItem::_DoRotateAnnotations( BOOL bClockwise, UINT Flags )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_DoRotateAnnotations( %s, Flags = 0x%x )"),_szFileName,Flags));

    if (!_pAnnotations)
    {
        WIA_RETURN_HR(E_INVALIDARG);
    }

    if (!_pImage)
    {
        WIA_RETURN_HR(E_INVALIDARG);
    }

    HRESULT hr;
    Gdiplus::REAL scaleY;

    //
    // Get width & height of backing image...
    //

    Gdiplus::RectF rectBounds;
    hr = _GetImageDimensions( _pImage, rectBounds, scaleY );

    if (SUCCEEDED(hr))
    {
        INT i = 0;
        CAnnotation * pA = NULL;
        INT iNewW = 0, iNewH = 0;

        if ((Flags & RF_USE_THUMBNAIL_DATA) || (Flags & RF_USE_MEDIUM_QUALITY_DATA))
        {
            //
            // We flip here, because in the main _DoHandleRotation we only
            // rotated the thumbnail data, so the backing image width & height
            // haven't changed.  It will be changed when we rotate to print, however,
            // so feed the correct values to the annotation rotate code...
            //

            iNewW = (INT)rectBounds.Height;
            iNewH = (INT)rectBounds.Width;
        }
        else
        {
            iNewW = (INT)rectBounds.Width;
            iNewH = (INT)rectBounds.Height;
        }

        WIA_TRACE((TEXT("CPhotoItem::_DoRotateAnnotations - bClockwise = %d, new width = %d, new height = %d"),bClockwise,iNewW,iNewH));

        //
        // rotate all the annotations
        //

        do
        {
            pA = _pAnnotations->GetAnnotation(i++);

            if (pA)
            {
                pA->Rotate( iNewW, iNewH, bClockwise );
            }

        } while( pA );

    }

    WIA_RETURN_HR(hr);
}

#define DO_CONVERT_GDIPLUS_STATUS(hr,status) if ( (status == Gdiplus::Ok) || \
                                                  (status == Gdiplus::OutOfMemory) || \
                                                  (status == Gdiplus::ObjectBusy) || \
                                                  (status == Gdiplus::FileNotFound) || \
                                                  (status == Gdiplus::AccessDenied) || \
                                                  (status == Gdiplus::Win32Error) \
                                                 ) \
                                             { \
                                                 hr = Gdiplus2HRESULT( status ); \
                                             }\
                                             else \
                                             {\
                                                 WIA_TRACE((TEXT("Mapping Gdiplus error %d to PPW_E_UNABLE_TO_ROTATE"),status));\
                                                 hr = PPW_E_UNABLE_TO_ROTATE;\
                                             }

/*****************************************************************************

   CPhotoItem::_DoHandleRotation

   Handle rotating the image to render if/when needed or specified...

 *****************************************************************************/

HRESULT CPhotoItem::_DoHandleRotation( Gdiplus::Image * pImage, Gdiplus::Rect &src, Gdiplus::Rect * pDest, UINT Flags, Gdiplus::REAL &ScaleFactorForY )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_DoHandleRotation( %s, Flags = 0x%x )"),_szFileName,Flags));

    HRESULT hr = S_OK;
    Gdiplus::GpStatus status = Gdiplus::Ok;

    if (Flags & RF_ROTATION_MASK)
    {
        WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - A rotation flag was specified"),_szFileName));
        if (Flags & RF_ROTATE_AS_NEEDED)
        {
            WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - RF_ROTATE_AS_NEEDED was specified"),_szFileName));

            //
            // If the source and destination aspect ratios are on the opposite sides of 1.0,
            // rotate the image 90 degrees
            //

            const DOUBLE srcAspect  = (DOUBLE)src.Width  / (DOUBLE)src.Height;
            const DOUBLE destAspect = (DOUBLE)pDest->Width / (DOUBLE)pDest->Height;

            if((srcAspect >= (DOUBLE)1.0) ^ (destAspect >= (DOUBLE)1.0))
            {
                //
                // Rotate the image as needed...
                //

                if (Flags & RF_ROTATE_270)
                {
                    WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - Rotating Image 270 degrees"),_szFileName));
                    status = pImage->RotateFlip( Gdiplus::Rotate270FlipNone );
                    if (status == Gdiplus::Ok)
                    {
                        _DoRotateAnnotations( FALSE, Flags );
                    }

                }
                else
                {
                    WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - Rotating Image 90 degrees"),_szFileName));
                    status = pImage->RotateFlip( Gdiplus::Rotate90FlipNone );
                    if (status == Gdiplus::Ok)
                    {
                        _DoRotateAnnotations( TRUE, Flags );
                    }
                }

                //
                // Map most of these error codes to UNABLE_TO_ROTATE...
                //

                DO_CONVERT_GDIPLUS_STATUS(hr,status)
            }

        }
        else
        {
            //
            // Rotate the image...
            //

            if (Flags & RF_ROTATE_90)
            {
                WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - Rotating Image 90 degrees"),_szFileName));
                status = pImage->RotateFlip( Gdiplus::Rotate90FlipNone );
                if (status == Gdiplus::Ok)
                {
                    _DoRotateAnnotations( TRUE, Flags );
                }
            }
            else if (Flags & RF_ROTATE_180)
            {
                WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - Rotating Image 180 degrees"),_szFileName));
                status = pImage->RotateFlip( Gdiplus::Rotate180FlipNone );

                if (status == Gdiplus::Ok)
                {
                    //
                    // Rotate 90 degrees twice...
                    //

                    _DoRotateAnnotations( TRUE, Flags );
                    _DoRotateAnnotations( TRUE, Flags );
                }

            }
            else if (Flags & RF_ROTATE_270)
            {
                WIA_TRACE((TEXT("CPhotoItem::_DoHandleRotation(%s) - Rotating Image 270 degrees"),_szFileName));
                status = pImage->RotateFlip( Gdiplus::Rotate270FlipNone );
                if (status == Gdiplus::Ok)
                {
                    _DoRotateAnnotations( FALSE, Flags );
                }
            }
            else
            {
                status = Gdiplus::Ok;
            }

            //
            // Map most of these error codes to UNABLE_TO_ROTATE...
            //

            DO_CONVERT_GDIPLUS_STATUS(hr,status);
        }

        //
        // If we were able to rotate the image, then update the source rectangle
        // to make sure it still reflects reality...
        //

        if (SUCCEEDED(hr))
        {
            Gdiplus::RectF rectBounds;
            hr = _GetImageDimensions( pImage, rectBounds, ScaleFactorForY );

            if (SUCCEEDED(hr))
            {
                src.Width   = (INT)rectBounds.Width;
                src.Height  = (INT)(rectBounds.Height * ScaleFactorForY);
                src.X       = (INT)rectBounds.X;
                src.Y       = (INT)(rectBounds.Y * ScaleFactorForY);
            }
            else
            {
                src.Width = 0;
                src.Height = 0;
                src.X = 0;
                src.Y = 0;
            }
        }
    }

    if (Flags & RF_NO_ERRORS_ON_FAILURE_TO_ROTATE)
    {
        WIA_RETURN_HR(S_OK);
    }

    WIA_RETURN_HR(hr);

}


/*****************************************************************************

   CPhotoItem::_RenderAnnotations

   If annotations exist, then render them on top of this image...

 *****************************************************************************/

HRESULT CPhotoItem::_RenderAnnotations( HDC hDC, RENDER_DIMENSIONS * pDim, Gdiplus::Rect * pDest, Gdiplus::Rect &src, Gdiplus::Rect &srcAfterClipping )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_RenderAnnotations(%s)"),_szFileName));

    if (!_pAnnotations || !hDC)
    {
        WIA_RETURN_HR(E_INVALIDARG);
    }

    //
    // Save the settings for this DC...
    //

    INT iSavedDC = SaveDC( hDC );

    //
    // setup the destination DC:
    //

    SetMapMode(hDC, MM_TEXT);
    SetStretchBltMode(hDC, COLORONCOLOR);

    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - dest is (%d,%d) @ (%d,%d)"),_szFileName,pDest->Width,pDest->Height,pDest->X,pDest->Y));
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - rcDevice is (%d,%d) @ (%d,%d)"),_szFileName,pDim->rcDevice.right - pDim->rcDevice.left,pDim->rcDevice.bottom - pDim->rcDevice.top,pDim->rcDevice.left,pDim->rcDevice.top));
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - NominalPhysicalSize is (%d,%d)"),_szFileName,pDim->NominalPhysicalSize.cx,pDim->NominalPhysicalSize.cy));
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - NominalDevicePrintArea is (%d,%d)"),_szFileName,pDim->NominalDevicePrintArea.cx,pDim->NominalDevicePrintArea.cy));

    //
    // Get device rect
    //

    Gdiplus::RectF rectDevice;

    rectDevice.X        = (Gdiplus::REAL)pDim->rcDevice.left;
    rectDevice.Y        = (Gdiplus::REAL)pDim->rcDevice.top;
    rectDevice.Width    = (Gdiplus::REAL)(pDim->rcDevice.right - pDim->rcDevice.left);
    rectDevice.Height   = (Gdiplus::REAL)(pDim->rcDevice.bottom - pDim->rcDevice.top);

    //
    // Compute LPtoDP scaling factors
    //

    Gdiplus::REAL xLPtoDP = 0.0;
    Gdiplus::REAL yLPtoDP = 0.0;

    if (pDim->bDeviceIsScreen)
    {
        xLPtoDP = rectDevice.Width  / (Gdiplus::REAL)pDim->NominalPhysicalSize.cx;
        yLPtoDP = rectDevice.Height / (Gdiplus::REAL)pDim->NominalPhysicalSize.cy;
    }
    else
    {
        xLPtoDP = rectDevice.Width  / (Gdiplus::REAL)pDim->NominalDevicePrintArea.cx;
        yLPtoDP = rectDevice.Height / (Gdiplus::REAL)pDim->NominalDevicePrintArea.cy;
    }

    //
    // Get destination rect in device coords...
    //

    Gdiplus::RectF rectDest;

    rectDest.X      = pDest->X * xLPtoDP;
    rectDest.Y      = pDest->Y * xLPtoDP;
    rectDest.Width  = pDest->Width * xLPtoDP;
    rectDest.Height = pDest->Height * xLPtoDP;

    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - original source rect is (%d, %d) @ (%d, %d)"),_szFileName,src.Width,src.Height,src.X,src.Y));
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - clipped  source rect is (%d, %d) @ (%d, %d)"),_szFileName,srcAfterClipping.Width,srcAfterClipping.Height,srcAfterClipping.X,srcAfterClipping.Y));
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - clipped destination rect in device coords is (%d, %d) @ (%d, %d)"),_szFileName,(INT)rectDest.Width, (INT)rectDest.Height, (INT)rectDest.X, (INT)rectDest.Y));


    //
    // dx & dy represent how much bigger a destination rectangle would be
    // for the whole image, rather than the copped image...
    //

    Gdiplus::REAL dx = (Gdiplus::REAL)(src.Width  - srcAfterClipping.Width)  * (rectDest.Width  / (Gdiplus::REAL)srcAfterClipping.Width);
    Gdiplus::REAL dy = (Gdiplus::REAL)(src.Height - srcAfterClipping.Height) * (rectDest.Height / (Gdiplus::REAL)srcAfterClipping.Height);

    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - dx = %d   dy = %d"),_szFileName,(INT)dx,(INT)dy));

    //
    // Set the clipping rectangle on the device hDC in device coords...
    //

    RECT rcClip;
    rcClip.left   = (INT)rectDest.X;
    rcClip.right  = rcClip.left + (INT)rectDest.Width;
    rcClip.top    = (INT)rectDest.Y;
    rcClip.bottom = rcClip.top + (INT)rectDest.Height;


    #ifdef SHOW_ANNOT_RECTS
    {
        WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - rcClip is (%d,%d) @ (%d,%d)"),_szFileName,rcClip.right-rcClip.left,rcClip.bottom-rcClip.top,rcClip.left,rcClip.top));
        HBRUSH hbr = CreateSolidBrush( RGB( 0xFF, 0x00, 0x00 ) );
        FrameRect( hDC, &rcClip, hbr );
        DeleteObject( (HGDIOBJ)hbr );
    }
    #endif

    HRGN hrgn = CreateRectRgnIndirect(&rcClip);
    if (hrgn != NULL)
    {
        WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - setting clip region to (%d, %d, %d, %d)"),_szFileName,rcClip.left, rcClip.top, rcClip.right, rcClip.bottom));
        SelectClipRgn(hDC, hrgn);
    }


    //
    // Make dest rect for whole image, knowing we will clip later...
    //

    rectDest.X -= (dx / (Gdiplus::REAL)2.0);
    rectDest.Y -= (dy / (Gdiplus::REAL)2.0);
    rectDest.Width += dx;
    rectDest.Height += dy;

    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - full dest image rect in device coords is (%d, %d) @ (%d,%d)"),_szFileName,(INT)rectDevice.Width,(INT)rectDevice.Height,(INT)rectDevice.X,(INT)rectDevice.Y));

    #ifdef SHOW_ANNOT_RECTS
    {
        RECT rc;
        rc.left = (INT)rectDest.X;
        rc.top  = (INT)rectDest.Y;
        rc.right = rc.left + (INT)rectDest.Width;
        rc.bottom = rc.top + (INT)rectDest.Height;
        HBRUSH hbr = CreateSolidBrush( RGB( 0x00, 0xFF, 0x00 ) );
        FrameRect( hDC, &rc, hbr );
        DeleteObject( (HGDIOBJ)hbr );
    }
    #endif

    //
    // set up mapping modes for annotations
    //

    SetMapMode(hDC, MM_ANISOTROPIC);

    //
    // Set window org/ext to entire image...
    //

    SetWindowOrgEx(hDC, src.X, src.Y, NULL);
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - set window org to (%d,%d)"),_szFileName,src.X,src.Y));

    SetWindowExtEx(hDC, src.Width, src.Height, NULL);
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - set window ext to (%d,%d)"),_szFileName,src.Width,src.Height));

    //
    // Set the viewport to be at the corner of the image we are trying
    // to draw annotations for...
    //

    SetViewportOrgEx( hDC, (INT)rectDest.X, (INT)rectDest.Y, NULL );
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - set viewport org to (%d,%d)"),_szFileName,(INT)rectDest.X,(INT)rectDest.Y));

    //
    // We need to set scaling mode of image to dest rect
    //

    SetViewportExtEx( hDC, (INT)rectDest.Width, (INT)rectDest.Height, NULL );
    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - set viewport ext to (%d,%d)"),_szFileName,(INT)rectDest.Width, (INT)rectDest.Height));

    //
    // Now that everything is set up, render the annotations...
    //

    WIA_TRACE((TEXT("CPhotoItem::_RenderAnnotations(%s) - calling RenderAllMarks(0x%x)"),_szFileName,hDC));
    _pAnnotations->RenderAllMarks(hDC);

    SelectClipRgn(hDC, NULL);

    if (hrgn != NULL)
        DeleteObject(hrgn);

    if (iSavedDC)
    {
        RestoreDC( hDC, iSavedDC );
    }

    WIA_RETURN_HR(S_OK);
}


/*****************************************************************************

   CPhotoItem::_MungeAnnotationDataForThumbnails

   If we're rendering using thumbnails, then we need to munge some data
   so that we will render correctly...

 *****************************************************************************/

HRESULT CPhotoItem::_MungeAnnotationDataForThumbnails( Gdiplus::Rect &src,
                                                       Gdiplus::Rect &srcBeforeClipping,
                                                       Gdiplus::Rect * pDest,
                                                       UINT Flags
                                                       )
{
    WIA_TRACE((TEXT("CPhotoItem::_MungeAnnotationDataForThumbnails(%s)"),_szFileName));

    HRESULT hr = _CreateGdiPlusImage();

    if (FAILED(hr))
    {
        WIA_RETURN_HR(hr);
    }

    if (!_pImage)
    {
        WIA_RETURN_HR(E_FAIL);
    }

    //
    // we need to construct the original image rectangle appropriate for
    // annotation use...
    //

    Gdiplus::RectF rectImage;
    Gdiplus::REAL  scaleY;

    hr = _GetImageDimensions( _pImage, rectImage, scaleY );

    if (FAILED(hr))
    {
        //
        // If we couldn't accurately get the image dimensions, then bail...
        //

        return hr;
    }

    //
    // Scale image if it's non-square pixels
    //

    if (scaleY != (Gdiplus::REAL)0.0)
    {
        rectImage.Height *= scaleY;
        rectImage.Y      *= scaleY;
    }

    WIA_TRACE((TEXT("CPhotoItem::_Munge(%s) - rectImage is (%d,%d) @ (%d,%d)"),_szFileName,(INT)rectImage.Width,(INT)rectImage.Height,(INT)rectImage.X,(INT)rectImage.Y));

    //
    // Now, do all the transforms on the real image rectangle...
    //

    const DOUBLE srcAspect  = (DOUBLE)rectImage.Width  / (DOUBLE)rectImage.Height;
    const DOUBLE destAspect = (DOUBLE)pDest->Width / (DOUBLE)pDest->Height;

    if((srcAspect >= (DOUBLE)1.0) ^ (destAspect >= (DOUBLE)1.0))
    {
        //
        // Image needs to be rotated, swap width & height
        //

        rectImage.X      = rectImage.Width;
        rectImage.Width  = rectImage.Height;
        rectImage.Height = rectImage.X;
        rectImage.X      = 0.0;
    }

    src.X      = (INT)rectImage.X;
    src.Y      = (INT)rectImage.Y;
    src.Width  = (INT)rectImage.Width;
    src.Height = (INT)rectImage.Height;

    WIA_TRACE((TEXT("CPhotoItem::_Munge(%s) - srcRect after rotation is (%d,%d) @ (%d,%d)"),_szFileName,src.Width,src.Height,src.X,src.Y));

    srcBeforeClipping = src;

    if (Flags & RF_CROP_TO_FIT)
    {
        hr = _CropImage( &src, pDest );
    }
    else if (Flags & RF_SCALE_TO_FIT)
    {
        hr = _ScaleImage( &src, pDest );
    }

    //
    // Unscale the src rect
    //

    if (scaleY != (Gdiplus::REAL)0.0)
    {
        src.Height = (INT)(((Gdiplus::REAL)src.Height) / scaleY);
        src.Y      = (INT)(((Gdiplus::REAL)src.Y)      / scaleY);

        srcBeforeClipping.Height = (INT)(((Gdiplus::REAL)srcBeforeClipping.Height) / scaleY);
        srcBeforeClipping.Y      = (INT)(((Gdiplus::REAL)srcBeforeClipping.Y)      / scaleY);

    }

    WIA_RETURN_HR(hr);
}



/*****************************************************************************

   CPhotoItem::_GetThumbnailQualityImage

   Returns in ppImage a pointer to an image class.  If pbNeedsToBeDeleted
   then the caller must call delete on the returned pImage.

 *****************************************************************************/

HRESULT CPhotoItem::_GetThumbnailQualityImage( Gdiplus::Image ** ppImage, RENDER_OPTIONS * pRO, BOOL * pbNeedsToBeDeleted )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_GetThumbnailQualityImage( %s )"),_szFileName));

    if (!ppImage || !pRO || !pbNeedsToBeDeleted)
    {
        WIA_ERROR((TEXT("CPhotoItem::_GetThumbnailQualityImage( %s ) - returning E_INVALIDARG!"),_szFileName));
        return E_INVALIDARG;
    }

    //
    // Initialize incoming params
    //

    *ppImage = NULL;
    *pbNeedsToBeDeleted = FALSE;

    //
    // Make sure we have a GDI+ image class for our thumbnail...
    //

    SIZE sizeDesired = { DEFAULT_THUMB_WIDTH, DEFAULT_THUMB_HEIGHT };
    HRESULT hr = _CreateGdiPlusThumbnail( sizeDesired, pRO->lFrame );

    if (SUCCEEDED(hr) && (NULL!=_pThumbnails) && (pRO->lFrame < _lFrameCount) && (NULL!=_pThumbnails[pRO->lFrame]))
    {
        //
        // If we already have thumbnail bits, then use those by creating
        // a GDI+ bitmap class over those bits...
        //

        *ppImage = Gdiplus::Bitmap::FromHBITMAP( _pThumbnails[pRO->lFrame], NULL );

        if (*ppImage)
        {
            hr = Gdiplus2HRESULT((*ppImage)->GetLastStatus());
            WIA_TRACE((TEXT("CPhotoItem::_GetThumbnailQualityImage(%s) -- pImage created from thumbnail data is sized as (%d x %d)"),_szFileName,(*ppImage)->GetWidth(),(*ppImage)->GetHeight()));

            if (SUCCEEDED(hr))
            {
                *pbNeedsToBeDeleted = TRUE;
            }
            else
            {
                delete (*ppImage);
                *ppImage = NULL;
            }
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

    }
    else
    {
        WIA_ERROR((TEXT("CPhotoItem::_GetThumbnailQualityImage(%s) -- no thumbnail exists (_pThumbnails=0x%x, lFrame = %d, _lFrameCount = %d)"),_szFileName,_pThumbnails,pRO->lFrame,_lFrameCount));
    }


    WIA_RETURN_HR(hr);

}

/*****************************************************************************

   CPhotoItem::_GetMediumQualityImage

   Returns in ppImage a pointer to an image class.  If pbNeedsToBeDeleted
   then the caller must call delete on the returned pImage.

 *****************************************************************************/

HRESULT CPhotoItem::_GetMediumQualityImage( Gdiplus::Image ** ppImage, RENDER_OPTIONS * pRO, BOOL * pbNeedsToBeDeleted )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_GetMediumQualityImage( %s )"),_szFileName));

    if (!ppImage || !pRO || !pbNeedsToBeDeleted)
    {
        WIA_ERROR((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - returning E_INVALIDARG!"),_szFileName));
        return E_INVALIDARG;
    }

    //
    // Initialize incoming params
    //

    *ppImage = NULL;
    *pbNeedsToBeDeleted = FALSE;

    //
    // We want to use the full high-res image.
    // Make sure we have a GDI+ image class for our photo...
    //

    HRESULT hr = _CreateGdiPlusImage();

    if (SUCCEEDED(hr) && _pImage)
    {
        //
        // If this a metafile type of image, just use the original image
        //

        GUID guidFormat = {0};

        hr = Gdiplus2HRESULT(_pImage->GetRawFormat(&guidFormat));

        if ( (SUCCEEDED(hr) && (guidFormat == ImageFormatIcon)) ||
             (Gdiplus::ImageTypeMetafile == _pImage->GetType())
            )
        {
            WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - this is a metafile or an icon, using the full image..."),_szFileName));
            hr = Gdiplus2HRESULT(_pImage->SelectActiveFrame( _bTimeFrames ? &Gdiplus::FrameDimensionTime : &Gdiplus::FrameDimensionPage, pRO->lFrame ));
            *ppImage = _pImage;
        }
        else
        {
            //
            // Select the specified page
            //

            hr = Gdiplus2HRESULT(_pImage->SelectActiveFrame( _bTimeFrames ? &Gdiplus::FrameDimensionTime : &Gdiplus::FrameDimensionPage, pRO->lFrame ));
            WIA_CHECK_HR(hr,"CPhotoItem::_GetMediumQualityImage() - couldn't select frame!");

            if (SUCCEEDED(hr))
            {

                //
                // Here's the algoritm to decide how big an image to create.
                //
                //  (1) At least thumbnail size (120x120)
                //  (2) Attempt to scale to either 150dpi or 180dpi, depending on X DPI resolution of the printer
                //

                INT xDPI = 0, yDPI = 0;

                if ((pRO->Dim.DPI.cx % 150) == 0)
                {
                    //
                    // DPI is some even multiple of 150 (i.e., 150, 300, 600, 1200, 2400, etc)
                    //

                    xDPI = 150;
                    yDPI = MulDiv( pRO->Dim.DPI.cy, xDPI, pRO->Dim.DPI.cx );
                }
                else
                {
                    //
                    // DPI is some even multiple of 180 (i.e., 180, 360, 720, 1440, 2880, etc)
                    //

                    xDPI = 180;
                    yDPI = MulDiv( pRO->Dim.DPI.cy, xDPI, pRO->Dim.DPI.cx );
                }

                WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - scaling to xDPI=%d yDPI=%d"),_szFileName,xDPI,yDPI));

                //
                // Handle the error case of trying to scale yDPI
                //

                if (yDPI <= 0)
                {
                    yDPI = xDPI;
                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - fixing up yDPI to be %d"),_szFileName,yDPI));
                }

                //
                // Figure out the desired size of the new image...
                //

                INT Width  = MulDiv( pRO->pDest->Width,  xDPI, 10000 );
                INT Height = MulDiv( pRO->pDest->Height, yDPI, 10000 );

                WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - desired size of image is (%d x %d)"),_szFileName,Width,Height));

                if ((Width < DEFAULT_THUMB_WIDTH) && (Height < DEFAULT_THUMB_HEIGHT))
                {
                    Width = 120;
                    Height = 120;
                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - desired size of image is smaller than thumbnail, making it thumbnail size (%d x %d)"),_szFileName,Width,Height));
                }

                //
                // Now we now what size we're trying to scale to, create an image scaled (without cropping) to that size...
                //

                Gdiplus::RectF rectImage;
                Gdiplus::REAL  scaleY;

                if (SUCCEEDED(_GetImageDimensions( _pImage, rectImage, scaleY )))
                {
                    //
                    // scale for non-square pixels...
                    //

                    if (scaleY != (Gdiplus::REAL)0.0)
                    {
                        rectImage.Height *= scaleY;
                        rectImage.Y      *= scaleY;
                    }

                    SIZE sizeDrawSize = {0};
                    sizeDrawSize = PrintScanUtil::ScalePreserveAspectRatio( Width,
                                                                            Height,
                                                                            (INT)rectImage.Width,
                                                                            (INT)rectImage.Height
                                                                           );

                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - size of full image( %d x %d )"),_szFileName, (INT)rectImage.Width, (INT)rectImage.Height));
                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - sizeDesired( %d x %d )"),_szFileName, Width, Height));
                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - sizeDrawsize( %d x %d )"),_szFileName, sizeDrawSize.cx, sizeDrawSize.cy));

                    //
                    // Create the target bitmap and make sure it succeeded
                    //

                    *ppImage = (Gdiplus::Image *)new Gdiplus::Bitmap( sizeDrawSize.cx, sizeDrawSize.cy );
                    if (*ppImage)
                    {
                        hr = Gdiplus2HRESULT((*ppImage)->GetLastStatus());
                        if (SUCCEEDED(hr))
                        {
                            //
                            // Set the resolution (DPI) for the bitmap
                            //

                            ((Gdiplus::Bitmap *)(*ppImage))->SetResolution( (Gdiplus::REAL)xDPI, (Gdiplus::REAL)yDPI );

                            //
                            // Get a graphics to render to
                            //

                            Graphics *pGraphics = Gdiplus::Graphics::FromImage(*ppImage);
                            if (pGraphics)
                            {
                                hr = Gdiplus2HRESULT(pGraphics->GetLastStatus());

                                //
                                // Make sure it is valid
                                //

                                if (SUCCEEDED(hr))
                                {
                                    //
                                    // Set the interpolation mode to high quality
                                    //

                                    pGraphics->SetInterpolationMode( Gdiplus::InterpolationModeHighQualityBicubic );

                                    //
                                    // Set the smoothing (anti-aliasing) mode to high quality as well
                                    //

                                    pGraphics->SetSmoothingMode( Gdiplus::SmoothingModeHighQuality );

                                    //
                                    // Draw scaled image
                                    //

                                    WIA_TRACE((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - calling pGraphics->DrawImage( _pImage, 0, 0, %d, %d )"),_szFileName,sizeDrawSize.cx,sizeDrawSize.cy));

                                    Gdiplus::Rect rectDest;
                                    rectDest.X = 0;
                                    rectDest.Y = 0;
                                    rectDest.Width = sizeDrawSize.cx;
                                    rectDest.Height = sizeDrawSize.cy;


                                    Gdiplus::ImageAttributes imageAttr;
                                    imageAttr.SetWrapMode( Gdiplus::WrapModeTileFlipXY, Gdiplus::Color(), FALSE );

                                    //
                                    // Undo scaling
                                    //

                                    if (scaleY != (Gdiplus::REAL)0.0)
                                    {
                                        rectImage.Height /= scaleY;
                                        rectImage.Y      /= scaleY;
                                    }

                                    //
                                    // Finally render the image w/the right settings
                                    //

                                    pGraphics->DrawImage( _pImage, rectDest, 0, 0, (INT)rectImage.Width, (INT)rectImage.Height, Gdiplus::UnitPixel, &imageAttr );

                                    WIA_CHECK_HR(hr,"CPhotoItem::_GetMediumQualityImage() - pGraphics->DrawImage( _pImage, 0, 0, sizeDrawSize.cx, sizeDrawSize.cy ) failed!");

                                    if (SUCCEEDED(hr))
                                    {
                                        *pbNeedsToBeDeleted = TRUE;
                                    }
                                    else
                                    {
                                        delete (*ppImage);
                                        *ppImage = NULL;
                                    }

                                }

                                //
                                // Clean up our dynamically allocated graphics
                                //

                                delete pGraphics;

                            }
                            else
                            {
                                WIA_ERROR((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - pGraphics was NULL!"),_szFileName));
                                hr = E_OUTOFMEMORY;
                            }
                        }
                        else
                        {
                            delete (*ppImage);
                            *ppImage = NULL;
                        }
                    }
                    else
                    {
                        WIA_ERROR((TEXT("CPhotoItem::_GetMediumQualityImage(%s) - failed to create new pImage for medium quality data!"),_szFileName));
                        hr = E_OUTOFMEMORY;
                    }

                }
            }
        }
    }

    WIA_RETURN_HR(hr);
}



/*****************************************************************************

    CPhotoItem::_GetFullQualityImage

    Returns in ppImage a pointer to an image class.  If pbNeedsToBeDeleted
    then the caller must call delete on the returned pImage.

 *****************************************************************************/

HRESULT CPhotoItem::_GetFullQualityImage( Gdiplus::Image ** ppImage, RENDER_OPTIONS * pRO, BOOL * pbNeedsToBeDeleted )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_GetFullQualityImage( %s )"),_szFileName));

    if (!ppImage || !pbNeedsToBeDeleted)
    {
        WIA_ERROR((TEXT("CPhotoItem::_GetFullQualityImage(%s) - returning E_INVALIDARG!"),_szFileName));
        return E_INVALIDARG;
    }

    //
    // Initialize incoming params
    //

    *ppImage = NULL;
    *pbNeedsToBeDeleted = FALSE;

    //
    // We want to use the full high-res image.
    // Make sure we have a GDI+ image class for our photo...
    //

    HRESULT hr = _CreateGdiPlusImage();

    if (SUCCEEDED(hr) && _pImage)
    {
        //
        // Select the specified page
        //

        hr = Gdiplus2HRESULT(_pImage->SelectActiveFrame( _bTimeFrames ? &Gdiplus::FrameDimensionTime : &Gdiplus::FrameDimensionPage, pRO->lFrame ));

        if (SUCCEEDED(hr))
        {
            *ppImage = _pImage;
            WIA_TRACE((TEXT("CPhotoItem::_GetFullQualityImage(%s) -- *ppImage created from full image data is sized as (%d x %d)"),_szFileName,_pImage->GetWidth(),_pImage->GetHeight()));
        }
        else
        {
            WIA_ERROR((TEXT("CPhotoItem::_GetFullQualityImage(%s) - couldn't select frame %d, hr = 0x%x"),_szFileName,pRO->lFrame,hr));
        }

    }

    WIA_RETURN_HR(hr);
}




#define CHECK_AND_EXIT_ON_FAILURE(hr) if (FAILED(hr)) {if (pImage && (pImage!=_pImage)) {delete pImage;} WIA_RETURN_HR(hr);}

/*****************************************************************************

   CPhotoItem::Render

   Renders the given item into the Graphics that is supplied...

 *****************************************************************************/

HRESULT CPhotoItem::Render( RENDER_OPTIONS * pRO )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::Render( %s, pRO = 0x%x)"),_szFileName,pRO));

    if (!pRO)
    {
        WIA_ERROR((TEXT("CPhotoItem::Render(%s) - pRO is NULL, don't have any input!"),_szFileName));
        return E_INVALIDARG;
    }

    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - Render Options were specificed as:"),_szFileName));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) -     g      = 0x%x"),_szFileName,pRO->g));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) -     pDest  = (%d x %d) at (%d,%d)"),_szFileName,pRO->pDest->Width,pRO->pDest->Height,pRO->pDest->X,pRO->pDest->Y));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) -     Flags  = 0x%x"),_szFileName,pRO->Flags));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) -     lFrame = %d"),_szFileName,pRO->lFrame));

    HRESULT             hr      = S_OK;
    Gdiplus::Image *    pImage  = NULL;
    BOOL                bNeedsToBeDeleted = FALSE;
    Gdiplus::GpStatus   status;

    //
    // Check for bad args...
    //

    if (!pRO->g)
    {
        WIA_ERROR((TEXT("CPhotoItem::Render(%s) - g is NULL, can't draw anything"),_szFileName));
        return E_INVALIDARG;
    }

    if ((pRO->Flags & RF_STRETCH_TO_FIT) && (pRO->Flags & (RF_CROP_TO_FIT | RF_SCALE_TO_FIT)))
    {
        WIA_ERROR((TEXT("CPhotoItem::Render(%s) - RF_STRETCH_TO_FIT can't be combined with CROP or SCALE"),_szFileName));
        return E_INVALIDARG;
    }


    CAutoCriticalSection lock(_csItem);

    //
    // Refresh annotation data if we have it
    //

    _LoadAnnotations();


    if (pRO->Flags & RF_USE_THUMBNAIL_DATA)
    {
        WIA_TRACE((TEXT("CPhotoItem::Render(%s) -- render using thumbnail data..."),_szFileName));
        hr = _GetThumbnailQualityImage( &pImage, pRO, &bNeedsToBeDeleted );
    }
    else if (pRO->Flags & RF_USE_MEDIUM_QUALITY_DATA)
    {
        WIA_TRACE((TEXT("CPhotoItem::Render(%s) -- render using high quality thumbnail data..."),_szFileName));
        hr = _GetMediumQualityImage( &pImage, pRO, &bNeedsToBeDeleted );

    }
    else if (pRO->Flags & RF_USE_FULL_IMAGE_DATA)
    {
        WIA_TRACE((TEXT("CPhotoItem::Render(%s) -- render using full image data..."),_szFileName));
        hr = _GetFullQualityImage( &pImage, pRO, &bNeedsToBeDeleted );
    }
    else
    {
        WIA_ERROR((TEXT("CPhotoItem::Render(%s) -- bad render data flags"),_szFileName));
        WIA_RETURN_HR(E_INVALIDARG);
    }

    CHECK_AND_EXIT_ON_FAILURE(hr);

    //
    // We've constructed the appropriate image, now try to load the annotations...
    //

    if (_pAnnotBits && _pAnnotBits[pRO->lFrame] && _pAnnotations && _pImage)
    {
        _pAnnotations->BuildAllMarksFromData( _pAnnotBits[pRO->lFrame]->value,
                                              _pAnnotBits[pRO->lFrame]->length,
                                              (ULONG)_pImage->GetHorizontalResolution(),
                                              (ULONG)_pImage->GetVerticalResolution()
                                             );

        WIA_TRACE((TEXT("CPhotoItem::Render(%s) -- %d annotation marks for frame %d found and initialized"),_szFileName,_pAnnotations->GetCount(),pRO->lFrame));

    }

    //
    // Get the dimensions of the source image...
    //

    Gdiplus::Rect src;

    //
    // Do this so EMF/WMF print and draw correctly...
    //

    Gdiplus::RectF rectBounds;
    Gdiplus::REAL  scaleY;

    hr = _GetImageDimensions( pImage, rectBounds, scaleY );
    if (SUCCEEDED(hr))
    {
        src.Width   = (INT)rectBounds.Width;
        src.Height  = (INT)(rectBounds.Height * scaleY);
        src.X       = (INT)rectBounds.X;
        src.Y       = (INT)(rectBounds.Y * scaleY);
    }

    CHECK_AND_EXIT_ON_FAILURE(hr);

    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - srcRect is (%d,%d) @ (%d,%d) before any changes"),_szFileName,src.Width, src.Height, src.X, src.Y));

    //
    // do any needed rotation
    //

    hr = _DoHandleRotation( pImage, src, pRO->pDest, pRO->Flags, scaleY );
    CHECK_AND_EXIT_ON_FAILURE(hr);

    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - srcRect is (%d,%d) @ (%d,%d) after any needed rotation"),_szFileName,src.Width,src.Height,src.X,src.Y));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - destRect is (%d,%d) @ (%d,%d) after any needed rotation"),_szFileName,pRO->pDest->Width,pRO->pDest->Height,pRO->pDest->X,pRO->pDest->Y));

    //
    // If things are still good, do croping/scaling and then draw the image...
    //
    // First check if we should crop...
    //

    Gdiplus::Rect srcBeforeClipping = src;

    if (pRO->Flags & (RF_CROP_TO_FIT | RF_SCALE_TO_FIT))
    {
        #ifdef DEBUG
        if (pRO->Flags & RF_CROP_TO_FIT)
        {
            WIA_TRACE((TEXT("CPhotoItem::Render(%s) - RF_CROP_TO_FIT was specified"),_szFileName));
        }
        if (pRO->Flags & RF_SCALE_TO_FIT)
        {
            WIA_TRACE((TEXT("CPhotoItem::Render(%s) - RF_SCALE_TO_FIT was specified"),_szFileName));
        }
        #endif

        if (pRO->Flags & RF_CROP_TO_FIT)
        {
            hr = _CropImage( &src, pRO->pDest );
        }
        else if (pRO->Flags & RF_SCALE_TO_FIT)
        {
            hr = _ScaleImage( &src, pRO->pDest );
        }
        else
        {
            WIA_ERROR((TEXT("CPhotoItem::Render(%s) - CropScale: unknown configuration"),_szFileName));
            hr = E_FAIL;
        }
    }

    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - srcRect is (%d,%d) @ (%d,%d) after scaling"),_szFileName,src.Width, src.Height, src.X, src.Y));
    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - destRect is (%d,%d) @ (%d,%d) after scaling"),_szFileName,pRO->pDest->Width, pRO->pDest->Height, pRO->pDest->X, pRO->pDest->Y));

    CHECK_AND_EXIT_ON_FAILURE(hr);

    //
    // set the destination rectangle...
    //

    Gdiplus::Rect destTemp( pRO->pDest->X, pRO->pDest->Y, pRO->pDest->Width, pRO->pDest->Height );

    //
    // If this is a non-square pixel image, we need to reset the source rectangle to be back to actual
    // pixels, instead of incorporating DPI as well...
    //

    if ((scaleY != (Gdiplus::REAL)0.0) && (scaleY != (Gdiplus::REAL)1.0))
    {
        src.Height = (INT)((Gdiplus::REAL)src.Height / scaleY);
        src.Y      = (INT)((Gdiplus::REAL)src.Y      / scaleY);
        srcBeforeClipping.Height = (INT)((Gdiplus::REAL)srcBeforeClipping.Height / scaleY);
        srcBeforeClipping.Y      = (INT)((Gdiplus::REAL)srcBeforeClipping.Y      / scaleY);
    }

    //
    // Set the interpolation mode to high quality
    //

    pRO->g->SetInterpolationMode( Gdiplus::InterpolationModeHighQualityBicubic );

    //
    // Set the smoothing (anti-aliasing) mode to high quality as well
    //

    pRO->g->SetSmoothingMode( Gdiplus::SmoothingModeHighQuality );

    //
    // Set the wrap mode
    //

    Gdiplus::ImageAttributes imageAttr;
    imageAttr.SetWrapMode( Gdiplus::WrapModeTileFlipXY, Gdiplus::Color(), FALSE );

    //
    // Time to draw the image.
    //

    WIA_TRACE((TEXT("CPhotoItem::Render(%s) - calling DrawImage( pImage, destTemp( %d x %d at %d,%d ), %d, %d, %d, %d )"),_szFileName,destTemp.Width,destTemp.Height,destTemp.X,destTemp.Y,src.X,src.Y,src.Width,src.Height));
    status = pRO->g->DrawImage( pImage, destTemp, src.X, src.Y, src.Width, src.Height, Gdiplus::UnitPixel, &imageAttr );

    //
    // Check for errors, and then draw annotations...
    //

    hr = Gdiplus2HRESULT(status);
    WIA_CHECK_HR(hr,"CPhotoItem::Render() - g->DrawImage( pImage ) failed!");

    //
    // Render annotations if they exist...
    //

    if (_pAnnotations && _pAnnotBits && _pAnnotBits[pRO->lFrame])
    {
        if ((pRO->Flags & RF_USE_THUMBNAIL_DATA) || (pRO->Flags & RF_USE_MEDIUM_QUALITY_DATA))
        {
            _MungeAnnotationDataForThumbnails( src, srcBeforeClipping, pRO->pDest, pRO->Flags );
        }

        HDC hdcTemp = pRO->g->GetHDC();
        if ((Gdiplus::Ok == pRO->g->GetLastStatus()) && hdcTemp)
        {
            _RenderAnnotations( hdcTemp, &pRO->Dim, pRO->pDest, srcBeforeClipping, src );
            pRO->g->ReleaseHDC( hdcTemp );
        }
    }



    //
    // If we created a new object for the image bits then delete it here...
    //

    if (bNeedsToBeDeleted)
    {
        delete pImage;
    }

    //
    // To save memory, once we have rendered the full image we discard it
    // so the memory can be reclaimed...
    //

    if ((pRO->Flags & RF_USE_FULL_IMAGE_DATA) || (pRO->Flags & RF_USE_MEDIUM_QUALITY_DATA))
    {
        _DiscardGdiPlusImages();
    }

    WIA_RETURN_HR(hr);
}



/*****************************************************************************

   CPhotoItem::_LoadAnnotations

   If there are annotations in this image, load them...

 *****************************************************************************/

HRESULT CPhotoItem::_LoadAnnotations()
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_LoadAnnotations(%s)"),_szFileName));

    //
    // Only do this if we don't already have the data and haven't already
    // tried to load this before and found out there are no annotations...
    //

    if (!_pAnnotBits && !_pAnnotations && !_bWeKnowAnnotationsDontExist)
    {
        //
        // Ensure we have the image...
        //

        _CreateGdiPlusImage();

        //
        // Make sure we have frame data
        //

        LONG lDummy = 0;
        GetImageFrameCount( &lDummy );

        //
        // If we have any annotations, then load them up accross all the frames...
        //

        UINT uSize = 0;
        BOOL bHasAnnotations = FALSE;
        Gdiplus::Status status;

        _pAnnotations = (CAnnotationSet *)new CAnnotationSet();

        if (_pAnnotations)
        {
            _pAnnotBits = (Gdiplus::PropertyItem **) new BYTE[ sizeof(LPVOID) * _lFrameCount ];

            if (_pAnnotBits)
            {
                for (LONG lCurFrame=0; lCurFrame < _lFrameCount; lCurFrame++)
                {
                    status = _pImage->SelectActiveFrame( _bTimeFrames ? &Gdiplus::FrameDimensionTime : &Gdiplus::FrameDimensionPage, lCurFrame );

                    if (Gdiplus::Ok == status)
                    {
                        //
                        // Load the annotation bits for this frame...
                        //

                        uSize = _pImage->GetPropertyItemSize( ANNOTATION_IMAGE_TAG );

                        if (uSize > 0)
                        {
                            _pAnnotBits[lCurFrame] = (Gdiplus::PropertyItem *) new BYTE[ uSize ];
                            if (_pAnnotBits[lCurFrame])
                            {
                                //
                                // Read the annotations tag from the file...
                                //

                                status = _pImage->GetPropertyItem( ANNOTATION_IMAGE_TAG, uSize, _pAnnotBits[lCurFrame] );
                                if ((Gdiplus::Ok == status) && _pAnnotBits[lCurFrame])
                                {
                                    bHasAnnotations = TRUE;
                                }
                                else
                                {
                                    WIA_ERROR((TEXT("CPhotoItem::_LoadAnnotations - GetPropertyItem failed w/hr=0x%x"),Gdiplus2HRESULT(status)));
                                }
                            }
                            else
                            {
                                WIA_ERROR((TEXT("CPhotoItem::_LoadAnnotations - couldn't create _pAnnotBits[%d]"),lCurFrame));
                            }
                        }
                        else
                        {
                            WIA_TRACE((TEXT("CPhotoItem::_LoadAnnotations - GetPropertyItemSize returned %d size"),uSize));
                        }

                    }
                    else
                    {
                        WIA_ERROR((TEXT("CPhotoItem::_LoadAnnotations - SelectActiveFrame(%d) failed w/hr=0x%x"),lCurFrame,Gdiplus2HRESULT(status)));
                    }
                }
            }
            else
            {
                WIA_ERROR((TEXT("CPhotoItem::_LoadAnnotations - couldn't create _pAnnotBits")));

                delete _pAnnotations;
                _pAnnotations = NULL;
            }
        }
        else
        {
            WIA_ERROR((TEXT("CPhotoItem::_LoadAnnotations - couldn't create _pAnnotations!")));
        }


        if (!bHasAnnotations)
        {
            WIA_TRACE((TEXT("CPhotoItem::_LoadAnnotations - no annotations were found!")));

            //
            // delete anything we created, as we didn't load any annotations...
            //

            if (_pAnnotBits)
            {
                for (LONG l=0; l < _lFrameCount; l++)
                {
                    delete [] _pAnnotBits[l];
                    _pAnnotBits[l] = NULL;
                }

                delete [] _pAnnotBits;
                _pAnnotBits = NULL;
            }

            if (_pAnnotations)
            {
                delete _pAnnotations;
                _pAnnotations = NULL;
            }

            //
            // We gave it our best shot -- there aren't any annotations
            // so don't bother trying again for this session of the wizard
            // for this image...

            _bWeKnowAnnotationsDontExist = TRUE;

        }

    }
    else
    {
        WIA_TRACE((TEXT("CPhotoItem::_LoadAnnotations - not loading because we already have pointers to the data.")));
    }

    WIA_RETURN_HR(S_OK);
}


/*****************************************************************************

   CPhotoItem::_CreateGdiPlusImage

   Instantiates Gdi+ plus over the given image...

 *****************************************************************************/

HRESULT CPhotoItem::_CreateGdiPlusImage()
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_CreateGdiPlusImage(%s)"),_szFileName));


    HRESULT hr = S_OK;

    CAutoCriticalSection lock(_csItem);

    //
    // Try and get the size of the file...
    //

    if (_llFileSize == 0)
    {
        TCHAR szPath[ MAX_PATH + 64 ];

        *szPath = 0;
        if (SHGetPathFromIDList( _pidlFull, szPath ) && *szPath)
        {
            HANDLE hFile = CreateFile( szPath,
                                       GENERIC_READ,
                                       FILE_SHARE_READ,
                                       NULL,
                                       OPEN_EXISTING,
                                       FILE_ATTRIBUTE_NORMAL,
                                       NULL
                                      );

            if (hFile != INVALID_HANDLE_VALUE)
            {
                LARGE_INTEGER li;
                if (GetFileSizeEx( hFile, &li ))
                {
                    _llFileSize = li.QuadPart;
                }

                CloseHandle( hFile );
            }

        }
    }

    //
    // Make sure we've got a stream pointer to the file
    //

    if (!_pImage)
    {
        //
        // Get an IStream pointer for our item
        //

        CComPtr<IShellFolder> psfDesktop;
        hr = SHGetDesktopFolder( &psfDesktop );
        if (SUCCEEDED(hr) && psfDesktop)
        {
            hr = psfDesktop->BindToObject( _pidlFull, NULL, IID_IStream, (LPVOID *)&_pStream );
            WIA_CHECK_HR(hr,"_CreateGdiPlusImage: psfDesktop->BindToObject( IStream for _pidlFull )");

            if (SUCCEEDED(hr) && _pStream)
            {
                //
                // Create GDI+ image object from stream
                //

                _pImage = new Gdiplus::Image( _pStream, TRUE );
                if (!_pImage)
                {
                    _pStream = NULL;
                    WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusImage(%s) - _pImage is NULL, creation of GDI+ image object failed!"),_szFileName));
                    hr = E_OUTOFMEMORY;
                }
                else
                {
                    hr = Gdiplus2HRESULT(_pImage->GetLastStatus());

                    if (FAILED(hr))
                    {
                        delete _pImage;
                        _pImage  = NULL;
                        _pStream = NULL;
                        WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusImage(%s) - creation of image failed w/GDI+ hr = 0x%x"),_szFileName,hr));
                    }
                }

            }
        }
        else
        {
            WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusImage(%s) - Couldn't get psfDesktop!"),_szFileName));
        }
    }

    WIA_RETURN_HR(hr);

}



/*****************************************************************************

   CPhotoItem::_CreateGdiPlusThumbnail

   Ensure we have a GdiPlus::Image for the thumbnail

 *****************************************************************************/

HRESULT CPhotoItem::_CreateGdiPlusThumbnail( const SIZE &sizeDesired, LONG lFrame )
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_CreateGdiPlusThumbnail( %s, this = 0x%x )"),_szFileName,this));

    HRESULT           hr     = S_OK;
    Gdiplus::GpStatus status = Gdiplus::Ok;

    CAutoCriticalSection lock(_csItem);

    //
    // Ensure we have backing Image for file..
    //

    hr = _CreateGdiPlusImage();

    if (SUCCEEDED(hr) && _pImage)
    {
        //
        // Get the number of frames...
        //

        LONG lFrameCount = 0;
        hr = GetImageFrameCount( &lFrameCount );

        if (SUCCEEDED(hr))
        {

            //
            // Our primary goal is to get at the thumbnail bitmap bits for the
            // specified frame.  First, make sure we've got an array to place
            // these in to.
            //

            if ((!_pThumbnails) && (lFrameCount >= 1))
            {
                WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - _pThumbnails(0x%x) and _lFrameCount(%d)"),_szFileName,_pThumbnails,lFrameCount));

                _pThumbnails = (HBITMAP *) new HBITMAP [lFrameCount];


                if (_pThumbnails)
                {
                    //
                    // Ensure we start out with NULL HBITMAPS...
                    //

                    for (INT i=0; i<lFrameCount; i++)
                    {
                        _pThumbnails[i] = NULL;
                    }
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                }

                WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - _pThumbnails is now (0x%x)"),_szFileName,_pThumbnails));
            }

            if (SUCCEEDED(hr) && _pThumbnails)
            {
                WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - we have _pThumbnails"),_szFileName));

                //
                // Do we already have thumbnail bits for this frame?
                //

                if ((lFrame < lFrameCount) && (!_pThumbnails[lFrame]))
                {
                    //
                    // Have to create thumbnail for this frame.
                    // Select the specified frame.
                    //

                    status = _pImage->SelectActiveFrame( _bTimeFrames ? &Gdiplus::FrameDimensionTime : &Gdiplus::FrameDimensionPage, lFrame );
                    hr = Gdiplus2HRESULT(status);

                    if (SUCCEEDED(hr))
                    {
                        GUID guidFormat = {0};
                        Gdiplus::Image * pThumb = NULL;

                        status = _pImage->GetRawFormat( &guidFormat );

                        if (status == Gdiplus::Ok && (guidFormat == ImageFormatIcon))
                        {
                            pThumb = _pImage;
                        }
                        else
                        {
                            pThumb = _pImage->GetThumbnailImage( 0, 0, NULL, NULL );
                        }


                        if (pThumb)
                        {

                            WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - SIZE - _pImage (%d x %d )"),_szFileName,_pImage->GetWidth(), _pImage->GetHeight()));
                            WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - SIZE - pThumb (%d x %d)"),_szFileName,pThumb->GetWidth(),pThumb->GetHeight()));

                            //
                            // Scale image to fill thumbnail space while preserving
                            // aspect ratio...
                            //

                            SIZE sizeDrawSize = {0};
                            sizeDrawSize = PrintScanUtil::ScalePreserveAspectRatio( sizeDesired.cx,
                                                                                    sizeDesired.cy,
                                                                                    _pImage->GetWidth(),
                                                                                    _pImage->GetHeight()
                                                                                   );

                            WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - SIZE - sizeDesired( %d x %d )"),_szFileName,sizeDesired.cx, sizeDesired.cy));
                            WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s) - SIZE - sizeDrawsize( %d x %d )"),_szFileName,sizeDrawSize.cx, sizeDrawSize.cy));


                            //
                            // Create an HBITMAP of the thumbnail...
                            //

                            Gdiplus::Bitmap * pBitmap = new Gdiplus::Bitmap( sizeDrawSize.cx, sizeDrawSize.cy );
                            if (pBitmap)
                            {
                                hr = Gdiplus2HRESULT(pBitmap->GetLastStatus());
                                if (SUCCEEDED(hr))
                                {
                                    //
                                    // Get a graphics to render to
                                    //

                                    Graphics *pGraphics = Gdiplus::Graphics::FromImage((Gdiplus::Image *)pBitmap);

                                    if (pGraphics)
                                    {
                                        hr = Gdiplus2HRESULT(pGraphics->GetLastStatus());

                                        //
                                        // Make sure it is valid
                                        //

                                        if (SUCCEEDED(hr))
                                        {
                                            //
                                            // erase the background of the image
                                            //

                                            pGraphics->Clear( g_wndColor );

                                            //
                                            // Set the interpolation mode to high quality
                                            //

                                            pGraphics->SetInterpolationMode( Gdiplus::InterpolationModeHighQualityBilinear );

                                            //
                                            // Draw scaled image
                                            //

                                            WIA_TRACE((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - calling pGraphics->DrawImage( pThumb, %d, %d, %d, %d )"),_szFileName,0 + ((sizeDesired.cx - sizeDrawSize.cx) / 2),0 + ((sizeDesired.cy - sizeDrawSize.cy) / 2),sizeDrawSize.cx,sizeDrawSize.cy));

                                            hr = Gdiplus2HRESULT(pGraphics->DrawImage( pThumb,
                                                                                       0,
                                                                                       0,
                                                                                       sizeDrawSize.cx,
                                                                                       sizeDrawSize.cy
                                                                                      ));

                                            WIA_CHECK_HR(hr,"CPhotoItem::GetThumbnailBitmap() - pGraphics->DrawImage( pThumb ) failed!");

                                            if (SUCCEEDED(hr))
                                            {
                                                DWORD dw = GetSysColor( COLOR_WINDOW );
                                                Gdiplus::Color wndClr(255,GetRValue(dw),GetGValue(dw),GetBValue(dw));

                                                pBitmap->GetHBITMAP( wndClr, &_pThumbnails[lFrame] );
                                            }

                                        }

                                        //
                                        // Clean up our dynamically allocated graphics
                                        //

                                        delete pGraphics;

                                    }
                                    else
                                    {
                                        WIA_ERROR((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - pGraphics was NULL!"),_szFileName));
                                        hr = E_OUTOFMEMORY;
                                    }
                                }
                                else
                                {
                                    WIA_ERROR((TEXT("CPhotoItem::GetThumbnailBitmap(%s) - pImage failed to be created, hr = 0x%x"),hr));
                                }

                                delete pBitmap;
                            }

                            if (pThumb != _pImage)
                            {
                                delete pThumb;
                            }
                        }
                        else
                        {
                            hr = Gdiplus2HRESULT(_pImage->GetLastStatus());
                            WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s): unable to GetThumbnailImage"),_szFileName));
                        }

                    }
                    else
                    {
                        WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s): unable to select frame %d"),_szFileName,lFrame));
                    }

                }
                else
                {
                    WIA_TRACE((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s): we already have _pThumbnails[%d], it is (0x%x)"),_szFileName,lFrame,_pThumbnails[lFrame]));
                }

            }

        }
        else
        {
            WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s): _pImage was NULL!"),_szFileName));
        }

    }
    else
    {
        WIA_ERROR((TEXT("CPhotoItem::_CreateGdiPlusThumbnail(%s): _pImage was NULL!"),_szFileName));
    }

    WIA_RETURN_HR(hr);
}


/*****************************************************************************

   CPhotoItem::_DiscardGdiPlusImages

   Releases GDI+ objects for thumbnail and image

 *****************************************************************************/

HRESULT CPhotoItem::_DiscardGdiPlusImages()
{
    WIA_PUSH_FUNCTION_MASK((TRACE_PHOTO_ITEM,TEXT("CPhotoItem::_DiscardGdiPlusImages(%s)"),_szFileName));

    CAutoCriticalSection lock(_csItem);

    //
    // Clear out GDI+ image objects...
    //

    if (_pImage)
    {
        delete _pImage;
        _pImage = NULL;
    }

    if (_pStream)
    {
        //
        // Since this is an CComPtr, setting this to NULL will free
        // the reference on the stream object...
        //

        _pStream = NULL;
    }

    if (_pClassBitmap)
    {
        delete _pClassBitmap;
        _pClassBitmap = NULL;
    }

    if (_pAnnotations)
    {
        delete _pAnnotations;
        _pAnnotations = NULL;
    }

    if (_pAnnotBits)
    {
        for (INT i=0; i < _lFrameCount; i++)
        {
            delete [] _pAnnotBits[i];
            _pAnnotBits[i] = NULL;
        }

        delete [] _pAnnotBits;
        _pAnnotBits = NULL;
    }

    return S_OK;

}