1 /* 2 * Copyright (c) 2013, 2018, 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 /** 27 * The main build script for JavaFX. 28 * 29 * MUST FIX tasks to complete: 30 * - build check -- making sure the final artifact has the right bits 31 * - some things worth automatically sanity checking: 32 * - are there images in the javadocs? 33 * - are all of the expected dylibs etc there? 34 * - Perform sanity checking to make sure a JDK exists with javac, etc 35 * - Support building with no known JDK location, as long as javac, etc are on the path 36 * - Check all of the native flags. We're adding weight to some libs that don't need it, and so forth. 37 * 38 * Additional projects to work on as we go: 39 * - Add "developer debug". This is where the natives do not have debug symbols, but the Java code does 40 * - The genVSproperties.bat doesn't find the directory where RC.exe lives. So it is hard coded. Might be a problem. 41 * - special tasks for common needs, such as: 42 * - updating copyright headers 43 * - stripping trailing whitespace (?) 44 * - checkstyle 45 * - findbugs 46 * - re needs? 47 * - sqe testing 48 * - API change check 49 * - Pushing results to a repo? 50 * - ServiceWithSecurityManagerTest fails to complete when run from gradle. 51 * - Integrate Parfait reports for C code 52 * - FXML Project tests are not running 53 */ 54 defaultTasks = ["sdk"] 55 56 import java.util.concurrent.CountDownLatch 57 import java.util.concurrent.ExecutorService 58 import java.util.concurrent.Executors 59 import java.util.concurrent.Future 60 61 /****************************************************************************** 62 * Utility methods * 63 *****************************************************************************/ 64 65 /** 66 * If the given named property is not defined, then this method will define 67 * it with the given defaultValue. Any properties defined by this method can 68 * be substituted on the command line by using -P, or by specifying a 69 * gradle.properties file in the user home dir 70 * 71 * @param name The name of the property to define 72 * @param defaultValue The default value to assign the property 73 */ 74 void defineProperty(String name, String defaultValue) { 75 if (!project.hasProperty(name)) { 76 project.ext.set(name, defaultValue); 77 } 78 } 79 80 /** 81 * If the given named property is not defined, then this method will attempt to 82 * look up the property in the props map, and use the defaultValue if it cannot be found. 83 * 84 * @param name The name of the property to look up and/or define 85 * @param props The properties to look for the named property in, if it has not already been defined 86 * @param defaultValue The default value if the property has not been defined and the 87 * props map does not contain the named property 88 */ 89 void defineProperty(String name, Properties props, String defaultValue) { 90 if (!project.hasProperty(name)) { 91 project.ext.set(name, props.getProperty(name, defaultValue)); 92 } 93 } 94 95 /** 96 * Converts cygwin style paths to windows style paths, but with a forward slash. 97 * This method is safe to call from any platform, and will only do work if 98 * called on Windows (in all other cases it simply returns the supplied path. 99 * 100 * @param path the path to convert 101 * @return the path converted to windows style, if on windows, otherwise it 102 * is the supplied path. 103 */ 104 String cygpath(String path) { 105 if (!IS_WINDOWS) return path; 106 if (path == null || "".equals(path)) return path; 107 String ret = path.replaceAll('\\\\', '/') 108 logger.info("Converting path '$path' via cygpath to "+ret) 109 return ret 110 } 111 112 /** 113 * Converts cygwin file paths for java executables to windows style 114 * executable paths by changing forward slashes to back slashes and 115 * adding the '.exe' extension. 116 * This method is safe to call from any platform, and will only do work if 117 * called on Windows (in all other cases it simply returns the supplied path). 118 * 119 * @param path the path to convert 120 * @return the path converted to windows style, if on windows, otherwise it 121 * is the supplied path. 122 */ 123 String cygpathExe(String path) { 124 if (!IS_WINDOWS) return path; 125 if (path == null || "".equals(path)) return path; 126 String ret = path.replaceAll('/', '\\\\') 127 logger.info("Converting path '$path' via cygpath to "+ret) 128 return ret + ".exe" 129 } 130 131 void loadProperties(String sourceFileName) { 132 def config = new Properties() 133 def propFile = new File(sourceFileName) 134 if (propFile.canRead()) { 135 config.load(new FileInputStream(propFile)) 136 for (java.util.Map.Entry property in config) { 137 def keySplit = property.key.split("\\."); 138 def key = keySplit[0]; 139 for (int i = 1; i < keySplit.length; i++) { 140 key = key + keySplit[i].capitalize(); 141 } 142 ext[key] = property.value; 143 } 144 } 145 } 146 147 /** 148 * Struct used to contain some information passed to the closure 149 * passed to compileTargets. 150 */ 151 class CompileTarget { 152 String name; 153 String upper; 154 String capital; 155 } 156 157 /** 158 * Iterates over each of the compile targets, passing the given closure 159 * a CompileTarget instance. 160 * 161 * @param c The closure to call 162 */ 163 void compileTargets(Closure c) { 164 if (COMPILE_TARGETS == "") { 165 return 166 } 167 COMPILE_TARGETS.split(",").each { target -> 168 CompileTarget ct = new CompileTarget(); 169 ct.name = target; 170 ct.upper = target.trim().toUpperCase(Locale.ROOT) 171 ct.capital = target.trim().capitalize() 172 c(ct) 173 } 174 } 175 176 /** 177 * Manages the execution of some closure which is responsible for producing 178 * content for a properties file built at build time and stored in the 179 * root project's $buildDir, and then loading that properties file and 180 * passing it to the processor closure. 181 * 182 * This is used on windows to produce a properties file containing all the 183 * windows visual studio paths and environment variables, and on Linux 184 * for storing the results of pkg-config calls. 185 * 186 * @param name the name of the file to produce 187 * @param loader a closure which is invoked, given the properties file. This 188 * closure is invoked only if the properties file needs to be created 189 * and is responsible for populating the properties file. 190 * @param processor a closure which is invoked every time this method is 191 * called and which will be given a Properties object, fully populated. 192 * The processor is then responsible for doing whatever it is that it 193 * must do with those properties (such as setting up environment 194 * variables used in subsequent native builds, or whatnot). 195 */ 196 void setupTools(String name, Closure loader, Closure processor) { 197 // Check to see whether $buildDir/$name.properties file exists. If not, 198 // then generate it. Once generated, we need to read the properties file to 199 // help us define the defaults for this block of properties 200 File propFile = file("$buildDir/${name}.properties"); 201 if (!propFile.exists()) { 202 // Create the properties file 203 propFile.getParentFile().mkdirs(); 204 propFile.createNewFile(); 205 loader(propFile); 206 } 207 208 // Try reading the properties in order to define the properties. If the property file cannot 209 // be located, then we will throw an exception because we cannot guess these values 210 InputStream propStream = null; 211 try { 212 Properties properties = new Properties(); 213 propStream = new FileInputStream(propFile); 214 properties.load(propStream); 215 processor(properties); 216 } finally { 217 try { propStream.close() } catch (Exception e) { } 218 } 219 } 220 221 String[] parseJavaVersion(String jRuntimeVersion) { 222 def jVersion = jRuntimeVersion.split("[-\\+]")[0] 223 def tmpBuildNumber = "0" 224 if (jVersion.startsWith("1.")) { 225 // This is a pre-JEP-223 version string 226 def dashbIdx = jRuntimeVersion.lastIndexOf("-b") 227 if (dashbIdx != -1) { 228 tmpBuildNumber = jRuntimeVersion.substring(dashbIdx + 2) 229 } 230 } else { 231 // This is a post-JEP-223 version string 232 def plusIdx = jRuntimeVersion.indexOf("+") 233 if (plusIdx != -1) { 234 tmpBuildNumber = jRuntimeVersion.substring(plusIdx + 1) 235 } 236 } 237 def jBuildNumber = tmpBuildNumber.split("[-\\+]")[0] 238 def versionInfo = new String[2]; 239 versionInfo[0] = jVersion 240 versionInfo[1] = jBuildNumber 241 return versionInfo 242 } 243 244 /** 245 * Fails the build with the specified error message 246 * 247 * @param msg the reason for the failure 248 */ 249 void fail(String msg) { 250 throw new GradleException("FAIL: " + msg); 251 } 252 253 /****************************************************************************** 254 * * 255 * Definition of project properties * 256 * * 257 * All properties defined using ext. are immediately available throughout * 258 * the script as variables that can be used. These variables are attached * 259 * to the root project (whereas if they were defined as def variables then * 260 * they would only be available within the root project scope). * 261 * * 262 * All properties defined using the "defineProperty" method can be replaced * 263 * on the command line by using the -P flag. For example, to override the * 264 * location of the binary plug, you would specify -PBINARY_PLUG=some/where * 265 * * 266 *****************************************************************************/ 267 268 // If the ../rt-closed directory exists, then we are doing a closed build. 269 // In this case, build and property files will be read from 270 // ../rt-closed/closed-build.gradle and ../rt-closed/closed-properties.gradle 271 // respectively 272 273 def closedDir = file("../rt-closed") 274 def buildClosed = closedDir.isDirectory() 275 ext.BUILD_CLOSED = buildClosed 276 277 ext.RUNARGSFILE = "run.args" 278 ext.COMPILEARGSFILE = "compile.args" 279 ext.RUNJAVAPOLICYFILE = 'run.java.policy' 280 281 ext.TESTCOMPILEARGSFILE = "testcompile.args" 282 ext.TESTRUNARGSFILE = "testrun.args" 283 ext.TESTJAVAPOLICYFILE = 'test.java.policy' 284 285 // the file containing "extra" --add-exports 286 ext.EXTRAADDEXPORTS = 'buildSrc/addExports' 287 288 ext.MODULESOURCEPATH = "modulesourcepath.args" 289 290 // These variables indicate what platform is running the build. Is 291 // this build running on a Mac, Windows, or Linux machine? 32 or 64 bit? 292 ext.OS_NAME = System.getProperty("os.name").toLowerCase() 293 ext.OS_ARCH = System.getProperty("os.arch") 294 ext.IS_64 = OS_ARCH.toLowerCase().contains("64") 295 ext.IS_MAC = OS_NAME.contains("mac") || OS_NAME.contains("darwin") 296 ext.IS_WINDOWS = OS_NAME.contains("windows") 297 ext.IS_LINUX = OS_NAME.contains("linux") 298 299 // Verify that the architecture & OS are supported configurations. Note that 300 // at present building on PI is not supported, but we would only need to make 301 // some changes on assumptions on what should be built (like SWT / Swing) and 302 // such and we could probably make it work. 303 if (!IS_MAC && !IS_WINDOWS && !IS_LINUX) fail("Unsupported build OS ${OS_NAME}") 304 if (IS_WINDOWS && OS_ARCH != "x86" && OS_ARCH != "amd64") { 305 fail("Unknown and unsupported build architecture: $OS_ARCH") 306 } else if (IS_MAC && OS_ARCH != "x86_64") { 307 fail("Unknown and unsupported build architecture: $OS_ARCH") 308 } else if (IS_LINUX && OS_ARCH != "i386" && OS_ARCH != "amd64") { 309 fail("Unknown and unsupported build architecture: $OS_ARCH") 310 } 311 312 313 // Get the JDK_HOME automatically based on the version of Java used to execute gradle. Or, if specified, 314 // use a user supplied JDK_HOME, STUB_RUNTIME, JAVAC, all of which may be specified 315 // independently (or we'll try to get the right one based on other supplied info). Sometimes the 316 // JRE might be the thing that is being used instead of the JRE embedded in the JDK, such as: 317 // c:\Program Files (x86)\Java\jdk1.8.0\jre 318 // c:\Program Files (x86)\Java\jre8\ 319 // Because of this, you may sometimes get the jdk's JRE (in which case the logic we used to have here 320 // was correct and consistent with all other platforms), or it might be the standalone JRE (for the love!). 321 def envJavaHome = cygpath(System.getenv("JDK_HOME")) 322 if (envJavaHome == null || envJavaHome.equals("")) envJavaHome = cygpath(System.getenv("JAVA_HOME")) 323 def javaHome = envJavaHome == null || envJavaHome.equals("") ? System.getProperty("java.home") : envJavaHome 324 def javaHomeFile = file(javaHome) 325 defineProperty("JDK_HOME", 326 javaHomeFile.name == "jre" ? 327 javaHomeFile.getParent().toString() : 328 javaHomeFile.name.startsWith("jre") ? 329 new File(javaHomeFile.getParent(), "jdk1.${javaHomeFile.name.substring(3)}.0").toString() : 330 javaHome) // we have to bail and set it to something and this is as good as any! 331 ext.JAVA_HOME = JDK_HOME 332 333 defineProperty("JAVA", cygpathExe("$JDK_HOME/bin/java")) 334 defineProperty("JAVAC", cygpathExe("$JDK_HOME/bin/javac")) 335 defineProperty("JAVADOC", cygpathExe("$JDK_HOME/bin/javadoc")) 336 defineProperty("JMOD", cygpathExe("$JDK_HOME/bin/jmod")) 337 defineProperty("JDK_DOCS", "https://docs.oracle.com/javase/10/docs/api/") 338 defineProperty("JDK_JMODS", cygpath(System.getenv("JDK_JMODS")) ?: cygpath(System.getenv("JDK_HOME") + "/jmods")) 339 340 defineProperty("javaRuntimeVersion", System.getProperty("java.runtime.version")) 341 def javaVersionInfo = parseJavaVersion(javaRuntimeVersion) 342 defineProperty("javaVersion", javaVersionInfo[0]) 343 defineProperty("javaBuildNumber", javaVersionInfo[1]) 344 345 defineProperty("libAVRepositoryURL", "https://libav.org/releases/") 346 defineProperty("FFmpegRepositoryURL", "https://www.ffmpeg.org/releases/") 347 348 loadProperties("$projectDir/build.properties") 349 350 def supplementalPreBuildFile = file("$closedDir/closed-pre-build.gradle"); 351 def supplementalBuildFile = file("$closedDir/closed-build.gradle"); 352 353 if (BUILD_CLOSED) { 354 apply from: supplementalPreBuildFile 355 } 356 357 // GRADLE_VERSION_CHECK specifies whether to fail the build if the 358 // gradle version check fails 359 defineProperty("GRADLE_VERSION_CHECK", "true") 360 ext.IS_GRADLE_VERSION_CHECK = Boolean.parseBoolean(GRADLE_VERSION_CHECK) 361 362 // JFX_DEPS_URL specifies the optional location of an alternate local repository 363 defineProperty("JFX_DEPS_URL", "") 364 365 // JDK_DOCS_LINK specifies the optional URL for offline javadoc linking 366 defineProperty("JDK_DOCS_LINK", "") 367 368 // COMPILE_WEBKIT specifies whether to build all of webkit. 369 defineProperty("COMPILE_WEBKIT", "false") 370 ext.IS_COMPILE_WEBKIT = Boolean.parseBoolean(COMPILE_WEBKIT) 371 372 // COMPILE_MEDIA specifies whether to build all of media. 373 defineProperty("COMPILE_MEDIA", "false") 374 ext.IS_COMPILE_MEDIA = Boolean.parseBoolean(COMPILE_MEDIA) 375 376 // BUILD_LIBAV_STUBS specifies whether to download and build libav/ffmpeg libraries 377 defineProperty("BUILD_LIBAV_STUBS", "false") 378 ext.IS_BUILD_LIBAV_STUBS = IS_LINUX ? Boolean.parseBoolean(BUILD_LIBAV_STUBS) : false 379 380 // BUILD_WORKING_LIBAV specifies whether to build libav/ffmpeg libraries with 381 // decoder, demuxer, etc. required to run media. Valid only if BUILD_LIBAV_STUBS is true. 382 defineProperty("BUILD_WORKING_LIBAV", "false") 383 ext.IS_BUILD_WORKING_LIBAV = IS_LINUX ? Boolean.parseBoolean(BUILD_WORKING_LIBAV) : false 384 385 // COMPILE_PANGO specifies whether to build javafx_font_pango. 386 defineProperty("COMPILE_PANGO", "${IS_LINUX}") 387 ext.IS_COMPILE_PANGO = Boolean.parseBoolean(COMPILE_PANGO) 388 389 // COMPILE_HARFBUZZ specifies whether to use Harfbuzz. 390 defineProperty("COMPILE_HARFBUZZ", "false") 391 ext.IS_COMPILE_HARFBUZZ = Boolean.parseBoolean(COMPILE_HARFBUZZ) 392 393 // COMPILE_PARFAIT specifies whether to build parfait 394 defineProperty("COMPILE_PARFAIT", "false") 395 ext.IS_COMPILE_PARFAIT = Boolean.parseBoolean(COMPILE_PARFAIT) 396 397 // BUILD_FXPACKAGER enables building the packager modules and native code 398 defineProperty("BUILD_FXPACKAGER", "false") 399 ext.IS_BUILD_FXPACKAGER = Boolean.parseBoolean(BUILD_FXPACKAGER) 400 401 // RETAIN_PACKAGER_TESTS specifies whether the tests in fxpackager should 402 // keep generated files instead of attempting to automatically delete them 403 defineProperty("RETAIN_PACKAGER_TESTS", "false") 404 ext.IS_RETAIN_PACKAGER_TESTS = Boolean.parseBoolean(RETAIN_PACKAGER_TESTS) 405 406 // TEST_PACKAGER_DMG whether tests that create DMG files via hdiutil 407 // should be run. On OSX 10.7 this tends to hang automated builds 408 defineProperty("TEST_PACKAGER_DMG", "false") 409 ext.IS_TEST_PACKAGER_DMG = Boolean.parseBoolean(TEST_PACKAGER_DMG) 410 411 // Define the SWT.jar that we are going to have to download during the build process based 412 // on what platform we are compiling from (not based on our target). 413 ext.SWT_FILE_NAME = IS_MAC ? "org.eclipse.swt.cocoa.macosx.x86_64_3.105.3.v20170228-0512" : 414 IS_WINDOWS && IS_64 ? "org.eclipse.swt.win32.win32.x86_64_3.105.3.v20170228-0512" : 415 IS_WINDOWS && !IS_64 ? "org.eclipse.swt.win32.win32.x86_3.105.3.v20170228-0512" : 416 IS_LINUX && IS_64 ? "org.eclipse.swt.gtk.linux.x86_64_3.105.3.v20170228-0512" : 417 IS_LINUX && !IS_64 ? "org.eclipse.swt.gtk.linux.x86_3.105.3.v20170228-0512" : "" 418 419 // Specifies whether to run full tests (true) or smoke tests (false) 420 defineProperty("FULL_TEST", "false") 421 ext.IS_FULL_TEST = Boolean.parseBoolean(FULL_TEST); 422 423 defineProperty("FORCE_TESTS", "false") 424 ext.IS_FORCE_TESTS = Boolean.parseBoolean(FORCE_TESTS); 425 426 // Specifies whether to run robot-based visual tests (only used when FULL_TEST is also enabled) 427 defineProperty("USE_ROBOT", "false") 428 ext.IS_USE_ROBOT = Boolean.parseBoolean(USE_ROBOT); 429 430 // Specified whether to run tests in headless mode 431 defineProperty("HEADLESS_TEST", "false") 432 ext.IS_HEADLESS_TEST = Boolean.parseBoolean(HEADLESS_TEST); 433 434 // Specifies whether to run system tests that depend on AWT (only used when FULL_TEST is also enabled) 435 defineProperty("AWT_TEST", "true") 436 ext.IS_AWT_TEST = Boolean.parseBoolean(AWT_TEST); 437 438 // Specifies whether to run system tests that depend on SWT (only used when FULL_TEST is also enabled) 439 defineProperty("SWT_TEST", "true") 440 ext.IS_SWT_TEST = Boolean.parseBoolean(SWT_TEST); 441 442 // Specifies whether to run unstable tests (true) - tests that don't run well with Hudson builds 443 // These tests should be protected with : 444 // assumeTrue(Boolean.getBoolean("unstable.test")); 445 defineProperty("UNSTABLE_TEST", "false") 446 ext.IS_UNSTABLE_TEST = Boolean.parseBoolean(UNSTABLE_TEST); 447 448 // Toggle diagnostic output from the Gradle workaround and the Sandbox test apps. 449 defineProperty("WORKER_DEBUG", "false") 450 ext.IS_WORKER_DEBUG = Boolean.parseBoolean(WORKER_DEBUG); 451 452 // Specify the build configuration (Release, Debug, or DebugNative) 453 defineProperty("CONF", "Debug") 454 ext.IS_DEBUG_JAVA = CONF == "Debug" || CONF == "DebugNative" 455 ext.IS_DEBUG_NATIVE = CONF == "DebugNative" 456 457 // Defines the compiler warning levels to use. If empty, then no warnings are generated. If 458 // not empty, then the expected syntax is as a space or comma separated list of names, such 459 // as defined in the javac documentation. 460 defineProperty("LINT", "none") 461 ext.IS_LINT = LINT != "none" 462 463 defineProperty("DOC_LINT", "all") 464 ext.IS_DOC_LINT = DOC_LINT != "" 465 466 // Specifies whether to use the "useDepend" option when compiling Java sources 467 defineProperty("USE_DEPEND", "true") 468 ext.IS_USE_DEPEND = Boolean.parseBoolean(USE_DEPEND) 469 470 // Specifies whether to use the "incremental" option when compiling Java sources 471 defineProperty("INCREMENTAL", "false") 472 ext.IS_INCREMENTAL = Boolean.parseBoolean(INCREMENTAL) 473 474 // Specifies whether to include the Null3D pipeline (for perf debugging) 475 defineProperty("INCLUDE_NULL3D", "false") 476 ext.IS_INCLUDE_NULL3D = Boolean.parseBoolean(INCLUDE_NULL3D) 477 478 // Specifies whether to include the ES2 pipeline if available 479 defineProperty("INCLUDE_ES2", IS_WINDOWS ? "false" : "true") 480 ext.IS_INCLUDE_ES2 = Boolean.parseBoolean(INCLUDE_ES2) 481 482 // Specifies whether to generate code coverage statistics when running tests 483 defineProperty("JCOV", "false") 484 ext.DO_JCOV = Boolean.parseBoolean(JCOV) 485 486 // Define the number of threads to use when compiling (specifically for native compilation) 487 // On Mac we limit it to 1 by default due to problems running gcc in parallel 488 if (IS_MAC) { 489 defineProperty("NUM_COMPILE_THREADS", "1") 490 } else { 491 defineProperty("NUM_COMPILE_THREADS", "${Runtime.runtime.availableProcessors()}") 492 } 493 494 // 495 // The next three sections of properties are used to generate the 496 // VersionInfo class, and the Windows DLL manifest. 497 // 498 499 // The following properties should be left alone by developers and set only from Hudson. 500 defineProperty("HUDSON_JOB_NAME", "not_hudson") 501 defineProperty("HUDSON_BUILD_NUMBER","0000") 502 defineProperty("PROMOTED_BUILD_NUMBER", "0") 503 defineProperty("MILESTONE_FCS", "false") 504 ext.IS_MILESTONE_FCS = Boolean.parseBoolean(MILESTONE_FCS) 505 506 // The following properties define the product name for Oracle JDK and OpenJDK 507 // for VersionInfo and the DLL manifest. 508 if (BUILD_CLOSED) { 509 defineProperty("PRODUCT_NAME", "Java(TM)") 510 defineProperty("COMPANY_NAME", "Oracle Corporation") 511 defineProperty("PLATFORM_NAME", "Platform SE") 512 } else { 513 defineProperty("PRODUCT_NAME", "OpenJFX") 514 defineProperty("COMPANY_NAME", "N/A") 515 defineProperty("PLATFORM_NAME", "Platform") 516 } 517 518 // The following properties are set based on properties defined in 519 // build.properties. The release version and suffix should be updated 520 // in that file. 521 def relVer = 0 522 if (jfxReleasePatchVersion == "0") { 523 if (jfxReleaseSecurityVersion == "0") { 524 if (jfxReleaseMinorVersion == "0") { 525 relVer = "${jfxReleaseMajorVersion}" 526 } else { 527 relVer = "${jfxReleaseMajorVersion}.${jfxReleaseMinorVersion}" 528 } 529 } else { 530 relVer = "${jfxReleaseMajorVersion}.${jfxReleaseMinorVersion}.${jfxReleaseSecurityVersion}" 531 } 532 } else { 533 relVer = "${jfxReleaseMajorVersion}.${jfxReleaseMinorVersion}.${jfxReleaseSecurityVersion}.${jfxReleasePatchVersion}" 534 } 535 defineProperty("RELEASE_VERSION", relVer) 536 defineProperty("RELEASE_VERSION_PADDED", "${jfxReleaseMajorVersion}.${jfxReleaseMinorVersion}.${jfxReleaseSecurityVersion}.${jfxReleasePatchVersion}") 537 538 def buildDate = new java.util.Date() 539 def buildTimestamp = new java.text.SimpleDateFormat("yyyy-MM-dd-HHmmss").format(buildDate) 540 defineProperty("BUILD_TIMESTAMP", buildTimestamp) 541 def relSuffix = "" 542 def relOpt = "" 543 if (HUDSON_JOB_NAME == "not_hudson") { 544 relSuffix = "-internal" 545 relOpt = "-${buildTimestamp}" 546 } else { 547 relSuffix = IS_MILESTONE_FCS ? "" : jfxReleaseSuffix 548 } 549 defineProperty("RELEASE_SUFFIX", relSuffix) 550 defineProperty("RELEASE_VERSION_SHORT", "${RELEASE_VERSION}${RELEASE_SUFFIX}") 551 defineProperty("RELEASE_VERSION_LONG", "${RELEASE_VERSION_SHORT}+${PROMOTED_BUILD_NUMBER}${relOpt}") 552 553 // Check whether the COMPILE_TARGETS property has been specified (if so, it was done by 554 // the user and not by this script). If it has not been defined then default 555 // to building the normal desktop build for this machine 556 project.ext.set("defaultHostTarget", IS_MAC ? "mac" : IS_WINDOWS ? "win" : IS_LINUX ? "linux" : ""); 557 defineProperty("COMPILE_TARGETS", "$defaultHostTarget") 558 559 // Flag indicating whether to import cross compile tools 560 def importCrossTools = false 561 if (hasProperty("IMPORT_CROSS_TOOLS")) { 562 importCrossTools = Boolean.parseBoolean(IMPORT_CROSS_TOOLS); 563 } 564 ext.IS_IMPORT_CROSS_TOOLS = importCrossTools 565 566 // Location of the cross compile tools 567 def crossToolsDir = "../crosslibs" 568 if (hasProperty("CROSS_TOOLS_DIR")) { 569 crossToolsDir = CROSS_TOOLS_DIR 570 } 571 ext.CROSS_TOOLS_DIR = file(crossToolsDir) 572 573 // Specifies whether to run tests with the existing javafx.* modules instead of compiling a new one 574 defineProperty("BUILD_SDK_FOR_TEST", "true") 575 ext.DO_BUILD_SDK_FOR_TEST = Boolean.parseBoolean(BUILD_SDK_FOR_TEST) 576 577 // All "classes" and "jar" tasks and their dependencies would be disabled 578 // when running with DO_BUILD_SDK_FOR_TEST=false as they're unneeded for running tests 579 if (!DO_BUILD_SDK_FOR_TEST) { 580 gradle.taskGraph.useFilter({ task -> !task.name.equals("classes") && !task.name.equals("jar") }) 581 } 582 583 // Make sure JDK_HOME/bin/java exists 584 if (!file(JAVA).exists()) throw new Exception("Missing or incorrect path to 'java': '$JAVA'. Perhaps bad JDK_HOME? $JDK_HOME") 585 if (!file(JAVAC).exists()) throw new Exception("Missing or incorrect path to 'javac': '$JAVAC'. Perhaps bad JDK_HOME? $JDK_HOME") 586 if (!file(JAVADOC).exists()) throw new Exception("Missing or incorrect path to 'javadoc': '$JAVADOC'. Perhaps bad JDK_HOME? $JDK_HOME") 587 588 // Determine the verion of Java in JDK_HOME. It looks like this: 589 // 590 // $ java -version 591 // java version "1.7.0_45" 592 // Java(TM) SE Runtime Environment (build 1.7.0_45-b18) 593 // Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode) 594 // 595 // We need to parse the second line 596 def inStream = new java.io.BufferedReader(new java.io.InputStreamReader(new java.lang.ProcessBuilder(JAVA, "-fullversion").start().getErrorStream())); 597 try { 598 String v = inStream.readLine().trim(); 599 if (v != null) { 600 int ib = v.indexOf("full version \""); 601 if (ib != -1) { 602 String str = v.substring(ib); 603 String ver = str.substring(str.indexOf("\"") + 1, str.size() - 1); 604 605 defineProperty("jdkRuntimeVersion", ver) 606 def jdkVersionInfo = parseJavaVersion(ver) 607 defineProperty("jdkVersion", jdkVersionInfo[0]) 608 defineProperty("jdkBuildNumber", jdkVersionInfo[1]) 609 } 610 } 611 } finally { 612 inStream.close(); 613 } 614 if (!project.hasProperty("jdkRuntimeVersion")) throw new Exception("Unable to determine the version of Java in JDK_HOME at $JDK_HOME"); 615 616 617 // Determine whether the javafx.* modules are present in the JDK. To do this, 618 // we will execute "java --list-modules" and search for javafx.base. 619 // Also, check if jdk.unsupported.desktop module is present in JDK to ensure 620 // javafx.swing do not use internal JDK classes directly. 621 ext.HAS_JAVAFX_MODULES = false; 622 ext.HAS_UNSUPPORTED_DESKTOP = false; 623 def inStream2 = new java.io.BufferedReader(new java.io.InputStreamReader(new java.lang.ProcessBuilder(JAVA, "--list-modules").start().getInputStream())); 624 try { 625 String v; 626 while ((v = inStream2.readLine()) != null) { 627 v = v.trim(); 628 if (v.startsWith("javafx.base")) ext.HAS_JAVAFX_MODULES = true; 629 if (v.startsWith("jdk.unsupported.desktop")) ext.HAS_UNSUPPORTED_DESKTOP = true; 630 } 631 } finally { 632 inStream2.close(); 633 } 634 635 // The HAS_JAVAFX_MODULES flag will be used to determine the mode for building 636 // and running the applications and tests. 637 // If HAS_JAVAFX_MODULES is true, then we will build / test javafx modules 638 // for exporting to a JDK build. If HAS_JAVAFX_MODULES is false, then we will 639 // build / test a standalone sdk for running with a JDK that does not include 640 // the javafx modules. 641 642 643 /** 644 * Fetch/Check that external tools are present for the build. This method 645 * will conditionally download the packages from project defined ivy repositories 646 * and unpack them into the specified destdir 647 * 648 * @param configName A unique name to distinguish the configuration (ie "ARMSFV6") 649 * @param packages A list of required packages (with extensions .tgz, .zip) 650 * @param destdir where the packages should be unpacked 651 * @param doFetch if true, the named packages will be download 652 */ 653 void fetchExternalTools(String configName, List packages, File destdir, boolean doFetch) { 654 if (doFetch) { 655 // create a unique configuration for this fetch 656 def String fetchToolsConfig = "fetchTools$configName" 657 rootProject.configurations.create(fetchToolsConfig) 658 659 def List<String> fetchedPackages = [] 660 def int fetchCount = 0 661 662 packages.each { pkgname-> 663 def int dotdex = pkgname.lastIndexOf('.') 664 def int dashdex = pkgname.lastIndexOf('-') 665 def String basename = pkgname.substring(0,dashdex) 666 def String ver = pkgname.substring(dashdex+1,dotdex) 667 def String ext = pkgname.substring(dotdex+1) 668 def File pkgdir = file("$destdir/$basename-$ver") 669 670 if (!pkgdir.isDirectory()) { 671 rootProject.dependencies.add(fetchToolsConfig, "javafx:$basename:$ver", { 672 artifact { 673 name = basename 674 type = ext 675 } 676 }) 677 println "adding $pkgname as a downloadable item did not find $pkgdir" 678 fetchedPackages.add(pkgname) 679 fetchCount++ 680 } 681 } 682 683 //fetch all the missing packages 684 if (fetchedPackages.size > 0) { 685 destdir.mkdirs() 686 687 logger.quiet "fetching missing packages $fetchedPackages" 688 copy { 689 from rootProject.configurations[fetchToolsConfig] 690 into destdir 691 } 692 693 // unpack the fetched packages 694 fetchedPackages.each { pkgname-> 695 logger.quiet "expanding the package $pkgname" 696 def srcball = file("${destdir}/${pkgname}") 697 698 if (!srcball.exists()) { 699 throw new GradleException("Failed to fetch $pkgname"); 700 } 701 702 def String basename = pkgname.substring(0,pkgname.lastIndexOf(".")) 703 def File pkgdir = file("$destdir/$basename") 704 705 if (pkgname.endsWith(".tgz")) { 706 if (IS_LINUX || IS_MAC) { 707 // use native tar to support symlinks 708 pkgdir.mkdirs() 709 exec { 710 workingDir pkgdir 711 commandLine "tar", "zxf", "${srcball}" 712 } 713 } else { 714 copy { 715 from tarTree(resources.gzip("${srcball}")) 716 into pkgdir 717 } 718 } 719 } else if (pkgname.endsWith(".zip")) { 720 copy { 721 from zipTree("${srcball}") 722 into pkgdir 723 } 724 } else { 725 throw new GradleException("Unhandled package type for compile package ${pkgname}") 726 } 727 srcball.deleteOnExit(); 728 } 729 } else { 730 logger.quiet "all tool packages are present $packages" 731 } 732 } else { // !doFetch - so just check they are present 733 // check that all the dirs are really there 734 def List<String> errors = [] 735 packages.each { pkgname-> 736 def String basename = pkgname.substring(0,pkgname.lastIndexOf(".")) 737 def File pkgdir = file("$destdir/$basename") 738 739 if (!pkgdir.isDirectory()) { 740 errors.add(pkgname) 741 } 742 } 743 if (errors.size > 0) { 744 throw new GradleException("Error: missing tool packages: $errors") 745 } else { 746 logger.quiet "all tool packages are present $packages" 747 } 748 } 749 } 750 751 // Make a forked ANT call. 752 // This needs to be forked so that ant can be used with the right JDK and updated modules 753 // for testing obscure things like packaging of apps 754 void ant(String conf, // platform configuration 755 String dir, // directory to run from 756 String target, // ant target 757 List<String> params // parameters (usually -Dxxx=yyy) 758 ) { 759 // Try to use ANT_HOME 760 String antHomeEnv = System.getenv("ANT_HOME") 761 String antHome = antHomeEnv != null ? cygpath(antHomeEnv) : null; 762 String ant = (antHome != null && !antHome.equals("")) ? "$antHome/bin/ant" : "ant"; 763 764 exec { 765 workingDir = dir 766 environment("JDK_HOME", JDK_HOME) 767 environment("JAVA_HOME", JDK_HOME) 768 if (IS_WINDOWS) { 769 environment([ 770 "VCINSTALLDIR" : WINDOWS_VS_VCINSTALLDIR, 771 "VSINSTALLDIR" : WINDOWS_VS_VSINSTALLDIR, 772 "DEVENVDIR" : WINDOWS_VS_DEVENVDIR, 773 "MSVCDIR" : WINDOWS_VS_MSVCDIR, 774 "INCLUDE" : WINDOWS_VS_INCLUDE, 775 "LIB" : WINDOWS_VS_LIB, 776 "LIBPATH" : WINDOWS_VS_LIBPATH, 777 "DXSDK_DIR" : WINDOWS_DXSDK_DIR 778 ]); 779 commandLine "cmd", "/c", ant, "-Dbuild.compiler=javac1.7" 780 } else { 781 commandLine ant, "-Dbuild.compiler=javac1.7" 782 } 783 if ((conf != null) && !rootProject.defaultHostTarget.equals(conf)) { 784 def targetProperties = rootProject.ext[conf.trim().toUpperCase()] 785 args("-Dcross.platform=$conf") 786 if (targetProperties.containsKey('arch')) { 787 args("-Dcross.platform.arch=${targetProperties.arch}") 788 } 789 } 790 if (params != null) { 791 params.each() { s-> 792 args(s) 793 } 794 } 795 if (IS_MILESTONE_FCS) { 796 args('-Djfx.release.suffix=""') 797 } 798 args(target); 799 } 800 } 801 802 List<String> computeLibraryPath(boolean working) { 803 List<String> lp = [] 804 805 if (HAS_JAVAFX_MODULES) { 806 List<String> modsWithNative = [ 'graphics', 'media', 'web' ] 807 808 // the build/modular-sdk area 809 def platformPrefix = "" 810 def bundledSdkDirName = "${platformPrefix}modular-sdk" 811 def bundledSdkDir = "${rootProject.buildDir}/${bundledSdkDirName}" 812 def modulesLibsDir = "${bundledSdkDir}/modules_libs" 813 814 modsWithNative.each() { m -> 815 lp << cygpath("${modulesLibsDir}/javafx.${m}") 816 } 817 } else { 818 def platformPrefix = "" 819 def standaloneSdkDirName = "${platformPrefix}sdk" 820 def standaloneSdkDir = "${rootProject.buildDir}/${standaloneSdkDirName}" 821 def modulesLibName = IS_WINDOWS ? "bin" : "lib" 822 def modulesLibsDir = "${standaloneSdkDir}/${modulesLibName}" 823 lp << cygpath("${modulesLibsDir}") 824 } 825 826 return lp 827 } 828 829 // Return list with the arguments needed for --patch-module or --module-path 830 // for the provided projects. Used with Java executables ie. tests 831 List<String> computePatchModuleArgs(List<String> deps, boolean test, boolean includeJLP) { 832 List<String> pma = [] 833 834 if (HAS_JAVAFX_MODULES) { 835 deps.each { String projname -> 836 def proj = project(projname) 837 if (proj.hasProperty("moduleName")) { 838 File dir; 839 if (test && proj.sourceSets.hasProperty('shims')) { 840 dir = file("${rootProject.buildDir}/shims") 841 } else { 842 dir = file("${rootProject.buildDir}/modular-sdk/modules") 843 } 844 String moduleName = proj.ext.moduleName 845 String dirpath = cygpath("${dir}/${moduleName}") 846 pma += "--patch-module=${moduleName}=${dirpath}" 847 } 848 } 849 } else { 850 String mp = null 851 deps.each { String projname -> 852 def proj = project(projname) 853 if (proj.hasProperty("moduleName")) { 854 String moduleName = proj.ext.moduleName 855 File dir; 856 if (test && proj.sourceSets.hasProperty('shims')) { 857 dir = file("${rootProject.buildDir}/shims/${moduleName}") 858 } else { 859 dir = file("${rootProject.buildDir}/sdk/lib/${moduleName}.jar") 860 } 861 if (mp == null) { 862 mp = dir.path 863 } else { 864 mp = mp + File.pathSeparator + dir.path 865 } 866 } 867 } 868 869 // in some cases like base we could end up with an empty 870 // path... make sure we don't pass one back 871 if (mp == null) { 872 return null 873 } 874 875 pma += '--module-path' 876 pma += mp 877 878 String addm = null 879 deps.each {String projname -> 880 def proj = project(projname) 881 if (proj.hasProperty("moduleName") && proj.buildModule) { 882 if (addm == null) { 883 addm = proj.moduleName 884 } else { 885 addm = addm + "," + proj.moduleName 886 } 887 } 888 } 889 if (addm != null) { 890 pma += "--add-modules=${addm}" 891 } 892 } 893 894 if (includeJLP) { 895 pma += "-Djava.library.path=" + computeLibraryPath(true).join(File.pathSeparator) 896 } 897 898 return pma 899 } 900 901 // Return a list containing the --upgrade-module-path or --module-path 902 // used with Javac 903 List<String> computeModulePathArgs(String pname, List<String> deps, boolean test) { 904 List<String> mpa = HAS_JAVAFX_MODULES ? [ '--upgrade-module-path' ] : [ '--module-path' ] 905 String mp = null 906 deps.each { String projname -> 907 def proj = project(projname) 908 // for a non test set of args, we don't want the current module in the list 909 // for a test test, we do need it to update what we built 910 911 if (proj.hasProperty("moduleName") && 912 proj.buildModule && 913 !(!test && proj.name.equals(pname))) { 914 915 File dir; 916 if (test && proj.sourceSets.hasProperty('shims')) { 917 dir = new File(proj.sourceSets.shims.java.outputDir, proj.ext.moduleName); 918 } else { 919 dir = new File(proj.sourceSets.main.java.outputDir, proj.ext.moduleName); 920 } 921 if (mp == null) { 922 mp = dir.path 923 } else { 924 mp = mp + File.pathSeparator + dir.path 925 } 926 } 927 } 928 929 // in some cases like base we could end up with an empty 930 // path... make sure we don't pass one back 931 if (mp == null) { 932 return null 933 } 934 935 mpa += mp 936 937 if (!HAS_JAVAFX_MODULES) { 938 String addm = null 939 deps.each {String projname -> 940 def proj = project(projname) 941 // for a non test set of args, we don't want the current module in the list 942 // for a test test, we do need it to update what we built 943 944 if (proj.hasProperty("moduleName") && 945 proj.buildModule && 946 !(!test && proj.name.equals(pname))) { 947 948 if (addm == null) { 949 addm = proj.moduleName 950 } else { 951 addm = addm + "," + proj.moduleName 952 } 953 } 954 } 955 if (addm != null) { 956 mpa += "--add-modules=${addm}" 957 } 958 } 959 960 return mpa 961 } 962 963 964 void writeRunArgsFile(File dest, List<String> libpath, List<String> modpath, List<String> modules) { 965 966 dest.delete() 967 968 logger.info("Creating file ${dest.path}") 969 970 if (libpath != null) { 971 dest << "-Djava.library.path=\"\\\n" 972 libpath.each() { e-> 973 dest << " " 974 dest << e 975 dest << File.pathSeparator 976 dest << "\\\n" 977 } 978 dest << " \"\n" 979 } 980 981 if (HAS_JAVAFX_MODULES) { 982 modpath.each { e -> 983 dest << "--patch-module=\"" 984 dest << e 985 dest << "\"\n" 986 } 987 } else { 988 if (modpath.size() == 1) { 989 dest << "--module-path=\"" 990 dest << modpath[0] 991 dest << "\"\n" 992 } else { 993 dest << "--module-path=\"\\\n" 994 modpath.each() { e-> 995 dest << " " 996 dest << e 997 dest << File.pathSeparator 998 dest << "\\\n" 999 } 1000 dest << " \"\n" 1001 } 1002 } 1003 1004 if (modules != null) { 1005 dest << "--add-modules=" 1006 dest << modules.join(",") 1007 dest << "\n" 1008 } 1009 } 1010 1011 void appendQualExports(File dest, List<String> qualExports) { 1012 qualExports.each { exp -> 1013 dest << exp 1014 dest << "\n" 1015 } 1016 } 1017 1018 // perform common project manipulation for modules 1019 void commonModuleSetup(Project p, List<String> moduleChain) { 1020 1021 p.ext.moduleChain = moduleChain 1022 1023 if (p.hasProperty("moduleName")) { 1024 p.ext.moduleDir = new File (p.sourceSets.main.java.outputDir, "${p.moduleName}") 1025 if (p.sourceSets.hasProperty('shims')) { 1026 p.ext.moduleShimsDir = new File (p.sourceSets.shims.java.outputDir, "${p.moduleName}") 1027 } 1028 } 1029 1030 def mpa = computeModulePathArgs(p.name, moduleChain, false) 1031 if (mpa != null) { 1032 p.ext.modulePathArgs = mpa 1033 } 1034 1035 p.ext.testModulePathArgs = computePatchModuleArgs(moduleChain, true, false) 1036 p.ext.patchModuleArgs = computePatchModuleArgs(moduleChain ,false, true) 1037 p.ext.testPatchModuleArgs = computePatchModuleArgs(moduleChain, true, true) 1038 1039 moduleChain.each() {e -> 1040 if (!e.equals(p.name)) { 1041 p.compileJava.dependsOn(project(e).classes) 1042 p.compileTestJava.dependsOn(project(e).testClasses) 1043 } 1044 } 1045 1046 // read in any addExports file 1047 File addExportsFile = new File(p.projectDir,"src/test/addExports") 1048 if (addExportsFile.exists()) { 1049 List<String> ae = [] 1050 addExportsFile.eachLine { line -> 1051 line = line.trim() 1052 if (!(line.startsWith("#") || line.equals(""))) { 1053 ae += line.split(' ') 1054 } 1055 } 1056 p.ext.testAddExports = ae.flatten() 1057 } 1058 1059 // read in the temporary addExports file EXTRAADDEXPORTS) 1060 // 1061 // These extra --add-exports will be used in two places and so we 1062 // create/modify two items: 1063 // p.testAddExports - add the extra items so they are included in test builds 1064 // 1065 // p.extraAddExports - for use in any other place where we don't automatically update 1066 // for example any non modular, non 'test' compile, any compile that does not 1067 // use a module-source-path that includes the dependent modules 1068 // 1069 // Note that we don't modify the modular build (main, shims) because they use 1070 // module-info directly, and we don't want to cover up any missing items there. 1071 // 1072 if (!rootProject.hasProperty("EXTRA_ADDEXPORTS_ARGS")) { 1073 List<String> extraAddExportsList = [] 1074 String fullae = "" 1075 File tmpaddExportsFile = new File(rootProject.projectDir, EXTRAADDEXPORTS) 1076 if (tmpaddExportsFile.exists()) { 1077 String nl = System.getProperty("line.separator") 1078 tmpaddExportsFile.eachLine { line -> 1079 line = line.trim() 1080 fullae += line + nl 1081 if (!(line.startsWith("#") || line.equals(""))) { 1082 extraAddExportsList += line.split(' ') 1083 } 1084 } 1085 } 1086 // This string is used in the creation of the build/*.args files 1087 // so we preserve comments 1088 if (!extraAddExportsList.isEmpty()) { 1089 rootProject.ext.EXTRA_ADDEXPORTS_STRING = fullae 1090 } 1091 rootProject.ext.EXTRA_ADDEXPORTS_ARGS = extraAddExportsList 1092 } 1093 1094 if (HAS_JAVAFX_MODULES) { 1095 // use this variable, because it shows we have a non empty addition 1096 if (rootProject.hasProperty("EXTRA_ADDEXPORTS_STRING")) { 1097 p.ext.extraAddExports = EXTRA_ADDEXPORTS_ARGS.flatten() 1098 if (p.hasProperty("testAddExports")) { 1099 p.testAddExports += EXTRA_ADDEXPORTS_ARGS.flatten() 1100 } 1101 } 1102 } 1103 } 1104 1105 // Now we need to define the native compilation tasks. The set of parameters to 1106 // native compilation depends on the target platform (and also to some extent what platform 1107 // you are compiling on). These settings are contained in various gradle files 1108 // such as mac.gradle and linux.gradle and armhf.gradle. Additionally, the developer 1109 // can specify COMPILE_FLAGS_FILE to be a URL or path to a different gradle file 1110 // that will contain the appropriate flags. 1111 defineProperty("COMPILE_FLAGS_FILES", COMPILE_TARGETS.split(",").collect {"buildSrc/${it.trim()}.gradle"}.join(",")) 1112 if (COMPILE_TARGETS == "all") { 1113 def tmp = [] 1114 File buildSrcDir = file("buildSrc") 1115 buildSrcDir.listFiles().each { File f -> 1116 if (f.isFile() && f.name.endsWith(".gradle") && !f.name.equals("build.gradle")) { 1117 def target = f.name.substring(0, f.name.lastIndexOf('.gradle')).toUpperCase(Locale.ROOT) 1118 apply from: f 1119 if (project.ext["${target}"].canBuild) { 1120 tmp.add(target) 1121 } 1122 } 1123 } 1124 COMPILE_FLAGS_FILES = tmp.collect { "buildSrc/${it}.gradle"}.join(",") 1125 COMPILE_TARGETS = tmp.collect { "${it.toLowerCase()}"}.join(",") 1126 } else { 1127 COMPILE_FLAGS_FILES.split(",").each { 1128 logger.info("Applying COMPILE_FLAGS_FILE '$it'") 1129 apply from: it 1130 } 1131 } 1132 1133 if (COMPILE_TARGETS != "") { 1134 def tmp = [] 1135 COMPILE_TARGETS.split(",").each {target -> 1136 if (project.ext["${target.toUpperCase(Locale.ROOT)}"].canBuild) { 1137 tmp.add(target) 1138 } 1139 } 1140 COMPILE_TARGETS = tmp.collect { "${it.toLowerCase()}"}.join(",") 1141 } 1142 1143 // Sanity check the expected properties all exist 1144 compileTargets { t -> 1145 // Every platform must define these variables 1146 if (!project.hasProperty(t.upper)) throw new Exception("ERROR: Incorrectly configured compile flags file, missing ${t.name} property") 1147 def props = project.ext[t.upper]; 1148 // TODO: we could remove libDest in favor of modLibDest 1149 ["compileSwing", "compileSWT", "compileFXPackager", "libDest"].each { prop -> 1150 if (!props.containsKey(prop)) throw new Exception("ERROR: Incorrectly configured compile flags file, missing ${prop} property on ${t.name}") 1151 } 1152 } 1153 1154 // Various build flags may be set by the different target files, such as 1155 // whether to build Swing, SWT, FXPackager, etc. We iterate over all 1156 // compile targets and look for these settings in our properties. Note that 1157 // these properties cannot be set from the command line, but are set by 1158 // the target build files such as armv6hf.gradle or mac.gradle. 1159 ext.COMPILE_SWING = false; 1160 ext.COMPILE_SWT = false; 1161 ext.COMPILE_FXPACKAGER = false; 1162 compileTargets { t -> 1163 def targetProperties = project.rootProject.ext[t.upper] 1164 1165 if (targetProperties.compileSwing) COMPILE_SWING = true 1166 if (targetProperties.compileSWT) COMPILE_SWT = true 1167 if (IS_BUILD_FXPACKAGER && HAS_JAVAFX_MODULES && targetProperties.compileFXPackager) COMPILE_FXPACKAGER = true 1168 1169 if (!targetProperties.containsKey('compileWebnodeNative')) { 1170 // unless specified otherwise, we will compile native Webnode if IS_COMPILE_WEBKIT 1171 targetProperties.compileWebnodeNative = true 1172 } 1173 1174 if (!targetProperties.containsKey('compileMediaNative')) { 1175 // unless specified otherwise, we will compile native Media if IS_COMPILE_MEDIA 1176 targetProperties.compileMediaNative = true 1177 } 1178 1179 if (!targetProperties.containsKey('includeSWT')) targetProperties.includeSWT = true 1180 if (!targetProperties.containsKey('includeSwing')) targetProperties.includeSwing = true 1181 if (!targetProperties.containsKey('includeNull3d')) targetProperties.includeNull3d = true 1182 if (!targetProperties.containsKey('includeMonocle')) targetProperties.includeMonocle = false 1183 if (!targetProperties.containsKey('includeEGL')) targetProperties.includeEGL = false 1184 1185 if (!targetProperties.containsKey('includeGTK')) targetProperties.includeGTK = IS_LINUX 1186 1187 if (!targetProperties.containsKey('modLibDest')) targetProperties.modLibDest = targetProperties.libDest 1188 1189 // This value is used as a prefix for various directories under ./build, 1190 // such as sdk, to allow for a common name for the hosted build 1191 // (for use when building apps) and a unique name for cross builds. 1192 if (rootProject.defaultHostTarget.equals(t.name)) { 1193 // use a simple common default for the "host" build 1194 targetProperties.platformPrefix="" 1195 } else { 1196 // and a more complex one for cross builds 1197 targetProperties.platformPrefix="${t.name}-" 1198 } 1199 } 1200 1201 /****************************************************************************** 1202 * * 1203 * Build Setup Sanity Checks * 1204 * * 1205 * Here we do a variety of checks so that if the version of Java you are * 1206 * building with is misconfigured, or you are using the wrong version of * 1207 * gradle, etc you will get some kind of helpful error / warning message * 1208 * * 1209 *****************************************************************************/ 1210 1211 // Sanity check that we actually have a list of compile targets to execute 1212 if (COMPILE_TARGETS == null || COMPILE_TARGETS == "") { 1213 throw new Exception("Unable to determine compilation platform, must specify valid COMPILE_TARGETS!") 1214 } 1215 1216 // Verify that CONF is something useful 1217 if (CONF != "Release" && CONF != "Debug" && CONF != "DebugNative") { 1218 logger.warn("Unknown configuration CONF='$CONF'. Treating as 'Release'") 1219 } 1220 1221 // If the number of compile threads is less than 1 then we have a problem! 1222 if (Integer.parseInt(NUM_COMPILE_THREADS.toString()) < 1) { 1223 logger.warn("NUM_COMPILE_THREADS was specified as '$NUM_COMPILE_THREADS' which is less than the minimum value of 1. " + 1224 "Building with a value of 1 instead.") 1225 NUM_COMPILE_THREADS = 1 1226 } 1227 1228 // Check for Gradle 4.8, error if < 4.3. 1229 if (gradle.gradleVersion != "4.8") { 1230 def ver = gradle.gradleVersion.split("[\\.]"); 1231 def gradleMajor = Integer.parseInt(ver[0]); 1232 def gradleMinor = Integer.parseInt(ver[1].split("[^0-9]")[0]); 1233 def err = ""; 1234 if (gradleMajor < 4 || (gradleMajor == 4 && gradleMinor < 3)) { 1235 err = "Gradle version too old: ${gradle.gradleVersion}; must be at least 4.3" 1236 } 1237 1238 if (IS_GRADLE_VERSION_CHECK && err != "") { 1239 fail(err); 1240 } 1241 1242 logger.warn("*****************************************************************"); 1243 logger.warn("Unsupported gradle version $gradle.gradleVersion in use."); 1244 logger.warn("Only version 4.8 is supported. Use this version at your own risk"); 1245 if ( err != "") logger.warn(err); 1246 logger.warn("*****************************************************************"); 1247 } 1248 1249 // Look for stub runtime in bundled sdk, standalone sdk, or boot JDK 1250 1251 def String cachedBundledRuntime = cygpath("$projectDir") + "/../caches/modular-sdk" 1252 def String cachedStandaloneRuntime = cygpath("$projectDir") + "/../caches/sdk" 1253 def String jdkStubRuntime = cygpath("$JDK_HOME") 1254 1255 def defaultStubRuntime = "" 1256 if (file(cachedBundledRuntime).exists()) { 1257 defaultStubRuntime = cachedBundledRuntime 1258 } else if (file(cachedStandaloneRuntime).exists()) { 1259 defaultStubRuntime = cachedStandaloneRuntime 1260 } else if (BUILD_CLOSED) { 1261 defaultStubRuntime = cachedBundledRuntime 1262 } else { 1263 defaultStubRuntime = jdkStubRuntime 1264 } 1265 1266 defineProperty("STUB_RUNTIME", defaultStubRuntime) 1267 1268 if (STUB_RUNTIME.endsWith("/modular-sdk")) { 1269 def stubModulesLib = "$STUB_RUNTIME/modules_libs" 1270 defineProperty("MEDIA_STUB", "$stubModulesLib/javafx.media") 1271 defineProperty("WEB_STUB", "$stubModulesLib/javafx.web") 1272 } else { 1273 def libraryStub = IS_WINDOWS ? "$STUB_RUNTIME/bin" : "$STUB_RUNTIME/lib" 1274 1275 defineProperty("MEDIA_STUB", libraryStub) 1276 defineProperty("WEB_STUB", libraryStub) 1277 } 1278 1279 ext.UPDATE_STUB_CACHE = (BUILD_CLOSED && STUB_RUNTIME != "" && !file(STUB_RUNTIME).isDirectory()) 1280 1281 1282 /****************************************************************************** 1283 * * 1284 * Logging of Properties and Settings * 1285 * * 1286 * Log some of the settings we've determined. We could log more here, it * 1287 * doesn't really hurt. * 1288 * * 1289 *****************************************************************************/ 1290 1291 logger.quiet("gradle.gradleVersion: $gradle.gradleVersion") 1292 logger.quiet("OS_NAME: $OS_NAME") 1293 logger.quiet("OS_ARCH: $OS_ARCH") 1294 logger.quiet("JAVA_HOME: $JAVA_HOME") 1295 logger.quiet("JDK_HOME: $JDK_HOME") 1296 logger.quiet("java.runtime.version: ${javaRuntimeVersion}") 1297 logger.quiet("java version: ${javaVersion}") 1298 logger.quiet("java build number: ${javaBuildNumber}") 1299 logger.quiet("jdk.runtime.version: ${jdkRuntimeVersion}") 1300 logger.quiet("jdk version: ${jdkVersion}") 1301 logger.quiet("jdk build number: ${jdkBuildNumber}") 1302 logger.quiet("minimum jdk version: ${jfxBuildJdkVersionMin}") 1303 logger.quiet("minimum jdk build number: ${jfxBuildJdkBuildnumMin}") 1304 logger.quiet("HAS_JAVAFX_MODULES: $HAS_JAVAFX_MODULES") 1305 logger.quiet("HAS_UNSUPPORTED_DESKTOP: $HAS_UNSUPPORTED_DESKTOP") 1306 logger.quiet("STUB_RUNTIME: $STUB_RUNTIME") 1307 logger.quiet("CONF: $CONF") 1308 logger.quiet("NUM_COMPILE_THREADS: $NUM_COMPILE_THREADS") 1309 logger.quiet("COMPILE_TARGETS: $COMPILE_TARGETS") 1310 logger.quiet("COMPILE_FLAGS_FILES: $COMPILE_FLAGS_FILES") 1311 logger.quiet("HUDSON_JOB_NAME: $HUDSON_JOB_NAME") 1312 logger.quiet("HUDSON_BUILD_NUMBER: $HUDSON_BUILD_NUMBER") 1313 logger.quiet("PROMOTED_BUILD_NUMBER: $PROMOTED_BUILD_NUMBER") 1314 logger.quiet("PRODUCT_NAME: $PRODUCT_NAME") 1315 logger.quiet("RELEASE_VERSION: $RELEASE_VERSION") 1316 logger.quiet("RELEASE_SUFFIX: $RELEASE_SUFFIX") 1317 logger.quiet("RELEASE_VERSION_SHORT: $RELEASE_VERSION_SHORT") 1318 logger.quiet("RELEASE_VERSION_LONG: $RELEASE_VERSION_LONG") 1319 logger.quiet("RELEASE_VERSION_PADDED: $RELEASE_VERSION_PADDED") 1320 logger.quiet("UPDATE_STUB_CACHE: $UPDATE_STUB_CACHE") 1321 1322 /****************************************************************************** 1323 * * 1324 * Definition of Native Code Compilation Tasks * 1325 * * 1326 * - CCTask compiles native code. Specifically it will compile .m, .c, * 1327 * .cpp, or .cc files. It uses the headers provided by running * 1328 * 'javac -h' plus additional platform specific headers. It will * 1329 * compile into .obj files. * 1330 * - LinkTask will perform native linking and create the .dll / .so / * 1331 * .dylib as necessary. * 1332 * * 1333 *****************************************************************************/ 1334 1335 // Save a reference to the buildSrc.jar file because we need it for actually 1336 // compiling things, not just for the sake of this build script 1337 // (such as generating the JSL files, etc) 1338 ext.BUILD_SRC = rootProject.files("buildSrc/build/libs/buildSrc.jar") 1339 1340 /** 1341 * Convenience method for creating cc, link, and "native" tasks in the given project. These 1342 * tasks are parameterized by name, so that we can produce, for example, ccGlass, etc 1343 * named tasks. 1344 * 1345 * @param project The project to add tasks to 1346 * @param name The name of the project, such as "prism-common". This name is used 1347 * in the name of the generated task, such as ccPrismCommon, and also 1348 * in the name of the final library, such as libprism-common.dylib. 1349 */ 1350 void addNative(Project project, String name) { 1351 // TODO if we want to handle 32/64 bit windows in the same build, 1352 // Then we will need to modify the win compile target to be win32 or win64 1353 def capitalName = name.split("-").collect{it.capitalize()}.join() 1354 def nativeTask = project.task("native$capitalName", group: "Build") { 1355 description = "Generates JNI headers, compiles, and builds native dynamic library for $name for all compile targets" 1356 } 1357 def cleanTask = project.task("cleanNative$capitalName", type: Delete, group: "Build") { 1358 description = "Clean native objects for $name" 1359 } 1360 if (project.hasProperty("nativeAllTask")) project.nativeAllTask.dependsOn nativeTask 1361 project.assemble.dependsOn(nativeTask) 1362 if (project.hasProperty("cleanNativeAllTask")) project.cleanNativeAllTask.dependsOn cleanTask 1363 1364 // Each of the different compile targets will be placed in a sub directory 1365 // of these root dirs, with the name of the dir being the name of the target 1366 def nativeRootDir = project.file("$project.buildDir/native/$name") 1367 def libRootDir = project.file("$project.buildDir/libs/$name") 1368 // For each compile target, create a cc / link pair 1369 compileTargets { t -> 1370 def targetProperties = project.rootProject.ext[t.upper] 1371 def library = targetProperties.library 1372 def properties = targetProperties.get(name) 1373 def nativeDir = file("$nativeRootDir/${t.name}") 1374 def headerDir = file("${project.buildDir}/gensrc/headers/${project.moduleName}") 1375 1376 // If there is not a library clause in the properties, assume it is not wanted 1377 if (!targetProperties.containsKey(name)) { 1378 println("Ignoring native library ${name}. Not defined in ${t.name} project properties"); 1379 return 1380 } 1381 1382 // check for the property disable${name} = true 1383 def String disableKey = "disable${name}" 1384 def boolean disabled = targetProperties.containsKey(disableKey) ? targetProperties.get(disableKey) : false 1385 if (disabled) { 1386 println("Native library ${name} disabled in ${t.name} project properties"); 1387 return 1388 } 1389 1390 def variants = properties.containsKey("variants") ? properties.variants : [""]; 1391 variants.each { variant -> 1392 def variantProperties = variant == "" ? properties : properties.get(variant) 1393 def capitalVariant = variant.capitalize() 1394 def ccOutput = variant == "" ? nativeDir : file("$nativeDir/$variant") 1395 def ccTask = project.task("cc${t.capital}$capitalName$capitalVariant", type: CCTask, group: "Build") { 1396 description = "Compiles native sources for ${name} for ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}" 1397 matches = ".*\\.c|.*\\.cpp|.*\\.m|.*\\.cc" 1398 headers = headerDir 1399 output(ccOutput) 1400 params.addAll(variantProperties.ccFlags) 1401 compiler = variantProperties.compiler 1402 source(variantProperties.nativeSource) 1403 cleanTask.delete ccOutput 1404 } 1405 def linkTask = project.task("link${t.capital}$capitalName$capitalVariant", type: LinkTask, dependsOn: ccTask, group: "Build") { 1406 description = "Creates native dynamic library for $name for ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}" 1407 objectDir = ccOutput 1408 linkParams.addAll(variantProperties.linkFlags) 1409 lib = file("$libRootDir/${t.name}/${variant == '' ? library(properties.lib) : library(variantProperties.lib)}") 1410 linker = variantProperties.linker 1411 cleanTask.delete "$libRootDir/${t.name}" 1412 } 1413 nativeTask.dependsOn(linkTask) 1414 if (IS_WINDOWS && t.name == "win") { 1415 def rcTask = project.task("rc$capitalName$capitalVariant", type: CompileResourceTask, group: "Build") { 1416 description = "Compiles native sources for $name" 1417 matches = ".*\\.rc" 1418 compiler = variantProperties.rcCompiler 1419 source(variantProperties.rcSource) 1420 if (variantProperties.rcFlags) { 1421 rcParams.addAll(variantProperties.rcFlags) 1422 } 1423 output(ccOutput) 1424 } 1425 linkTask.dependsOn rcTask; 1426 } 1427 } 1428 1429 def useLipo = targetProperties.containsKey('useLipo') ? targetProperties.useLipo : false 1430 if (useLipo) { 1431 def lipoTask = project.task("lipo${t.capital}$capitalName", type: LipoTask, group: "Build") { 1432 description = "Creates native fat library for $name for ${t.name}" 1433 libDir = file("$libRootDir/${t.name}") 1434 lib = file("$libRootDir/${t.name}/${library(properties.lib)}") 1435 } 1436 nativeTask.dependsOn(lipoTask) 1437 } 1438 } 1439 } 1440 1441 void addJSL(Project project, String name, String pkg, List<String> addExports, Closure compile) { 1442 def lowerName = name.toLowerCase() 1443 1444 def modulePath = "${project.sourceSets.main.java.outputDir}" 1445 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.base/build/classes/java/main" 1446 def compileCompilers = project.task("compile${name}Compilers", 1447 type: JavaCompile, 1448 dependsOn: project.compileJava) { 1449 description = "Compile the $name JSL Compilers" 1450 1451 classpath = 1452 project.files(project.sourceSets.jslc.java.outputDir) + 1453 project.configurations.antlr 1454 source = [project.file("src/main/jsl-$lowerName")] 1455 destinationDir = project.file("$project.buildDir/classes/jsl-compilers/$lowerName") 1456 1457 options.compilerArgs.addAll([ 1458 "-implicit:none", 1459 "--module-path", modulePath, 1460 "--add-modules=javafx.graphics" 1461 ]) 1462 if (addExports != null) { 1463 options.compilerArgs.addAll(addExports) 1464 } 1465 } 1466 1467 def generateShaders = project.task("generate${name}Shaders", 1468 dependsOn: compileCompilers) { 1469 description = "Generate $name shaders from JSL" 1470 def sourceDir = project.file("src/main/jsl-$lowerName") 1471 def destinationDir = project.file("$project.buildDir/gensrc/jsl-$lowerName") 1472 inputs.dir sourceDir 1473 outputs.dir destinationDir 1474 doLast { 1475 compile(sourceDir, destinationDir) 1476 } 1477 } 1478 1479 def compileHLSLShaders = project.task("compile${name}HLSLShaders", 1480 dependsOn: generateShaders, 1481 type: CompileHLSLTask) { 1482 enabled = IS_WINDOWS 1483 description = "Compile $name HLSL files into .obj files" 1484 matches = ".*\\.hlsl" 1485 output project.file("$project.buildDir/hlsl/$name/$pkg") 1486 source project.file("$project.buildDir/gensrc/jsl-$lowerName/$pkg") 1487 } 1488 1489 def processShaders = project.task("process${name}Shaders", 1490 dependsOn: [generateShaders, compileHLSLShaders], 1491 type: Copy, 1492 description: "Copy hlsl / frag shaders to build/resources/jsl-$lowerName") { 1493 from("$project.buildDir/hlsl/$name") { 1494 include "**/*.obj" 1495 } 1496 from("$project.buildDir/gensrc/jsl-$lowerName") { 1497 include("**/*.frag") 1498 } 1499 into project.moduleDir 1500 } 1501 1502 project.processShaders.dependsOn(processShaders) 1503 project.sourceSets.shaders.output.dir("$project.buildDir/gensrc/jsl-$lowerName", builtBy: processShaders ) 1504 1505 def processShimsShaders = project.task("process${name}ShimsShaders", 1506 dependsOn: [generateShaders, compileHLSLShaders], 1507 type: Copy, 1508 description: "Copy hlsl / frag shaders to shims") { 1509 from("$project.buildDir/hlsl/$name") { 1510 include "**/*.obj" 1511 } 1512 from("$project.buildDir/gensrc/jsl-$lowerName") { 1513 include("**/*.frag") 1514 } 1515 into project.moduleShimsDir 1516 } 1517 1518 project.processShimsShaders.dependsOn(processShimsShaders) 1519 1520 } 1521 1522 /** 1523 * Parses a JDK version string. The string must be in one of the following 1524 * two formats: 1525 * 1526 * major.minor.subminor 1527 * or 1528 * major.minor.subminor_update 1529 * 1530 * In both cases a list of 4 integers is returned, with element 3 set to 1531 * 0 in the former case. 1532 */ 1533 List parseJdkVersion(String version) { 1534 def arr = version.split("[_\\.]"); 1535 def intArr = []; 1536 arr.each { s -> intArr += Integer.parseInt(s); } 1537 while (intArr.size() < 4) intArr += 0; 1538 return intArr; 1539 } 1540 1541 /** 1542 * Returns -1, 0, or 1 depending on whether JDK version "a" is less than, 1543 * equal to, or grater than version "b". 1544 */ 1545 int compareJdkVersion(String a, String b) { 1546 def aIntArr = parseJdkVersion(a); 1547 def bIntArr = parseJdkVersion(b); 1548 1549 for (int i = 0; i < 4; i++) { 1550 if (aIntArr[i] < bIntArr[i]) return -1; 1551 if (aIntArr[i] > bIntArr[i]) return 1; 1552 } 1553 return 0; 1554 } 1555 1556 // Task to verify the minimum level of Java needed to build JavaFX 1557 task verifyJava() { 1558 doLast { 1559 def status = compareJdkVersion(jdkVersion, jfxBuildJdkVersionMin); 1560 if (status < 0) { 1561 fail("java version mismatch: JDK version (${jdkVersion}) < minimum version (${jfxBuildJdkVersionMin})") 1562 } else if (status == 0) { 1563 def buildNum = Integer.parseInt(jdkBuildNumber) 1564 def minBuildNum = Integer.parseInt(jfxBuildJdkBuildnumMin) 1565 if (buildNum != 0 && buildNum < minBuildNum) { 1566 fail("JDK build number ($buildNum) < minimum build number ($minBuildNum)") 1567 } 1568 } 1569 } 1570 } 1571 1572 task updateCacheIfNeeded() { 1573 // an empty task we can add to as needed for UPDATE_STUB_CACHE 1574 } 1575 1576 task createTestArgfiles { 1577 // an empty task we can add to as needed 1578 } 1579 1580 1581 /***************************************************************************** 1582 * Project definitions (dependencies, etc) * 1583 *****************************************************************************/ 1584 1585 void addJCov(p, test) { 1586 test.doFirst { 1587 def jcovJVMArgument = 1588 "include=javafx," + 1589 "include=com.sun.javafx," + 1590 "include=com.sun.glass," + 1591 "include=com.sun.openpisces," + 1592 "include=com.sun.pisces," + 1593 "include=com.sun.prism," + 1594 "include=com.sun.scenario," + 1595 "include=com.sun.webkit," + 1596 "exclude=com," + 1597 "exclude=java," + 1598 "exclude=javax," + 1599 "exclude=\"**.test\"," + 1600 "exclude=\"**.*Test\"," + 1601 "file=build/reports/jcov/report.xml," + 1602 "merge=merge"; 1603 test.jvmArgs("-javaagent:${p.configurations.testCompile.files.find { it.name.startsWith('jcov') }}=$jcovJVMArgument"); 1604 p.mkdir p.file("build/reports/jcov") 1605 } 1606 test.doLast { 1607 def reportFile = p.file("build/reports/jcov/report.xml") 1608 if (reportFile.exists()) { 1609 p.javaexec { 1610 workingDir = p.file("build/reports/jcov") 1611 classpath = p.files(p.configurations.testCompile.files.find { it.name.startsWith('jcov') }) 1612 main = "com.sun.tdk.jcov.Helper" 1613 args = [ 1614 "RepGen", 1615 "-exclude", "\"**.test\"", 1616 "-exclude", "\"**.*Test\"", 1617 "-output", ".", 1618 "-source", p.sourceSets.main.java.srcDirs.collect{p.file(it)}.join(":"), 1619 "report.xml" 1620 ] 1621 } 1622 } 1623 } 1624 } 1625 1626 allprojects { 1627 1628 // Setup the repositories that we'll download libraries from. 1629 // By default we use Maven Central for most things. The custom "ivy" 1630 // repo is for downloading SWT. The way it works is to setup the 1631 // download URL such that it will resolve to the actual jar file to 1632 // download. See SWT_FILE_NAME for the name of the jar that will be 1633 // used as the "artifact" in the pattern below. 1634 // If JFX_DEPS_URL is set, then that overrides the default 1635 // repositories. This allows the dependencies to be cached locally. 1636 1637 if (JFX_DEPS_URL != "") { 1638 repositories { 1639 ivy { 1640 url JFX_DEPS_URL 1641 layout "pattern", { 1642 artifact "[artifact]-[revision](-[classifier]).[ext]" 1643 artifact "[artifact].[ext]" 1644 } 1645 } 1646 } 1647 } 1648 1649 if (JFX_DEPS_URL == "") { 1650 repositories { 1651 mavenCentral() 1652 ivy { 1653 url "http://download.eclipse.org/eclipse/updates/4.6/R-4.6.3-201703010400/plugins/" 1654 layout "pattern", { 1655 artifact "[artifact].[ext]" 1656 } 1657 } 1658 } 1659 } 1660 1661 if (JFX_DEPS_URL == "" && IS_BUILD_LIBAV_STUBS) { 1662 repositories { 1663 ivy { 1664 url libAVRepositoryURL 1665 layout "pattern", { 1666 artifact "[artifact].[ext]" 1667 } 1668 } 1669 ivy { 1670 url FFmpegRepositoryURL 1671 layout "pattern", { 1672 artifact "[artifact].[ext]" 1673 } 1674 } 1675 } 1676 } 1677 1678 // We want to configure all projects as java projects and use the same compile settings 1679 // etc, except for the root project which we just want to ignore (and for now media) 1680 if (project == rootProject) { 1681 return 1682 } 1683 if (project.path.startsWith(":apps")) { 1684 // Lets handle the apps tree differently, as it is a collection of ant builds, 1685 // and the ant importer collides with the 'apply plugin:java' 1686 return 1687 } 1688 1689 // All of our projects are java projects 1690 1691 apply plugin: "java" 1692 sourceCompatibility = 1.9 1693 1694 // By default all of our projects require junit for testing so we can just 1695 // setup this dependency here. 1696 dependencies { 1697 testCompile group: "junit", name: "junit", version: "4.8.2" 1698 if (BUILD_CLOSED && DO_JCOV) { 1699 testCompile name: "jcov" 1700 } 1701 } 1702 1703 compileJava.dependsOn verifyJava 1704 1705 // At the moment the ASM library shipped with Gradle that is used to 1706 // discover the different test classes fails on Java 8, so in order 1707 // to have sourceCompatibility set to 1.8 I have to also turn scanForClasses off 1708 // and manually specify the includes / excludes. At the moment we use 1709 // Java 7 but when we switch to 8 this will be needed, and probably again when 1710 // we start building with Java 9. 1711 test { 1712 executable = JAVA; 1713 enableAssertions = true; 1714 testLogging.exceptionFormat = "full"; 1715 scanForTestClasses = false; 1716 include("**/*Test.*"); 1717 if (BUILD_CLOSED && DO_JCOV) { 1718 addJCov(project, test) 1719 } 1720 1721 if (IS_HEADLESS_TEST) { 1722 systemProperty 'glass.platform', 'Monocle' 1723 systemProperty 'monocle.platform', 'Headless' 1724 systemProperty 'prism.order', 'sw' 1725 systemProperty 'com.sun.javafx.gestures.zoom', 'true' 1726 systemProperty 'com.sun.javafx.gestures.rotate', 'true' 1727 systemProperty 'com.sun.javafx.gestures.scroll', 'true' 1728 } 1729 1730 systemProperty 'unstable.test', IS_UNSTABLE_TEST 1731 } 1732 1733 compileTestJava { 1734 } 1735 } 1736 1737 // Qualified exports needed by javafx.swing 1738 def qualExportsSwing = [ 1739 "--add-exports=java.desktop/java.awt.dnd.peer=javafx.swing", 1740 "--add-exports=java.desktop/sun.awt=javafx.swing", 1741 "--add-exports=java.desktop/sun.awt.dnd=javafx.swing", 1742 "--add-exports=java.desktop/sun.awt.image=javafx.swing", 1743 "--add-exports=java.desktop/sun.java2d=javafx.swing", 1744 "--add-exports=java.desktop/sun.swing=javafx.swing", 1745 ] 1746 1747 // These strings define the module-source-path to be used in compilation. 1748 // They need to contain the full paths to the sources and the * will be 1749 // used to infer the module name that is used. 1750 project.ext.defaultModuleSourcePath = 1751 cygpath(rootProject.projectDir.path + '/modules/*/src/main/java') + 1752 File.pathSeparator + 1753 cygpath(rootProject.projectDir.path + '/modules/*/build/gensrc/{java,jsl-decora,jsl-prism}') 1754 1755 // graphics pass one 1756 project.ext.defaultModuleSourcePath_GraphicsOne = 1757 cygpath(rootProject.projectDir.path + '/modules/*/src/main/java') + 1758 File.pathSeparator + 1759 cygpath(rootProject.projectDir.path + '/modules/*/build/gensrc/{java,jsl-decora,jsl-prism}') 1760 1761 // web pass one 1762 project.ext.defaultModuleSourcePath_WebOne = 1763 cygpath(rootProject.projectDir.path + '/modules/*/src/main/java') 1764 1765 // Compiling the test shim files too. 1766 project.ext.defaultModuleSourcePathShim = 1767 cygpath(rootProject.projectDir.path + '/modules/*/src/{main,shims}/java') + 1768 File.pathSeparator + 1769 cygpath(rootProject.projectDir.path + '/modules/*/build/gensrc/{java,jsl-decora,jsl-prism}') 1770 1771 // The "base" project is our first module and the most basic one required for 1772 // all other modules. It is useful even for non-GUI applications. 1773 project(":base") { 1774 project.ext.buildModule = true 1775 project.ext.includeSources = true 1776 project.ext.moduleRuntime = true 1777 project.ext.moduleName = "javafx.base" 1778 1779 sourceSets { 1780 main 1781 shims 1782 test 1783 } 1784 1785 dependencies { 1786 testCompile group: "junit", name: "junit", version: "4.8.2" 1787 } 1788 1789 commonModuleSetup(project, [ 'base' ]) 1790 1791 project.ext.moduleSourcePath = defaultModuleSourcePath 1792 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 1793 1794 // We need to take the VersionInfo.java file and replace the various 1795 // properties within it 1796 def replacements = [ 1797 "BUILD_TIMESTAMP": BUILD_TIMESTAMP, 1798 "HUDSON_JOB_NAME": HUDSON_JOB_NAME, 1799 "HUDSON_BUILD_NUMBER": HUDSON_BUILD_NUMBER, 1800 "PROMOTED_BUILD_NUMBER": PROMOTED_BUILD_NUMBER, 1801 "PRODUCT_NAME": PRODUCT_NAME, 1802 "RELEASE_VERSION": RELEASE_VERSION, 1803 "RELEASE_SUFFIX": RELEASE_SUFFIX]; 1804 task processVersionInfo(type: Copy, description: "Replace params in VersionInfo and copy file to destination") { 1805 doFirst { mkdir "$buildDir/gensrc/java" } 1806 from "src/main/version-info" 1807 into "$buildDir/gensrc/java/com/sun/javafx/runtime" 1808 filter {line-> 1809 replacements.each() {k, v -> 1810 line = line.replace("@$k@", v.toString()); 1811 } 1812 line 1813 } 1814 } 1815 1816 // Make sure to include $buildDir/gensrc/java that we previously created. 1817 // We DO NOT want to include src/main/version-info 1818 1819 sourceSets.main.java.srcDirs += "$buildDir/gensrc/java" 1820 1821 compileJava.dependsOn processVersionInfo 1822 } 1823 1824 // The graphics module is needed for any graphical JavaFX application. It requires 1825 // the base module and includes the scene graph, layout, css, prism, windowing, etc. 1826 // This is a fairly complicated module. There are many different types of native components 1827 // that all need to be compiled. 1828 project(":graphics") { 1829 1830 project.ext.buildModule = true 1831 project.ext.includeSources = true 1832 project.ext.moduleRuntime = true 1833 project.ext.moduleName = "javafx.graphics" 1834 1835 getConfigurations().create("antlr"); 1836 1837 sourceSets { 1838 jslc // JSLC gramar subset 1839 main 1840 shims 1841 shaders // generated shaders (prism & decora) 1842 test 1843 stub 1844 } 1845 1846 dependencies { 1847 stubCompile group: "junit", name: "junit", version: "4.8.2" 1848 1849 antlr group: "org.antlr", name: "antlr-complete", version: "3.5.2" 1850 } 1851 1852 project.ext.moduleSourcePath = defaultModuleSourcePath_GraphicsOne 1853 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 1854 1855 commonModuleSetup(project, [ 'base', 'graphics' ]) 1856 1857 List<String> decoraAddExports = [ 1858 '--add-exports=javafx.graphics/com.sun.scenario.effect=ALL-UNNAMED', 1859 '--add-exports=javafx.graphics/com.sun.scenario.effect.light=ALL-UNNAMED', 1860 '--add-exports=javafx.graphics/com.sun.scenario.effect.impl.state=ALL-UNNAMED' 1861 ] 1862 /* 1863 Graphics compilation is "complicated" by the generated shaders. 1864 1865 We have two shader groups - Decora and Prism. 1866 1867 The shader groups each will generate a custom compiler that 1868 then genarates the shader code. These compilers rely on the JSLC 1869 gramar parser which is antlr generated and compile separately. 1870 1871 The decora compiler relies on compileJava - which is sourceSet.main.java 1872 It also accesses module private packages, so will need add-exports 1873 1874 Once the shader java code is generated, we can compileFullJava 1875 1876 After that, we can generate the required native header and then build the native code 1877 */ 1878 1879 project.task("processShaders") { 1880 // an empty task to hang the prism and decora shaders on 1881 } 1882 1883 project.task("processShimsShaders") { 1884 // an empty task to hang the prism and decora shaders on 1885 } 1886 1887 compileShimsJava.dependsOn("processShimsShaders") 1888 1889 // Generate the JSLC support grammar 1890 project.task("generateGrammarSource", type: JavaExec) { 1891 // use antlr to generate our grammar. 1892 // note: the antlr plugin creates some issues with the other compiles 1893 // so we will do this by hand 1894 1895 File wd = file(project.projectDir.path + "/src/jslc/antlr") 1896 1897 executable = JAVA 1898 classpath = project.configurations.antlr 1899 workingDir = wd 1900 main = "org.antlr.Tool" 1901 1902 args = [ 1903 "-Xconversiontimeout", 1904 "30000", 1905 "-o", 1906 "$buildDir/gensrc/antlr", 1907 "com/sun/scenario/effect/compiler/JSL.g" ] 1908 1909 inputs.dir wd 1910 outputs.dir file("$buildDir/gensrc/antlr") 1911 } 1912 sourceSets.jslc.java.srcDirs += "$buildDir/gensrc/antlr" 1913 1914 // and compile the JSLC support classes 1915 compileJslcJava.dependsOn(generateGrammarSource) 1916 compileJslcJava.classpath = project.configurations.antlr 1917 1918 compileJava.dependsOn(compileJslcJava) 1919 1920 // this task is the "second pass" compile of all of the module classes 1921 project.task("compileFullJava", type: JavaCompile, dependsOn: processShaders) { 1922 description = "Compile all of the graphics java classes - main and shaders" 1923 1924 classpath = configurations.compile 1925 1926 source = project.sourceSets.main.java.srcDirs 1927 source += "$buildDir/gensrc/java" 1928 source += project.sourceSets.shaders.output 1929 1930 destinationDir = project.sourceSets.main.java.outputDir 1931 options.compilerArgs.addAll([ 1932 '-h', "$buildDir/gensrc/headers/", // Note: this creates the native headers 1933 '-implicit:none', 1934 '--module-source-path', defaultModuleSourcePath 1935 ] ) 1936 } 1937 classes.dependsOn(compileFullJava) 1938 1939 project.sourceSets.shims.java.srcDirs += project.sourceSets.shaders.output 1940 project.sourceSets.shims.java.srcDirs += "$buildDir/gensrc/jsl-prism" 1941 project.sourceSets.shims.java.srcDirs += "$buildDir/gensrc/jsl-decora" 1942 1943 compileShimsJava.dependsOn(compileFullJava) 1944 1945 // Create a single "native" task which will depend on all the individual native tasks for graphics 1946 project.ext.nativeAllTask = task("native", group: "Build", description: "Compiles and Builds all native libraries for Graphics"); 1947 project.ext.cleanNativeAllTask = task("cleanNative", group: "Build", description: "Clean all native libraries and objects for Graphics"); 1948 1949 // Add tasks for native compilation 1950 addNative(project, "glass"); 1951 addNative(project, "prism") 1952 addNative(project, "prismSW") 1953 addNative(project, "font") 1954 addNative(project, "iio") 1955 addNative(project, "prismES2") 1956 1957 if (IS_COMPILE_PANGO) { 1958 addNative(project, "fontFreetype") 1959 addNative(project, "fontPango") 1960 } 1961 1962 if (IS_WINDOWS) { 1963 addNative(project, "prismD3D") 1964 // TODO need to hook this up to be executed only if PassThroughVS.h is missing or PassThroughVS.hlsl is changed 1965 task generateD3DHeaders(group: "Build") { 1966 enabled = IS_WINDOWS 1967 inputs.file "src/main/native-prism-d3d/hlsl/Mtl1PS.hlsl" 1968 inputs.file "src/main/native-prism-d3d/hlsl/Mtl1VS.hlsl" 1969 inputs.file "src/main/native-prism-d3d/PassThroughVS.hlsl" 1970 outputs.dir "$buildDir/headers/PrismD3D/" 1971 outputs.dir "$buildDir/headers/PrismD3D/hlsl/" 1972 description = "Generate headers by compiling hlsl files" 1973 doLast { 1974 mkdir file("$buildDir/headers/PrismD3D/hlsl") 1975 def PS_3D_SRC = file("src/main/native-prism-d3d/hlsl/Mtl1PS.hlsl") 1976 def VS_3D_SRC = file("src/main/native-prism-d3d/hlsl/Mtl1VS.hlsl") 1977 def PASSTHROUGH_VS_SRC = file("src/main/native-prism-d3d/PassThroughVS.hlsl") 1978 def jobs = [ 1979 ["$FXC", "/nologo", "/T", "vs_3_0", "/Fh", "$buildDir/headers/PrismD3D/PassThroughVS.h", "/E", "passThrough", "$PASSTHROUGH_VS_SRC"], 1980 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS.h", "/DSpec=0", "/DSType=0", "$PS_3D_SRC"], 1981 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_i.h", "/DSpec=0", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"], 1982 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1n.h", "/DSpec=1", "/DSType=0", "$PS_3D_SRC"], 1983 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2n.h", "/DSpec=2", "/DSType=0", "$PS_3D_SRC"], 1984 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3n.h", "/DSpec=3", "/DSType=0", "$PS_3D_SRC"], 1985 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1t.h", "/DSpec=1", "/DSType=1", "$PS_3D_SRC"], 1986 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2t.h", "/DSpec=2", "/DSType=1", "$PS_3D_SRC"], 1987 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3t.h", "/DSpec=3", "/DSType=1", "$PS_3D_SRC"], 1988 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1c.h", "/DSpec=1", "/DSType=2", "$PS_3D_SRC"], 1989 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2c.h", "/DSpec=2", "/DSType=2", "$PS_3D_SRC"], 1990 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3c.h", "/DSpec=3", "/DSType=2", "$PS_3D_SRC"], 1991 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1m.h", "/DSpec=1", "/DSType=3", "$PS_3D_SRC"], 1992 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2m.h", "/DSpec=2", "/DSType=3", "$PS_3D_SRC"], 1993 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3m.h", "/DSpec=3", "/DSType=3", "$PS_3D_SRC"], 1994 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1n.h", "/DSpec=1", "/DSType=0", "/DBump=1", "$PS_3D_SRC"], 1995 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2n.h", "/DSpec=2", "/DSType=0", "/DBump=1", "$PS_3D_SRC"], 1996 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3n.h", "/DSpec=3", "/DSType=0", "/DBump=1", "$PS_3D_SRC"], 1997 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1t.h", "/DSpec=1", "/DSType=1", "/DBump=1", "$PS_3D_SRC"], 1998 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2t.h", "/DSpec=2", "/DSType=1", "/DBump=1", "$PS_3D_SRC"], 1999 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3t.h", "/DSpec=3", "/DSType=1", "/DBump=1", "$PS_3D_SRC"], 2000 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1c.h", "/DSpec=1", "/DSType=2", "/DBump=1", "$PS_3D_SRC"], 2001 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2c.h", "/DSpec=2", "/DSType=2", "/DBump=1", "$PS_3D_SRC"], 2002 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3c.h", "/DSpec=3", "/DSType=2", "/DBump=1", "$PS_3D_SRC"], 2003 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1m.h", "/DSpec=1", "/DSType=3", "/DBump=1", "$PS_3D_SRC"], 2004 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2m.h", "/DSpec=2", "/DSType=3", "/DBump=1", "$PS_3D_SRC"], 2005 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3m.h", "/DSpec=3", "/DSType=3", "/DBump=1", "$PS_3D_SRC"], 2006 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ni.h", "/DSpec=1", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"], 2007 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ni.h", "/DSpec=2", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"], 2008 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ni.h", "/DSpec=3", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"], 2009 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ti.h", "/DSpec=1", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"], 2010 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ti.h", "/DSpec=2", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"], 2011 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ti.h", "/DSpec=3", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"], 2012 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ci.h", "/DSpec=1", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"], 2013 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ci.h", "/DSpec=2", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"], 2014 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ci.h", "/DSpec=3", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"], 2015 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1mi.h", "/DSpec=1", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"], 2016 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2mi.h", "/DSpec=2", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"], 2017 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3mi.h", "/DSpec=3", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"], 2018 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1ni.h", "/DSpec=1", "/DSType=0", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2019 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2ni.h", "/DSpec=2", "/DSType=0", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2020 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3ni.h", "/DSpec=3", "/DSType=0", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2021 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1ti.h", "/DSpec=1", "/DSType=1", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2022 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2ti.h", "/DSpec=2", "/DSType=1", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2023 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3ti.h", "/DSpec=3", "/DSType=1", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2024 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1ci.h", "/DSpec=1", "/DSType=2", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2025 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2ci.h", "/DSpec=2", "/DSType=2", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2026 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3ci.h", "/DSpec=3", "/DSType=2", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2027 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1mi.h", "/DSpec=1", "/DSType=3", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2028 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2mi.h", "/DSpec=2", "/DSType=3", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2029 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3mi.h", "/DSpec=3", "/DSType=3", "/DBump=1", "/DIllumMap=1", "$PS_3D_SRC"], 2030 ["$FXC", "/nologo", "/T", "vs_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1VS_Obj.h", "/DVertexType=ObjVertex", "$VS_3D_SRC"] 2031 ] 2032 final ExecutorService executor = Executors.newFixedThreadPool(Integer.parseInt(project.NUM_COMPILE_THREADS.toString())); 2033 final CountDownLatch latch = new CountDownLatch(jobs.size()); 2034 List futures = new ArrayList<Future>(); 2035 jobs.each { cmd -> 2036 futures.add(executor.submit(new Runnable() { 2037 @Override public void run() { 2038 try { 2039 exec { 2040 commandLine cmd 2041 } 2042 } finally { 2043 latch.countDown(); 2044 } 2045 } 2046 })); 2047 } 2048 latch.await(); 2049 // Looking for whether an exception occurred while executing any of the futures. 2050 // By calling "get()" on each future an exception will be thrown if one had occurred 2051 // on the background thread. 2052 futures.each {it.get();} 2053 } 2054 } 2055 2056 ccWinPrismD3D.dependsOn generateD3DHeaders 2057 } 2058 2059 // The Decora and Prism JSL files have to be generated in a very specific set of steps. 2060 // 1) Compile the *Compile.java classes. These live in src/main/jsl-* and will be 2061 // output to $buildDir/classes/jsl-compilers/* (where * == decora or prism). 2062 // 2) Generate source files from the JSL files contained in src/main/jsl-*. These 2063 // will be output to $buildDir/gensrc/jsl-* 2064 // 3) Compile the JSL Java sources in $buildDir/gensrc/jsl-* and put the output 2065 // into classes/jsl-* 2066 // 4) Compile the native JSL sources in $buildDir/gensrc/jsl-* and put the obj 2067 // files into native/jsl-* and the resulting library into libs/jsl-*.dll|so|dylib 2068 // 5) Modify the jar step to include classes/jsl-* 2069 // The native library must be copied over during SDK creation time in the "sdk" task. In 2070 // addition to these steps, the clean task is created. Note that I didn't bother to create 2071 // a new task for each of the decora files, preferring instead just to create a rule?? Also 2072 // need "clean" tasks for each compile task. 2073 2074 def modulePath = "${project.sourceSets.main.java.outputDir}" 2075 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.base/build/classes/java/main" 2076 addJSL(project, "Decora", "com/sun/scenario/effect/impl/hw/d3d/hlsl", decoraAddExports) { sourceDir, destinationDir -> 2077 [[fileName: "ColorAdjust", generator: "CompileJSL", outputs: "-all"], 2078 [fileName: "Brightpass", generator: "CompileJSL", outputs: "-all"], 2079 [fileName: "SepiaTone", generator: "CompileJSL", outputs: "-all"], 2080 [fileName: "PerspectiveTransform", generator: "CompileJSL", outputs: "-all"], 2081 [fileName: "DisplacementMap", generator: "CompileJSL", outputs: "-all"], 2082 [fileName: "InvertMask", generator: "CompileJSL", outputs: "-all"], 2083 [fileName: "Blend", generator: "CompileBlend", outputs: "-all"], 2084 [fileName: "PhongLighting", generator: "CompilePhong", outputs: "-all"], 2085 [fileName: "LinearConvolve", generator: "CompileLinearConvolve", outputs: "-hw"], 2086 [fileName: "LinearConvolveShadow", generator: "CompileLinearConvolve", outputs: "-hw"]].each { settings -> 2087 javaexec { 2088 executable = JAVA 2089 workingDir = project.projectDir 2090 main = settings.generator 2091 classpath = configurations.compile + configurations.antlr 2092 classpath += files(project.sourceSets.jslc.java.outputDir) 2093 2094 classpath += files("${project.projectDir}/src/jslc/resources") 2095 2096 classpath += files("$buildDir/classes/jsl-compilers/decora") 2097 jvmArgs += "--module-path=$modulePath" 2098 jvmArgs += "--add-modules=javafx.graphics" 2099 jvmArgs += decoraAddExports 2100 args += ["-i", sourceDir, "-o", destinationDir, "-t", "-pkg", "com/sun/scenario/effect", "$settings.outputs", "$settings.fileName"] 2101 } 2102 } 2103 } 2104 2105 2106 task nativeDecora(dependsOn: compileDecoraHLSLShaders, group: "Build") { 2107 description = "Generates JNI headers, compiles, and builds native dynamic library for Decora" 2108 } 2109 task cleanNativeDecora(type: Delete, group: "Build") { 2110 description = "Clean native objects for Decora" 2111 } 2112 2113 def headerDir = file("$buildDir/gensrc/headers/javafx.graphics") 2114 def nativeRootDir = project.file("$project.buildDir/native/jsl-decora") 2115 def libRootDir = project.file("$project.buildDir/libs/jsl-decora") 2116 // For each compile target, create cc and link tasks 2117 compileTargets { t -> 2118 def target = t.name 2119 def upperTarget = t.upper 2120 def capitalTarget = t.capital 2121 def targetProperties = rootProject.ext[upperTarget]; 2122 def library = targetProperties.library 2123 def properties = targetProperties.get('decora') 2124 def nativeDir = file("$nativeRootDir/$target"); 2125 2126 def variants = properties.containsKey("variants") ? properties.variants : [""]; 2127 variants.each { variant -> 2128 def variantProperties = variant == "" ? properties : properties.get(variant) 2129 def capitalVariant = variant.capitalize() 2130 def ccOutput = variant == "" ? nativeDir : file("$nativeDir/$variant") 2131 2132 def ccTask = task("compileDecoraNativeShaders$capitalTarget$capitalVariant", type: CCTask ) { 2133 description = "Compiles Decora SSE natives for ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}" 2134 matches = ".*\\.cc" 2135 source file("$buildDir/gensrc/jsl-decora") 2136 source file(project.projectDir.path + "/src/main/native-decora") 2137 headers = headerDir 2138 params.addAll(variantProperties.ccFlags) 2139 output(ccOutput) 2140 compiler = variantProperties.compiler 2141 cleanNativeDecora.delete ccOutput 2142 } 2143 2144 def linkTask = task("linkDecoraNativeShaders$capitalTarget$capitalVariant", type: LinkTask, dependsOn: ccTask) { 2145 description = "Creates native dynamic library for Decora SSE ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}" 2146 objectDir = ccOutput 2147 linkParams.addAll(variantProperties.linkFlags) 2148 lib = file("$libRootDir/$t.name/${library(variantProperties.lib)}") 2149 linker = variantProperties.linker 2150 cleanNativeDecora.delete "$libRootDir/$t.name/" 2151 } 2152 2153 if (IS_WINDOWS && target == "win") { 2154 def rcTask = project.task("rcDecoraNativeShaders$capitalTarget$capitalVariant", type: CompileResourceTask) { 2155 description = "Compiles native sources for Decora SSE" 2156 matches = ".*\\.rc" 2157 compiler = variantProperties.rcCompiler 2158 source(variantProperties.rcSource) 2159 if (variantProperties.rcFlags) { 2160 rcParams.addAll(variantProperties.rcFlags) 2161 } 2162 output(ccOutput) 2163 } 2164 linkTask.dependsOn rcTask; 2165 } 2166 2167 nativeDecora.dependsOn(linkTask) 2168 } 2169 } 2170 2171 // Prism JSL 2172 addJSL(project, "Prism", "com/sun/prism/d3d/hlsl", null) { sourceDir, destinationDir -> 2173 def inputFiles = fileTree(dir: sourceDir) 2174 inputFiles.include "**/*.jsl" 2175 inputFiles.each { file -> 2176 javaexec { 2177 executable = JAVA 2178 workingDir = project.projectDir 2179 main = "CompileJSL" 2180 classpath = configurations.compile + configurations.antlr 2181 classpath += files(project.sourceSets.jslc.java.outputDir) 2182 classpath += files(project.sourceSets.jslc.resources) 2183 classpath += files("$buildDir/classes/jsl-compilers/prism", 2184 project.projectDir.path + "/src/main/jsl-prism") // for the .stg 2185 args = ["-i", sourceDir, "-o", destinationDir, "-t", "-pkg", "com/sun/prism", "-d3d", "-es2", "-name", "$file"] 2186 } 2187 } 2188 } 2189 2190 nativePrism.dependsOn compilePrismHLSLShaders; 2191 2192 project.nativeAllTask.dependsOn nativeDecora 2193 project.cleanNativeAllTask.dependsOn cleanNativeDecora 2194 assemble.dependsOn nativeDecora 2195 processResources.dependsOn processDecoraShaders, processPrismShaders 2196 2197 test { 2198 def cssDir = file("$buildDir/classes/java/main/${moduleName}/javafx") 2199 jvmArgs "-Djavafx.toolkit=test.com.sun.javafx.pgstub.StubToolkit", 2200 "-DCSS_META_DATA_TEST_DIR=$cssDir" 2201 enableAssertions = true 2202 testLogging.exceptionFormat = "full" 2203 scanForTestClasses = false 2204 include "**/*Test.*" 2205 if (BUILD_CLOSED && DO_JCOV) { 2206 addJCov(project, test) 2207 } 2208 } 2209 2210 // To enable the IDEs to all be happy (no red squiggles) we need to have the libraries 2211 // available in some known location. Maybe in the future the Gradle plugins to each 2212 // of the IDEs will be good enough that we won't need this hack anymore. 2213 classes { 2214 doLast { 2215 // Copy all of the download libraries to the libs directory for the sake of the IDEs 2216 File libsDir = rootProject.file("build/libs"); 2217 2218 // In some IDEs (Eclipse for example), touching these libraries 2219 // cauese a full build within the IDE. When gradle is used 2220 // outside of the IDE, for example to build the native code, 2221 // a full rebuild is caused within the IDE. The fix is to check 2222 // for the presence of the target files in the lib directory 2223 // and not copy the files if all are present. 2224 2225 libsDir.mkdirs(); 2226 2227 def allLibsPresent = true 2228 def libNames = [ "antlr-complete-3.5.2.jar" ] 2229 libNames.each { name -> 2230 File f = new File(libsDir, name) 2231 if (!f.exists()) allLibsPresent = false 2232 } 2233 if (allLibsPresent) return; 2234 2235 for (File f : [configurations.compile.files, configurations.antlr.files].flatten()) { 2236 copy { 2237 into libsDir 2238 from f.getParentFile() 2239 include "**/antlr-complete-3.5.2.jar" 2240 includeEmptyDirs = false 2241 } 2242 } 2243 } 2244 } 2245 } 2246 2247 project(":controls") { 2248 project.ext.buildModule = true 2249 project.ext.includeSources = true 2250 project.ext.moduleRuntime = true 2251 project.ext.moduleName = "javafx.controls" 2252 2253 sourceSets { 2254 main 2255 shims 2256 test 2257 } 2258 2259 project.ext.moduleSourcePath = defaultModuleSourcePath 2260 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 2261 2262 commonModuleSetup(project, [ 'base', 'graphics', 'controls' ]) 2263 2264 dependencies { 2265 testCompile project(":graphics").sourceSets.test.output 2266 testCompile project(":base").sourceSets.test.output 2267 } 2268 2269 test { 2270 def cssDir = file("$buildDir/classes/java/main/${moduleName}/javafx") 2271 jvmArgs "-Djavafx.toolkit=test.com.sun.javafx.pgstub.StubToolkit", 2272 "-DCSS_META_DATA_TEST_DIR=$cssDir" 2273 } 2274 2275 def modulePath = "${project.sourceSets.main.java.outputDir}" 2276 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.graphics/build/classes/java/main" 2277 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.base/build/classes/java/main" 2278 processResources { 2279 doLast { 2280 def cssFiles = fileTree(dir: "$moduleDir/com/sun/javafx/scene/control/skin") 2281 cssFiles.include "**/*.css" 2282 cssFiles.each { css -> 2283 logger.info("converting CSS to BSS ${css}"); 2284 2285 javaexec { 2286 executable = JAVA 2287 workingDir = project.projectDir 2288 jvmArgs += patchModuleArgs 2289 jvmArgs += "--module-path=$modulePath" 2290 jvmArgs += "--add-modules=javafx.graphics" 2291 main = "com.sun.javafx.css.parser.Css2Bin" 2292 args css 2293 } 2294 } 2295 } 2296 } 2297 2298 processShimsResources.dependsOn(project.task("copyShimBss", type: Copy) { 2299 from project.moduleDir 2300 into project.moduleShimsDir 2301 include "**/*.bss" 2302 }) 2303 } 2304 2305 project(":swing") { 2306 2307 tasks.all { 2308 if (!COMPILE_SWING) it.enabled = false 2309 } 2310 2311 project.ext.buildModule = COMPILE_SWING 2312 project.ext.includeSources = true 2313 project.ext.moduleRuntime = true 2314 project.ext.moduleName = "javafx.swing" 2315 2316 sourceSets { 2317 main 2318 //shims // no test shims needed 2319 test 2320 } 2321 2322 project.ext.moduleSourcePath = defaultModuleSourcePath 2323 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 2324 2325 commonModuleSetup(project, [ 'base', 'graphics', 'swing' ]) 2326 2327 dependencies { 2328 } 2329 2330 test { 2331 enabled = IS_FULL_TEST && IS_AWT_TEST 2332 2333 if (!HAS_JAVAFX_MODULES) { 2334 jvmArgs += qualExportsSwing 2335 } 2336 } 2337 2338 sourceSets.main.java.srcDirs += "$buildDir/gensrc/java" 2339 sourceSets.main.java { 2340 if (!HAS_UNSUPPORTED_DESKTOP) { 2341 exclude("com/sun/javafx/embed/swing/newimpl/**") 2342 } 2343 } 2344 task checkJDKUnsupportedModule(type: Copy, description: "copy module-info file to gensrc") { 2345 from "src/main/module-info/module-info.java" 2346 into "$buildDir/gensrc/java/" 2347 filter { line-> 2348 !HAS_UNSUPPORTED_DESKTOP && line.contains('jdk.unsupported.desktop') ? null : line 2349 } 2350 } 2351 compileJava.dependsOn checkJDKUnsupportedModule 2352 2353 compileJava.options.compilerArgs.addAll(qualExportsSwing) 2354 } 2355 2356 project(":swt") { 2357 tasks.all { 2358 if (!COMPILE_SWT) it.enabled = false 2359 } 2360 2361 // javafx.swt is an automatic module 2362 project.ext.buildModule = false 2363 2364 commonModuleSetup(project, [ 'base', 'graphics' ]) 2365 2366 dependencies { 2367 compile name: SWT_FILE_NAME 2368 } 2369 2370 classes { 2371 doLast { 2372 // Copy all of the download libraries to libs directory for the sake of the IDEs 2373 File libsDir = rootProject.file("build/libs"); 2374 File swtLib = new File(libsDir, "swt-debug.jar") 2375 libsDir.mkdirs(); 2376 2377 // Skip copy if file is present. 2378 if (swtLib.exists()) return; 2379 2380 for (File f : configurations.compile.files) { 2381 // Have to rename the swt jar because it is some platform specific name but 2382 // for the sake of the IDEs we need to have a single stable name that works 2383 // on every platform 2384 copy { 2385 into libsDir 2386 from f.getParentFile() 2387 include "**/*swt*.jar" 2388 includeEmptyDirs = false 2389 rename ".*swt.*jar", "swt-debug\\.jar" 2390 } 2391 } 2392 } 2393 } 2394 2395 compileJava.options.compilerArgs.addAll([ 2396 "--add-exports=javafx.graphics/com.sun.glass.ui=ALL-UNNAMED", 2397 "--add-exports=javafx.graphics/com.sun.javafx.cursor=ALL-UNNAMED", 2398 "--add-exports=javafx.graphics/com.sun.javafx.embed=ALL-UNNAMED", 2399 "--add-exports=javafx.graphics/com.sun.javafx.stage=ALL-UNNAMED", 2400 "--add-exports=javafx.graphics/com.sun.javafx.tk=ALL-UNNAMED", 2401 ]) 2402 2403 test { 2404 //enabled = IS_FULL_TEST && IS_SWT_TEST 2405 enabled = false // FIXME: JIGSAW -- support this with modules 2406 logger.info("JIGSAW Testing disabled for swt") 2407 2408 if (IS_MAC) { 2409 enabled = false 2410 logger.info("SWT tests are disabled on MAC, because Gradle test runner does not handle -XstartOnFirstThread properly (https://issues.gradle.org/browse/GRADLE-3290).") 2411 } 2412 } 2413 } 2414 2415 project(":fxml") { 2416 project.ext.buildModule = true 2417 project.ext.includeSources = true 2418 project.ext.moduleRuntime = true 2419 project.ext.moduleName = "javafx.fxml" 2420 2421 sourceSets { 2422 main 2423 shims 2424 test 2425 } 2426 2427 project.ext.moduleSourcePath = defaultModuleSourcePath 2428 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 2429 2430 commonModuleSetup(project, [ 'base', 'graphics', 'controls', 'fxml' ]) 2431 2432 2433 dependencies { 2434 testCompile project(":graphics").sourceSets.test.output 2435 testCompile project(":base").sourceSets.test.output 2436 } 2437 2438 test { 2439 // StubToolkit is not *really* needed here, but because some code inadvertently invokes performance 2440 // tracker and this attempts to fire up the toolkit and this looks for native libraries and fails, 2441 // we have to use the stub toolkit for now. 2442 jvmArgs "-Djavafx.toolkit=test.com.sun.javafx.pgstub.StubToolkit" 2443 // FIXME: change this to also allow JDK 9 boot jdk 2444 classpath += files("$JDK_HOME/jre/lib/ext/nashorn.jar") 2445 } 2446 } 2447 2448 project(":fxpackagerservices") { 2449 project.ext.buildModule = COMPILE_FXPACKAGER 2450 project.ext.includeSources = true 2451 project.ext.moduleRuntime = false 2452 project.ext.moduleName = "jdk.packager.services" 2453 2454 sourceSets { 2455 main 2456 //shims // no test shims needed 2457 test 2458 } 2459 2460 project.ext.moduleSourcePath = defaultModuleSourcePath 2461 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 2462 2463 commonModuleSetup(project, [ 'base', 'graphics', 'controls' ]) 2464 2465 tasks.all { 2466 if (!COMPILE_FXPACKAGER) it.enabled = false 2467 } 2468 2469 2470 compileTestJava.enabled = false // FIXME: JIGSAW -- support this with modules 2471 2472 test { 2473 enabled = false // FIXME: JIGSAW -- support this with modules 2474 logger.info("JIGSAW Testing disabled for fxpackagerservices") 2475 } 2476 } 2477 2478 project(":fxpackager") { 2479 project.ext.buildModule = COMPILE_FXPACKAGER 2480 project.ext.includeSources = true 2481 project.ext.moduleRuntime = false 2482 project.ext.moduleName = "jdk.packager" 2483 2484 sourceSets { 2485 main 2486 //shims // no test shims needed 2487 antplugin { 2488 java { 2489 compileClasspath += main.output 2490 runtimeClasspath += main.output 2491 } 2492 } 2493 test 2494 } 2495 2496 project.ext.moduleSourcePath = defaultModuleSourcePath 2497 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 2498 2499 commonModuleSetup(project, [ 'base', 'graphics', 'controls', 'fxpackagerservices', 'fxpackager' ]) 2500 2501 manifest { 2502 attributes( 2503 "Main-Class": "com.sun.javafx.tools.packager.Main" 2504 ) 2505 } 2506 2507 tasks.all { 2508 if (!COMPILE_FXPACKAGER) it.enabled = false 2509 } 2510 2511 // fxpackager has a dependency on ant in order to build the ant jar, 2512 // and as such needs to point to the apache binary repository 2513 if (JFX_DEPS_URL == "") { 2514 repositories { 2515 maven { 2516 url "https://repository.apache.org" 2517 } 2518 } 2519 } 2520 2521 dependencies { 2522 antpluginCompile group: "org.apache.ant", name: "ant", version: "1.8.2" 2523 2524 testCompile project(":controls"), 2525 group: "org.apache.ant", name: "ant", version: "1.8.2", 2526 sourceSets.antplugin.output 2527 } 2528 2529 //Note: these should be reflected in the module-info additions passed to the JDK 2530 compileJava.options.compilerArgs.addAll([ 2531 "--add-exports=java.base/sun.security.timestamp=jdk.packager", 2532 "--add-exports=java.base/sun.security.x509=jdk.packager", 2533 2534 // Note: retain jdk.jlink qualified export for cases where the JDK does 2535 // not contain the jdk.packager module. 2536 "--add-exports=jdk.jlink/jdk.tools.jlink.internal.packager=jdk.packager", 2537 2538 // Note: not in extras... 2539 "--add-exports=java.base/sun.security.pkcs=jdk.packager", 2540 "--add-exports=java.logging/java.util.logging=jdk.packager", 2541 ]) 2542 2543 compileAntpluginJava.dependsOn([ compileJava, processResources ]) 2544 compileAntpluginJava.options.compilerArgs.addAll( 2545 computeModulePathArgs("antlib", project.moduleChain, false)) 2546 2547 task buildVersionFile() { 2548 File dir = new File("${project.projectDir}/build/resources/antplugin/resources"); 2549 File versionFile = new File(dir, "/version.properties"); 2550 doLast { 2551 dir.mkdirs() 2552 if (!versionFile.exists()) { 2553 versionFile << "version=$RELEASE_VERSION\n" 2554 } 2555 } 2556 outputs.file(versionFile) 2557 } 2558 2559 // When producing the ant-javafx.jar, we need to relocate a few class files 2560 // from their normal location to a resources/classes or resources/web-files 2561 // location 2562 task antpluginJar(type: Jar, dependsOn: [ compileJava, jar, compileAntpluginJava, buildVersionFile ]) { 2563 includeEmptyDirs = false 2564 archiveName = "ant-javafx.jar" 2565 2566 from (sourceSets.antplugin.output) { 2567 eachFile { FileCopyDetails details -> 2568 if (details.path.startsWith("com/javafx/main")) { 2569 details.path = "resources/classes/$details.path" 2570 } 2571 } 2572 } 2573 2574 from (sourceSets.main.resources) { 2575 includes = [ "com/sun/javafx/tools/ant/**" ] 2576 } 2577 2578 from (sourceSets.main.output.resourcesDir) { 2579 includes = [ "resources/web-files/**" ] 2580 } 2581 } 2582 2583 assemble.dependsOn(antpluginJar) 2584 2585 // The "man" task will create a $buildDir/man containing the man 2586 // files for the system being built 2587 task man(type: Copy) { 2588 includeEmptyDirs = false 2589 enabled = (IS_LINUX || IS_MAC) && COMPILE_FXPACKAGER 2590 from "src/main/man" 2591 into "$buildDir/man" 2592 exclude "**/*.html" 2593 if (IS_MAC) exclude "**/ja_JP.UTF-8/**" 2594 } 2595 processResources.dependsOn man 2596 2597 String buildClassesDir = "${sourceSets.main.java.outputDir}/${moduleName}" 2598 2599 // Compile the native launchers. These are included in jdk.packager.jmod. 2600 if (IS_WINDOWS && COMPILE_FXPACKAGER) { 2601 task buildWinLauncher(type: CCTask, group: "Build") { 2602 description = "Compiles native sources for the application co-bundle launcher"; 2603 matches = "WinLauncher\\.cpp"; 2604 params.addAll(WIN.launcher.ccFlags); 2605 output(file("$buildDir/native/WinLauncher")); 2606 source(file("src/main/native/launcher/win")); 2607 compiler = WIN.launcher.compiler 2608 exe = true; 2609 linkerOptions.addAll(WIN.launcher.linkFlags); 2610 } 2611 2612 task copyWinLauncher(type: Copy, group: "Build", dependsOn: buildWinLauncher) { 2613 from "$buildDir/native/WinLauncher/WinLauncher.exe" 2614 from "$MSVCR" 2615 from "$MSVCP" 2616 into "${buildClassesDir}/com/oracle/tools/packager/windows" 2617 } 2618 2619 task compileWinLibrary(type: CCTask, group: "Build") { 2620 description = "Compiles native sources for the application co-bundle launcher library"; 2621 matches = ".*\\.cpp" 2622 source(file("src/main/native/library/common")); 2623 params.addAll(WIN.launcherlibrary.ccFlags) 2624 output(file("$buildDir/native/WinLauncher/obj")); 2625 compiler = WIN.launcherlibrary.compiler 2626 } 2627 2628 task linkWinLibrary(type: LinkTask, group: "Build", dependsOn: compileWinLibrary) { 2629 description = "Links native sources for the application co-bundle launcher library"; 2630 objectDir = file("$buildDir/native/WinLauncher/obj") 2631 linkParams.addAll(WIN.launcherlibrary.linkFlags); 2632 lib = file("$buildDir/native/WinLauncher/packager.dll") 2633 linker = WIN.launcherlibrary.linker 2634 } 2635 2636 task copyWinLibrary(type: Copy, group: "Build", dependsOn: linkWinLibrary) { 2637 from "$buildDir/native/WinLauncher/packager.dll" 2638 into "${buildClassesDir}/com/oracle/tools/packager/windows" 2639 } 2640 2641 task buildWinLauncherSvc(type: CCTask, group: "Build") { 2642 description = "Compiles native sources for the application co-bundle launcher"; 2643 matches = "WinLauncherSvc\\.cpp"; 2644 params.addAll(WIN.launcher.ccFlags); 2645 output(file("$buildDir/native/WinLauncherSvc")); 2646 source(file("src/main/native/service/win")); 2647 compiler = WIN.launcher.compiler 2648 exe = true; 2649 linkerOptions.addAll(WIN.launcher.linkFlags); 2650 } 2651 2652 task copyWinLauncherSvc(type: Copy, group: "Build", dependsOn: buildWinLauncherSvc) { 2653 from "$buildDir/native/WinLauncherSvc/WinLauncherSvc.exe" 2654 into "${buildClassesDir}/com/oracle/tools/packager/windows" 2655 } 2656 2657 task compileLauncher(dependsOn: [copyWinLauncher, copyWinLibrary, copyWinLauncherSvc]) 2658 } else if (IS_MAC && COMPILE_FXPACKAGER) { 2659 task buildMacLauncher(type: CCTask, group: "Build") { 2660 description = "Compiles native sources for the application co-bundle launcher" 2661 matches = ".*\\.m" 2662 source file("src/main/native/launcher/mac") 2663 params.addAll(MAC.launcher.ccFlags) 2664 compiler = MAC.launcher.compiler 2665 output(file("${buildClassesDir}/com/oracle/tools/packager/mac")) 2666 outputs.file(file("${buildClassesDir}/main/com/oracle/tools/packager/mac/JavaAppLauncher")) 2667 eachOutputFile = { f -> 2668 return new File(f.getParent(), "JavaAppLauncher") 2669 } 2670 } 2671 task compileMacLibrary(type: CCTask, group: "Build") { 2672 description = "Compiles native sources for the application co-bundle launcher library" 2673 matches = ".*\\.cpp|.*\\.mm" 2674 source file("src/main/native/library/common"); 2675 params.addAll(MAC.launcherlibrary.ccFlags) 2676 compiler = MAC.launcherlibrary.compiler 2677 output(file("$buildDir/native/maclauncher/obj")) 2678 } 2679 task linkMacLibrary(type: LinkTask, group: "Build", dependsOn: compileMacLibrary) { 2680 description = "Links native sources for the application co-bundle launcher library" 2681 objectDir = file("$buildDir/native/maclauncher/obj") 2682 linkParams.addAll(MAC.launcherlibrary.linkFlags) 2683 linker = MAC.launcherlibrary.linker 2684 lib = file("${buildClassesDir}/com/oracle/tools/packager/mac/libpackager.dylib") 2685 } 2686 task compileLauncher(dependsOn: [buildMacLauncher, linkMacLibrary]) 2687 } else if (IS_LINUX && COMPILE_FXPACKAGER) { 2688 task compileLinuxLauncher(type: CCTask, group: "Build") { 2689 description = "Compiles native sources for the application co-bundle launcher" 2690 matches = ".*\\.cpp" 2691 source file("src/main/native/launcher/linux") 2692 params.addAll(LINUX.launcher.ccFlags) 2693 compiler = LINUX.launcher.compiler 2694 output(file("$buildDir/native/linuxlauncher/launcherobj")) 2695 } 2696 task linkLinuxLauncher(type: LinkTask, dependsOn: compileLinuxLauncher, group: "Build") { 2697 description = "Links native dynamic library for the application co-bundle launcher" 2698 objectDir = file("$buildDir/native/linuxlauncher/launcherobj") 2699 linkParams.addAll(LINUX.launcher.linkFlags) 2700 linker = LINUX.launcher.linker 2701 lib = file("${buildClassesDir}/com/oracle/tools/packager/linux/JavaAppLauncher") 2702 } 2703 task compileLinuxLibrary(type: CCTask, group: "Build") { 2704 description = "Compiles native sources for the application co-bundle launcher library" 2705 matches = ".*\\.cpp" 2706 source file("src/main/native/library/common") 2707 params.addAll(LINUX.launcherlibrary.ccFlags) 2708 compiler = LINUX.launcherlibrary.compiler 2709 output(file("$buildDir/native/linuxlauncher/obj")) 2710 } 2711 task linkLinuxLibrary(type: LinkTask, dependsOn: compileLinuxLibrary, group: "Build") { 2712 description = "Links native dynamic library for the application co-bundle launcher library" 2713 objectDir = file("$buildDir/native/linuxlauncher/obj") 2714 linkParams.addAll(LINUX.launcherlibrary.linkFlags) 2715 linker = LINUX.launcherlibrary.linker 2716 lib = file("${buildClassesDir}/com/oracle/tools/packager/linux/libpackager.so") 2717 } 2718 task compileLauncher(dependsOn: [linkLinuxLauncher, linkLinuxLibrary]) 2719 } 2720 2721 // Builds the javapackager executable. For everything other than windows, 2722 // this is simply moving the existing shell script and ensuring it has proper 2723 // permissions. For Windows, this includes compiling the native executable 2724 if (IS_WINDOWS && COMPILE_FXPACKAGER){ 2725 task setupCompileJavaPackager(type: Copy, group: "Build") { 2726 mkdir "$buildDir/native" 2727 mkdir "$buildDir/native/javapackager" 2728 from file("src/main/native/javapackager/win/javapackager.manifest") 2729 into file("$buildDir/native/javapackager") 2730 filter { line-> 2731 line = line.replace("FXVERSION", RELEASE_VERSION_PADDED) 2732 } 2733 } 2734 2735 task compileJavaPackager(type: CCTask, group: "Build", dependsOn: setupCompileJavaPackager) { 2736 description = "Compiles native sources for javapackager.exe" 2737 matches = ".*\\.cpp" 2738 params.addAll(WIN.fxpackager.ccFlags) 2739 compiler = WIN.fxpackager.compiler 2740 output(file("$buildDir/native/javapackager/obj")) 2741 source WIN.fxpackager.nativeSource 2742 doLast { 2743 mkdir "$buildDir/native" 2744 exec { 2745 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 2746 commandLine(WIN.fxpackager.rcCompiler) 2747 args(WIN.fxpackager.rcFlags) 2748 args("/fo$buildDir/native/javapackager/javapackager.res") 2749 args(WIN.fxpackager.rcSource) 2750 } 2751 } 2752 } 2753 2754 task linkJavaPackager(type: LinkTask, dependsOn: compileJavaPackager, group: "Build") { 2755 description = "Links javapackager.exe" 2756 objectDir = file("$buildDir/native/javapackager/obj") 2757 linkParams.addAll(WIN.fxpackager.linkFlags); 2758 lib = file("$buildDir/native/javapackager/javapackager.exe") 2759 linker = WIN.fxpackager.linker 2760 doLast { 2761 exec({ 2762 commandLine("$MC", "-manifest", 2763 "$buildDir/native/javapackager/javapackager.manifest", 2764 "-outputresource:$buildDir/native/javapackager/javapackager.exe") 2765 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 2766 }) 2767 } 2768 } 2769 2770 task copyJavaPackager(type: Copy, group: "Build", dependsOn: linkJavaPackager) { 2771 from file("$buildDir/native/javapackager/javapackager.exe") 2772 into file("$buildDir/javapackager") 2773 } 2774 2775 task buildJavaPackager(dependsOn: [copyJavaPackager]) 2776 } else { 2777 task buildJavaPackager(type: Copy, group: "Build") { 2778 enabled = COMPILE_FXPACKAGER 2779 from "src/main/native/javapackager/shell" 2780 into "$buildDir/javapackager" 2781 fileMode = 0755 2782 } 2783 } 2784 2785 if (COMPILE_FXPACKAGER) { 2786 assemble.dependsOn compileLauncher; 2787 assemble.dependsOn buildJavaPackager 2788 } 2789 2790 classes { 2791 doLast { 2792 // Copy all of the download libraries to libs directory for the sake of the IDEs 2793 File libsDir = rootProject.file("build/libs"); 2794 File antLib = new File(libsDir, "ant-1.8.2.jar") 2795 libsDir.mkdirs(); 2796 2797 // Skip copy if file is present. 2798 if (antLib.exists()) return; 2799 2800 for (File f : configurations.compile.files) { 2801 copy { 2802 into libsDir 2803 from f.getParentFile() 2804 include "**/ant-1.8.2.jar" 2805 includeEmptyDirs = false 2806 } 2807 } 2808 } 2809 } 2810 2811 task setupPackagerFakeJar(type: Copy) { 2812 from "$projectDir/src/main/resources/com/oracle/tools/packager/linux/javalogo_white_48.png" 2813 from "$projectDir/src/main/resources/com/oracle/tools/packager/mac/GenericAppHiDPI.icns" 2814 from "$projectDir/src/main/resources/com/oracle/tools/packager/windows/javalogo_white_48.ico" 2815 from "$projectDir/src/test/resources/hello/java-logo2.gif" 2816 from "$projectDir/src/test/resources/hello/small.ico" 2817 from "$projectDir/src/test/resources/hello/test.icns" 2818 from "$projectDir/src/test/resources/hello/LICENSE-RTF.rtf" 2819 from "$projectDir/../../LICENSE" 2820 into project.file("$projectDir/build/tmp/tests/appResources") 2821 } 2822 2823 task setupPackagerFakeJarLicense(type: Copy) { 2824 from "$projectDir/../../LICENSE" 2825 into project.file("$projectDir/build/tmp/tests/appResources") 2826 rename '(.*)LICENSE', '$1LICENSE2' 2827 } 2828 2829 task packagerFakeJar(type: Jar, dependsOn: [setupPackagerFakeJar, setupPackagerFakeJarLicense]) { 2830 dependsOn compileTestJava 2831 from compileTestJava.destinationDir 2832 include "hello/**" 2833 2834 destinationDir project.file("build/tmp/tests/appResources") 2835 archiveName "mainApp.jar" 2836 2837 manifest { 2838 attributes( 2839 "Main-Class": "hello.HelloRectangle", 2840 "Custom-Attribute": " Is it stripped?" 2841 ) 2842 } 2843 } 2844 2845 task packagerFXPackagedJar(type: Jar) { 2846 dependsOn packagerFakeJar 2847 from compileTestJava.destinationDir 2848 include "hello/**" 2849 2850 destinationDir project.file("build/tmp/tests/appResources") 2851 archiveName "packagedMainApp.jar" 2852 2853 manifest { 2854 attributes( 2855 "JavaFX-Application-Class": "hello.TestPackager", 2856 ) 2857 } 2858 } 2859 2860 if (!DO_BUILD_SDK_FOR_TEST) { 2861 def antJavafxJar = new File(rootProject.buildDir, 2862 "modular-sdk/modules_libs/${project.ext.moduleName}/ant-javafx.jar") 2863 [compileTestJava, test].each { 2864 it.classpath = files(antJavafxJar) + it.classpath 2865 } 2866 } 2867 2868 compileTestJava.enabled = false // FIXME: JIGSAW -- support this with modules 2869 test { 2870 enabled = false // FIXME: JIGSAW -- support this with modules 2871 logger.info("JIGSAW Testing disabled for fxpackager") 2872 2873 dependsOn packagerFXPackagedJar 2874 systemProperty "RETAIN_PACKAGER_TESTS", RETAIN_PACKAGER_TESTS 2875 systemProperty "TEST_PACKAGER_DMG", TEST_PACKAGER_DMG 2876 systemProperty "FULL_TEST", FULL_TEST 2877 executable = JAVA; 2878 } 2879 2880 def packagerDevOpts = [] 2881 try { 2882 packagerDevOpts.addAll(PACKAGER_DEV_OPTS.split(' ')) 2883 } catch (MissingPropertyException ignore) { 2884 packagerDevOpts.addAll("image") 2885 } 2886 2887 task packagerDev(dependsOn: [jar, testClasses, packagerFakeJar], type:JavaExec) { 2888 workingDir = project.file("build/tmp/tests/appResources/") 2889 executable = JAVA 2890 classpath = project.files("build/libs/ant-javafx.jar", "build/classes/test", "build/resources/test") 2891 main = "hello.SimpleBundle" 2892 args = [ 2893 '--module-path', JDK_JMODS, 2894 '-o', "$projectDir/build/dev", 2895 '-all', 2896 packagerDevOpts 2897 ].flatten() 2898 } 2899 2900 task createPackagerServicesModule(type: Jar) { 2901 if (project.hasProperty("DEBUGJDK_HOME")) { 2902 def dir = file("$DEBUGJDK_HOME/newmodules") 2903 dir.mkdirs() 2904 2905 includeEmptyDirs = false 2906 archiveName = "jdk.packager.services.jar" 2907 destinationDir = dir 2908 2909 from (project.file("$rootProject.buildDir/modular-sdk/modules/jdk.packager.services")) { 2910 include "**" 2911 } 2912 2913 from (project.file("$rootProject.buildDir/../modules/jdk.packager/build/classes/java/main/jdk.packager.services")) { 2914 include "module-info.class" 2915 } 2916 } 2917 } 2918 2919 task createPackagerModule(type: Jar) { 2920 if (project.hasProperty("DEBUGJDK_HOME")) { 2921 def dir = file("$DEBUGJDK_HOME/newmodules") 2922 dir.mkdirs() 2923 2924 includeEmptyDirs = false 2925 archiveName = "jdk.packager.jar" 2926 destinationDir = dir 2927 2928 from (project.file("$rootProject.buildDir/modular-sdk/modules/jdk.packager")) { 2929 include "**" 2930 } 2931 2932 from (project.file("$rootProject.buildDir/../modules/jdk.packager/build/classes/java/main/jdk.packager")) { 2933 include "module-info.class" 2934 } 2935 } 2936 } 2937 2938 task createRunScript() { 2939 def TEXT = "DEBUG_ARG=\"-J-Xdebug:\"\n" + 2940 "\n" + 2941 "# Argument parsing.\n" + 2942 "ARGS=()\n" + 2943 "for i in \"\$@\"; do\n" + 2944 " if [[ \"\$i\" == \${DEBUG_ARG}* ]]; then\n" + 2945 " ADDRESS=\${i:\${#DEBUG_ARG}}\n" + 2946 " DEBUG=\"-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=\${ADDRESS}\"\n" + 2947 " else\n" + 2948 " ARGS+=(\"\$i\")\n" + 2949 " fi\n" + 2950 "done\n" + 2951 "\n" + 2952 "\${JAVA_HOME}/bin/java.original --upgrade-module-path \${JAVA_HOME}/newmodules \$(IFS=\$\' \'; echo \"\${ARGS[*]}\")\n" 2953 2954 doLast { 2955 new File("$DEBUGJDK_HOME/bin").mkdirs() 2956 def runscript = new File("$DEBUGJDK_HOME/bin/java")//.withWriter('utf-8') //{ 2957 runscript.write(TEXT) 2958 } 2959 2960 doLast { 2961 exec { 2962 commandLine('chmod', '+x', "$DEBUGJDK_HOME/bin/java") 2963 } 2964 } 2965 } 2966 2967 task createBuildScript() { 2968 def TEXT = "DEBUG_ARG=\"-J-Xdebug:\"\n" + 2969 "\n" + 2970 "# Argument parsing.\n" + 2971 "ARGS=()\n" + 2972 "for i in \"\$@\"; do\n" + 2973 " if [[ \"\$i\" == \${DEBUG_ARG}* ]]; then\n" + 2974 " ADDRESS=\${i:\${#DEBUG_ARG}}\n" + 2975 " DEBUG=\"-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=\${ADDRESS}\"\n" + 2976 " else\n" + 2977 " ARGS+=(\"\$i\")\n" + 2978 " fi\n" + 2979 "done\n" + 2980 "\n" + 2981 "\${JAVA_HOME}/bin/javac.original --upgrade-module-path \${JAVA_HOME}/newmodules \$(IFS=\$\' \'; echo \"\${ARGS[*]}\")\n" 2982 2983 doLast { 2984 new File("$DEBUGJDK_HOME/bin").mkdirs() 2985 def buildscript = new File("$DEBUGJDK_HOME/bin/javac")//.withWriter('utf-8') //{ 2986 buildscript.write(TEXT) 2987 } 2988 2989 doLast { 2990 exec { 2991 commandLine('chmod', '+x', "$DEBUGJDK_HOME/bin/javac") 2992 } 2993 } 2994 } 2995 2996 task createDebugJDK(dependsOn: [createPackagerModule, createPackagerServicesModule, createRunScript, createBuildScript]) { 2997 def EXE = IS_WINDOWS ? ".exe" : "" 2998 2999 doLast { 3000 copy { 3001 from SOURCEJDK_HOME 3002 into DEBUGJDK_HOME 3003 exclude("*/ant-javafx.jar") 3004 exclude("*/javapackager$EXE") 3005 exclude("*/java$EXE") 3006 exclude("*/javac$EXE") 3007 exclude("*/jdk.packager.services.jmod") 3008 } 3009 3010 copy { 3011 from "$SOURCEJDK_HOME/bin/java$EXE" 3012 into "$DEBUGJDK_HOME/bin" 3013 rename "java$EXE", "java.original$EXE" 3014 } 3015 3016 copy { 3017 from "$SOURCEJDK_HOME/bin/javac$EXE" 3018 into "$DEBUGJDK_HOME/bin" 3019 rename "javac$EXE", "javac.original$EXE" 3020 } 3021 3022 copy { 3023 from "$rootProject.buildDir/modular-sdk/modules_libs/jdk.packager/ant-javafx.jar" 3024 into "$DEBUGJDK_HOME/lib" 3025 } 3026 3027 copy { 3028 from "$rootProject.buildDir/modular-sdk/modules_cmds/jdk.packager/javapackager$EXE" 3029 into "$DEBUGJDK_HOME/bin" 3030 } 3031 3032 copy { 3033 from "$DEBUGJDK_HOME/newmodules/jdk.packager.services.jar" 3034 into "$DEBUGJDK_HOME/jmods" 3035 } 3036 } 3037 } 3038 3039 task copyRedistributableFiles(type: Copy) { 3040 def projectDir = "tools/java/legacy" 3041 def sourceDir = "src/$projectDir" 3042 def buildDir = "build/$projectDir" 3043 def resourceDir = "${moduleDir}/jdk/packager/internal/resources/tools/legacy" 3044 3045 from "$sourceDir/jre.list" 3046 into project.file("$resourceDir") 3047 } 3048 3049 processResources.dependsOn copyRedistributableFiles 3050 3051 task copyDTtoPackager(type: Copy) { 3052 def destDt = "${moduleDir}/com/sun/javafx/tools/resource" 3053 from (sourceSets.main.output.resourcesDir) { 3054 includes = [ "resources/web-files/**" ] 3055 } 3056 into new File("$destDt", "dtoolkit") 3057 } 3058 3059 processResources.dependsOn copyDTtoPackager 3060 } 3061 3062 project(":media") { 3063 configurations { 3064 media 3065 } 3066 3067 project.ext.buildModule = true 3068 project.ext.includeSources = true 3069 project.ext.moduleRuntime = true 3070 project.ext.moduleName = "javafx.media" 3071 3072 sourceSets { 3073 main 3074 //shims // no test shims needed 3075 test 3076 tools { 3077 java.srcDir "src/tools/java" 3078 } 3079 } 3080 3081 project.ext.moduleSourcePath = defaultModuleSourcePath 3082 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 3083 3084 commonModuleSetup(project, [ 'base', 'graphics', 'media' ]) 3085 3086 dependencies { 3087 if (IS_BUILD_LIBAV_STUBS) { 3088 media name: "libav-9.14", ext: "tar.gz" 3089 media name: "libav-11.4", ext: "tar.gz" 3090 media name: "libav-12.1", ext: "tar.gz" 3091 media name: "ffmpeg-3.3.3", ext: "tar.gz" 3092 } 3093 } 3094 3095 compileJava.dependsOn updateCacheIfNeeded 3096 3097 compileJava { 3098 // generate the native headers during compile 3099 options.compilerArgs.addAll([ 3100 '-h', "${project.buildDir}/gensrc/headers" 3101 ]) 3102 } 3103 3104 compileToolsJava { 3105 enabled = IS_COMPILE_MEDIA 3106 def modulePath = "${project.sourceSets.main.java.outputDir}" 3107 options.compilerArgs.addAll([ 3108 "--module-path=$modulePath", 3109 "--add-modules=javafx.media", 3110 '--add-exports', 'javafx.media/com.sun.media.jfxmedia=ALL-UNNAMED', 3111 ]) 3112 } 3113 3114 project.ext.makeJobsFlag = IS_WINDOWS && IS_DEBUG_NATIVE ? "-j1" : "-j5"; 3115 project.ext.buildType = IS_DEBUG_NATIVE ? "Debug" : "Release"; 3116 3117 def nativeSrcDir = file("${projectDir}/src/main/native") 3118 def generatedHeadersDir = file("${buildDir}/gensrc/headers/${project.moduleName}") 3119 3120 task generateMediaErrorHeader(dependsOn: [compileJava, compileToolsJava]) { 3121 enabled = IS_COMPILE_MEDIA 3122 def headerpath = file("$generatedHeadersDir/jfxmedia_errors.h"); 3123 doLast { 3124 def classpath = files(sourceSets.tools.output); 3125 def sourcepath = sourceSets.main.java.srcDirs; 3126 def srcRoot = (sourcepath.toArray())[0]; 3127 3128 mkdir generatedHeadersDir; 3129 3130 def modulePath = "${project.sourceSets.main.java.outputDir}" 3131 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.graphics/build/classes/java/main" 3132 modulePath += File.pathSeparator + "${rootProject.projectDir}/modules/javafx.base/build/classes/java/main" 3133 3134 exec { 3135 commandLine("$JAVA"); 3136 args += patchModuleArgs 3137 args += [ "--module-path=$modulePath" ] 3138 args += [ "--add-modules=javafx.media" ] 3139 args += [ '--add-exports=javafx.media/com.sun.media.jfxmedia=ALL-UNNAMED' ] 3140 args += [ '-classpath', "${classpath.asPath}" ] 3141 args += [ "headergen.HeaderGen", "$headerpath", "$srcRoot" ] 3142 } 3143 } 3144 outputs.file(project.file("$headerpath")) 3145 } 3146 3147 task buildNativeTargets { 3148 enabled = IS_COMPILE_MEDIA 3149 } 3150 3151 compileTargets { t-> 3152 def targetProperties = project.rootProject.ext[t.upper] 3153 def nativeOutputDir = file("${buildDir}/native/${t.name}") 3154 def projectDir = t.name.startsWith("arm") ? "linux" : t.name 3155 def mediaProperties = targetProperties.media 3156 // Makefile for OSX needs to know if we're building for parfait 3157 def compileParfait = IS_COMPILE_PARFAIT ? "true" : "false" 3158 3159 def buildNative = task("build${t.capital}Native", dependsOn: [generateMediaErrorHeader]) { 3160 enabled = targetProperties.compileMediaNative 3161 if (!targetProperties.compileMediaNative) { 3162 println("Not compiling native Media for ${t.name} per configuration request"); 3163 } 3164 3165 doLast { 3166 exec { 3167 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/jfxmedia/projects/${projectDir}") 3168 args("JAVA_HOME=${JDK_HOME}", "GENERATED_HEADERS_DIR=${generatedHeadersDir}", 3169 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=jfxmedia", 3170 "COMPILE_PARFAIT=${compileParfait}", 3171 IS_64 ? "ARCH=x64" : "ARCH=x32", 3172 "CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}") 3173 3174 if (t.name == "win") { 3175 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3176 args( "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.jfxmediaRcFile}") 3177 } else { 3178 if (t.name.startsWith("arm")) { 3179 args("EXTRA_CFLAGS=${mediaProperties.extra_cflags}", "EXTRA_LDFLAGS=${mediaProperties.extra_ldflags}") 3180 } else { 3181 args("HOST_COMPILE=1") 3182 } 3183 } 3184 } 3185 } 3186 } 3187 3188 // check for the property disable${name} = true 3189 def boolean disabled = targetProperties.containsKey('disableMedia') ? targetProperties.get('disableMedia') : false 3190 if (!disabled) { 3191 // Building GStreamer 3192 def buildGStreamer = task("build${t.capital}GStreamer") { 3193 enabled = IS_COMPILE_MEDIA 3194 doLast { 3195 exec { 3196 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/gstreamer-lite") 3197 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=gstreamer-lite", 3198 IS_64 ? "ARCH=x64" : "ARCH=x32", "CC=${mediaProperties.compiler}", 3199 "AR=${mediaProperties.ar}", "LINKER=${mediaProperties.linker}") 3200 3201 if (t.name == "win") { 3202 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3203 args("RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.gstreamerRcFile}") 3204 } 3205 } 3206 } 3207 } 3208 3209 def buildPlugins = task("build${t.capital}Plugins", dependsOn: buildGStreamer) { 3210 enabled = IS_COMPILE_MEDIA 3211 3212 doLast { 3213 exec { 3214 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/fxplugins") 3215 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=fxplugins", 3216 IS_64 ? "ARCH=x64" : "ARCH=x32", 3217 "CC=${mediaProperties.compiler}", "AR=${mediaProperties.ar}", "LINKER=${mediaProperties.linker}") 3218 3219 if (t.name == "win") { 3220 Map winEnv = new HashMap(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3221 3222 String sdkDir = System.getenv("BASECLASSES_SDK_DIR"); 3223 if (sdkDir == null) { 3224 sdkDir = "C:/Program Files/Microsoft SDKs/Windows/v7.1" // Default value 3225 winEnv["BASECLASSES_SDK_DIR"] = sdkDir 3226 } 3227 environment(winEnv) 3228 3229 args("RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.fxpluginsRcFile}") 3230 } 3231 } 3232 } 3233 } 3234 3235 buildNative.dependsOn buildPlugins 3236 3237 if (t.name == "linux") { 3238 // Pre-defined command line arguments 3239 def cfgCMDArgs = ["sh", "configure"] 3240 def commonCfgArgs = ["--enable-shared", "--disable-debug", "--disable-static", "--disable-yasm", "--disable-doc", "--disable-programs", "--disable-everything"] 3241 def codecsCfgArgs = ["--enable-decoder=aac,mp3,mp3float,h264", "--enable-parser=aac,h264", "--enable-demuxer=aac,h264,mpegts,mpegtsraw"] 3242 3243 def copyLibAVStubs = {String fromDir, String toDir -> 3244 FileCollection config = files("config.h") 3245 FileCollection libavcodec = files("avcodec.h", "avfft.h", "dxva2.h", "vaapi.h", "vda.h", 3246 "vdpau.h", "version.h", "xvmc.h", "old_codec_ids.h") 3247 FileCollection libavdevice = files("avdevice.h", "version.h") 3248 FileCollection libavfilter = files("avfiltergraph.h", "avfilter.h", "buffersink.h", "buffersrc.h", "version.h"); 3249 FileCollection libavformat = files("avformat.h", "avio.h", "version.h") 3250 FileCollection libavresample = files("avresample.h", "version.h") 3251 FileCollection libavutil = files("adler32.h", "blowfish.h", "error.h", "log.h", "pixfmt.h", 3252 "aes.h", "bswap.h", "eval.h", "lzo.h", "random_seed.h", 3253 "attributes.h", "buffer.h", "fifo.h", "macros.h", "rational.h", 3254 "audio_fifo.h", "channel_layout.h", "file.h", "mathematics.h", "samplefmt.h", 3255 "avassert.h", "common.h", "frame.h", "md5.h", "sha.h", 3256 "avconfig.h", "imgutils.h", "mem.h", "time.h", "avstring.h", 3257 "cpu_internal.h", "intfloat.h", "opt.h", "version.h", "avutil.h", 3258 "crc.h", "intreadwrite.h", "parseutils.h", "xtea.h", "base64.h", 3259 "dict.h", "lfg.h", "pixdesc.h", "intfloat_readwrite.h", "old_pix_fmts.h", "audioconvert.h", 3260 "cpu.h") 3261 FileCollection libavutil_x86 = files("cpu.h") // Use cpu.h from x86 instead of libavutil root if exist 3262 FileCollection libswscale = files("swscale.h", "version.h") 3263 3264 def copyLibAVFiles = {FileCollection files, String fDir, String tDir -> 3265 File dir = file(tDir) 3266 dir.mkdirs() 3267 3268 files.each { File file -> 3269 copy { 3270 from fDir 3271 into tDir 3272 include file.name 3273 } 3274 } 3275 } 3276 3277 copyLibAVFiles(config, fromDir, "${toDir}/include") 3278 copyLibAVFiles(libavcodec, "${fromDir}/libavcodec", "${toDir}/include/libavcodec") 3279 copyLibAVFiles(libavdevice, "${fromDir}/libavdevice", "${toDir}/include/libavdevice") 3280 copyLibAVFiles(libavfilter, "${fromDir}/libavfilter", "${toDir}/include/libavfilter") 3281 copyLibAVFiles(libavformat, "${fromDir}/libavformat", "${toDir}/include/libavformat") 3282 copyLibAVFiles(libavresample, "${fromDir}/libavresample", "${toDir}/include/libavresample") 3283 copyLibAVFiles(libavutil, "${fromDir}/libavutil", "${toDir}/include/libavutil") 3284 copyLibAVFiles(libavutil_x86, "${fromDir}/libavutil/x86", "${toDir}/include/libavutil") 3285 copyLibAVFiles(libswscale, "${fromDir}/libswscale", "${toDir}/include/libswscale") 3286 3287 // Copy libs 3288 FileTree libs = fileTree(dir: "${fromDir}", include: "**/*.so*") 3289 libs.each {File file -> 3290 copy { 3291 from file 3292 into "${toDir}/lib" 3293 } 3294 } 3295 } 3296 3297 def buildLibAVStubs = task("buildLibAVStubs", dependsOn: []) { 3298 enabled = IS_BUILD_LIBAV_STUBS 3299 3300 doLast { 3301 project.ext.libav = [:] 3302 project.ext.libav.basedir = "${buildDir}/native/linux/libav" 3303 project.ext.libav.versions = [ "9.14", "11.4", "12.1" ] 3304 project.ext.libav.versionmap = [ "9.14" : "54", "11.4" : "56", "12.1" : "57" ] 3305 3306 libav.versions.each { version -> 3307 def libavDir = "${libav.basedir}/libav-${version}" 3308 for (File f : configurations.media.files) { 3309 if (f.name.startsWith("libav-${version}")) { 3310 File dir = file(libavDir) 3311 dir.mkdirs() 3312 def libavTar = "${libav.basedir}/libav-${version}.tar" 3313 ant.gunzip(src: f, dest: libavTar) 3314 ant.untar(src: libavTar, dest: libav.basedir) 3315 } 3316 } 3317 } 3318 3319 libav.versions.each { version -> 3320 def libavDir = "${libav.basedir}/libav-${version}" 3321 File dir = file(libavDir) 3322 if (dir.exists()) { 3323 def configFile = "${libav.basedir}/libav-${version}/config.h" 3324 File cfgFile = file(configFile) 3325 if (!cfgFile.exists()) { 3326 // Add execute permissions to version.sh, otherwise build fails 3327 exec { 3328 workingDir("$libavDir") 3329 commandLine("chmod", "+x", "version.sh") 3330 } 3331 exec { 3332 workingDir("$libavDir") 3333 if (IS_BUILD_WORKING_LIBAV) { 3334 commandLine(cfgCMDArgs + commonCfgArgs + codecsCfgArgs) 3335 } else { 3336 commandLine(cfgCMDArgs + commonCfgArgs) 3337 } 3338 } 3339 } 3340 exec { 3341 workingDir("$libavDir") 3342 commandLine("make") 3343 } 3344 } 3345 } 3346 3347 libav.versions.each { version -> 3348 def fromDir = "${libav.basedir}/libav-${version}" 3349 def majorVersion = libav.versionmap[version] 3350 def toDir = "${libav.basedir}/libav-${majorVersion}" 3351 copyLibAVStubs(fromDir, toDir) 3352 } 3353 } 3354 } 3355 3356 def buildLibAVFFmpegStubs = task("buildLibAVFFmpegStubs", dependsOn: []) { 3357 enabled = IS_BUILD_LIBAV_STUBS 3358 3359 def extraCfgArgs = ["--build-suffix=-ffmpeg"] 3360 3361 doLast { 3362 project.ext.libav = [:] 3363 project.ext.libav.basedir = "${buildDir}/native/linux/libavffmpeg" 3364 project.ext.libav.versions = [ "11.4" ] 3365 project.ext.libav.versionmap = [ "11.4" : "56" ] 3366 3367 libav.versions.each { version -> 3368 def libavDir = "${libav.basedir}/libav-${version}" 3369 for (File f : configurations.media.files) { 3370 if (f.name.startsWith("libav-${version}")) { 3371 File dir = file(libavDir) 3372 dir.mkdirs() 3373 def libavTar = "${libav.basedir}/libav-${version}.tar" 3374 ant.gunzip(src: f, dest: libavTar) 3375 ant.untar(src: libavTar, dest: libav.basedir) 3376 } 3377 } 3378 } 3379 3380 libav.versions.each { version -> 3381 def libavDir = "${libav.basedir}/libav-${version}" 3382 File dir = file(libavDir) 3383 if (dir.exists()) { 3384 def configFile = "${libav.basedir}/libav-${version}/config.h" 3385 File cfgFile = file(configFile) 3386 if (!cfgFile.exists()) { 3387 // Patch *.v files, so we have *_FFMPEG_$MAJOR instead of *_$MAJOR, otherwise library will not be loaded 3388 FileTree vfiles = fileTree(dir: "${libavDir}", include: "**/*.v") 3389 vfiles.each {File file -> 3390 String data = file.getText("UTF-8") 3391 data = data.replace("_\$MAJOR", "_FFMPEG_\$MAJOR") 3392 file.write(data, "UTF-8") 3393 } 3394 // Add execute permissions to version.sh, otherwise build fails 3395 exec { 3396 workingDir("$libavDir") 3397 commandLine("chmod", "+x", "version.sh") 3398 } 3399 exec { 3400 workingDir("$libavDir") 3401 if (IS_BUILD_WORKING_LIBAV) { 3402 commandLine(cfgCMDArgs + commonCfgArgs + codecsCfgArgs + extraCfgArgs) 3403 } else { 3404 commandLine(cfgCMDArgs + commonCfgArgs + extraCfgArgs) 3405 } 3406 } 3407 } 3408 exec { 3409 workingDir("$libavDir") 3410 commandLine("make") 3411 } 3412 } 3413 } 3414 3415 libav.versions.each { version -> 3416 def fromDir = "${libav.basedir}/libav-${version}" 3417 def majorVersion = libav.versionmap[version] 3418 def toDir = "${libav.basedir}/libav-${majorVersion}" 3419 copyLibAVStubs(fromDir, toDir) 3420 3421 // Special case to copy *-ffmpeg.so to *.so 3422 FileTree libs = fileTree(dir: "${fromDir}", include: "**/*-ffmpeg.so") 3423 libs.each {File file -> 3424 copy { 3425 from file 3426 into "${toDir}/lib" 3427 rename { String fileName -> 3428 fileName.replace("-ffmpeg", "") 3429 } 3430 } 3431 } 3432 } 3433 } 3434 } 3435 3436 def buildFFmpegStubs = task("buildFFmpegStubs", dependsOn: []) { 3437 enabled = IS_BUILD_LIBAV_STUBS 3438 3439 doLast { 3440 project.ext.libav = [:] 3441 project.ext.libav.basedir = "${buildDir}/native/linux/ffmpeg" 3442 project.ext.libav.versions = [ "3.3.3" ] 3443 project.ext.libav.versionmap = [ "3.3.3" : "57" ] 3444 3445 libav.versions.each { version -> 3446 def libavDir = "${libav.basedir}/ffmpeg-${version}" 3447 for (File f : configurations.media.files) { 3448 if (f.name.startsWith("ffmpeg-${version}")) { 3449 File dir = file(libavDir) 3450 dir.mkdirs() 3451 def libavTar = "${libav.basedir}/ffmpeg-${version}.tar" 3452 ant.gunzip(src: f, dest: libavTar) 3453 ant.untar(src: libavTar, dest: libav.basedir) 3454 } 3455 } 3456 } 3457 3458 libav.versions.each { version -> 3459 def libavDir = "${libav.basedir}/ffmpeg-${version}" 3460 File dir = file(libavDir) 3461 if (dir.exists()) { 3462 def configFile = "${libav.basedir}/ffmpeg-${version}/config.h" 3463 File cfgFile = file(configFile) 3464 if (!cfgFile.exists()) { 3465 // Add execute permissions to version.sh, otherwise build fails 3466 exec { 3467 workingDir("$libavDir") 3468 commandLine("chmod", "+x", "version.sh") 3469 } 3470 exec { 3471 workingDir("$libavDir") 3472 if (IS_BUILD_WORKING_LIBAV) { 3473 commandLine(cfgCMDArgs + commonCfgArgs + codecsCfgArgs) 3474 } else { 3475 commandLine(cfgCMDArgs + commonCfgArgs) 3476 } 3477 } 3478 } 3479 exec { 3480 workingDir("$libavDir") 3481 commandLine("make") 3482 } 3483 } 3484 } 3485 3486 libav.versions.each { version -> 3487 def fromDir = "${libav.basedir}/ffmpeg-${version}" 3488 def majorVersion = libav.versionmap[version] 3489 def toDir = "${libav.basedir}/ffmpeg-${majorVersion}" 3490 copyLibAVStubs(fromDir, toDir) 3491 } 3492 } 3493 } 3494 3495 def buildAVPlugin = task( "buildAVPlugin", dependsOn: [buildPlugins, buildLibAVStubs, buildLibAVFFmpegStubs, buildFFmpegStubs]) { 3496 enabled = IS_COMPILE_MEDIA 3497 3498 doLast { 3499 if (IS_BUILD_LIBAV_STUBS) { 3500 project.ext.libav = [:] 3501 project.ext.libav.basedir = "${buildDir}/native/linux/libav/libav" 3502 project.ext.libav.versions = [ "53", "54", "55", "56", "57" ] 3503 project.ext.libav.libavffmpeg = [:] 3504 project.ext.libav.libavffmpeg.basedir = "${buildDir}/native/linux/libavffmpeg/libav" 3505 project.ext.libav.libavffmpeg.versions = [ "56" ] 3506 project.ext.libav.ffmpeg = [:] 3507 project.ext.libav.ffmpeg.basedir = "${buildDir}/native/linux/ffmpeg/ffmpeg" 3508 project.ext.libav.ffmpeg.versions = [ "57" ] 3509 3510 project.ext.libav.versions.each { version -> 3511 def libavDir = "${project.ext.libav.basedir}-${version}" 3512 File dir = file(libavDir) 3513 if (dir.exists()) { 3514 exec { 3515 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/linux/avplugin") 3516 args("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}", 3517 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", 3518 "BASE_NAME=avplugin", "VERSION=${version}", "LIBAV_DIR=${libavDir}", 3519 "SUFFIX=", IS_64 ? "ARCH=x64" : "ARCH=x32") 3520 } 3521 } 3522 } 3523 3524 project.ext.libav.libavffmpeg.versions.each { version -> 3525 def libavDir = "${project.ext.libav.libavffmpeg.basedir}-${version}" 3526 File dir = file(libavDir) 3527 if (dir.exists()) { 3528 exec { 3529 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/linux/avplugin") 3530 args("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}", 3531 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", 3532 "BASE_NAME=avplugin", "VERSION=${version}", "LIBAV_DIR=${libavDir}", 3533 "SUFFIX=-ffmpeg", IS_64 ? "ARCH=x64" : "ARCH=x32") 3534 } 3535 } 3536 } 3537 3538 project.ext.libav.ffmpeg.versions.each { version -> 3539 def libavDir = "${project.ext.libav.ffmpeg.basedir}-${version}" 3540 File dir = file(libavDir) 3541 if (dir.exists()) { 3542 exec { 3543 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/linux/avplugin") 3544 args("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}", 3545 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", 3546 "BASE_NAME=avplugin", "VERSION=${version}", "LIBAV_DIR=${libavDir}", 3547 "SUFFIX=-ffmpeg", IS_64 ? "ARCH=x64" : "ARCH=x32") 3548 } 3549 } 3550 } 3551 } else { 3552 // Building fxavcodec plugin (libav plugin) 3553 exec { 3554 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/linux/avplugin") 3555 args("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}", 3556 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", 3557 "BASE_NAME=avplugin", IS_64 ? "ARCH=x64" : "ARCH=x32") 3558 } 3559 } 3560 } 3561 } 3562 buildNative.dependsOn buildAVPlugin 3563 } 3564 3565 if (t.name == "win") { 3566 def buildResources = task("buildResources") { 3567 doLast { 3568 def rcOutputDir = "${nativeOutputDir}/${buildType}" 3569 mkdir rcOutputDir 3570 exec { 3571 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3572 commandLine (WIN.media.rcCompiler) 3573 args(WIN.media.glibRcFlags) 3574 args("/Fo${rcOutputDir}/${WIN.media.glibRcFile}", WIN.media.rcSource) 3575 } 3576 3577 exec { 3578 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3579 commandLine (WIN.media.rcCompiler) 3580 args(WIN.media.gstreamerRcFlags) 3581 args("/Fo${rcOutputDir}/${WIN.media.gstreamerRcFile}", WIN.media.rcSource) 3582 } 3583 3584 exec { 3585 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3586 commandLine (WIN.media.rcCompiler) 3587 args(WIN.media.fxpluginsRcFlags) 3588 args("/Fo${rcOutputDir}/${WIN.media.fxpluginsRcFile}", WIN.media.rcSource) 3589 } 3590 3591 exec { 3592 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3593 commandLine (WIN.media.rcCompiler) 3594 args(WIN.media.jfxmediaRcFlags) 3595 args("/Fo${rcOutputDir}/${WIN.media.jfxmediaRcFile}", WIN.media.rcSource) 3596 } 3597 } 3598 } 3599 3600 def buildGlib = task("build${t.capital}Glib", dependsOn: [buildResources]) { 3601 enabled = IS_COMPILE_MEDIA 3602 doLast { 3603 exec { 3604 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3605 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/glib-lite") 3606 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=glib-lite", 3607 IS_64 ? "ARCH=x64" : "ARCH=x32", "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.glibRcFile}", 3608 "CC=${mediaProperties.compiler}", "AR=${mediaProperties.ar}", "LINKER=${mediaProperties.linker}") 3609 } 3610 } 3611 } 3612 buildGStreamer.dependsOn buildGlib 3613 3614 } else if (t.name == "mac") { 3615 def buildGlib = task("build${t.capital}Glib") { 3616 enabled = IS_COMPILE_MEDIA 3617 doLast { 3618 exec { 3619 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/libffi") 3620 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=ffi") 3621 args ("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}", "AR=${mediaProperties.ar}") 3622 } 3623 3624 exec { 3625 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/glib-lite") 3626 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=glib-lite") 3627 args ("CC=${mediaProperties.compiler}", "LINKER=${mediaProperties.linker}") 3628 } 3629 } 3630 } 3631 buildGStreamer.dependsOn buildGlib 3632 } 3633 } 3634 3635 buildNativeTargets.dependsOn buildNative 3636 } 3637 3638 jar { 3639 exclude("headergen/**") 3640 3641 dependsOn compileJava 3642 if (IS_COMPILE_MEDIA) { 3643 dependsOn buildNativeTargets 3644 } 3645 } 3646 } 3647 3648 project(":web") { 3649 configurations { 3650 webkit 3651 } 3652 project.ext.buildModule = true 3653 project.ext.includeSources = true 3654 project.ext.moduleRuntime = true 3655 project.ext.moduleName = "javafx.web" 3656 3657 sourceSets { 3658 main 3659 shims 3660 test 3661 } 3662 3663 project.ext.moduleSourcePath = defaultModuleSourcePath 3664 project.ext.moduleSourcePathShim = defaultModuleSourcePathShim 3665 3666 commonModuleSetup(project, [ 'base', 'graphics', 'controls', 'media', 'web' ]) 3667 3668 dependencies { 3669 } 3670 3671 compileJava.dependsOn updateCacheIfNeeded 3672 3673 task webArchiveJar(type: Jar) { 3674 from (project.file("$projectDir/src/test/resources/test/html")) { 3675 include "**/archive-*.*" 3676 } 3677 archiveName = "webArchiveJar.jar" 3678 destinationDir = file("$buildDir/testing/resources") 3679 } 3680 3681 def gensrcDir = "${buildDir}/gensrc/java" 3682 3683 // add in the wrappers to the compile 3684 sourceSets.main.java.srcDirs += "${gensrcDir}" 3685 3686 if (IS_COMPILE_WEBKIT) { 3687 compileJava { 3688 // generate the native headers during compile 3689 // only needed if we are doing the native compile 3690 options.compilerArgs.addAll([ 3691 '-h', "${project.buildDir}/gensrc/headers" 3692 ]) 3693 } 3694 } 3695 3696 // Copy these to a common location in the moduleSourcePath 3697 def copyWrappers = project.task("copyPreGeneratedWrappers", type: Copy) { 3698 from "src/main/native/Source/WebCore/bindings/java/dom3/java" 3699 into "${gensrcDir}" 3700 } 3701 3702 compileJava.dependsOn(copyWrappers); 3703 3704 test { 3705 doFirst { 3706 if (!IS_COMPILE_WEBKIT) { 3707 println "*****************************************************" 3708 println "WARNING: running web tests without building webkit." 3709 println "The webkit native library will be copied from the JDK," 3710 println "which might lead to failures in some web tests." 3711 println "To avoid these failures, you should either build" 3712 println "webkit locally, copy the native webkit library from a" 3713 println "recent build, or skip execution of web test cases with" 3714 println "'-x :web:test'" 3715 println "*****************************************************" 3716 } 3717 } 3718 // Run web tests in headless mode 3719 systemProperty 'glass.platform', 'Monocle' 3720 systemProperty 'monocle.platform', 'Headless' 3721 systemProperty 'prism.order', 'sw' 3722 dependsOn webArchiveJar 3723 def testResourceDir = file("$buildDir/testing/resources") 3724 jvmArgs "-DWEB_ARCHIVE_JAR_TEST_DIR=$testResourceDir" 3725 } 3726 3727 task compileJavaDOMBinding() 3728 3729 compileTargets { t -> 3730 def targetProperties = project.rootProject.ext[t.upper] 3731 def webkitProperties = targetProperties.webkit 3732 def classifier = (t.name != "linux" && t.name != "win") ? t.name : 3733 IS_64 ? "${t.name}-amd64" : "${t.name}-i586" 3734 3735 def webkitOutputDir = cygpath("$buildDir/${t.name}") 3736 def webkitConfig = IS_DEBUG_NATIVE ? "Debug" : "Release" 3737 3738 File nativeBuildDir = new File("${webkitOutputDir}") 3739 nativeBuildDir.mkdirs() 3740 3741 def compileNativeTask = task("compileNative${t.capital}", dependsOn: [compileJava]) { 3742 println "Building Webkit configuration /$webkitConfig/ into $webkitOutputDir" 3743 enabled = (IS_COMPILE_WEBKIT) 3744 3745 doLast { 3746 exec { 3747 workingDir("$webkitOutputDir") 3748 commandLine("perl", "$projectDir/src/main/native/Tools/Scripts/set-webkit-configuration", "--$webkitConfig") 3749 environment(["WEBKIT_OUTPUTDIR" : webkitOutputDir]) 3750 } 3751 3752 exec { 3753 workingDir("$webkitOutputDir") 3754 def cmakeArgs = "-DENABLE_TOOLS=1" 3755 if (t.name == "win") { 3756 String parfaitPath = IS_COMPILE_PARFAIT ? System.getenv().get("PARFAIT_PATH") + ";" : ""; 3757 Map environmentSettings = new HashMap(WINDOWS_NATIVE_COMPILE_ENVIRONMENT) 3758 environmentSettings["PATH"] = parfaitPath + "$WINDOWS_VS_PATH" 3759 /* To build with ICU: 3760 1. Download http://javaweb.us.oracle.com/jcg/fx-webrevs/RT-17164/WebKitLibrariesICU.zip 3761 and unzip it to WebKitLibraries folder. 3762 2. Copy DLLs from 3763 WebKitLibrariesICU.zip\WebKitLibraries\import\runtime 3764 to %windir%\system32 3765 3. Uncomment the line below 3766 */ 3767 // args("--icu-unicode") 3768 3769 // To enable ninja build on Windows 3770 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT + ['CC' : 'cl', 'CXX' : 'cl']) 3771 } else if (t.name == "mac") { 3772 cmakeArgs = "-DCMAKE_OSX_DEPLOYMENT_TARGET=$MACOSX_MIN_VERSION -DCMAKE_OSX_SYSROOT=$MACOSX_SDK_PATH" 3773 } else if (t.name == "linux") { 3774 cmakeArgs = "-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_C_COMPILER=${webkitProperties.compiler}" 3775 if (IS_64) { 3776 cmakeArgs = "$cmakeArgs -DCMAKE_SYSTEM_PROCESSOR=x86_64" 3777 } else { 3778 cmakeArgs = "$cmakeArgs -DCMAKE_SYSTEM_PROCESSOR=i586" 3779 } 3780 // TODO: Use cflags and ldflags from all platforms 3781 def cFlags = webkitProperties.ccFlags?.join(' ') ?: '' 3782 def lFlags = webkitProperties.linkFlags?.join(' ') ?: '' 3783 // -shared flag should be omitted while creating executable. 3784 def exeFlags = webkitProperties.linkFlags?.join(' ')?.replace('-shared', '') ?: '' 3785 cmakeArgs = "$cmakeArgs -DCMAKE_C_FLAGS='${cFlags}' -DCMAKE_CXX_FLAGS='${cFlags}'" 3786 cmakeArgs = "$cmakeArgs -DCMAKE_SHARED_LINKER_FLAGS='${lFlags}' -DCMAKE_EXE_LINKER_FLAGS='${exeFlags}'" 3787 } else if (t.name.startsWith("arm")) { 3788 fail("ARM target is not supported as of now.") 3789 } 3790 3791 if (IS_COMPILE_PARFAIT) { 3792 environment([ 3793 "COMPILE_PARFAIT" : "true" 3794 ]) 3795 cmakeArgs = "-DCMAKE_C_COMPILER=parfait-gcc -DCMAKE_CXX_COMPILER=parfait-g++" 3796 } 3797 3798 environment([ 3799 "JAVA_HOME" : JDK_HOME, 3800 "WEBKIT_OUTPUTDIR" : webkitOutputDir, 3801 "PYTHONDONTWRITEBYTECODE" : "1", 3802 ]) 3803 3804 def targetCpuBitDepthSwitch = "" 3805 if (IS_64) { 3806 targetCpuBitDepthSwitch = "--64-bit" 3807 } else { 3808 targetCpuBitDepthSwitch = "--32-bit" 3809 } 3810 cmakeArgs += " -DJAVAFX_RELEASE_VERSION=${jfxReleaseMajorVersion}" 3811 commandLine("perl", "$projectDir/src/main/native/Tools/Scripts/build-webkit", 3812 "--java", "--icu-unicode", targetCpuBitDepthSwitch, 3813 "--cmakeargs=${cmakeArgs}") 3814 } 3815 } 3816 } 3817 3818 def copyDumpTreeNativeTask = task("copyDumpTreeNative${t.capital}", type: Copy, 3819 dependsOn: [ compileNativeTask]) { 3820 def library = rootProject.ext[t.upper].library 3821 from "$webkitOutputDir/$webkitConfig/lib/${library('DumpRenderTreeJava')}" 3822 into "$buildDir/test/${t.name}" 3823 } 3824 3825 def copyNativeTask = task("copyNative${t.capital}", type: Copy, 3826 dependsOn: [compileNativeTask, , copyDumpTreeNativeTask]) { 3827 enabled = (IS_COMPILE_WEBKIT) 3828 def library = rootProject.ext[t.upper].library 3829 from "$webkitOutputDir/$webkitConfig/lib/${library('jfxwebkit')}" 3830 into "$buildDir/libs/${t.name}" 3831 } 3832 3833 if (IS_WINDOWS && t.name == "win") { 3834 def rcTask = project.task("rc${t.capital}", type: CompileResourceTask) { 3835 compiler = webkitProperties.rcCompiler 3836 source(webkitProperties.rcSource) 3837 if (webkitProperties.rcFlags) { 3838 rcParams.addAll(webkitProperties.rcFlags) 3839 } 3840 output(file("$webkitOutputDir/$webkitConfig/WebCore/obj")) 3841 } 3842 compileNativeTask.dependsOn rcTask 3843 } 3844 3845 def compileJavaDOMBindingTask = task("compileJavaDOMBinding${t.capital}", type: JavaCompile, 3846 dependsOn: [compileJava, compileNativeTask, copyNativeTask]) { 3847 destinationDir = file("$buildDir/classes/java/main") 3848 classpath = configurations.compile 3849 source = project.sourceSets.main.java.srcDirs 3850 options.compilerArgs.addAll([ 3851 '-implicit:none', 3852 '--module-source-path', defaultModuleSourcePath 3853 ]) 3854 } 3855 3856 compileJavaDOMBinding.dependsOn compileJavaDOMBindingTask 3857 3858 if (!targetProperties.compileWebnodeNative) { 3859 println("Not compiling native Webkit for ${t.name} per configuration request"); 3860 compileNativeTask.enabled = false 3861 } 3862 } 3863 3864 def drtClasses = "**/com/sun/javafx/webkit/drt/**" 3865 task drtJar(type: Jar, dependsOn: compileJava) { 3866 archiveName = "drt.jar" 3867 destinationDir = file("$buildDir/test") 3868 from "$buildDir/classes/java/main/javafx.web/" 3869 include drtClasses 3870 includeEmptyDirs = false 3871 } 3872 3873 if (IS_COMPILE_WEBKIT) { 3874 assemble.dependsOn compileJavaDOMBinding, drtJar 3875 } 3876 } 3877 3878 // This project is for system tests that need to run with a full SDK. 3879 // Most of them display a stage or do other things that preclude running 3880 // them in a shared JVM or as part of the "smoke test" run (which must 3881 // not pop up any windows or use audio). As such, they are only enabled 3882 // when FULL_TEST is specified, and each test runs in its own JVM 3883 project(":systemTests") { 3884 3885 sourceSets { 3886 test 3887 3888 // Source sets for standalone test apps (used for launcher tests) 3889 testapp1 3890 3891 // Modular applications 3892 testapp2 3893 testapp3 3894 testapp4 3895 testapp5 3896 testapp6 3897 } 3898 3899 project.ext.buildModule = false 3900 project.ext.moduleRuntime = false 3901 project.ext.moduleName = "systemTests" 3902 3903 dependencies { 3904 testCompile project(":graphics").sourceSets.test.output 3905 testCompile project(":base").sourceSets.test.output 3906 testCompile project(":controls").sourceSets.test.output 3907 testCompile project(":swing").sourceSets.test.output 3908 } 3909 3910 def dependentProjects = [ 'base', 'graphics', 'controls', 'media', 'web', 'swing', 'fxml' ] 3911 commonModuleSetup(project, dependentProjects) 3912 3913 File testJavaPolicyFile = new File(rootProject.buildDir, TESTJAVAPOLICYFILE); 3914 File testRunArgsFile = new File(rootProject.buildDir,TESTRUNARGSFILE); 3915 3916 File stRunArgsFile = new File(project.buildDir,"st.run.args"); 3917 3918 def sts = task("systemTestSetup") { 3919 outputs.file(stRunArgsFile) 3920 3921 doLast() { 3922 stRunArgsFile.delete() 3923 3924 logger.info("Creating patchmodule.args file ${stRunArgsFile}") 3925 3926 // Create an argfile with the information needed to launch 3927 // the stand alone system unit tests. 3928 3929 //First add in all of the patch-module args we use for the 3930 //normal unit tests, copied from test.run.args 3931 testRunArgsFile.eachLine { str -> 3932 stRunArgsFile << "${str}\n" 3933 } 3934 3935 // Now add in the working classpath elements (junit, test classes...) 3936 stRunArgsFile << "-cp \"\\\n" 3937 test.classpath.each() { elem -> 3938 def e = cygpath("${elem}") 3939 stRunArgsFile << " ${e}${File.pathSeparator}\\\n" 3940 } 3941 stRunArgsFile << "\"\n" 3942 } 3943 } 3944 3945 test.dependsOn(sts) 3946 test.dependsOn(createTestArgfiles); 3947 3948 // Tasks to create standalone test applications for the launcher tests 3949 3950 if (project.hasProperty('testModulePathArgs')) { 3951 compileTestapp1Java.options.compilerArgs.addAll(testModulePathArgs) 3952 } 3953 dependentProjects.each { e -> 3954 compileTestapp1Java.dependsOn(rootProject.project(e).testClasses) 3955 } 3956 3957 def testapp1JarName = "testapp1.jar" 3958 task createTestapp1Jar1(type: Jar) { 3959 dependsOn compileTestapp1Java 3960 enabled = IS_FULL_TEST 3961 3962 destinationDir = file("$buildDir/testapp1") 3963 archiveName = testapp1JarName 3964 includeEmptyDirs = false 3965 from project.sourceSets.testapp1.java.outputDir 3966 include("testapp/**") 3967 include("com/javafx/main/**") 3968 3969 manifest { 3970 attributes( 3971 "Main-Class" : "com.javafx.main.Main", 3972 "JavaFX-Version" : "2.2", 3973 "JavaFX-Application-Class" : "testapp.HelloWorld", 3974 "JavaFX-Class-Path" : "jar2.jar" 3975 ) 3976 } 3977 } 3978 3979 task createTestapp1Jar2(type: Jar) { 3980 dependsOn compileTestapp1Java 3981 enabled = IS_FULL_TEST 3982 3983 destinationDir = file("$buildDir/testapp1") 3984 archiveName = "jar2.jar"; 3985 includeEmptyDirs = false 3986 from project.sourceSets.testapp1.java.outputDir 3987 include("pkg2/**") 3988 } 3989 3990 task createTestApps() { 3991 dependsOn(createTestapp1Jar1) 3992 dependsOn(createTestapp1Jar2) 3993 } 3994 test.dependsOn(createTestApps); 3995 3996 def modtestapps = [ "testapp2", "testapp3", "testapp4", "testapp5", "testapp6" ] 3997 modtestapps.each { testapp -> 3998 def testappCapital = testapp.capitalize() 3999 def copyTestAppTask = task("copy${testappCapital}", type: Copy) { 4000 from project.sourceSets."${testapp}".java.outputDir 4001 from project.sourceSets."${testapp}".output.resourcesDir 4002 into "${project.buildDir}/modules/${testapp}" 4003 } 4004 4005 def List<String> testAppSourceDirs = [] 4006 project.sourceSets."${testapp}".java.srcDirs.each { dir -> 4007 testAppSourceDirs += dir 4008 } 4009 def testappCompileTasks = project.getTasksByName("compile${testappCapital}Java", true); 4010 def testappResourceTasks = project.getTasksByName("process${testappCapital}Resources", true); 4011 testappCompileTasks.each { appCompileTask -> 4012 appCompileTask.options.compilerArgs.addAll([ 4013 '-implicit:none', 4014 '--module-source-path', testAppSourceDirs.join(File.pathSeparator), 4015 ] ) 4016 if (project.hasProperty('testModulePathArgs')) { 4017 appCompileTask.options.compilerArgs.addAll(testModulePathArgs) 4018 } 4019 4020 dependentProjects.each { e -> 4021 appCompileTask.dependsOn(rootProject.project(e).testClasses) 4022 } 4023 4024 copyTestAppTask.dependsOn(appCompileTask) 4025 } 4026 testappResourceTasks.each { appResourceTask -> 4027 copyTestAppTask.dependsOn(appResourceTask) 4028 } 4029 4030 createTestApps.dependsOn(copyTestAppTask) 4031 } 4032 4033 test { 4034 enabled = IS_FULL_TEST 4035 4036 // Parse testPatchModuleArgs looking for "--module-path". 4037 // Save path if found so we can pass it to the module launcher tests 4038 def pendingModulePath = false 4039 testPatchModuleArgs.each { str -> 4040 if (pendingModulePath) { 4041 project.ext.launcherModulePath = str; 4042 pendingModulePath = false 4043 } else if (str == "--module-path") { 4044 pendingModulePath = true 4045 } 4046 } 4047 4048 // Properties passed to launcher tests 4049 systemProperty "launchertest.testapp1.jar", "build/testapp1/$testapp1JarName" 4050 modtestapps.each { testapp -> 4051 systemProperty "launchertest.${testapp}.module.path", 4052 "${project.buildDir}/modules/${testapp}" 4053 } 4054 4055 // Properties passed to test.util.Util 4056 systemProperties 'worker.debug': IS_WORKER_DEBUG 4057 systemProperties 'worker.patchmodule.file': cygpath(stRunArgsFile.path) 4058 if (project.hasProperty("launcherModulePath")) { 4059 systemProperties 'worker.module.path': launcherModulePath 4060 } 4061 systemProperties 'worker.patch.policy': cygpath(testJavaPolicyFile.path) 4062 systemProperties 'worker.java.cmd': JAVA 4063 4064 if (!IS_USE_ROBOT) { 4065 // Disable all robot-based visual tests 4066 exclude("test/robot/**"); 4067 } 4068 if (!IS_UNSTABLE_TEST) { 4069 // JDK-8196607 Don't run monocle test cases 4070 exclude("test/robot/com/sun/glass/ui/monocle/**"); 4071 } 4072 if (!IS_AWT_TEST) { 4073 // Disable all AWT-based tests 4074 exclude("**/javafx/embed/swing/*.*"); 4075 exclude("**/com/sun/javafx/application/Swing*.*"); 4076 } 4077 4078 if (!HAS_JAVAFX_MODULES) { 4079 jvmArgs += qualExportsSwing 4080 } 4081 4082 forkEvery = 1 4083 } 4084 } 4085 4086 allprojects { 4087 // The following block is a workaround for the fact that presently Gradle 4088 // can't set the -XDignore.symbol.file flag, because it appears that the 4089 // javac API is lacking support for it. So what we'll do is find any Compile 4090 // task and manually provide the options necessary to fire up the 4091 // compiler with the right settings. 4092 tasks.withType(JavaCompile) { compile -> 4093 if (compile.options.hasProperty("useAnt")) { 4094 compile.options.useAnt = true 4095 compile.options.useDepend = IS_USE_DEPEND 4096 } else if (compile.options.hasProperty("incremental")) { 4097 compile.options.incremental = IS_INCREMENTAL 4098 } 4099 compile.options.debug = true // we always generate debugging info in the class files 4100 compile.options.debugOptions.debugLevel = IS_DEBUG_JAVA ? "source,lines,vars" : "source,lines" 4101 compile.options.fork = true 4102 4103 compile.options.forkOptions.executable = JAVAC 4104 4105 compile.options.warnings = IS_LINT 4106 4107 compile.options.compilerArgs += ["-XDignore.symbol.file", "-encoding", "UTF-8"] 4108 4109 // we use a custom javadoc command 4110 project.javadoc.enabled = false 4111 4112 // Add in the -Xlint options 4113 if (IS_LINT) { 4114 LINT.split("[, ]").each { s -> 4115 compile.options.compilerArgs += "-Xlint:$s" 4116 } 4117 } 4118 } // tasks with javaCompile 4119 4120 // If I am a module.... 4121 if (project.hasProperty('moduleSourcePath') && 4122 (project.hasProperty('buildModule') && project.buildModule)) { 4123 project.compileJava { 4124 options.compilerArgs.addAll([ 4125 '-implicit:none', 4126 '--module-source-path', project.moduleSourcePath 4127 ]) 4128 } 4129 // no jars needed for modules 4130 project.jar.enabled = false 4131 4132 // and redirect the resources into the module 4133 project.processResources.destinationDir = project.moduleDir 4134 } 4135 4136 if (project.hasProperty('moduleSourcePathShim') && 4137 project.sourceSets.hasProperty('shims')) { 4138 4139 // sync up the obvious source directories with the shims 4140 // others (like the shaders in graphics) should be added in there 4141 project.sourceSets.shims.java.srcDirs += project.sourceSets.main.java.srcDirs 4142 project.sourceSets.shims.java.srcDirs += "$buildDir/gensrc/java" 4143 4144 project.compileShimsJava { 4145 options.compilerArgs.addAll([ 4146 '-implicit:none', 4147 '--module-source-path', project.moduleSourcePathShim 4148 ]) 4149 } 4150 project.compileShimsJava.dependsOn(project.compileJava) 4151 4152 def copyGeneratedShimsTask = task("copyGeneratedShims", type: Copy, dependsOn: [compileShimsJava, processShimsResources]) { 4153 from project.sourceSets.shims.java.outputDir 4154 into "${rootProject.buildDir}/shims" 4155 if (HAS_JAVAFX_MODULES) { 4156 exclude("*/module-info.class") 4157 } 4158 } 4159 4160 project.processShimsResources.dependsOn(project.processResources) 4161 4162 // shims resources should have the main resouces as a base 4163 project.sourceSets.shims.resources.srcDirs += project.sourceSets.main.resources.srcDirs 4164 4165 // and redirect the resources into the module 4166 project.processShimsResources.destinationDir = project.moduleShimsDir 4167 4168 compileTestJava.dependsOn(copyGeneratedShimsTask) 4169 } 4170 4171 if (project.hasProperty('modulePathArgs')) { 4172 project.compileJava.options.compilerArgs.addAll(modulePathArgs) 4173 } 4174 4175 if (project.hasProperty('testModulePathArgs')) { 4176 project.compileTestJava.options.compilerArgs.addAll(testModulePathArgs) 4177 } 4178 4179 if (project.hasProperty('testPatchModuleArgs')) { 4180 project.test.jvmArgs += testPatchModuleArgs 4181 } 4182 4183 /* Note: we should not have to add extraAddExports to the normal 4184 * modular compile, as it contains all of the module-info files. 4185 * In fact doing so might cover up a module-info issue. 4186 * so we don't do it, and I will leave this commented out 4187 * block as a reminder of this fact. 4188 if (project.hasProperty('extraAddExports')) { 4189 project.compileJava.options.compilerArgs.addAll(extraAddExports); 4190 } 4191 */ 4192 4193 if (project.hasProperty('testAddExports')) { 4194 project.compileTestJava.options.compilerArgs.addAll(testAddExports); 4195 project.test.jvmArgs += testAddExports 4196 } 4197 4198 if (rootProject.hasProperty("EXTRA_TEST_ARGS") && project.hasProperty('test')) { 4199 EXTRA_TEST_ARGS.split(' ').each() { e -> 4200 project.test.jvmArgs += e 4201 } 4202 } 4203 4204 if (rootProject.hasProperty("EXTRA_COMPILE_ARGS") && project.hasProperty('compileJava')) { 4205 project.compileJava.options.compilerArgs.addAll(EXTRA_COMPILE_ARGS.split(' ')) 4206 } 4207 4208 if (rootProject.hasProperty("EXTRA_COMPILE_ARGS") && project.hasProperty('compileTestJava')) { 4209 project.compileTestJava.options.compilerArgs.addAll(EXTRA_COMPILE_ARGS.split(' ')) 4210 } 4211 4212 } 4213 4214 /****************************************************************************** 4215 * * 4216 * Top Level Tasks * 4217 * * 4218 * These are the tasks which are defined only for the top level project and * 4219 * not for any sub projects. These are generally the entry point that is * 4220 * used by Hudson and by the continuous build system. * 4221 * * 4222 *****************************************************************************/ 4223 4224 task clean() { 4225 group = "Basic" 4226 description = "Deletes the build directory and the build directory of all sub projects" 4227 getSubprojects().each { subProject -> 4228 dependsOn(subProject.getTasksByName("clean", true)); 4229 } 4230 doLast { 4231 delete(buildDir); 4232 } 4233 } 4234 4235 task cleanAll() { 4236 group = "Basic" 4237 description = "Scrubs the repo of build artifacts" 4238 dependsOn(clean) 4239 doLast { 4240 //delete(".gradle"); This causes problems on windows. 4241 delete("buildSrc/build"); 4242 } 4243 } 4244 4245 task createMSPfile() { 4246 group = "Build" 4247 File mspFile = new File(rootProject.buildDir,MODULESOURCEPATH) 4248 outputs.file(mspFile) 4249 4250 doLast { 4251 mspFile.delete() 4252 mspFile << "--module-source-path\n" 4253 mspFile << defaultModuleSourcePath 4254 mspFile << "\n" 4255 4256 if (!HAS_JAVAFX_MODULES) { 4257 appendQualExports(mspFile, qualExportsSwing) 4258 } 4259 } 4260 } 4261 4262 task javadoc(type: Javadoc, dependsOn: createMSPfile) { 4263 group = "Basic" 4264 description = "Generates the JavaDoc for all the public API" 4265 executable = JAVADOC 4266 def projectsToDocument = [ 4267 project(":base"), project(":graphics"), project(":controls"), project(":media"), 4268 project(":swing"), /*project(":swt"),*/ project(":fxml"), project(":web")] 4269 source(projectsToDocument.collect({ 4270 [it.sourceSets.main.java] 4271 })); 4272 setDestinationDir(new File(buildDir, 'javadoc')); 4273 4274 exclude("com/**/*", "Compile*", "javafx/builder/**/*", "javafx/scene/accessibility/**/*"); 4275 4276 options.tags("apiNote:a:API Note:") 4277 options.tags("implSpec:a:Implementation Requirements:") 4278 options.tags("implNote:a:Implementation Note:") 4279 options.tags("param") 4280 options.tags("return") 4281 options.tags("throws") 4282 options.tags("moduleGraph:X") 4283 options.tags("since") 4284 options.tags("version") 4285 options.tags("serialData") 4286 options.tags("factory") 4287 options.tags("see") 4288 4289 options.windowTitle("${javadocTitle}") 4290 options.header("${javadocHeader}") 4291 options.bottom("${javadocBottom}") 4292 options.locale("en"); 4293 if (JDK_DOCS_LINK != "") { 4294 options.linksOffline(JDK_DOCS, JDK_DOCS_LINK); 4295 } else { 4296 options.links(JDK_DOCS); 4297 } 4298 options.addBooleanOption("XDignore.symbol.file").setValue(true); 4299 options.addBooleanOption("Xdoclint:${DOC_LINT}").setValue(IS_DOC_LINT); 4300 options.addBooleanOption("html5").setValue(true); 4301 options.addBooleanOption("javafx").setValue(true); 4302 options.addBooleanOption("use").setValue(true); 4303 4304 options.setOptionFiles([ 4305 new File(rootProject.buildDir,MODULESOURCEPATH) 4306 ]); 4307 4308 doLast { 4309 projectsToDocument.each { p -> 4310 copy { 4311 from("$p.projectDir/src/main/docs") { 4312 include "**/*.html" 4313 filter { line-> 4314 line = line.replace("@FXVERSION@", RELEASE_VERSION) 4315 } 4316 } 4317 from("$p.projectDir/src/main/docs") { 4318 exclude "**/*.html" 4319 } 4320 4321 into "$buildDir/javadoc" 4322 } 4323 } 4324 } 4325 4326 dependsOn(projectsToDocument.collect { project -> project.getTasksByName("classes", true)}); 4327 } 4328 4329 task sdk() { 4330 if (DO_BUILD_SDK_FOR_TEST) { 4331 rootProject.getTasksByName("test", true).each { t -> 4332 if (t.enabled) t.dependsOn(sdk) 4333 } 4334 } 4335 } 4336 4337 task jmods() { 4338 dependsOn(sdk) 4339 // real work items added later. 4340 } 4341 4342 task appsjar() { 4343 dependsOn(sdk) 4344 // Note: the jar dependencies get added elsewhere see project(":apps") 4345 } 4346 4347 // these are empty tasks, allowing us to depend on the task, which may have other 4348 // real work items added later. 4349 task copyAppsArtifacts() { 4350 dependsOn(appsjar) 4351 } 4352 4353 task apps() { 4354 dependsOn(sdk) 4355 dependsOn(appsjar) 4356 dependsOn(copyAppsArtifacts) 4357 } 4358 4359 task findbugs() { 4360 dependsOn(sdk) 4361 4362 doLast { 4363 if (!BUILD_CLOSED) { 4364 println "findbugs task is only run for a closed build" 4365 } 4366 } 4367 } 4368 4369 // create the zip file of modules for a JDK build 4370 task jdkZip { 4371 dependsOn(sdk) 4372 } 4373 4374 // The following tasks are for the closed build only. They are a no-op for the open build 4375 4376 task checkCache() { 4377 dependsOn(updateCacheIfNeeded) 4378 } 4379 4380 task publicExports() { 4381 dependsOn(sdk, jmods, apps, javadoc, jdkZip) 4382 // note the real work is below in the compileTargets 4383 } 4384 4385 task perf() { 4386 dependsOn(sdk, apps) 4387 doLast { 4388 if (!BUILD_CLOSED) { 4389 println "perf task is only run for a closed build" 4390 } 4391 } 4392 } 4393 4394 task zips() { 4395 dependsOn(sdk, jmods, javadoc, apps, jdkZip, publicExports, perf) 4396 // note the real work is below in the compileTargets 4397 } 4398 4399 task all() { 4400 dependsOn(sdk,publicExports,apps,perf,zips) 4401 } 4402 4403 4404 // Construct list of subprojects that are modules 4405 ext.moduleProjList = [] 4406 subprojects { 4407 if (project.hasProperty("buildModule") && project.ext.buildModule) { 4408 rootProject.ext.moduleProjList += project 4409 println "module: $project (buildModule=YES)" 4410 } else { 4411 println "module: $project (buildModule=NO)" 4412 } 4413 } 4414 4415 4416 // Define the sdk task, which also produces the javafx.swt modular jar 4417 4418 compileTargets { t -> 4419 4420 def javafxSwtTask = task("javafxSwt$t.capital", type: Jar) { 4421 enabled = COMPILE_SWT 4422 group = "Basic" 4423 description = "Creates the javafx-swt.jar for the $t.name target" 4424 archiveName = "${project(":swt").buildDir}/libs/javafx-swt.jar"; 4425 includeEmptyDirs = false 4426 from("${project(":swt").buildDir}/classes/java/main"); 4427 include("**/javafx/embed/swt/**") 4428 4429 dependsOn( 4430 project(":swt").compileJava, 4431 project(":swt").processResources, 4432 // note: assemble and classes are not enough for DidWork 4433 project(":swt").classes, 4434 // classes is needed for a jar copy 4435 ) 4436 } 4437 4438 // FIXME: do we really need the index task for this modular jar? 4439 def javafxSwtIndexTask = task("javafxSwtIndex$t.capital") { 4440 //the following is a workaround for the lack of indexing in gradle 1.4 through 1.7 4441 dependsOn(javafxSwtTask) 4442 4443 doLast() { 4444 ant.jar (update: true, index: true, destfile: javafxSwtTask.archiveName) 4445 } 4446 } 4447 4448 def sdkTask = task("sdk$t.capital") { 4449 group = "Basic" 4450 dependsOn(javafxSwtIndexTask) 4451 } 4452 4453 sdk.dependsOn(sdkTask) 4454 } 4455 4456 project(":apps") { 4457 // The apps build is Ant based, we will exec ant from gradle. 4458 4459 // Download the Lucene libraries needed for the Ensemble8 app 4460 getConfigurations().create("lucene"); 4461 dependencies { 4462 lucene group: "org.apache.lucene", name: "lucene-core", version: "7.1.0" 4463 lucene group: "org.apache.lucene", name: "lucene-grouping", version: "7.1.0" 4464 lucene group: "org.apache.lucene", name: "lucene-queryparser", version: "7.1.0" 4465 } 4466 4467 // Copy Lucene libraries into the Ensemble8/lib directory 4468 File ensembleLibDir = rootProject.file("apps/samples/Ensemble8/lib"); 4469 def libNames = [ "lucene-core-7.1.0.jar", 4470 "lucene-grouping-7.1.0.jar", 4471 "lucene-queryparser-7.1.0.jar" ] 4472 4473 4474 task getLucene(type: Copy) { 4475 doFirst { 4476 ensembleLibDir.mkdirs(); 4477 } 4478 into ensembleLibDir 4479 includeEmptyDirs = false 4480 configurations.lucene.files.each { f -> 4481 libNames.each { name -> 4482 if (name == f.getName()) { 4483 from f.getPath() 4484 } 4485 } 4486 } 4487 } 4488 4489 compileTargets { t -> 4490 List<String> params = [] 4491 4492 params << "-DtargetBld=$t.name" 4493 4494 if (!rootProject.ext[t.upper].compileSwing) { 4495 params << "-DJFX_CORE_ONLY=true" 4496 } 4497 params << "-Dplatforms.JDK_1.9.home=${rootProject.ext.JDK_HOME}" 4498 params << "-Dcompile.patch=@${rootProject.buildDir}/${COMPILEARGSFILE}" 4499 params << "-Drun.patch=@${rootProject.buildDir}/${RUNARGSFILE}" 4500 4501 def appsJar = project.task("appsJar${t.capital}") { 4502 dependsOn(sdk, getLucene) 4503 doLast() { 4504 ant(t.name, 4505 projectDir.path, 4506 "appsJar", 4507 params); 4508 } 4509 } 4510 rootProject.appsjar.dependsOn(appsJar) 4511 4512 def appsClean = project.task("clean${t.capital}") { 4513 doLast() { 4514 ant(t.name, 4515 project.projectDir.path, 4516 "clean", 4517 params); 4518 delete(ensembleLibDir); 4519 } 4520 } 4521 rootProject.clean.dependsOn(appsClean) 4522 } 4523 } 4524 4525 // Tasks to create the disk layout for the sdk, jmods, and docs 4526 // in the artifacts directory (publicExports), and zip them up in 4527 // artifacts/bundles (zips) 4528 // These tasks are only used for the standalone SDK. 4529 compileTargets { t -> 4530 if (!HAS_JAVAFX_MODULES) { 4531 def targetProperties = rootProject.ext[t.upper] 4532 def platformPrefix = targetProperties.platformPrefix 4533 4534 def artifactsDir = "${rootProject.buildDir}/artifacts" 4535 def bundlesDir = "${artifactsDir}/bundles" 4536 4537 def sdkDirName = "${platformPrefix}sdk" 4538 def sdkDir = "${rootProject.buildDir}/${sdkDirName}" 4539 def sdkBundleName = "javafx-sdk-${RELEASE_VERSION}" 4540 def sdkArtifactsDir = "${artifactsDir}/${sdkBundleName}" 4541 4542 def docsDirName = "javadoc" 4543 def docsDir = "${rootProject.buildDir}/${docsDirName}" 4544 def docsBundleName = "javafx-docs-${RELEASE_VERSION}" 4545 def docsArtifactsDir = "${artifactsDir}/${docsBundleName}" 4546 4547 def jmodsDirName = "jmods" 4548 def jmodsDir = "${rootProject.buildDir}/${jmodsDirName}" 4549 def jmodsBundleName = "javafx-jmods-${RELEASE_VERSION}" 4550 def jmodsArtifactsDir = "${artifactsDir}/${jmodsBundleName}" 4551 4552 def publicExportsTask = task ("publicExportsStandalone${t.capital}") { 4553 group = "Basic" 4554 description = "Creates the disk layout for sdk, jmods, and docs" 4555 } 4556 publicExports.dependsOn(publicExportsTask) 4557 4558 def copyArtifactsSdkTask = task("copyArtifactsSdk$t.capital", type: Copy, dependsOn: [sdk,jmods,apps,javadoc]) { 4559 from sdkDir 4560 into sdkArtifactsDir 4561 } 4562 publicExportsTask.dependsOn(copyArtifactsSdkTask) 4563 4564 // Need to modify file permissions Windows to make sure that the 4565 // execute bit is set, and that the files are world readable 4566 def chmodArtifactsSdkTask = task("chmodArtifactsSdk$t.capital", dependsOn: copyArtifactsSdkTask) { 4567 if (IS_WINDOWS) { 4568 doLast { 4569 exec { 4570 workingDir(sdkArtifactsDir) 4571 commandLine("chmod", "-R", "755", ".") 4572 } 4573 } 4574 } 4575 } 4576 publicExportsTask.dependsOn(chmodArtifactsSdkTask) 4577 4578 def copyArtifactsDocsTask = task("copyArtifactsDocs$t.capital", type: Copy, dependsOn: chmodArtifactsSdkTask) { 4579 from docsDir 4580 into "${docsArtifactsDir}/api" 4581 } 4582 publicExportsTask.dependsOn(copyArtifactsDocsTask) 4583 4584 def copyArtifactsJmodsTask = task("copyArtifactsJmods$t.capital", type: Copy, dependsOn: copyArtifactsDocsTask) { 4585 from jmodsDir 4586 into "${jmodsArtifactsDir}" 4587 } 4588 publicExportsTask.dependsOn(copyArtifactsJmodsTask) 4589 4590 def zipsTask = task ("zipsStandalone${t.capital}") { 4591 group = "Basic" 4592 description = "Creates the public zip bundles" 4593 } 4594 zips.dependsOn(zipsTask) 4595 4596 // Use native zip tool so that file permissions are preserved on Windows 4597 def zipSdkTask = task("zipSdk$t.capital", dependsOn: publicExportsTask) { 4598 doLast { 4599 def outZipFile = "${bundlesDir}/${sdkBundleName}.zip" 4600 mkdir bundlesDir 4601 exec { 4602 workingDir(artifactsDir) 4603 commandLine("zip", "-q", "-r", outZipFile, sdkBundleName) 4604 } 4605 } 4606 } 4607 zipsTask.dependsOn(zipSdkTask) 4608 4609 def zipDocsTask = task("zipDocs$t.capital", type: Zip, dependsOn: zipSdkTask) { 4610 destinationDir = file("${bundlesDir}") 4611 archiveName = "${docsBundleName}.zip" 4612 includeEmptyDirs = false 4613 from docsArtifactsDir 4614 into "${docsBundleName}" 4615 } 4616 zipsTask.dependsOn(zipDocsTask) 4617 4618 def zipJmodsTask = task("zipJmods$t.capital", type: Zip, dependsOn: zipDocsTask) { 4619 destinationDir = file("${bundlesDir}") 4620 archiveName = "${jmodsBundleName}.zip" 4621 includeEmptyDirs = false 4622 from jmodsArtifactsDir 4623 into "${jmodsBundleName}" 4624 } 4625 zipsTask.dependsOn(zipJmodsTask) 4626 } 4627 } 4628 4629 4630 /****************************************************************************** 4631 * * 4632 * Modules * 4633 * * 4634 *****************************************************************************/ 4635 4636 ext.moduleDependencies = [file("dependencies")] 4637 4638 task buildModules { 4639 } 4640 4641 // Combine the classes, lib, and bin for each module 4642 compileTargets { t -> 4643 def targetProperties = project.ext[t.upper] 4644 4645 def platformPrefix = targetProperties.platformPrefix 4646 def bundledSdkDirName = "${platformPrefix}modular-sdk" 4647 def bundledSdkDir = "${rootProject.buildDir}/${bundledSdkDirName}" 4648 def modulesDir = "${bundledSdkDir}/modules" 4649 def modulesCmdsDir = "${bundledSdkDir}/modules_cmds" 4650 def modulesLibsDir = "${bundledSdkDir}/modules_libs" 4651 def modulesSrcDir = "${bundledSdkDir}/modules_src" 4652 def modulesConfDir = "${bundledSdkDir}/modules_conf" 4653 def modulesLegalDir = "${bundledSdkDir}/modules_legal" 4654 def modulesMakeDir = "${bundledSdkDir}/make" 4655 4656 final File runArgsFile = file("${rootProject.buildDir}/${RUNARGSFILE}") 4657 final File compileArgsFile = file("${rootProject.buildDir}/${COMPILEARGSFILE}") 4658 4659 project.files(runArgsFile); 4660 4661 def buildModulesTask = task("buildModules$t.capital", group: "Build") { 4662 // BUNDLED SDK 4663 4664 // Copy dependencies/*/module-info.java.extra 4665 // merging as needed, removing duplicates 4666 // only lines with 'exports' will be copied 4667 def dependencyRoots = moduleDependencies 4668 if (rootProject.hasProperty("closedModuleDepedencies")) { 4669 dependencyRoots = [dependencyRoots, closedModuleDepedencies].flatten() 4670 } 4671 4672 // Create the inputs/outputs list first to support UP-TO-DATE 4673 ArrayList outputNames = new ArrayList() 4674 dependencyRoots.each { root -> 4675 FileTree ft = fileTree(root).include('**/*.extra') 4676 ft.each() { e-> 4677 inputs.file(e) 4678 4679 String usename = e.path 4680 String filePath = e.getAbsolutePath() 4681 String folderPath = root.getAbsolutePath() 4682 if (filePath.startsWith(folderPath)) { 4683 usename = filePath.substring(folderPath.length() + 1); 4684 } 4685 if (! outputNames.contains(usename) ) { 4686 outputNames.add(usename) 4687 } 4688 } 4689 } 4690 4691 outputNames.each() { e-> 4692 File f = new File(modulesSrcDir, e) 4693 outputs.file(f) 4694 } 4695 4696 def outputPolicyDir = "${modulesConfDir}/java.base/security" 4697 def outputPolicyFile = file("${outputPolicyDir}/java.policy.extra") 4698 4699 outputs.file(outputPolicyFile) 4700 moduleProjList.each { project -> 4701 def policyDir = "${project.projectDir}/src/main/conf/security" 4702 def policyFile = file("${policyDir}/java.policy") 4703 if (policyFile.exists()) { 4704 inputs.file(policyFile) 4705 } 4706 } 4707 4708 doLast { 4709 Map extras = [:] 4710 4711 dependencyRoots.each { root -> 4712 FileTree ft = fileTree(root).include('**/*.extra') 4713 ft.each() { e-> 4714 String usename = e.path 4715 String filePath = e.getAbsolutePath() 4716 String folderPath = root.getAbsolutePath() 4717 if (filePath.startsWith(folderPath)) { 4718 usename = filePath.substring(folderPath.length() + 1); 4719 } 4720 if (extras.containsKey(usename)) { 4721 List<String> lines = extras.get(usename) 4722 e.eachLine { line -> 4723 line = line.trim() 4724 if (line.length() > 1 && Character.isLetter(line.charAt(0))) { 4725 lines << line 4726 } 4727 } 4728 4729 } else { 4730 List<String> lines = [] 4731 e.eachLine { line -> 4732 line = line.trim() 4733 if (line.length() > 1 && Character.isLetter(line.charAt(0))) { 4734 lines << line 4735 } 4736 } 4737 extras.put(usename,lines) 4738 } 4739 } 4740 } 4741 extras.keySet().each() { e-> 4742 File f = new File(modulesSrcDir, e) 4743 f.getParentFile().mkdirs() 4744 f.delete() 4745 4746 extras.get(e).unique().each() { l-> 4747 f << l 4748 f << "\n" 4749 } 4750 } 4751 4752 // concatecate java.policy files into a single file 4753 // 4754 mkdir outputPolicyDir 4755 outputPolicyFile.delete() 4756 moduleProjList.each { project -> 4757 def policyDir = "${project.projectDir}/src/main/conf/security" 4758 def policyFile = file("${policyDir}/java.policy") 4759 if (policyFile.exists()) outputPolicyFile << policyFile.text 4760 } 4761 } 4762 } 4763 buildModules.dependsOn(buildModulesTask) 4764 4765 // BUNDLED SDK 4766 moduleProjList.each { project -> 4767 // Copy classes, bin, and lib directories 4768 4769 def moduleName = project.ext.moduleName 4770 def buildDir = project.buildDir 4771 4772 def srcClassesDir = "${buildDir}/${platformPrefix}module-classes" 4773 def dstClassesDir = "${modulesDir}/${moduleName}" 4774 def copyClassFilesTask = project.task("copyClassFiles$t.capital", type: Copy, dependsOn: project.assemble) { 4775 from srcClassesDir 4776 into dstClassesDir 4777 exclude("module-info.class") 4778 } 4779 4780 def srcCmdsDir = "${buildDir}/${platformPrefix}module-bin" 4781 def dstCmdsDir = "${modulesCmdsDir}/${moduleName}" 4782 def copyBinFilesTask = project.task("copyBinFiles$t.capital", type: Copy, dependsOn: copyClassFilesTask) { 4783 from srcCmdsDir 4784 into dstCmdsDir 4785 } 4786 4787 def srcLibsDir = "${buildDir}/${platformPrefix}module-lib" 4788 def dstLibsDir = "${modulesLibsDir}/${moduleName}" 4789 def copyLibFilesTask = project.task("copyLibFiles$t.capital", type: Copy, dependsOn: copyBinFilesTask) { 4790 from srcLibsDir 4791 into dstLibsDir 4792 } 4793 4794 // Copy module sources 4795 // FIXME: javafx.swt sources? 4796 def copySources = project.hasProperty("includeSources") && project.includeSources 4797 def copySourceFilesTask = project.task("copySourceFiles$t.capital", type: Copy, dependsOn: copyLibFilesTask) { 4798 if (copySources) { 4799 from "${project.projectDir}/src/main/java" 4800 if (project.name.equals("base") || project.name.equals("swing")) { 4801 from "${project.projectDir}/build/gensrc/java" 4802 } 4803 if (project.name.equals("web")) { 4804 from "${project.projectDir}/src/main/native/Source/WebCore/bindings/java/dom3/java" 4805 } 4806 } else { 4807 from "${project.projectDir}/src/main/java/module-info.java" 4808 } 4809 into "${modulesSrcDir}/${moduleName}" 4810 include "**/*.java" 4811 if (!HAS_UNSUPPORTED_DESKTOP) { 4812 exclude("com/sun/javafx/embed/swing/newimpl/**") 4813 } 4814 4815 if (project.hasProperty("sourceFilter")) { 4816 filter(project.sourceFilter) 4817 } 4818 } 4819 4820 // Copy .html and other files needed for doc bundles 4821 def copyDocFiles = project.task("copyDocFiles$t.capital", type: Copy, dependsOn: copySourceFilesTask) { 4822 if (copySources) { 4823 from("${project.projectDir}/src/main/docs") { 4824 include "**/*.html" 4825 filter { line-> 4826 line = line.replace("@FXVERSION@", RELEASE_VERSION) 4827 } 4828 } 4829 from("${project.projectDir}/src/main/docs") { 4830 exclude "**/*.html" 4831 } 4832 from("${project.projectDir}/src/main/java") { 4833 exclude "**/*.java" 4834 } 4835 4836 into "${modulesSrcDir}/${moduleName}" 4837 } 4838 } 4839 4840 // Copy make/build.properties 4841 def srcMakeDir = "${project.projectDir}/make" 4842 def dstMakeDir = "${modulesMakeDir}/${moduleName}" 4843 def copyBuildPropertiesTask = project.task("copyBuildProperties$t.capital", type: Copy, dependsOn: copyDocFiles) { 4844 from srcMakeDir 4845 into dstMakeDir 4846 } 4847 4848 // Copy legal files 4849 def srcLegalDir = "${project.projectDir}/src/main/legal" 4850 def dstLegalDir = "${modulesLegalDir}/${moduleName}" 4851 def copyLegalTask = project.task("copyLegal$t.capital", type: Copy, dependsOn: copyBuildPropertiesTask) { 4852 from srcLegalDir 4853 into dstLegalDir 4854 4855 // Exclude ANGLE since we (currently) do not use it 4856 exclude("angle.md") 4857 } 4858 4859 buildModulesTask.dependsOn( 4860 copyClassFilesTask, 4861 copyLibFilesTask, 4862 copySourceFilesTask, 4863 copyDocFiles, 4864 copyBuildPropertiesTask, 4865 copyLegalTask) 4866 } 4867 4868 // ============================================================ 4869 4870 def standaloneSdkDirName = "${platformPrefix}sdk" 4871 def standaloneSdkDir = "${rootProject.buildDir}/${standaloneSdkDirName}" 4872 def standaloneLibDir = "${standaloneSdkDir}/lib" 4873 def libDest=targetProperties.libDest 4874 def standaloneNativeDir = "${standaloneSdkDir}/${libDest}" 4875 def standaloneLegalDir = "${standaloneSdkDir}/legal" 4876 def standaloneSrcZipName = "src.zip" 4877 4878 // STANDALONE SDK 4879 moduleProjList.each { project -> 4880 // Copy classes, bin, and lib directories 4881 4882 def moduleName = project.ext.moduleName 4883 def buildDir = project.buildDir 4884 4885 // Create modular jars 4886 def srcClassesDir = "${buildDir}/${platformPrefix}module-classes" 4887 def dstModularJarDir = "${standaloneLibDir}" 4888 def modularJarName = "${moduleName}.jar" 4889 def modularJarTask = project.task("modularJarStandalone$t.capital", type: Jar, dependsOn: project.assemble) { 4890 destinationDir = file("${dstModularJarDir}") 4891 archiveName = modularJarName 4892 includeEmptyDirs = false 4893 from srcClassesDir 4894 } 4895 4896 // Copy native libraries 4897 def srcNativeDir = "${buildDir}/${platformPrefix}module-lib" 4898 def dstNativeDir = "${standaloneNativeDir}" 4899 def copyNativeFilesTask = project.task("copyNativeFilesStandalone$t.capital", type: Copy, dependsOn: modularJarTask) { 4900 from srcNativeDir 4901 into dstNativeDir 4902 include("*.dll") 4903 } 4904 4905 // Copy other lib files 4906 def srcLibsDir = "${buildDir}/${platformPrefix}module-lib" 4907 def dstLibsDir = "${standaloneLibDir}" 4908 def copyLibFilesTask = project.task("copyLibFilesStandalone$t.capital", type: Copy, dependsOn: copyNativeFilesTask) { 4909 from srcLibsDir 4910 into dstLibsDir 4911 exclude("*.dll") 4912 } 4913 4914 // Copy legal files 4915 def licenseFiles = [ "ADDITIONAL_LICENSE_INFO", "ASSEMBLY_EXCEPTION", "LICENSE" ] 4916 def srcLegalDir = "${project.projectDir}/src/main/legal" 4917 def dstLegalDir = "${standaloneLegalDir}/${moduleName}" 4918 def copyLegalTask = project.task("copyLegalStandalone$t.capital", type: Copy, dependsOn: copyLibFilesTask) { 4919 4920 def rtDir = rootProject.file('.') 4921 licenseFiles.each { lFile -> 4922 from "${rtDir}/${lFile}" 4923 } 4924 4925 from srcLegalDir 4926 4927 into dstLegalDir 4928 4929 // Exclude ANGLE since we (currently) do not use it 4930 exclude("angle.md") 4931 } 4932 4933 buildModulesTask.dependsOn( 4934 modularJarTask, 4935 copyNativeFilesTask, 4936 copyLibFilesTask, 4937 copyLegalTask) 4938 } 4939 4940 // Zip module sources for standalone SDK 4941 // 4942 // NOTE: the input is taken from the modular-sdk/modules_src dir 4943 // so that we don't have to duplicate the logic and create another 4944 // temporary directory. This is somewhat inelegant, since the bundled sdk 4945 // and the standalone sdk should be independent of one another, but seems 4946 // better than the alternatives. 4947 def zipSourceFilesTask = project.task("zipSourceFilesStandalone$t.capital", type: Zip, dependsOn: buildModulesTask) { 4948 destinationDir = file("${standaloneLibDir}") 4949 archiveName = standaloneSrcZipName 4950 includeEmptyDirs = false 4951 from modulesSrcDir 4952 include "**/*.java" 4953 } 4954 buildModules.dependsOn(zipSourceFilesTask) 4955 4956 // ============================================================ 4957 4958 def buildRunArgsTask = task("buildRunArgs$t.capital", 4959 group: "Build", dependsOn: buildModulesTask) { 4960 outputs.file(runArgsFile); 4961 inputs.file(EXTRAADDEXPORTS); 4962 doLast() { 4963 List<String>modpath = [] 4964 List<String>modnames = [] 4965 4966 moduleProjList.each { project -> 4967 def moduleName = project.ext.moduleName 4968 def dstModuleDir = cygpath("${modulesDir}/${moduleName}") 4969 if (HAS_JAVAFX_MODULES) { 4970 modpath << "${moduleName}=${dstModuleDir}" 4971 } else { 4972 modnames << moduleName 4973 } 4974 } 4975 4976 if (HAS_JAVAFX_MODULES) { 4977 writeRunArgsFile(runArgsFile, computeLibraryPath(true), modpath, null) 4978 writeRunArgsFile(compileArgsFile, null, modpath, null) 4979 4980 if (rootProject.hasProperty("EXTRA_ADDEXPORTS_STRING")) { 4981 runArgsFile << EXTRA_ADDEXPORTS_STRING 4982 compileArgsFile << EXTRA_ADDEXPORTS_STRING 4983 } 4984 } else { 4985 modpath = [ cygpath("${standaloneLibDir}") ] 4986 writeRunArgsFile(runArgsFile, null, modpath, modnames) 4987 writeRunArgsFile(compileArgsFile, null, modpath, modnames) 4988 } 4989 } 4990 } 4991 buildModules.dependsOn(buildRunArgsTask) 4992 4993 def isWindows = IS_WINDOWS && t.name == "win"; 4994 def isMac = IS_MAC && t.name == "mac"; 4995 4996 // Create layout for modular classes 4997 moduleProjList.each { project -> 4998 def buildModuleClassesTask = project.task("buildModule$t.capital", group: "Build", type: Copy) { 4999 dependsOn(project.assemble) 5000 def buildDir = project.buildDir 5001 def sourceBuildDirs = [ 5002 "${buildDir}/classes/java/main/${project.moduleName}", 5003 ] 5004 5005 def moduleClassesDir = "$buildDir/${platformPrefix}module-classes" 5006 includeEmptyDirs = false 5007 sourceBuildDirs.each { d -> 5008 from d 5009 } 5010 into moduleClassesDir 5011 5012 // Exclude obsolete, experimental, or non-shipping code 5013 exclude("version.rc") 5014 exclude("com/sun/glass/ui/swt") 5015 exclude("com/sun/javafx/tools/ant") 5016 exclude("com/javafx/main") 5017 exclude("com/sun/javafx/webkit/drt") 5018 if (!IS_INCLUDE_NULL3D) { 5019 exclude ("com/sun/prism/null3d") 5020 } 5021 if (!IS_INCLUDE_ES2) { 5022 exclude("com/sun/prism/es2", 5023 "com/sun/scenario/effect/impl/es2") 5024 } 5025 5026 // Exclude platform-specific classes for other platforms 5027 5028 if (!isMac) { 5029 exclude ("com/sun/media/jfxmediaimpl/platform/osx", 5030 "com/sun/prism/es2/MacGL*", 5031 "com/sun/glass/events/mac", 5032 "com/sun/glass/ui/mac", 5033 ) 5034 } 5035 5036 if (!isWindows) { 5037 exclude ("**/*.hlsl", 5038 "com/sun/glass/ui/win", 5039 "com/sun/prism/d3d", 5040 "com/sun/prism/es2/WinGL*", 5041 "com/sun/scenario/effect/impl/hw/d3d" 5042 ) 5043 } 5044 5045 if (!targetProperties.includeGTK) { //usually IS_LINUX 5046 exclude ( 5047 "com/sun/glass/ui/gtk", 5048 "com/sun/prism/es2/EGL*", 5049 "com/sun/prism/es2/X11GL*" 5050 ) 5051 } 5052 5053 if (!targetProperties.includeEGL) { 5054 exclude ("com/sun/prism/es2/EGL*") 5055 } 5056 5057 if (!targetProperties.includeMonocle) { 5058 exclude ("com/sun/glass/ui/monocle") 5059 exclude("com/sun/prism/es2/Monocle*") 5060 } 5061 5062 if (t.name != 'ios') { 5063 exclude ("com/sun/media/jfxmediaimpl/platform/ios", 5064 "com/sun/glass/ui/ios", 5065 "com/sun/prism/es2/IOS*" 5066 ) 5067 } 5068 5069 if (t.name != 'android' && t.name != 'dalvik') { 5070 exclude ("com/sun/glass/ui/android") 5071 } 5072 5073 // Filter out other platform-specific classes 5074 if (targetProperties.containsKey('jfxrtJarExcludes')) { 5075 exclude(targetProperties.jfxrtJarExcludes) 5076 } 5077 5078 /* FIXME: JIGSAW -- handle this in the module itself 5079 String webbld = project(":web").buildDir.path 5080 String ctrlbld = project(":controls").buildDir.path 5081 if (t.name == 'android') { 5082 from ("${webbld}/classes/android", 5083 "${webbld}/resources/android", 5084 "${ctrlbld}/classes/android", 5085 "${ctrlbld}/resources/android") 5086 } else if (t.name == 'ios') { 5087 from ("${webbld}/classes/ios", 5088 "${webbld}/resources/ios") 5089 } else { 5090 from ("${webbld}/classes/java/main") 5091 } 5092 */ 5093 } 5094 buildModulesTask.dependsOn(buildModuleClassesTask) 5095 } 5096 5097 def buildModuleLibsTask = task("buildModuleLibs$t.capital") { 5098 group = "Basic" 5099 5100 def baseProject = project(":base"); 5101 5102 def graphicsProject = project(":graphics"); 5103 5104 def mediaProject = project(":media"); 5105 5106 def webProject = project(":web"); 5107 dependsOn(webProject.assemble) 5108 5109 def swtProject = project(":swt"); 5110 5111 def packagerProject = project(":fxpackager"); 5112 dependsOn(packagerProject.assemble) 5113 dependsOn(packagerProject.jar) 5114 dependsOn(project(":fxpackagerservices").jar) 5115 5116 def library = targetProperties.library 5117 5118 def useLipo = targetProperties.containsKey('useLipo') ? targetProperties.useLipo : false 5119 def modLibDest = targetProperties.modLibDest 5120 def moduleNativeDirName = "${platformPrefix}module-$modLibDest" 5121 5122 def buildModuleBaseTask = task("buildModuleBase$t.capital", dependsOn: baseProject.assemble) { 5123 group = "Basic" 5124 description = "creates javafx.base property files" 5125 5126 def moduleLibDir = "${baseProject.buildDir}/${platformPrefix}module-lib" 5127 final File javafxProperties = file("${moduleLibDir}/javafx.properties") 5128 outputs.file(javafxProperties) 5129 5130 if (targetProperties.containsKey("javafxPlatformProperties")) { 5131 final File javafxPlatformProperties = file("${moduleLibDir}/javafx.platform.properties") 5132 outputs.file(javafxPlatformProperties) 5133 } 5134 5135 doLast { 5136 mkdir moduleLibDir 5137 5138 javafxProperties.delete() 5139 javafxProperties << "javafx.version=$RELEASE_VERSION_SHORT"; 5140 javafxProperties << "\n" 5141 javafxProperties << "javafx.runtime.version=$RELEASE_VERSION_LONG"; 5142 javafxProperties << "\n" 5143 javafxProperties << "javafx.runtime.build=$PROMOTED_BUILD_NUMBER"; 5144 javafxProperties << "\n" 5145 // Include any properties that have been defined (most likely in 5146 // one of the various platform gradle files) 5147 if (targetProperties.containsKey("javafxProperties")) { 5148 javafxProperties << targetProperties.javafxProperties 5149 javafxProperties << "\n" 5150 } 5151 5152 // Embedded builds define this file as well 5153 if (targetProperties.containsKey("javafxPlatformProperties")) { 5154 final File javafxPlatformProperties = file("${moduleLibDir}/javafx.platform.properties") 5155 javafxPlatformProperties.delete() 5156 javafxPlatformProperties << targetProperties.javafxPlatformProperties 5157 javafxPlatformProperties << "\n" 5158 } 5159 } 5160 } 5161 5162 def buildModuleGraphicsTask = task("buildModuleGraphics$t.capital", type: Copy, dependsOn: graphicsProject.assemble) { 5163 group = "Basic" 5164 description = "copies javafx.graphics native libraries" 5165 5166 into "${graphicsProject.buildDir}/${moduleNativeDirName}" 5167 5168 from("${graphicsProject.buildDir}/libs/jsl-decora/${t.name}/${library(targetProperties.decora.lib)}") 5169 def libs = ['font', 'prism', 'prismSW', 'glass', 'iio'] 5170 if (IS_INCLUDE_ES2) { 5171 libs += ['prismES2']; 5172 } 5173 if (IS_COMPILE_PANGO) { 5174 libs += ['fontFreetype', 'fontPango']; 5175 } 5176 libs.each { lib -> 5177 def variants = targetProperties[lib].containsKey('variants') && !useLipo ? targetProperties[lib].variants : [null] 5178 variants.each { variant -> 5179 def variantProperties = variant ? targetProperties[lib][variant] : targetProperties[lib] 5180 from ("${graphicsProject.buildDir}/libs/$lib/$t.name/${library(variantProperties.lib)}") 5181 } 5182 } 5183 if (IS_WINDOWS) { 5184 from ("${graphicsProject.buildDir}/libs/prismD3D/${t.name}/${library(targetProperties.prismD3D.lib)}"); 5185 targetProperties.VS2017DLLs.each { vslib -> 5186 from ("$vslib"); 5187 } 5188 targetProperties.WinSDKDLLs.each { winsdklib -> 5189 from ("$winsdklib"); 5190 } 5191 } 5192 } 5193 5194 def buildModuleMediaTask = task("buildModuleMedia$t.capital", type: Copy, dependsOn: mediaProject.assemble) { 5195 group = "Basic" 5196 description = "copies javafx.media native libraries" 5197 5198 into "${mediaProject.buildDir}/${moduleNativeDirName}" 5199 5200 def mediaBuildType = project(":media").ext.buildType 5201 if (IS_COMPILE_MEDIA) { 5202 [ "fxplugins", "gstreamer-lite", "jfxmedia" ].each { name -> 5203 from ("${mediaProject.buildDir}/native/${t.name}/${mediaBuildType}/${library(name)}") } 5204 5205 if (t.name == "mac") { 5206 // OSX media natives 5207 [ "jfxmedia_qtkit", "jfxmedia_avf", "glib-lite" ].each { name -> 5208 from ("${mediaProject.buildDir}/native/${t.name}/${mediaBuildType}/${library(name)}") } 5209 } else if (t.name == "linux") { 5210 from("${mediaProject.buildDir}/native/${t.name}/${mediaBuildType}") { include "libavplugin*.so" } 5211 } else from ("${mediaProject.buildDir}/native/${t.name}/${mediaBuildType}/${library("glib-lite")}") 5212 } else { 5213 if (t.name != "android" && t.name != "dalvik" ) { 5214 [ "fxplugins", "gstreamer-lite", "jfxmedia" ].each { name -> 5215 from ("$MEDIA_STUB/${library(name)}") } 5216 } 5217 5218 if (t.name == "mac") { 5219 // copy libjfxmedia_{avf,qtkit}.dylib if they exist 5220 [ "jfxmedia_qtkit", "jfxmedia_avf", "glib-lite" ].each { name -> 5221 from ("$MEDIA_STUB/${library(name)}") } 5222 } else if (t.name == "linux") { 5223 from(MEDIA_STUB) { include "libavplugin*.so" } 5224 } 5225 else if (t.name != "android" && t.name != "dalvik" ) { 5226 from ("$MEDIA_STUB/${library("glib-lite")}") 5227 } 5228 } 5229 } 5230 5231 def buildModuleWeb = task("buildModuleWeb$t.capital", type: Copy, dependsOn: webProject.assemble) { 5232 group = "Basic" 5233 description = "copies javafx.web native libraries" 5234 5235 into "${webProject.buildDir}/${moduleNativeDirName}" 5236 5237 if (IS_COMPILE_WEBKIT) { 5238 from ("${webProject.buildDir}/libs/${t.name}/${library('jfxwebkit')}") 5239 } else { 5240 if (t.name != "android" && t.name != "ios" && t.name != "dalvik") { 5241 from ("$WEB_STUB/${library('jfxwebkit')}") 5242 } 5243 } 5244 } 5245 5246 def buildModuleSWT = task("buildModuleSWT$t.capital", type: Copy) { 5247 group = "Basic" 5248 description = "copies SWT JAR" 5249 5250 // FIXME: the following is a hack to workaround the fact that there 5251 // is no way to deliver javafx-swt.jar other than in one of the 5252 // existing runtime modules. 5253 5254 dependsOn(buildModuleGraphicsTask) // we copy to the graphics module 5255 5256 if (COMPILE_SWT) { 5257 def javafxSwtIndexTask = tasks.getByName("javafxSwtIndex${t.capital}"); 5258 dependsOn(javafxSwtIndexTask) 5259 //enabled = COMPILE_SWT 5260 } 5261 5262 // Copy javafx-swt.jar to the javafx-graphics module lib dir 5263 from "${swtProject.buildDir}/libs/javafx-swt.jar" 5264 into "${graphicsProject.buildDir}/${platformPrefix}module-lib" 5265 } 5266 5267 def buildModulePackagerLibs = task("buildModulePackagerLibs$t.capital", 5268 type: Copy, 5269 dependsOn: [ packagerProject.assemble, project(":fxpackagerservices").assemble ]) { 5270 group = "Basic" 5271 description = "copies jdk.packager libraries" 5272 5273 from "${packagerProject.buildDir}/libs" 5274 into "${packagerProject.buildDir}/${platformPrefix}module-lib" 5275 } 5276 5277 def buildModulePackagerExes = task("buildModulePackagerExe$t.capital", 5278 type: Copy, 5279 dependsOn: [ packagerProject.assemble, project(":fxpackagerservices").assemble ]) { 5280 group = "Basic" 5281 description = "copies jdk.packager executable" 5282 5283 // Copy over the javapackager executable 5284 enabled = (t.name == "win" || t.name == "linux" || t.name == "mac") 5285 5286 from "${packagerProject.buildDir}/javapackager" 5287 into "${packagerProject.buildDir}/${platformPrefix}module-bin" 5288 } 5289 5290 dependsOn( 5291 buildModuleBaseTask, 5292 buildModuleGraphicsTask, 5293 buildModuleMediaTask, 5294 buildModuleWeb, 5295 buildModuleSWT, 5296 buildModulePackagerLibs, 5297 buildModulePackagerExes 5298 ) 5299 } 5300 buildModulesTask.dependsOn(buildModuleLibsTask) 5301 5302 def zipTask = project.task("buildModuleZip$t.capital", type: Zip, group: "Build", 5303 dependsOn: buildModulesTask ) { 5304 5305 // FIXME: JIGSAW -- this should be moved to a sub-directory so we can keep the same name 5306 def jfxBundle = "${platformPrefix}javafx-exports.zip" 5307 5308 doFirst() { 5309 file("${rootProject.buildDir}/${jfxBundle}").delete() 5310 } 5311 5312 archiveName = jfxBundle 5313 destinationDir = file("${rootProject.buildDir}") 5314 includeEmptyDirs = false 5315 from "${bundledSdkDir}" 5316 } 5317 jdkZip.dependsOn(zipTask) 5318 5319 Task testArgFiles = task("createTestArgfiles${t.capital}") { 5320 5321 File testRunArgsFile = new File(rootProject.buildDir, TESTRUNARGSFILE) 5322 //test (shimed) version 5323 File testCompileArgsFile = new File(rootProject.buildDir, TESTCOMPILEARGSFILE) 5324 // And a test java.policy file 5325 File testJavaPolicyFile = new File(rootProject.buildDir, TESTJAVAPOLICYFILE) 5326 // and the non-test version to go with run.args 5327 File runJavaPolicyFile = new File(rootProject.buildDir, RUNJAVAPOLICYFILE); 5328 5329 outputs.file(testRunArgsFile) 5330 outputs.file(testCompileArgsFile) 5331 outputs.file(testJavaPolicyFile) 5332 outputs.file(runJavaPolicyFile) 5333 inputs.file(EXTRAADDEXPORTS); 5334 5335 doLast() { 5336 rootProject.buildDir.mkdir() 5337 5338 List<String> projNames = [] 5339 moduleProjList.each { project -> 5340 projNames << project.name 5341 } 5342 5343 // And the test (shimed) variation... 5344 5345 testRunArgsFile.delete() 5346 testCompileArgsFile.delete() 5347 5348 testJavaPolicyFile.delete() 5349 runJavaPolicyFile.delete() 5350 5351 List<String> modpath = [] 5352 5353 if (HAS_JAVAFX_MODULES) { 5354 moduleProjList.each { project -> 5355 if (project.hasProperty("moduleName") && project.buildModule) { 5356 File dir; 5357 if (project.sourceSets.hasProperty('shims')) { 5358 dir = new File(rootProject.buildDir, "shims/${project.ext.moduleName}") 5359 } else { 5360 dir = new File(rootProject.buildDir, "modular-sdk/modules/${project.ext.moduleName}") 5361 } 5362 5363 def dstModuleDir = cygpath(dir.path) 5364 modpath << "${project.ext.moduleName}=${dstModuleDir}" 5365 5366 String themod = dir.toURI() 5367 testJavaPolicyFile << "grant codeBase \"${themod}\" {\n" + 5368 " permission java.security.AllPermission;\n" + 5369 "};\n" 5370 5371 dir = new File(rootProject.buildDir, "modular-sdk/modules/${project.ext.moduleName}") 5372 themod = dir.toURI() 5373 runJavaPolicyFile << "grant codeBase \"${themod}\" {\n" + 5374 " permission java.security.AllPermission;\n" + 5375 "};\n" 5376 } 5377 } 5378 5379 writeRunArgsFile(testCompileArgsFile, null, modpath, null) 5380 writeRunArgsFile(testRunArgsFile, computeLibraryPath(true), modpath, null) 5381 5382 if (rootProject.hasProperty("EXTRA_ADDEXPORTS_STRING")) { 5383 testCompileArgsFile << EXTRA_ADDEXPORTS_STRING 5384 testRunArgsFile << EXTRA_ADDEXPORTS_STRING 5385 } 5386 } else { 5387 def modnames = [] 5388 moduleProjList.each { project -> 5389 if (project.hasProperty("moduleName") && project.buildModule) { 5390 modnames << project.ext.moduleName 5391 File dir; 5392 if (project.sourceSets.hasProperty('shims')) { 5393 dir = new File(rootProject.buildDir, "shims/${project.ext.moduleName}") 5394 } else { 5395 dir = new File(rootProject.buildDir, "sdk/lib/${project.ext.moduleName}.jar") 5396 } 5397 5398 def dstModuleDir = cygpath(dir.path) 5399 modpath << "${dstModuleDir}" 5400 5401 String themod = dir.toURI() 5402 testJavaPolicyFile << "grant codeBase \"${themod}\" {\n" + 5403 " permission java.security.AllPermission;\n" + 5404 "};\n" 5405 5406 dir = new File(rootProject.buildDir, "sdk/lib/${project.ext.moduleName}.jar") 5407 themod = dir.toURI() 5408 runJavaPolicyFile << "grant codeBase \"${themod}\" {\n" + 5409 " permission java.security.AllPermission;\n" + 5410 "};\n" 5411 } 5412 } 5413 5414 writeRunArgsFile(testCompileArgsFile, null, modpath, modnames) 5415 writeRunArgsFile(testRunArgsFile, computeLibraryPath(true), modpath, modnames) 5416 5417 appendQualExports(testCompileArgsFile, qualExportsSwing) 5418 appendQualExports(testRunArgsFile, qualExportsSwing) 5419 } 5420 } 5421 } 5422 sdk.dependsOn(testArgFiles) 5423 createTestArgfiles.dependsOn(testArgFiles) 5424 5425 def sdkTask = tasks.getByName("sdk${t.capital}"); 5426 sdkTask.dependsOn(buildModulesTask) 5427 } 5428 sdk.dependsOn(buildModules) 5429 5430 // Build the jmod for each module for the standalone SDK only. 5431 compileTargets { t -> 5432 if (!HAS_JAVAFX_MODULES) { 5433 def targetProperties = project.ext[t.upper] 5434 5435 def platformPrefix = targetProperties.platformPrefix 5436 def jmodsDirName = "${platformPrefix}jmods" 5437 def jmodsDir = "${rootProject.buildDir}/${jmodsDirName}" 5438 def standaloneSdkDirName = "${platformPrefix}sdk" 5439 def standaloneSdkDir = "${rootProject.buildDir}/${standaloneSdkDirName}" 5440 def standaloneLegalDir = "${standaloneSdkDir}/legal" 5441 5442 moduleProjList.each { project -> 5443 def moduleName = project.ext.moduleName 5444 def buildDir = project.buildDir 5445 5446 def srcClassesDir = "${buildDir}/${platformPrefix}module-classes" 5447 def srcLibDir = "${buildDir}/${platformPrefix}module-lib" 5448 def srcLegalDir = "${standaloneLegalDir}/${moduleName}" 5449 5450 def jmodName = "${moduleName}.jmod" 5451 def jmodFile = "${jmodsDir}/${jmodName}" 5452 def jmodTask = project.task("jmod$t.capital", group: "Build", dependsOn: sdk) { 5453 doLast { 5454 mkdir jmodsDir 5455 delete(jmodFile); 5456 exec { 5457 commandLine(JMOD) 5458 args("create") 5459 args("--class-path") 5460 args(srcClassesDir) 5461 // Not all modules have a "lib" dir 5462 if (file(srcLibDir).isDirectory()) { 5463 args("--libs") 5464 args(srcLibDir) 5465 } 5466 args("--legal-notices") 5467 args(srcLegalDir) 5468 args(jmodFile) 5469 } 5470 } 5471 } 5472 5473 jmods.dependsOn(jmodTask) 5474 } 5475 } 5476 } 5477 5478 task checkrepo() { 5479 doLast { 5480 logger.info("checking for whitespace (open)"); 5481 exec { 5482 if (IS_WINDOWS) { 5483 commandLine 'bash', 'tools/scripts/checkWhiteSpace' 5484 } else { 5485 commandLine 'bash', 'tools/scripts/checkWhiteSpace', '-x' 5486 } 5487 } 5488 } 5489 } 5490 5491 task checkrepoall() { 5492 doLast { 5493 logger.info("checking for all whitespace (open)"); 5494 exec { 5495 if (IS_WINDOWS) { 5496 commandLine 'bash', 'tools/scripts/checkWhiteSpace', '-a' 5497 } else { 5498 commandLine 'bash', 'tools/scripts/checkWhiteSpace', '-x', '-a' 5499 } 5500 } 5501 } 5502 } 5503 5504 /****************************************************************************** 5505 * * 5506 * BUILD_CLOSED * 5507 * * 5508 * This next section should remain at the end of the build script. It allows * 5509 * for a "supplemental" gradle file to be used to extend the normal build * 5510 * structure. For example, this is used for passing a supplemental gradle * 5511 * file for producing official JavaFX builds. * 5512 * * 5513 *****************************************************************************/ 5514 5515 if (BUILD_CLOSED) { 5516 apply from: supplementalBuildFile 5517 } 5518 5519 task showFlags { 5520 } 5521 5522 compileTargets { t -> 5523 // Every platform must define these variables 5524 def props = project.ext[t.upper]; 5525 showFlags.dependsOn( 5526 project.task("showFlags$t.upper") { 5527 doLast() { 5528 println "Properties set for $t.upper" 5529 props.each { println it } 5530 } 5531 } 5532 ) 5533 5534 }