You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
708 lines
18 KiB
708 lines
18 KiB
/////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1998 Active Voice Corporation. All Rights Reserved.
|
|
//
|
|
// Active Agent(r) and Unified Communications(tm) are trademarks of Active Voice Corporation.
|
|
//
|
|
// Other brand and product names used herein are trademarks of their respective owners.
|
|
//
|
|
// The entire program and user interface including the structure, sequence, selection,
|
|
// and arrangement of the dialog, the exclusively "yes" and "no" choices represented
|
|
// by "1" and "2," and each dialog message are protected by copyrights registered in
|
|
// the United States and by international treaties.
|
|
//
|
|
// Protected by one or more of the following United States patents: 5,070,526, 5,488,650,
|
|
// 5,434,906, 5,581,604, 5,533,102, 5,568,540, 5,625,676, 5,651,054.
|
|
//
|
|
// Active Voice Corporation
|
|
// Seattle, Washington
|
|
// USA
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////
|
|
// splash.c - splash screen functions
|
|
////
|
|
|
|
#include "winlocal.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "splash.h"
|
|
#include "gfx.h"
|
|
#include "mem.h"
|
|
#include "trace.h"
|
|
#include "wnd.h"
|
|
|
|
////
|
|
// private definitions
|
|
////
|
|
|
|
#define SPLASHCLASS TEXT("SplashClass")
|
|
|
|
#define ID_TIMER_MINSHOW 100
|
|
#define ID_TIMER_MAXSHOW 200
|
|
|
|
// splash control struct
|
|
//
|
|
typedef struct SPLASH
|
|
{
|
|
DWORD dwVersion;
|
|
HINSTANCE hInst;
|
|
HTASK hTask;
|
|
UINT msMinShow;
|
|
UINT msMaxShow;
|
|
DWORD dwFlags;
|
|
HWND hwndSplash;
|
|
HBITMAP hBitmap;
|
|
BOOL fVisible;
|
|
BOOL fHideAfterMinShowTimer;
|
|
BOOL fMinShowTimerSet;
|
|
BOOL fMaxShowTimerSet;
|
|
} SPLASH, FAR *LPSPLASH;
|
|
|
|
// helper functions
|
|
//
|
|
LRESULT DLLEXPORT CALLBACK SplashWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
static BOOL SplashOnNCCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct);
|
|
static void SplashOnPaint(HWND hwnd);
|
|
static void SplashOnTimer(HWND hwnd, UINT id);
|
|
static UINT SplashOnNCHitTest(HWND hwnd, int x, int y);
|
|
static void SplashOnChar(HWND hwnd, UINT ch, int cRepeat);
|
|
static void SplashOnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
|
|
static void SplashOnRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
|
|
static int SplashAbort(LPSPLASH lpSplash);
|
|
static LPSPLASH SplashGetPtr(HSPLASH hSplash);
|
|
static HSPLASH SplashGetHandle(LPSPLASH lpSplash);
|
|
|
|
////
|
|
// public functions
|
|
////
|
|
|
|
// SplashCreate - create splash screen
|
|
// <dwVersion> (i) must be SPLASH_VERSION
|
|
// <hInst> (i) instance handle of calling module
|
|
// <hwndParent> (i) window which will own the splash screen
|
|
// NULL desktop window
|
|
// <hBitmapMono> (i) bitmap to display on mono displays
|
|
// <hBitmapColor> (i) bitmap to display on color displays
|
|
// 0 use mono bitmap
|
|
// <msMinShow> (i) minimum time (ms) to show splash screen
|
|
// 0 no minimum time
|
|
// <msMaxShow> (i) maximum time (ms) to show splash screen
|
|
// 0 no maximum time
|
|
// <dwFlags> (i) control flags
|
|
// SPLASH_SETFOCUS SplashShow will set focus to splash screen
|
|
// SPLASH_NOFOCUS user cannot set focus to splash screen
|
|
// SPLASH_ABORT user can hide splash screen w/mouse or keybd
|
|
// SPLASH_NOMOVE user cannot move the splash screen w/mouse
|
|
// return handle (NULL if error)
|
|
//
|
|
// NOTE: SplashCreate creates the window but does not show it.
|
|
// See SplashShow and SplashHide
|
|
//
|
|
HSPLASH DLLEXPORT WINAPI SplashCreate(DWORD dwVersion, HINSTANCE hInst,
|
|
HWND hwndParent, HBITMAP hBitmapMono, HBITMAP hBitmapColor,
|
|
UINT msMinShow, UINT msMaxShow, DWORD dwFlags)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash = NULL;
|
|
WNDCLASS wc;
|
|
|
|
if (dwVersion != SPLASH_VERSION)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (hInst == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if ((lpSplash = (LPSPLASH) MemAlloc(NULL, sizeof(SPLASH), 0)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else
|
|
{
|
|
lpSplash->dwVersion = dwVersion;
|
|
lpSplash->hInst = hInst;
|
|
lpSplash->hTask = GetCurrentTask();
|
|
lpSplash->msMinShow = msMinShow;
|
|
lpSplash->msMaxShow = msMaxShow;
|
|
lpSplash->dwFlags = dwFlags;
|
|
lpSplash->hwndSplash = NULL;
|
|
lpSplash->hBitmap = NULL;
|
|
lpSplash->fVisible = FALSE;
|
|
lpSplash->fHideAfterMinShowTimer = FALSE;
|
|
lpSplash->fMinShowTimerSet = FALSE;
|
|
lpSplash->fMaxShowTimerSet = FALSE;
|
|
|
|
if (hwndParent == NULL)
|
|
hwndParent = GetDesktopWindow();
|
|
|
|
// store either the mono or color bitmap, as appropriate
|
|
//
|
|
if (GfxDeviceIsMono(NULL) || hBitmapColor == 0)
|
|
lpSplash->hBitmap = hBitmapMono;
|
|
else
|
|
lpSplash->hBitmap = hBitmapColor;
|
|
}
|
|
|
|
// register splash screen class unless it has been already
|
|
//
|
|
if (fSuccess && GetClassInfo(lpSplash->hInst, SPLASHCLASS, &wc) == 0)
|
|
{
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hIcon = (HICON) NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.hInstance = lpSplash->hInst;
|
|
wc.lpszClassName = SPLASHCLASS;
|
|
wc.hbrBackground = NULL;
|
|
wc.lpfnWndProc = SplashWndProc;
|
|
wc.style = 0L;
|
|
wc.cbWndExtra = sizeof(lpSplash);
|
|
wc.cbClsExtra = 0;
|
|
|
|
if (!RegisterClass(&wc))
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
|
|
// create a splash screen window
|
|
//
|
|
if (fSuccess && (lpSplash->hwndSplash = CreateWindowEx(
|
|
0L,
|
|
SPLASHCLASS,
|
|
(LPTSTR) TEXT(""),
|
|
WS_POPUP,
|
|
0, 0, 0, 0, // we will calculate size and position later
|
|
hwndParent,
|
|
(HMENU) NULL,
|
|
lpSplash->hInst,
|
|
lpSplash)) == NULL)
|
|
{
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
BITMAP Bitmap;
|
|
|
|
// the size of the window is equal to the size of the bitmap
|
|
//
|
|
if (GetObject((HGDIOBJ) lpSplash->hBitmap, sizeof(BITMAP), &Bitmap) == 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (!SetWindowPos(lpSplash->hwndSplash,
|
|
NULL, 0, 0, Bitmap.bmWidth, Bitmap.bmHeight,
|
|
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER))
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
int cxOffCenter = 0;
|
|
int cyOffCenter = 0;
|
|
|
|
// try to avoid having the window overlap
|
|
// the icons at the bottom of the desktop window
|
|
//
|
|
if (hwndParent == GetDesktopWindow())
|
|
{
|
|
#if 0
|
|
cyOffCenter = -1 * ((GetSystemMetrics(SM_CYICON) +
|
|
GetSystemMetrics(SM_CYCAPTION) * 2) / 2);
|
|
#endif
|
|
}
|
|
|
|
// center the window on its parent
|
|
//
|
|
if (WndCenterWindow(lpSplash->hwndSplash,
|
|
hwndParent, cxOffCenter, cyOffCenter) != 0)
|
|
{
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
}
|
|
|
|
if (!fSuccess)
|
|
{
|
|
SplashDestroy(SplashGetHandle(lpSplash));
|
|
lpSplash = NULL;
|
|
}
|
|
|
|
return fSuccess ? SplashGetHandle(lpSplash) : NULL;
|
|
}
|
|
|
|
// SplashDestroy - destroy splash screen
|
|
// <hSplash> (i) handle returned from SplashCreate
|
|
// return 0 if success
|
|
//
|
|
// NOTE: SplashDestroy always destroys the splash screen,
|
|
// whether or not the minimum show time has elapsed.
|
|
//
|
|
int DLLEXPORT WINAPI SplashDestroy(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if (SplashHide(hSplash) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if ((lpSplash = SplashGetPtr(hSplash)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (lpSplash->hwndSplash != NULL &&
|
|
!DestroyWindow(lpSplash->hwndSplash))
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if ((lpSplash = MemFree(NULL, lpSplash)) != NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return fSuccess ? 0 : -1;
|
|
}
|
|
|
|
// SplashShow - show splash screen
|
|
// <hSplash> (i) handle returned from SplashCreate
|
|
// return 0 if success
|
|
//
|
|
// NOTE: SplashShow() makes the splash screen visible. Also, timers are
|
|
// initiated for minimum and maximum show times, if they were specified.
|
|
//
|
|
int DLLEXPORT WINAPI SplashShow(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if ((lpSplash = SplashGetPtr(hSplash)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (lpSplash->fVisible)
|
|
; // already visible, so no need to do anything else
|
|
|
|
else
|
|
{
|
|
// prevent user input if SPLASH_NOFOCUS flag set
|
|
//
|
|
if (lpSplash->dwFlags & SPLASH_NOFOCUS)
|
|
EnableWindow(lpSplash->hwndSplash, FALSE);
|
|
|
|
// show the window
|
|
//
|
|
ShowWindow(lpSplash->hwndSplash, SW_SHOW);
|
|
UpdateWindow(lpSplash->hwndSplash);
|
|
lpSplash->fVisible = TRUE;
|
|
|
|
// set focus to splash screen if SPLASH_SETFOCUS flag set
|
|
//
|
|
if (lpSplash->dwFlags & SPLASH_SETFOCUS)
|
|
SetFocus(lpSplash->hwndSplash);
|
|
|
|
// set min show timer if necessary
|
|
//
|
|
if (!lpSplash->fMinShowTimerSet &&
|
|
lpSplash->msMinShow > 0)
|
|
{
|
|
if (!SetTimer(lpSplash->hwndSplash, ID_TIMER_MINSHOW,
|
|
lpSplash->msMinShow, NULL))
|
|
fSuccess = TraceFALSE(NULL);
|
|
else
|
|
lpSplash->fMinShowTimerSet = TRUE;
|
|
}
|
|
|
|
// set max show timer if necessary
|
|
//
|
|
if (!lpSplash->fMaxShowTimerSet &&
|
|
lpSplash->msMaxShow > 0)
|
|
{
|
|
if (!SetTimer(lpSplash->hwndSplash, ID_TIMER_MAXSHOW,
|
|
lpSplash->msMaxShow, NULL))
|
|
fSuccess = TraceFALSE(NULL);
|
|
else
|
|
lpSplash->fMaxShowTimerSet = TRUE;
|
|
}
|
|
}
|
|
|
|
return fSuccess ? 0 : -1;
|
|
}
|
|
|
|
// SplashHide - hide splash screen
|
|
// <hSplash> (i) handle returned from SplashCreate
|
|
// return 0 if success
|
|
//
|
|
// NOTE: SplashHide() will hide the splash screen, unless
|
|
// 1) the minimum show time has not yet elapsed. If not,
|
|
// the splash screen will remain visible until then.
|
|
// 2) the maximum show time has already elapsed. If so,
|
|
// the splash screen has already been hidden.
|
|
//
|
|
int DLLEXPORT WINAPI SplashHide(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if ((lpSplash = SplashGetPtr(hSplash)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (!lpSplash->fVisible)
|
|
; // already hidden, so no need to do anything else
|
|
|
|
else if (lpSplash->fMinShowTimerSet)
|
|
{
|
|
// minimum show time not yet elapsed
|
|
// set a flag so we know to hide window later
|
|
//
|
|
lpSplash->fHideAfterMinShowTimer = TRUE;
|
|
}
|
|
|
|
else
|
|
{
|
|
// hide the window
|
|
//
|
|
ShowWindow(lpSplash->hwndSplash, SW_HIDE);
|
|
lpSplash->fVisible = FALSE;
|
|
lpSplash->fHideAfterMinShowTimer = FALSE;
|
|
|
|
// kill min show timer if necessary
|
|
//
|
|
if (lpSplash->fMinShowTimerSet &&
|
|
!KillTimer(lpSplash->hwndSplash, ID_TIMER_MINSHOW))
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else
|
|
lpSplash->fMinShowTimerSet = FALSE;
|
|
|
|
// kill max show timer if necessary
|
|
//
|
|
if (lpSplash->fMaxShowTimerSet &&
|
|
!KillTimer(lpSplash->hwndSplash, ID_TIMER_MAXSHOW))
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else
|
|
lpSplash->fMaxShowTimerSet = FALSE;
|
|
}
|
|
|
|
return fSuccess ? 0 : -1;
|
|
}
|
|
|
|
// SplashIsVisible - get visible flag
|
|
// <hSplash> (i) handle returned from SplashCreate
|
|
// return TRUE if splash screen is visible, FALSE if hidden or error
|
|
//
|
|
int DLLEXPORT WINAPI SplashIsVisible(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if ((lpSplash = SplashGetPtr(hSplash)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return fSuccess ? lpSplash->fVisible : FALSE;
|
|
}
|
|
|
|
// SplashGetWindowHandle - get splash screen window handle
|
|
// <hSplash> (i) handle returned from SplashCreate
|
|
// return window handle (NULL if error)
|
|
//
|
|
HWND DLLEXPORT WINAPI SplashGetWindowHandle(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if ((lpSplash = SplashGetPtr(hSplash)) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return fSuccess ? lpSplash->hwndSplash : NULL;
|
|
}
|
|
|
|
////
|
|
// helper functions
|
|
////
|
|
|
|
// SplashWndProc - window procedure for splash screen
|
|
//
|
|
LRESULT DLLEXPORT CALLBACK SplashWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LRESULT lResult;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_NCCREATE:
|
|
lResult = (LRESULT) HANDLE_WM_NCCREATE(hwnd, wParam, lParam, SplashOnNCCreate);
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
lResult = (LRESULT) HANDLE_WM_PAINT(hwnd, wParam, lParam, SplashOnPaint);
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
lResult = (LRESULT) HANDLE_WM_TIMER(hwnd, wParam, lParam, SplashOnTimer);
|
|
break;
|
|
|
|
case WM_NCHITTEST:
|
|
lResult = (LRESULT) HANDLE_WM_NCHITTEST(hwnd, wParam, lParam, SplashOnNCHitTest);
|
|
break;
|
|
|
|
case WM_CHAR:
|
|
lResult = (LRESULT) HANDLE_WM_CHAR(hwnd, wParam, lParam, SplashOnChar);
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
lResult = (LRESULT) HANDLE_WM_LBUTTONDOWN(hwnd, wParam, lParam, SplashOnLButtonDown);
|
|
break;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
lResult = (LRESULT) HANDLE_WM_RBUTTONDOWN(hwnd, wParam, lParam, SplashOnRButtonDown);
|
|
break;
|
|
|
|
default:
|
|
lResult = DefWindowProc(hwnd, msg, wParam, lParam);
|
|
break;
|
|
}
|
|
|
|
return lResult;
|
|
}
|
|
|
|
// SplashOnNCCreate - handler for WM_NCCREATE message
|
|
//
|
|
static BOOL SplashOnNCCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct)
|
|
{
|
|
LPSPLASH lpSplash = (LPSPLASH) lpCreateStruct->lpCreateParams;
|
|
|
|
lpSplash->hwndSplash = hwnd;
|
|
|
|
// store lpSplash in window extra bytes
|
|
//
|
|
SetWindowLongPtr(hwnd, 0, (LONG_PTR) lpSplash);
|
|
|
|
return FORWARD_WM_NCCREATE(hwnd, lpCreateStruct, DefWindowProc);
|
|
}
|
|
|
|
// SplashOnPaint - handler for WM_PAINT message
|
|
//
|
|
static void SplashOnPaint(HWND hwnd)
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
|
|
// display splash screen bitmap
|
|
//
|
|
GfxBitmapDisplay(hdc, lpSplash->hBitmap, 0, 0, FALSE);
|
|
|
|
EndPaint(hwnd, &ps);
|
|
|
|
return;
|
|
}
|
|
|
|
// SplashOnTimer - handler for WM_TIMER message
|
|
//
|
|
static void SplashOnTimer(HWND hwnd, UINT id)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
|
|
switch (id)
|
|
{
|
|
case ID_TIMER_MINSHOW:
|
|
{
|
|
// kill the timer so it does not repeat
|
|
//
|
|
if (lpSplash->fMinShowTimerSet &&
|
|
!KillTimer(lpSplash->hwndSplash, ID_TIMER_MINSHOW))
|
|
fSuccess = TraceFALSE(NULL);
|
|
else
|
|
{
|
|
lpSplash->fMinShowTimerSet = FALSE;
|
|
|
|
// hide window if SplashHide was called earlier
|
|
//
|
|
if (lpSplash->fVisible &&
|
|
lpSplash->fHideAfterMinShowTimer &&
|
|
SplashHide(SplashGetHandle(lpSplash)) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ID_TIMER_MAXSHOW:
|
|
{
|
|
// kill the timer so it does not repeat
|
|
//
|
|
if (lpSplash->fMaxShowTimerSet &&
|
|
!KillTimer(lpSplash->hwndSplash, ID_TIMER_MAXSHOW))
|
|
fSuccess = TraceFALSE(NULL);
|
|
else
|
|
{
|
|
lpSplash->fMaxShowTimerSet = FALSE;
|
|
|
|
// hide window if max show time expired
|
|
//
|
|
if (lpSplash->fVisible &&
|
|
SplashHide(SplashGetHandle(lpSplash)) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// SplashOnNCHitTest - handler for WM_NCHITTEST message
|
|
//
|
|
static UINT SplashOnNCHitTest(HWND hwnd, int x, int y)
|
|
{
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
UINT uResult;
|
|
|
|
// prevent the user from dragging the window
|
|
// if SPLASH_NOMOVE flag is set
|
|
//
|
|
if (lpSplash->dwFlags & SPLASH_NOMOVE)
|
|
uResult = FORWARD_WM_NCHITTEST(hwnd, x, y, DefWindowProc);
|
|
|
|
else
|
|
{
|
|
POINT pt;
|
|
RECT rc;
|
|
|
|
// get current mouse cursor position relative to client area
|
|
//
|
|
pt.x = x;
|
|
pt.y = y;
|
|
ScreenToClient(lpSplash->hwndSplash, &pt);
|
|
|
|
// if mouse cursor is within window client area
|
|
// pretend it is actually within the title bar
|
|
//
|
|
GetClientRect(lpSplash->hwndSplash, &rc);
|
|
if (PtInRect(&rc, pt))
|
|
uResult = HTCAPTION;
|
|
else
|
|
uResult = FORWARD_WM_NCHITTEST(hwnd, x, y, DefWindowProc);
|
|
}
|
|
|
|
return uResult;
|
|
}
|
|
|
|
// SplashOnChar - handler for WM_CHAR message
|
|
//
|
|
static void SplashOnChar(HWND hwnd, UINT ch, int cRepeat)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
|
|
// hide window if key pressed
|
|
//
|
|
if (SplashAbort(lpSplash) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return;
|
|
}
|
|
|
|
// SplashOnLButtonDown - handler for WM_LBUTTONDOWN message
|
|
//
|
|
static void SplashOnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
|
|
// hide window if mouse clicked on window
|
|
//
|
|
if (SplashAbort(lpSplash) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return;
|
|
}
|
|
|
|
// SplashOnRButtonDown - handler for WM_LBUTTONDOWN message
|
|
//
|
|
static void SplashOnRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
// retrieve lpSplash from window extra bytes
|
|
//
|
|
LPSPLASH lpSplash = (LPSPLASH) GetWindowLongPtr(hwnd, 0);
|
|
|
|
// hide window if mouse clicked on window
|
|
//
|
|
if (SplashAbort(lpSplash) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return;
|
|
}
|
|
|
|
// SplashAbort - hide splash window if SPLASH_ABORT flag set
|
|
// <lpSplash> (i) pointer to SPLASH struct
|
|
// return 0 if success
|
|
//
|
|
static int SplashAbort(LPSPLASH lpSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
// hide window if SPLASH_ABORT flag set
|
|
//
|
|
if ((lpSplash->dwFlags & SPLASH_ABORT) &&
|
|
lpSplash->fVisible &&
|
|
SplashHide(SplashGetHandle(lpSplash)) != 0)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return fSuccess ? 0 : -1;
|
|
}
|
|
|
|
// SplashGetPtr - verify that splash handle is valid,
|
|
// <hSplash> (i) handle returned from SplashInit
|
|
// return corresponding splash pointer (NULL if error)
|
|
//
|
|
static LPSPLASH SplashGetPtr(HSPLASH hSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
LPSPLASH lpSplash;
|
|
|
|
if ((lpSplash = (LPSPLASH) hSplash) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
else if (IsBadWritePtr(lpSplash, sizeof(SPLASH)))
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
#ifdef CHECKTASK
|
|
// make sure current task owns the splash handle
|
|
//
|
|
else if (lpSplash->hTask != GetCurrentTask())
|
|
fSuccess = TraceFALSE(NULL);
|
|
#endif
|
|
|
|
return fSuccess ? lpSplash : NULL;
|
|
}
|
|
|
|
// SplashGetHandle - verify that splash pointer is valid,
|
|
// <lpSplash> (i) pointer to SPLASH struct
|
|
// return corresponding splash handle (NULL if error)
|
|
//
|
|
static HSPLASH SplashGetHandle(LPSPLASH lpSplash)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
HSPLASH hSplash;
|
|
|
|
if ((hSplash = (HSPLASH) lpSplash) == NULL)
|
|
fSuccess = TraceFALSE(NULL);
|
|
|
|
return fSuccess ? hSplash : NULL;
|
|
}
|
|
|