rev 54098 : 8260616: Removing remaining JNF dependencies in the java.desktop module
8259729: Missed JNFInstanceOf -> IsInstanceOf conversion

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