1 /*
   2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 // copy from awt.h
  27 #ifndef _WIN32_WINNT
  28 #define _WIN32_WINNT 0x0600
  29 #endif
  30 
  31 // copy from awt.h
  32 #ifndef _WIN32_IE
  33 #define _WIN32_IE 0x0600
  34 #endif
  35 
  36 #include "splashscreen_impl.h"
  37 #include <windowsx.h>
  38 #include <windows.h>
  39 #include <winuser.h>
  40 #include "sizecalc.h"
  41 
  42 #ifndef WS_EX_LAYERED
  43 #define WS_EX_LAYERED 0x80000
  44 #endif
  45 
  46 #ifndef ULW_ALPHA
  47 #define ULW_ALPHA               0x00000002
  48 #endif
  49 
  50 #ifndef AC_SRC_OVER
  51 #define AC_SRC_OVER                 0x00
  52 #endif
  53 
  54 #ifndef AC_SRC_ALPHA
  55 #define AC_SRC_ALPHA                0x01
  56 #endif
  57 
  58 #define WM_SPLASHUPDATE         WM_USER+1
  59 #define WM_SPLASHRECONFIGURE    WM_USER+2
  60 


  61 /* Could use npt but decided to cut down on linked code size */
  62 char* SplashConvertStringAlloc(const char* in, int *size) {
  63     int len, outChars, rc;
  64     WCHAR* buf;
  65     if (!in) {
  66         return NULL;
  67     }
  68     len = strlen(in);
  69     outChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, in, len,
  70                                        NULL, 0);
  71     buf = (WCHAR*) SAFE_SIZE_ARRAY_ALLOC(malloc, outChars, sizeof(WCHAR));
  72     if (!buf) {
  73         return NULL;
  74     }
  75     rc = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, in, len,
  76                                  buf, outChars);
  77     if (rc==0) {
  78         free(buf);
  79         return NULL;
  80     } else {
  81         if (size) {
  82             *size = rc;
  83         }
  84         return (char*)buf;
  85     }
  86 }
  87 
  88 unsigned
  89 SplashTime(void)
  90 {
  91     return GetTickCount();
  92 }
  93 
  94 void
  95 SplashInitFrameShape(Splash * splash, int imageIndex)
  96 {
  97     RGNDATA *pRgnData;
  98     RGNDATAHEADER *pRgnHdr;
  99     ImageRect maskRect;
 100 
 101     if (!splash->maskRequired)
 102         return;
 103 
 104     /* reserving memory for the worst case */
 105     if (!IS_SAFE_SIZE_MUL(splash->width / 2 + 1, splash->height)) {
 106         return;
 107     }
 108     pRgnData = (RGNDATA *) SAFE_SIZE_STRUCT_ALLOC(malloc, sizeof(RGNDATAHEADER),
 109             sizeof(RECT), (splash->width / 2 + 1) * splash->height);
 110     if (!pRgnData) {
 111         return;
 112     }
 113     pRgnHdr = (RGNDATAHEADER *) pRgnData;
 114     initRect(&maskRect, 0, 0, splash->width, splash->height, 1,
 115             splash->width * splash->imageFormat.depthBytes,
 116             splash->frames[imageIndex].bitmapBits, &splash->imageFormat);
 117 
 118     pRgnHdr->dwSize = sizeof(RGNDATAHEADER);
 119     pRgnHdr->iType = RDH_RECTANGLES;
 120     pRgnHdr->nRgnSize = 0;
 121     pRgnHdr->rcBound.top = 0;
 122     pRgnHdr->rcBound.left = 0;
 123     pRgnHdr->rcBound.bottom = splash->height;
 124     pRgnHdr->rcBound.right = splash->width;
 125 
 126     pRgnHdr->nCount = BitmapToYXBandedRectangles(&maskRect,
 127             (RECT *) (((BYTE *) pRgnData) + sizeof(RGNDATAHEADER)));
 128 
 129     splash->frames[imageIndex].hRgn = ExtCreateRegion(NULL,
 130             sizeof(RGNDATAHEADER) + sizeof(RECT) * pRgnHdr->nCount, pRgnData);
 131 
 132     free(pRgnData);
 133 }
 134 
 135 /* paint current splash screen frame to hdc
 136    this function is unused in layered window mode */
 137 
 138 void
 139 SplashPaint(Splash * splash, HDC hdc)
 140 {
 141     unsigned numColors = splash->screenFormat.colorMap ?
 142         splash->screenFormat.numColors : 0;
 143     BITMAPV4HEADER *pBmi;
 144     HPALETTE hOldPal = NULL;
 145 
 146     if (!splash->frames)
 147         return;
 148     if (splash->currentFrame < 0 || splash->currentFrame >= splash->frameCount)
 149         return;
 150     pBmi = (BITMAPV4HEADER *) SAFE_SIZE_STRUCT_ALLOC(alloca, sizeof(BITMAPV4HEADER),
 151             sizeof(RGBQUAD), numColors);
 152     if (!pBmi) {
 153         return;
 154     }
 155     memset(pBmi, 0, sizeof(BITMAPV4HEADER));
 156     if (splash->screenFormat.colorMap)
 157         memcpy(((BYTE *) pBmi) + sizeof(BITMAPV4HEADER),
 158                 splash->screenFormat.colorMap, sizeof(RGBQUAD) * numColors);
 159 
 160     pBmi->bV4Size = sizeof(BITMAPV4HEADER);
 161     pBmi->bV4Width = splash->width;
 162     pBmi->bV4Height = -splash->height;
 163     pBmi->bV4Planes = 1;
 164     pBmi->bV4BitCount = (WORD) (splash->screenFormat.depthBytes * 8);
 165     /* we're ALWAYS using BGRA in screenFormat */
 166     pBmi->bV4V4Compression = BI_RGB;
 167     pBmi->bV4ClrUsed = numColors;
 168     pBmi->bV4ClrImportant = numColors;
 169     pBmi->bV4AlphaMask = splash->screenFormat.mask[3];
 170     pBmi->bV4RedMask = splash->screenFormat.mask[2];
 171     pBmi->bV4GreenMask = splash->screenFormat.mask[1];
 172     pBmi->bV4BlueMask = splash->screenFormat.mask[0];
 173 
 174     /*  creating the palette in SplashInitPlatform does not work, so I'm creating it
 175        here on demand */
 176     if (!splash->hPalette) {
 177         unsigned i;
 178         LOGPALETTE *pLogPal = (LOGPALETTE *) SAFE_SIZE_STRUCT_ALLOC(malloc,
 179                 sizeof(LOGPALETTE), sizeof(PALETTEENTRY), numColors);
 180         if (!pLogPal) {
 181             return;
 182         }
 183 
 184         pLogPal->palVersion = 0x300;
 185         pLogPal->palNumEntries = (WORD) numColors;
 186         for (i = 0; i < numColors; i++) {
 187             pLogPal->palPalEntry[i].peRed = (BYTE)
 188                 QUAD_RED(splash->colorMap[i]);
 189             pLogPal->palPalEntry[i].peGreen = (BYTE)
 190                 QUAD_GREEN(splash->colorMap[i]);
 191             pLogPal->palPalEntry[i].peBlue = (BYTE)
 192                 QUAD_BLUE(splash->colorMap[i]);
 193             pLogPal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
 194         }
 195         splash->hPalette = CreatePalette(pLogPal);
 196         free(pLogPal);
 197     }
 198     if (splash->hPalette) {
 199         hOldPal = SelectPalette(hdc, splash->hPalette, FALSE);
 200         RealizePalette(hdc);
 201     }
 202 
 203     StretchDIBits(hdc, 0, 0, splash->width, splash->height, 0, 0,
 204             splash->width, splash->height, splash->screenData,
 205             (BITMAPINFO *) pBmi, DIB_RGB_COLORS, SRCCOPY);
 206     if (hOldPal)
 207         SelectPalette(hdc, hOldPal, FALSE);
 208 }
 209 
 210 
 211 /* The function makes the window visible if it is hidden
 212  or is not yet shown. */
 213 void
 214 SplashRedrawWindow(Splash * splash)
 215 {
 216     if (!SplashIsStillLooping(splash)) {
 217         KillTimer(splash->hWnd, 0);
 218     }
 219 
 220     if (splash->currentFrame < 0) {
 221         return;
 222     }
 223 
 224     SplashUpdateScreenData(splash);
 225     if (splash->isLayered) {
 226         BLENDFUNCTION bf;
 227         POINT ptSrc;
 228         HDC hdcSrc = CreateCompatibleDC(NULL), hdcDst;
 229         BITMAPINFOHEADER bmi;
 230         void *bitmapBits;
 231         HBITMAP hBitmap, hOldBitmap;
 232         RECT rect;
 233         POINT ptDst;
 234         SIZE size;
 235 
 236         bf.BlendOp = AC_SRC_OVER;
 237         bf.BlendFlags = 0;
 238         bf.AlphaFormat = AC_SRC_ALPHA;
 239         bf.SourceConstantAlpha = 0xFF;
 240         ptSrc.x = ptSrc.y = 0;
 241 
 242         memset(&bmi, 0, sizeof(bmi));
 243         bmi.biSize = sizeof(BITMAPINFOHEADER);
 244         bmi.biWidth = splash->width;
 245         bmi.biHeight = -splash->height;
 246         bmi.biPlanes = 1;
 247         bmi.biBitCount = 32;
 248         bmi.biCompression = BI_RGB;
 249 
 250         //      FIXME: this is somewhat ineffective
 251         //      maybe if we allocate memory for all frames as DIBSections,
 252         //      then we could select the frames into the DC directly
 253 
 254         hBitmap = CreateDIBSection(NULL, (BITMAPINFO *) & bmi, DIB_RGB_COLORS,
 255                 &bitmapBits, NULL, 0);
 256         memcpy(bitmapBits, splash->screenData,
 257                 splash->screenStride * splash->height);
 258         hOldBitmap = (HBITMAP) SelectObject(hdcSrc, hBitmap);
 259         hdcDst = GetDC(splash->hWnd);
 260 
 261         GetWindowRect(splash->hWnd, &rect);
 262 
 263         ptDst.x = rect.left;
 264         ptDst.y = rect.top;
 265 
 266         size.cx = splash->width;
 267         size.cy = splash->height;
 268 
 269         UpdateLayeredWindow(splash->hWnd, hdcDst, &ptDst, &size,
 270                 hdcSrc, &ptSrc, 0, &bf, ULW_ALPHA);
 271 
 272         ReleaseDC(splash->hWnd, hdcDst);
 273         SelectObject(hdcSrc, hOldBitmap);
 274         DeleteObject(hBitmap);
 275         DeleteDC(hdcSrc);
 276     }
 277     else {
 278        InvalidateRect(splash->hWnd, NULL, FALSE);
 279        if (splash->maskRequired) {
 280             HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
 281 
 282             CombineRgn(hRgn, splash->frames[splash->currentFrame].hRgn,
 283                     splash->frames[splash->currentFrame].hRgn, RGN_COPY);
 284             SetWindowRgn(splash->hWnd, hRgn, TRUE);
 285         } else {
 286             SetWindowRgn(splash->hWnd, NULL, TRUE);
 287         }
 288         UpdateWindow(splash->hWnd);
 289     }
 290     if (!IsWindowVisible(splash->hWnd)) {
 291         POINT cursorPos;
 292         ShowWindow(splash->hWnd, SW_SHOW);
 293         // Windows won't update the cursor after the window is shown,
 294         // if the cursor is already above the window. need to do this manually.
 295         GetCursorPos(&cursorPos);
 296         if (WindowFromPoint(cursorPos) == splash->hWnd) {
 297             // unfortunately Windows fail to understand that the window
 298             // thread should own the cursor, even though the mouse pointer
 299             // is over the window, until the mouse has been moved.
 300             // we're using SetCursorPos here to fake the mouse movement
 301             // and enable proper update of the cursor.
 302             SetCursorPos(cursorPos.x, cursorPos.y);
 303             SetCursor(LoadCursor(NULL, IDC_WAIT));
 304         }
 305     }
 306     if (SplashIsStillLooping(splash)) {
 307         int time = splash->time +
 308             splash->frames[splash->currentFrame].delay - SplashTime();
 309 
 310         if (time < 0)
 311             time = 0;
 312         SetTimer(splash->hWnd, 0, time, NULL);
 313     }
 314 }
 315 
 316 void SplashReconfigureNow(Splash * splash) {
 317     splash->x = (GetSystemMetrics(SM_CXSCREEN) - splash->width) / 2;
 318     splash->y = (GetSystemMetrics(SM_CYSCREEN) - splash->height) / 2;
 319     if (splash->hWnd) {
 320         //Fixed 6474657: splash screen image jumps towards left while
 321         //    setting the new image using setImageURL()
 322         // We may safely hide the splash window because SplashRedrawWindow()
 323         //    will show the window again.
 324         ShowWindow(splash->hWnd, SW_HIDE);
 325         MoveWindow(splash->hWnd, splash->x, splash->y, splash->width, splash->height, FALSE);
 326     }
 327     SplashRedrawWindow(splash);
 328 }
 329 
 330 static LRESULT CALLBACK
 331 SplashWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 332 {
 333     PAINTSTRUCT ps;
 334     HDC hdc;
 335 
 336 
 337     switch (message) {
 338 
 339     case WM_ERASEBKGND:
 340         return TRUE;            // to avoid flicker
 341 
 342     case WM_SYSCOMMAND:
 343         if (wParam==SC_CLOSE||wParam==SC_DEFAULT||wParam==SC_HOTKEY||
 344             wParam==SC_KEYMENU||wParam==SC_MAXIMIZE||
 345             wParam==SC_MINIMIZE||wParam==SC_MOUSEMENU||wParam==SC_MOVE||
 346             wParam==SC_RESTORE||wParam==SC_SIZE)
 347         {
 348             return 0;
 349         }
 350 
 351     /* double switch to avoid prologue/epilogue duplication */
 352     case WM_TIMER:
 353     case WM_SPLASHUPDATE:
 354     case WM_PAINT:
 355     case WM_SPLASHRECONFIGURE:
 356         {
 357             Splash *splash = (Splash *) GetWindowLongPtr(hWnd, GWLP_USERDATA);
 358 
 359             SplashLock(splash);
 360             if (splash->isVisible>0) {
 361                 switch(message) {
 362                 case WM_TIMER:
 363                     SplashNextFrame(splash);
 364                     SplashRedrawWindow(splash);
 365                     break;
 366                 case WM_SPLASHUPDATE:
 367                     SplashRedrawWindow(splash);
 368                     break;
 369                 case WM_PAINT:
 370                     hdc = BeginPaint(hWnd, &ps);
 371                     SplashPaint(splash, hdc);
 372                     EndPaint(hWnd, &ps);
 373                     break;
 374                 case WM_SPLASHRECONFIGURE:
 375                     SplashReconfigureNow(splash);
 376                     break;
 377                 }
 378             }
 379             SplashUnlock(splash);
 380             break;
 381         }
 382     case WM_DESTROY:
 383         PostQuitMessage(0);
 384         break;
 385     default:
 386         return DefWindowProc(hWnd, message, wParam, lParam);
 387 
 388     }
 389     return 0;
 390 }
 391 
 392 HWND
 393 SplashCreateWindow(Splash * splash)
 394 {
 395     WNDCLASSEX wcex;
 396     ATOM wndClass;
 397     DWORD style, exStyle;
 398     HWND hWnd;
 399 
 400     ZeroMemory(&wcex, sizeof(WNDCLASSEX));
 401 
 402     wcex.cbSize = sizeof(WNDCLASSEX);
 403     wcex.style = CS_HREDRAW | CS_VREDRAW;
 404     wcex.lpfnWndProc = (WNDPROC) SplashWndProc;
 405     wcex.hInstance = GetModuleHandle(NULL);
 406     wcex.lpszClassName = "JavaSplash";
 407     wcex.hCursor = LoadCursor(NULL, IDC_WAIT);
 408 
 409     wndClass = RegisterClassEx(&wcex);
 410     if (!wndClass) {
 411         return 0;
 412     }
 413 
 414     splash->x = (GetSystemMetrics(SM_CXSCREEN) - splash->width) / 2;
 415     splash->y = (GetSystemMetrics(SM_CYSCREEN) - splash->height) / 2;
 416     exStyle = splash->isLayered ? WS_EX_LAYERED : 0;
 417     exStyle |= WS_EX_TOOLWINDOW;        /* don't show the window on taskbar */
 418     style = WS_POPUP;
 419     hWnd = CreateWindowEx(exStyle, (LPCSTR) wndClass, "", style,
 420             splash->x, splash->y, splash->width, splash->height, NULL, NULL,
 421             wcex.hInstance, NULL);
 422     SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR) splash);
 423     return hWnd;
 424 }
 425 
 426 void
 427 SplashLock(Splash * splash)
 428 {
 429     EnterCriticalSection(&splash->lock);
 430 }
 431 
 432 void
 433 SplashUnlock(Splash * splash)
 434 {
 435     LeaveCriticalSection(&splash->lock);
 436 }
 437 
 438 void
 439 SplashInitPlatform(Splash * splash)
 440 {
 441     HDC hdc;
 442     int paletteMode;
 443 
 444     InitializeCriticalSection(&splash->lock);
 445     splash->isLayered = FALSE;
 446     hdc = GetDC(NULL);
 447     paletteMode = (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) != 0;
 448     if (UpdateLayeredWindow && !paletteMode) {
 449         splash->isLayered = TRUE;
 450     }
 451     splash->byteAlignment = 4;
 452     if (splash->isLayered) {
 453         initFormat(&splash->screenFormat,
 454                 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
 455         splash->screenFormat.premultiplied = 1;
 456         splash->maskRequired = 0;
 457     }
 458     else {
 459         splash->maskRequired = 1;
 460         if (paletteMode) {
 461             int numColors = GetDeviceCaps(hdc, SIZEPALETTE) -
 462                 GetDeviceCaps(hdc, NUMRESERVED);
 463             int i;
 464             int numComponents[3];
 465 
 466             initFormat(&splash->screenFormat, 0, 0, 0, 0);
 467             /*      FIXME: maybe remapping to non-reserved colors would improve performance */
 468             for (i = 0; i < numColors; i++) {
 469                 splash->colorIndex[i] = i;
 470             }
 471             numColors = quantizeColors(numColors, numComponents);
 472             initColorCube(numComponents, splash->colorMap, splash->dithers,
 473                     splash->colorIndex);
 474             splash->screenFormat.colorIndex = splash->colorIndex;
 475             splash->screenFormat.depthBytes = 1;
 476             splash->screenFormat.colorMap = splash->colorMap;
 477             splash->screenFormat.dithers = splash->dithers;
 478             splash->screenFormat.numColors = numColors;
 479             splash->hPalette = NULL;
 480         }
 481         else {
 482             initFormat(&splash->screenFormat,
 483                     0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
 484         }
 485     }
 486     ReleaseDC(NULL, hdc);
 487 }
 488 
 489 void
 490 SplashCleanupPlatform(Splash * splash)
 491 {
 492     int i;
 493 
 494     if (splash->frames) {
 495         for (i = 0; i < splash->frameCount; i++) {
 496             if (splash->frames[i].hRgn) {
 497                 DeleteObject(splash->frames[i].hRgn);
 498                 splash->frames[i].hRgn = NULL;
 499             }
 500         }
 501     }
 502     if (splash->hPalette)
 503         DeleteObject(splash->hPalette);
 504     splash->maskRequired = !splash->isLayered;
 505 }
 506 
 507 void
 508 SplashDonePlatform(Splash * splash)
 509 {
 510     if (splash->hWnd)
 511         DestroyWindow(splash->hWnd);
 512 }
 513 
 514 void
 515 SplashMessagePump()
 516 {
 517     MSG msg;
 518 
 519     while (GetMessage(&msg, NULL, 0, 0)) {
 520         TranslateMessage(&msg);
 521         DispatchMessage(&msg);
 522     }
 523 }
 524 
 525 DWORD WINAPI
 526 SplashScreenThread(LPVOID param)
 527 {
 528     Splash *splash = (Splash *) param;
 529 
 530     splash->currentFrame = 0;
 531     SplashLock(splash);
 532     splash->time = SplashTime();
 533     splash->hWnd = SplashCreateWindow(splash);
 534     if (splash->hWnd) {
 535         SplashRedrawWindow(splash);
 536         SplashUnlock(splash);
 537         SplashMessagePump();
 538         SplashLock(splash);
 539     }
 540     SplashDone(splash);
 541     splash->isVisible = -1;
 542     SplashUnlock(splash);
 543     return 0;
 544 }
 545 
 546 void
 547 SplashCreateThread(Splash * splash)
 548 {
 549     DWORD threadId;
 550 
 551     CreateThread(NULL, 0, SplashScreenThread, (LPVOID) splash, 0, &threadId);
 552 }
 553 
 554 void
 555 SplashClosePlatform(Splash * splash)
 556 {
 557     PostMessage(splash->hWnd, WM_QUIT, 0, 0);
 558 }
 559 
 560 void
 561 SplashUpdate(Splash * splash)
 562 {
 563     PostMessage(splash->hWnd, WM_SPLASHUPDATE, 0, 0);
 564 }
 565 
 566 void
 567 SplashReconfigure(Splash * splash)
 568 {
 569     PostMessage(splash->hWnd, WM_SPLASHRECONFIGURE, 0, 0);
 570 }
 571 
 572 SPLASHEXPORT char*
 573 SplashGetScaledImageName(const char* jarName, const char* fileName,
 574                            float *scaleFactor)
 575 {



































 576     *scaleFactor = 1;














 577     return NULL;
 578 }
--- EOF ---