Application Modernization: What Is It and How to Get Started
A very common requirement for applications that take a lot of time to start is to throw up a nice looking splash window at startup. Here, I will discuss how such splash windows can be developed using the new layering APIs available with Win2000 and later versions of Windows.
- Bitmap files for the splash image
- Simple, non-MFC, C++ interface
- Uses only Win32 calls
- Works only on WinXP/Win2000 and later
- Image formats other than BMP are not supported
- Text messages or progress bar to display initialization progress is not present, although it can be added if required
This application also shows how visually rich modules can be developed using C++ and Win32 without MFC.
Preparing the Image
First, create the image you would like to show as the splash in your favorite image editor. Then, choose the part of the image you would not like to be rendered on the screen and give it a particular color that does not occur anywhere else on the image. For example, if your image is a red circle with some logo or text inside it in blue, fill all the region outside the circle with a color such as green (anything other than red and blue; I used grey 128,128,128). Note the R, G, B values of the color.
The interface of the class is very simple. Use the overloaded constructor and specify the bitmap file path and the color on it to be made transparent. Then, use thed ShowSplash metho to show the splash screen. The function returns immediately. You then can complete all your initialization and, at the end, call CloseSplash to remove the splash window. The code follows:
#include "splash.h" // Include the class header in your file // Give the path of the image and the transparent color CSplash splash1(TEXT(".\\Splash.bmp"), RGB(128, 128, 128)); // Display the splash splash1.ShowSplash(); // your startup initialization code goes here // Close the splash screen splash1.CloseSplash();
The other alternative is to use the default constructor and then use individual calls to set up the bitmap path and transparent color. In the sample project, the SplashClient.cpp source file contains code that demonstrates both ways of using the CSplash class.
Under the Hood
The class is implemented using Win32 API calls.
The constructor stores the pointer to the layering Win32 SetLayeredWindowAttributes call that is used to make the window transparent from USER32.dll into a g_pSetLayeredWindowAttributes function pointer.
The SetBitmap method opens the bitmap file, loads it, and stores a handle to it in the m_hBitmap member. It also stores its width and height in m_dwWidth and m_dwHeight.
SetTransparentColor calls MakeTransparent, which sets the layering style of the window and uses the g_pSetLayeredWindowAttributes function pointer to make the requested color transparent for the CSplash window.
The RegAndCreateWindow private function registers and creates the window for the splash window. The window procedure used with this window is an ExtWndProc external function. With the CreateWindowEx call, we pass the this pointer. This makes the pointer to CSplash class reach the ExtWndProc function as lparam with the WM_CREATE message. ExtWndProc stores this pointer and forwards all subsequent messages to the CSplash::WindowProc member function.
CSplash::WindowProc contains code to call OnPainton receiving a WM_PAINT message. Inside OnPaint, we select the bitmap (in m_hBitmap) to a device context in memory and then BitBlt it to the screen device context. And we are done displaying the splash window.
To close the window, CloseSplash destroys the window and unregisters the class associated with the window.