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