1 /*
   2  * Copyright (c) 2011, 2013, 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 #include "splashscreen_impl.h"
  27 
  28 #import <Cocoa/Cocoa.h>
  29 #import <objc/objc-auto.h>
  30 
  31 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  32 #import "NSApplicationAWT.h"
  33 
  34 #include <sys/time.h>
  35 #include <pthread.h>
  36 #include <iconv.h>
  37 #include <langinfo.h>
  38 #include <locale.h>
  39 #include <fcntl.h>
  40 #include <poll.h>
  41 #include <errno.h>
  42 #include <sys/types.h>
  43 #include <signal.h>
  44 #include <unistd.h>
  45 #include <dlfcn.h>
  46 
  47 #include <sizecalc.h>
  48 #import "ThreadUtilities.h"
  49 
  50 static NSScreen* SplashNSScreen()
  51 {
  52     return [[NSScreen screens] objectAtIndex: 0];
  53 }
  54 
  55 static void SplashCenter(Splash * splash)
  56 {
  57     NSRect screenFrame = [SplashNSScreen() frame];
  58 
  59     splash->x = (screenFrame.size.width - splash->width) / 2;
  60     splash->y = (screenFrame.size.height - splash->height) / 2 + screenFrame.origin.y;
  61 }
  62 
  63 unsigned
  64 SplashTime(void) {
  65     struct timeval tv;
  66     struct timezone tz;
  67     unsigned long long msec;
  68 
  69     gettimeofday(&tv, &tz);
  70     msec = (unsigned long long) tv.tv_sec * 1000 +
  71         (unsigned long long) tv.tv_usec / 1000;
  72 
  73     return (unsigned) msec;
  74 }
  75 
  76 /* Could use npt but decided to cut down on linked code size */
  77 char* SplashConvertStringAlloc(const char* in, int* size) {
  78     const char     *codeset;
  79     const char     *codeset_out;
  80     iconv_t         cd;
  81     size_t          rc;
  82     char           *buf = NULL, *out;
  83     size_t          bufSize, inSize, outSize;
  84     const char* old_locale;
  85 
  86     if (!in) {
  87         return NULL;
  88     }
  89     old_locale = setlocale(LC_ALL, "");
  90 
  91     codeset = nl_langinfo(CODESET);
  92     if ( codeset == NULL || codeset[0] == 0 ) {
  93         goto done;
  94     }
  95     /* we don't need BOM in output so we choose native BE or LE encoding here */
  96     codeset_out = (platformByteOrder()==BYTE_ORDER_MSBFIRST) ?
  97         "UCS-2BE" : "UCS-2LE";
  98 
  99     cd = iconv_open(codeset_out, codeset);
 100     if (cd == (iconv_t)-1 ) {
 101         goto done;
 102     }
 103     inSize = strlen(in);
 104     buf = SAFE_SIZE_ARRAY_ALLOC(malloc, inSize, 2);
 105     if (!buf) {
 106         return NULL;
 107     }
 108     bufSize = inSize*2; // need 2 bytes per char for UCS-2, this is
 109                         // 2 bytes per source byte max
 110     out = buf; outSize = bufSize;
 111     /* linux iconv wants char** source and solaris wants const char**...
 112        cast to void* */
 113     rc = iconv(cd, (void*)&in, &inSize, &out, &outSize);
 114     iconv_close(cd);
 115 
 116     if (rc == (size_t)-1) {
 117         free(buf);
 118         buf = NULL;
 119     } else {
 120         if (size) {
 121             *size = (bufSize-outSize)/2; /* bytes to wchars */
 122         }
 123     }
 124 done:
 125     setlocale(LC_ALL, old_locale);
 126     return buf;
 127 }
 128 
 129 char* SplashGetScaledImageName(const char* jar, const char* file,
 130                                float *scaleFactor) {
 131     NSAutoreleasePool *pool = [NSAutoreleasePool new];
 132     *scaleFactor = 1;
 133     char* scaledFile = nil;
 134     __block float screenScaleFactor = 1;
 135 
 136     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
 137         screenScaleFactor = [SplashNSScreen() backingScaleFactor];
 138     }];
 139 
 140     if (screenScaleFactor > 1) {
 141         NSString *fileName = [NSString stringWithUTF8String: file];
 142         NSUInteger length = [fileName length];
 143         NSRange range = [fileName rangeOfString: @"."
 144                                         options:NSBackwardsSearch];
 145         NSUInteger dotIndex = range.location;
 146         NSString *fileName2x = nil;
 147         
 148         if (dotIndex == NSNotFound) {
 149             fileName2x = [fileName stringByAppendingString: @"@2x"];
 150         } else {
 151             fileName2x = [fileName substringToIndex: dotIndex];
 152             fileName2x = [fileName2x stringByAppendingString: @"@2x"];
 153             fileName2x = [fileName2x stringByAppendingString:
 154                           [fileName substringFromIndex: dotIndex]];
 155         }
 156         
 157         if ((fileName2x != nil) && (jar || [[NSFileManager defaultManager]
 158                     fileExistsAtPath: fileName2x])){
 159             *scaleFactor = 2;
 160             scaledFile = strdup([fileName2x UTF8String]);
 161         }
 162     }
 163     [pool drain];
 164     return scaledFile;
 165 }
 166 
 167 void
 168 SplashInitPlatform(Splash * splash) {
 169     pthread_mutex_init(&splash->lock, NULL);
 170 
 171     splash->maskRequired = 0;
 172 
 173     
 174     //TODO: the following is too much of a hack but should work in 90% cases.
 175     //      besides we don't use device-dependant drawing, so probably
 176     //      that's very fine indeed
 177     splash->byteAlignment = 1;
 178     initFormat(&splash->screenFormat, 0xff << 8,
 179             0xff << 16, 0xff << 24, 0xff << 0);
 180     splash->screenFormat.byteOrder = 1 ?  BYTE_ORDER_LSBFIRST : BYTE_ORDER_MSBFIRST;
 181     splash->screenFormat.depthBytes = 4;
 182 
 183     // If this property is present we are running SWT and should not start a runLoop
 184     // Can't check if running SWT in webstart, so splash screen in webstart SWT
 185     // applications is not supported
 186     char envVar[80];
 187     snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid());
 188     if (getenv(envVar) == NULL) {
 189         [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^() {
 190             [NSApplicationAWT runAWTLoopWithApp:[NSApplicationAWT sharedApplication]];
 191         }];
 192     }
 193 }
 194 
 195 void
 196 SplashCleanupPlatform(Splash * splash) {
 197     splash->maskRequired = 0;
 198 }
 199 
 200 void
 201 SplashDonePlatform(Splash * splash) {
 202     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 203 
 204     pthread_mutex_destroy(&splash->lock);
 205     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 206         if (splash->window) {
 207             [splash->window orderOut:nil];
 208             [splash->window release];
 209         }
 210     }];
 211     [pool drain];
 212 }
 213 
 214 void
 215 SplashLock(Splash * splash) {
 216     pthread_mutex_lock(&splash->lock);
 217 }
 218 
 219 void
 220 SplashUnlock(Splash * splash) {
 221     pthread_mutex_unlock(&splash->lock);
 222 }
 223 
 224 void
 225 SplashInitFrameShape(Splash * splash, int imageIndex) {
 226     // No shapes, we rely on alpha compositing
 227 }
 228 
 229 void * SplashScreenThread(void *param);
 230 void
 231 SplashCreateThread(Splash * splash) {
 232     pthread_t thr;
 233     pthread_attr_t attr;
 234     int rc;
 235 
 236     pthread_attr_init(&attr);
 237     rc = pthread_create(&thr, &attr, SplashScreenThread, (void *) splash);
 238 }
 239 
 240 void
 241 SplashRedrawWindow(Splash * splash) {
 242     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 243 
 244     SplashUpdateScreenData(splash);
 245 
 246     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 247         // NSDeviceRGBColorSpace vs. NSCalibratedRGBColorSpace ?
 248         NSBitmapImageRep * rep = [[NSBitmapImageRep alloc]
 249             initWithBitmapDataPlanes: (unsigned char**)&splash->screenData
 250                           pixelsWide: splash->width
 251                           pixelsHigh: splash->height
 252                        bitsPerSample: 8
 253                      samplesPerPixel: 4
 254                             hasAlpha: YES
 255                             isPlanar: NO
 256                       colorSpaceName: NSDeviceRGBColorSpace
 257                         bitmapFormat: NSAlphaFirstBitmapFormat | NSAlphaNonpremultipliedBitmapFormat
 258                          bytesPerRow: splash->width * 4
 259                         bitsPerPixel: 32];
 260 
 261         NSImage * image = [[NSImage alloc]
 262             initWithSize: NSMakeSize(splash->width, splash->height)];
 263         [image setBackgroundColor: [NSColor clearColor]];
 264 
 265         [image addRepresentation: rep];
 266         float scaleFactor = splash->scaleFactor;
 267         if (scaleFactor > 0 && scaleFactor != 1) {
 268             [image setScalesWhenResized:YES];
 269             NSSize size = [image size];
 270             size.width /= scaleFactor;
 271             size.height /= scaleFactor;
 272             [image setSize: size];
 273         }
 274         
 275         NSImageView * view = [[NSImageView alloc] init];
 276 
 277         [view setImage: image];
 278         [view setEditable: NO];
 279         //NOTE: we don't set a 'wait cursor' for the view because:
 280         //      1. The Cocoa GUI guidelines suggest to avoid it, and use a progress
 281         //         bar instead.
 282         //      2. There simply isn't an instance of NSCursor that represent
 283         //         the 'wait cursor'. So that is undoable.
 284 
 285         //TODO: only the first image in an animated gif preserves transparency.
 286         //      Loos like the splash->screenData contains inappropriate data
 287         //      for all but the first frame.
 288 
 289         [image release];
 290         [rep release];
 291 
 292         [splash->window setContentView: view];
 293         [splash->window orderFrontRegardless];
 294     }];
 295 
 296     [pool drain];
 297 }
 298 
 299 void SplashReconfigureNow(Splash * splash) {
 300     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 301 
 302     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 303         SplashCenter(splash);
 304 
 305         if (!splash->window) {
 306             return;
 307         }
 308 
 309         [splash->window orderOut:nil];
 310         [splash->window setFrame: NSMakeRect(splash->x, splash->y, splash->width, splash->height)
 311                          display: NO];
 312     }];
 313 
 314     [pool drain];
 315 
 316     SplashRedrawWindow(splash);
 317 }
 318 
 319 void
 320 SplashEventLoop(Splash * splash) {
 321 
 322     /* we should have splash _locked_ on entry!!! */
 323 
 324     while (1) {
 325         struct pollfd pfd[1];
 326         int timeout = -1;
 327         int ctl = splash->controlpipe[0];
 328         int rc;
 329         int pipes_empty;
 330 
 331         pfd[0].fd = ctl;
 332         pfd[0].events = POLLIN | POLLPRI;
 333 
 334         errno = 0;
 335         if (splash->isVisible>0 && SplashIsStillLooping(splash)) {
 336             timeout = splash->time + splash->frames[splash->currentFrame].delay
 337                 - SplashTime();
 338             if (timeout < 0) {
 339                 timeout = 0;
 340             }
 341         }
 342         SplashUnlock(splash);
 343         rc = poll(pfd, 1, timeout);
 344         SplashLock(splash);
 345         if (splash->isVisible > 0 && splash->currentFrame >= 0 &&
 346                 SplashTime() >= splash->time + splash->frames[splash->currentFrame].delay) {
 347             SplashNextFrame(splash);
 348             SplashRedrawWindow(splash);
 349         }
 350         if (rc <= 0) {
 351             errno = 0;
 352             continue;
 353         }
 354         pipes_empty = 0;
 355         while(!pipes_empty) {
 356             char buf;
 357 
 358             pipes_empty = 1;
 359             if (read(ctl, &buf, sizeof(buf)) > 0) {
 360                 pipes_empty = 0;
 361                 switch (buf) {
 362                 case SPLASHCTL_UPDATE:
 363                     if (splash->isVisible>0) {
 364                         SplashRedrawWindow(splash);
 365                     }
 366                     break;
 367                 case SPLASHCTL_RECONFIGURE:
 368                     if (splash->isVisible>0) {
 369                         SplashReconfigureNow(splash);
 370                     }
 371                     break;
 372                 case SPLASHCTL_QUIT:
 373                     return;
 374                 }
 375             }
 376         }
 377     }
 378 }
 379 
 380 void *
 381 SplashScreenThread(void *param) {
 382     objc_registerThreadWithCollector();
 383 
 384     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 385     Splash *splash = (Splash *) param;
 386 
 387     SplashLock(splash);
 388     pipe(splash->controlpipe);
 389     fcntl(splash->controlpipe[0], F_SETFL,
 390         fcntl(splash->controlpipe[0], F_GETFL, 0) | O_NONBLOCK);
 391     splash->time = SplashTime();
 392     splash->currentFrame = 0;
 393     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 394         SplashCenter(splash);
 395 
 396         splash->window = (void*) [[NSWindow alloc]
 397             initWithContentRect: NSMakeRect(splash->x, splash->y, splash->width, splash->height)
 398                       styleMask: NSBorderlessWindowMask
 399                         backing: NSBackingStoreBuffered
 400                           defer: NO
 401                          screen: SplashNSScreen()];
 402 
 403         [splash->window setOpaque: NO];
 404         [splash->window setBackgroundColor: [NSColor clearColor]];
 405     }];
 406     fflush(stdout);
 407     if (splash->window) {
 408         [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 409             [splash->window orderFrontRegardless];
 410         }];
 411         SplashRedrawWindow(splash);
 412         SplashEventLoop(splash);
 413     }
 414     SplashUnlock(splash);
 415     SplashDone(splash);
 416 
 417     splash->isVisible=-1;
 418 
 419     [pool drain];
 420 
 421     return 0;
 422 }
 423 
 424 void
 425 sendctl(Splash * splash, char code) {
 426     if (splash && splash->controlpipe[1]) {
 427         write(splash->controlpipe[1], &code, 1);
 428     }
 429 }
 430 
 431 void
 432 SplashClosePlatform(Splash * splash) {
 433     sendctl(splash, SPLASHCTL_QUIT);
 434 }
 435 
 436 void
 437 SplashUpdate(Splash * splash) {
 438     sendctl(splash, SPLASHCTL_UPDATE);
 439 }
 440 
 441 void
 442 SplashReconfigure(Splash * splash) {
 443     sendctl(splash, SPLASHCTL_RECONFIGURE);
 444 }
 445