FaderWnd - a Window Fader for Windows 2000

/*----------------------------------------------------------------------------*/
/*            CFaderWnd implementation                                        */
/*----------------------------------------------------------------------------*/
//
//	File:			FaderWnd.cpp
//	Author:		Phil J. Pearson
//	Created:	20 June 2000  14:26
//	Last Mod: 23 June 2000  19:06
//
/*----------------------------------------------------------------------------
/*
/* Copyright (C) 2000 by Real World Software
/* All Rights Reserved.
/*
/*----------------------------------------------------------------------------*/

///////////////////////////////////////////////////////////////////////////////
//
// An MFC class to fade out any window, requiring only one extra line of
// code, typically:
//	new CFaderWnd(this);
//
// It uses the UpdateLayeredWindow function, not available on Win9x or NT.
// It uses GetProcAddress instead of implicitly linking to the function so
// that code using this class will load and run on any Win32 platform. If
// the necessary function is not available then the fade will simply not
// happen.
// It works by making an exact copy of the source window and fading the copy
// so it is usual to hide or destroy the source window immediately after
// creating an instance of this class. For example,
//	new CFaderWnd(this);
//	ShowWindow(SW_HIDE);
// or
//	new CFaderWnd(this);
//	DestroyWindow();
// or
//	new CFaderWnd(this);
//	EndDialog(nResult);
// Note that it's essential to construct the CFaderWnd FIRST.
//
// CFaderWnd must ALWAYS be contructed on the heap (with new CFaderWnd...).
// It is NEVER necessary to call the destructor (delete ...) since CFaderWnd
// takes care of deleting itself (tidies up and closes the door behind itself).
//
///////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "FaderWnd.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// how much we decrease the alpha each time
#define ALPHA_STEP 5

/////////////////////////////////////////////////////////////////////////////
// CFaderWnd

CFaderWnd::CFaderWnd(CWnd *pWndToFade, UINT nFadeTime /*= 2000*/, BYTE byAlpha /*= 255*/)
	: m_pWndToFade(pWndToFade)
	{
	ASSERT(pWndToFade);
	ASSERT_VALID(pWndToFade);

	// Try to get the address of the UpdateLayeredWindow function. It may not be available.
  HMODULE hUser32 = GetModuleHandle(_T("USER32.DLL"));

	m_pUpdateLayeredWindow = (lpfnUpdateLayeredWindow)GetProcAddress(hUser32, "UpdateLayeredWindow");

	// If OS doesn't provide the function we can't fade, just commit suicide.
	if (NULL == m_pUpdateLayeredWindow)
		delete this;
	else
		{
		CRect		rc;
		CPoint	ptSrc(0, 0);
		SIZE		size;

		// Get the window rect of the source window.
		m_pWndToFade->GetWindowRect(rc);

		// Make a new window to match.
		//	WS_EX_LAYERED is necessary for UpdateLayeredWindow to be enabled.
		//	WS_EX_TRANSPARENT allows mouse clicks through to the window "underneath",
		//										(it's nothing to do with optical transparency).
		CreateEx(WS_EX_LAYERED|WS_EX_TRANSPARENT|WS_EX_TOPMOST|WS_EX_TOOLWINDOW, 
							"STATIC", "", WS_POPUP|WS_VISIBLE, rc, AfxGetMainWnd(), 0);

		// UpdateLayeredWindow needs the size and origin of the source window.
		size.cx = rc.Width();
		size.cy = rc.Height();
		ptSrc = rc.TopLeft();
  
		// Set up the BLENDFUNCTION struct used by UpdateLayeredWindow
		m_Blend.BlendOp = AC_SRC_OVER;					// the only BlendOp defined in Windows 2000
		m_Blend.BlendFlags = 0;									// nothing else is special ...
		m_Blend.AlphaFormat = 0;								// ...
		m_Blend.SourceConstantAlpha = byAlpha;	// the initial alpha value

		// Display the new static window with the exact content and position of the source window.
		// When we return the caller can hide or destroy the source window and nothing will
		// appear to change. Subsequently (in OnTimer) we will reduce the alpha value to fade away
		// this copy window.
		m_pUpdateLayeredWindow(GetSafeHwnd(), NULL, NULL, &size, ::GetDC(m_pWndToFade->GetSafeHwnd()),
														&ptSrc, 0, &m_Blend, ULW_ALPHA);

		// Calculate the timer interval required to complete the fade in the specified time.
		UINT	nElapse = nFadeTime / (byAlpha / ALPHA_STEP);
		SetTimer(1, nElapse, NULL);
		}
	}


CFaderWnd::~CFaderWnd()
	{
	}


BEGIN_MESSAGE_MAP(CFaderWnd, CWnd)
	//{{AFX_MSG_MAP(CFaderWnd)
	ON_WM_TIMER()
	ON_WM_SETFOCUS()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CFaderWnd message handlers


void CFaderWnd::OnTimer(UINT nIDEvent) 
	{
	if (m_Blend.SourceConstantAlpha >= ALPHA_STEP)
		{
		// Reduce the alpha value (towards transparency) and update the window.
		m_Blend.SourceConstantAlpha -= ALPHA_STEP;
		m_pUpdateLayeredWindow(GetSafeHwnd(), NULL, NULL, NULL, NULL, NULL, NULL, &m_Blend, ULW_ALPHA);
		}
	else
		{
		// Reached minimum alpha. Kill the timer and destroy our window.
		// PostNcDestroy will delete this CFaderWnd instance.
		KillTimer(nIDEvent);
		DestroyWindow();
		}
	}


void CFaderWnd::OnSetFocus(CWnd* pOldWnd) 
	{
	// When we get the input focus pass it back to the previous holder, if any.
	if (pOldWnd)
		pOldWnd->SetFocus();
	}