1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /**
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 * - is jfxrt.jar there?
35 * - does jfxrt.jar contain stuff it shouldn't (doc-files, iml, etc)
36 * - does jfxrt.jar contain stuff it should (bss files, etc)
37 * - Perform sanity checking to make sure a JDK exists with javac, javah, etc
38 * - Support building with no known JDK location, as long as javac, javah, etc are on the path
39 * - Check all of the native flags. We're adding weight to some libs that don't need it, and so forth.
40 *
41 * Additional projects to work on as we go:
42 * - Add "developer debug". This is where the natives do not have debug symbols, but the Java code does
43 * - The genVSproperties.bat doesn't find the directory where RC.exe lives. So it is hard coded. Might be a problem.
44 * - special tasks for common needs, such as:
45 * - updating copyright headers
46 * - stripping trailing whitespace (?)
47 * - checkstyle
48 * - findbugs
49 * - re needs?
50 * - sqe testing
51 * - API change check
52 * - Pushing results to a repo?
53 * - ServiceWithSecurityManagerTest fails to complete when run from gradle.
54 * - Integrate Parfait reports for C code
55 * - FXML Project tests are not running
56 */
57 defaultTasks = ["sdk"]
58
59 import java.util.concurrent.CountDownLatch
60 import java.util.concurrent.ExecutorService
61 import java.util.concurrent.Executors
62 import java.util.concurrent.Future
63
64 /******************************************************************************
65 * Utility methods *
66 *****************************************************************************/
67
68 /**
69 * If the given named property is not defined, then this method will define
70 * it with the given defaultValue. Any properties defined by this method can
71 * be substituted on the command line by using -P, or by specifying a
72 * gradle.properties file in the user home dir
73 *
74 * @param name The name of the property to define
75 * @param defaultValue The default value to assign the property
76 */
77 void defineProperty(String name, String defaultValue) {
78 if (!project.hasProperty(name)) {
79 project.ext.set(name, defaultValue);
80 }
81 }
82
83 /**
84 * If the given named property is not defined, then this method will attempt to
85 * look up the property in the props map, and use the defaultValue if it cannot be found.
86 *
87 * @param name The name of the property to look up and/or define
88 * @param props The properties to look for the named property in, if it has not already been defined
89 * @param defaultValue The default value if the property has not been defined and the
90 * props map does not contain the named property
91 */
92 void defineProperty(String name, Properties props, String defaultValue) {
93 if (!project.hasProperty(name)) {
94 project.ext.set(name, props.getProperty(name, defaultValue));
95 }
96 }
97
98 /**
99 * Converts cygwin style paths to windows style paths, but with a forward slash.
100 * This method is safe to call from any platform, and will only do work if
101 * called on Windows (in all other cases it simply returns the supplied path.
102 * In the future I would like to modify this so that it only does work if
103 * cygwin is installed, as I hope one day to remove the requirement to build
104 * with cygwin, but at present (due to GStreamer / Webkit) cygwin is needed
105 * anyway.
106 *
107 * @param path the path to convert
108 * @return the path converted to windows style, if on windows, otherwise it
109 * is the supplied path.
110 */
111 String cygpath(String path) {
112 if (!IS_WINDOWS) return path;
113 if (path == null || "".equals(path)) return path;
114 ByteArrayOutputStream out = new ByteArrayOutputStream();
115 logger.info("Converting path '$path' via cygpath")
116 exec {
117 standardOutput = out
118 commandLine "cmd", "/c", "cygpath", "-m", path
119 }
120 return out.toString().trim();
121 }
122
123 void loadProperties(String sourceFileName) {
124 def config = new Properties()
125 def propFile = new File(sourceFileName)
126 if (propFile.canRead()) {
127 config.load(new FileInputStream(propFile))
128 for (Map.Entry property in config) {
129 def keySplit = property.key.split("\\.");
130 def key = keySplit[0];
131 for (int i = 1; i < keySplit.length; i++) {
132 key = key + keySplit[i].capitalize();
133 }
134 ext[key] = property.value;
135 }
136 }
137 }
138
139 /**
140 * Struct used to contain some information passed to the closure
141 * passed to compileTargets.
142 */
143 class CompileTarget {
144 String name;
145 String upper;
146 String capital;
147 }
148
149 /**
150 * Iterates over each of the compile targets, passing the given closure
151 * a CompileTarget instance.
152 *
153 * @param c The closure to call
154 */
155 void compileTargets(Closure c) {
156 if (COMPILE_TARGETS == "") {
157 return
158 }
159 COMPILE_TARGETS.split(",").each { target ->
160 CompileTarget ct = new CompileTarget();
161 ct.name = target;
162 ct.upper = target.trim().toUpperCase(Locale.ROOT)
163 ct.capital = target.trim().capitalize()
164 c(ct)
165 }
166 }
167
168 /**
169 * Manages the execution of some closure which is responsible for producing
170 * content for a properties file built at build time and stored in the
171 * root project's $buildDir, and then loading that properties file and
172 * passing it to the processor closure.
173 *
174 * This is used on windows to produce a properties file containing all the
175 * windows visual studio paths and environment variables, and on Linux
176 * for storing the results of pkg-config calls.
177 *
178 * @param name the name of the file to produce
179 * @param loader a closure which is invoked, given the properties file. This
180 * closure is invoked only if the properties file needs to be created
181 * and is responsible for populating the properties file.
182 * @param processor a closure which is invoked every time this method is
183 * called and which will be given a Properties object, fully populated.
184 * The processor is then responsible for doing whatever it is that it
185 * must do with those properties (such as setting up environment
186 * variables used in subsequent native builds, or whatnot).
187 */
188 void setupTools(String name, Closure loader, Closure processor) {
189 // Check to see whether $buildDir/$name.properties file exists. If not,
190 // then generate it. Once generated, we need to read the properties file to
191 // help us define the defaults for this block of properties
192 File propFile = file("$buildDir/${name}.properties");
193 if (!propFile.exists()) {
194 // Create the properties file
195 propFile.getParentFile().mkdirs();
196 propFile.createNewFile();
197 loader(propFile);
198 }
199
200 // Try reading the properties in order to define the properties. If the property file cannot
201 // be located, then we will throw an exception because we cannot guess these values
202 InputStream propStream = null;
203 try {
204 Properties properties = new Properties();
205 propStream = new FileInputStream(propFile);
206 properties.load(propStream);
207 processor(properties);
208 } finally {
209 try { propStream.close() } catch (Exception e) { }
210 }
211 }
212
213 /**
214 * Fails the build with the specified error message
215 *
216 * @param msg the reason for the failure
217 */
218 void fail(String msg) {
219 throw new GradleException("FAIL: " + msg);
220 }
221
222 /******************************************************************************
223 * *
224 * Definition of project properties *
225 * *
226 * All properties defined using ext. are immediately available throughout *
227 * the script as variables that can be used. These variables are attached *
228 * to the root project (whereas if they were defined as def variables then *
229 * they would only be available within the root project scope). *
230 * *
231 * All properties defined using the "defineProperty" method can be replaced *
232 * on the command line by using the -P flag. For example, to override the *
233 * location of the binary plug, you would specify -PBINARY_PLUG=some/where *
234 * *
235 *****************************************************************************/
236
237 // If the ../rt-closed directory exists, then we are doing a closed build.
238 // In this case, build and property files will be read from
239 // ../rt-closed/closed-build.gradle and ../rt-closed/closed-properties.gradle
240 // respectively
241
242 def closedDir = file("../rt-closed")
243 def buildClosed = closedDir.isDirectory()
244 ext.BUILD_CLOSED = buildClosed
245
246 // These variables indicate what platform is running the build. Is
247 // this build running on a Mac, Windows, or Linux machine? 32 or 64 bit?
248 ext.OS_NAME = System.getProperty("os.name").toLowerCase()
249 ext.OS_ARCH = System.getProperty("os.arch")
250 ext.IS_64 = OS_ARCH.toLowerCase().contains("64")
251 ext.IS_MAC = OS_NAME.contains("mac") || OS_NAME.contains("darwin")
252 ext.IS_WINDOWS = OS_NAME.contains("windows")
253 ext.IS_LINUX = OS_NAME.contains("linux")
254
255 // Get the JDK_HOME automatically based on the version of Java used to execute gradle. Or, if specified,
256 // use a user supplied JDK_HOME, STUB_RUNTIME, JAVAC, and/or JAVAH, all of which may be specified
257 // independently (or we'll try to get the right one based on other supplied info). Sometimes the
258 // JRE might be the thing that is being used instead of the JRE embedded in the JDK, such as:
259 // c:\Program Files (x86)\Java\jdk1.8.0\jre
260 // c:\Program Files (x86)\Java\jre8\
261 // Because of this, you may sometimes get the jdk's JRE (in which case the logic we used to have here
262 // was correct and consistent with all other platforms), or it might be the standalone JRE (for the love!).
263 def envJavaHome = cygpath(System.getenv("JDK_HOME"))
264 if (envJavaHome == null || envJavaHome.equals("")) envJavaHome = cygpath(System.getenv("JAVA_HOME"))
265 def javaHome = envJavaHome == null || envJavaHome.equals("") ? System.getProperty("java.home") : envJavaHome
266 def javaHomeFile = file(javaHome)
267 defineProperty("JDK_HOME",
268 javaHomeFile.name == "jre" ?
269 javaHomeFile.getParent().toString() :
270 javaHomeFile.name.startsWith("jre") ?
271 new File(javaHomeFile.getParent(), "jdk1.${javaHomeFile.name.substring(3)}.0").toString() :
272 javaHome) // we have to bail and set it to something and this is as good as any!
273 ext.JAVA_HOME = JDK_HOME
274 defineProperty("JAVA", cygpath("$JDK_HOME/bin/java${IS_WINDOWS ? '.exe' : ''}"))
275 defineProperty("JAVAC", cygpath("$JDK_HOME/bin/javac${IS_WINDOWS ? '.exe' : ''}"))
276 defineProperty("JAVAH", cygpath("$JDK_HOME/bin/javah${IS_WINDOWS ? '.exe' : ''}"))
277 defineProperty("JAVADOC", cygpath("$JDK_HOME/bin/javadoc${IS_WINDOWS ? '.exe' : ''}"))
278 defineProperty("JDK_DOCS", "http://download.oracle.com/javase/7/docs/api")
279
280 defineProperty("javaRuntimeVersion", System.getProperty("java.runtime.version"))
281 defineProperty("javaVersion", javaRuntimeVersion.split("[_\\-]")[0])
282 defineProperty("javaBuildNumber", javaRuntimeVersion.substring(javaRuntimeVersion.lastIndexOf("-b") + 2))
283
284 loadProperties("$projectDir/build.properties")
285
286 def String closedCacheStubRuntime = cygpath("$projectDir") + "/../caches/sdk/rt"
287 defineProperty("STUB_RUNTIME", BUILD_CLOSED ? closedCacheStubRuntime : cygpath("$JDK_HOME/jre"))
288 defineProperty("LIBRARY_STUB", IS_MAC ? "$STUB_RUNTIME/lib" :
289 IS_WINDOWS ? "$STUB_RUNTIME/bin" :
290 "$STUB_RUNTIME/lib/$OS_ARCH")
291 defineProperty("UPDATE_STUB_CACHE", (STUB_RUNTIME.equals(closedCacheStubRuntime) ? 'true' : 'false'))
292
293 def supplementalPreBuildFile = file("$closedDir/closed-pre-build.gradle");
294 def supplementalBuildFile = file("$closedDir/closed-build.gradle");
295
296 if (BUILD_CLOSED) {
297 apply from: supplementalPreBuildFile
298 }
299
300 // COMPILE_WEBKIT specifies whether to build all of webkit.
301 defineProperty("COMPILE_WEBKIT", "false")
302 ext.IS_COMPILE_WEBKIT = Boolean.parseBoolean(COMPILE_WEBKIT)
303
304 // COMPILE_MEDIA specifies whether to build all of media.
305 defineProperty("COMPILE_MEDIA", "false")
306 ext.IS_COMPILE_MEDIA = Boolean.parseBoolean(COMPILE_MEDIA)
307
308 // COMPILE_PANGO specifies whether to build javafx_font_pango.
309 defineProperty("COMPILE_PANGO", "${IS_LINUX}")
310 ext.IS_COMPILE_PANGO = Boolean.parseBoolean(COMPILE_PANGO)
311
312 // COMPILE_PARFAIT specifies whether to build parfait
313 defineProperty("COMPILE_PARFAIT", "false")
314 ext.IS_COMPILE_PARFAIT = Boolean.parseBoolean(COMPILE_PARFAIT)
315
316
317 // Define the SWT.jar that we are going to have to download during the build process based
318 // on what platform we are compiling from (not based on our target).
319 ext.SWT_FILE_NAME = IS_MAC ? "org.eclipse.swt.cocoa.macosx.x86_64_3.7.2.v3740f" :
320 IS_WINDOWS && IS_64 ? "org.eclipse.swt.win32.win32.x86_64_3.7.2.v3740f" :
321 IS_WINDOWS && !IS_64 ? "org.eclipse.swt.win32.win32.x86_3.7.2.v3740f" :
322 IS_LINUX && IS_64 ? "org.eclipse.swt.gtk.linux.x86_64_3.7.2.v3740f" :
323 IS_LINUX && !IS_64 ? "org.eclipse.swt.gtk.linux.x86_3.7.2.v3740f" : ""
324
325 // Build javadocs only if BUILD_JAVADOC=true
326 defineProperty("BUILD_JAVADOC", "false")
327 ext.IS_BUILD_JAVADOC = Boolean.parseBoolean(BUILD_JAVADOC)
328
329 // Specifies whether to build the javafx-src bundle
330 defineProperty("BUILD_SRC_ZIP", "false")
331 ext.IS_BUILD_SRC_ZIP = Boolean.parseBoolean(BUILD_SRC_ZIP)
332
333 // Specifies whether to run full tests (true) or smoke tests (false)
334 defineProperty("FULL_TEST", "false")
335 ext.IS_FULL_TEST = Boolean.parseBoolean(FULL_TEST);
336
337 // Specifies whether to run robot-based visual tests (only used when FULL_TEST is also enabled)
338 defineProperty("USE_ROBOT", "true")
339 ext.IS_USE_ROBOT = Boolean.parseBoolean(USE_ROBOT);
340
341 // Specifies whether to run system tests that depend on AWT (only used when FULL_TEST is also enabled)
342 defineProperty("AWT_TEST", "true")
343 ext.IS_AWT_TEST = Boolean.parseBoolean(AWT_TEST);
344
345 // Specify the build configuration (Release, Debug, or DebugNative)
346 defineProperty("CONF", "Debug")
347 ext.IS_DEBUG_JAVA = CONF == "Debug" || CONF == "DebugNative"
348 ext.IS_DEBUG_NATIVE = CONF == "DebugNative"
349
350 // Defines the compiler warning levels to use. If empty, then no warnings are generated. If
351 // not empty, then the expected syntax is as a space or comma separated list of names, such
352 // as defined in the javac documentation.
353 defineProperty("LINT", "none")
354 ext.IS_LINT = LINT != "none"
355
356 defineProperty("DOC_LINT", "none")
357 ext.IS_DOC_LINT = DOC_LINT != "none"
358
359 // Specifies whether to use the "useDepend" option when compiling Java sources
360 defineProperty("USE_DEPEND", "true")
361 ext.IS_USE_DEPEND = Boolean.parseBoolean(USE_DEPEND)
362
363 // Specifies whether to generate code coverage statistics when running tests
364 defineProperty("JCOV", "false")
365 ext.DO_JCOV = Boolean.parseBoolean(JCOV)
366
367 // Define the number of threads to use when compiling (specifically for native compilation)
368 defineProperty("NUM_COMPILE_THREADS", "${Runtime.runtime.availableProcessors()}")
369
370 //
371 // The next three sections of properties are used to generate the
372 // VersionInfo class, and the Windows DLL manifest.
373 //
374
375 // The following properties should be left alone by developers and set only from Hudson.
376 defineProperty("HUDSON_JOB_NAME", "not_hudson")
377 defineProperty("HUDSON_BUILD_NUMBER","0000")
378 defineProperty("PROMOTED_BUILD_NUMBER", "00")
379
380 // The following properties define the product name for Oracle JDK and OpenJDK
381 // for VersionInfo and the DLL manifest.
382 if (BUILD_CLOSED) {
383 defineProperty("PRODUCT_NAME", "Java(TM)")
384 defineProperty("COMPANY_NAME", "Oracle Corporation")
385 defineProperty("PLATFORM_NAME", "Platform SE")
386 } else {
387 defineProperty("PRODUCT_NAME", "OpenJFX")
388 defineProperty("COMPANY_NAME", "N/A")
389 defineProperty("PLATFORM_NAME", "Platform")
390 }
391
392 // The following properties are set based on properties defined in
393 // build.properties. The release number or milestone number should be updated
394 // in that file.
395 def jfxReleaseVersion = "${jfxReleaseMajorVersion}.${jfxReleaseMinorVersion}.${jfxReleaseMicroVersion}"
396 defineProperty("RAW_VERSION", jfxReleaseVersion)
397 defineProperty("RELEASE_NAME", jfxReleaseName)
398 defineProperty("RELEASE_MILESTONE", jfxReleaseMilestone)
399
400 // Check whether the COMPILE_TARGETS property has been specified (if so, it was done by
401 // the user and not by this script). If it has not been defined then default
402 // to building the normal desktop build for this machine
403 project.ext.set("defaultHostTarget", IS_MAC ? "mac" : IS_WINDOWS ? "win" : IS_LINUX ? "linux" : "");
404 defineProperty("COMPILE_TARGETS", "$defaultHostTarget")
405
406 // Flag indicating whether to import cross compile tools
407 def importCrossTools = BUILD_CLOSED ? true : false;
408 if (!importCrossTools && hasProperty("IMPORT_CROSS_TOOLS")) {
409 importCrossTools = Boolean.parseBoolean(IMPORT_CROSS_TOOLS);
410 }
411 ext.IS_IMPORT_CROSS_TOOLS = importCrossTools
412
413 // Location of the cross compile tools
414 def crossToolsDir = "../crosslibs"
415 if (hasProperty("CROSS_TOOLS_DIR")) {
416 crossToolsDir = CROSS_TOOLS_DIR
417 }
418 ext.CROSS_TOOLS_DIR = file(crossToolsDir)
419
420 /**
421 * Fetch/Check that external tools are present for the build. This method
422 * will conditionally download the packages from project defined ivy repositories
423 * and unpack them into the specified destdir
424 *
425 * @param configName A unique name to distinguish the configuration (ie "ARMSFV6")
426 * @param packages A list of required packages (with extensions .tgz, .zip)
427 * @param destdir where the packages should be unpacked
428 * @param doFetch if true, the named packages will be download
429 */
430 void fetchExternalTools(String configName, List packages, File destdir, boolean doFetch) {
431 if (doFetch) {
432 // create a unique configuration for this fetch
433 def String fetchToolsConfig = "fetchTools$configName"
434 rootProject.configurations.create(fetchToolsConfig)
435
436 def List<String> fetchedPackages = []
437 def int fetchCount = 0
438
439 packages.each { pkgname->
440 def int dotdex = pkgname.lastIndexOf('.')
441 def int dashdex = pkgname.lastIndexOf('-')
442 def String basename = pkgname.substring(0,dashdex)
443 def String ver = pkgname.substring(dashdex+1,dotdex)
444 def String ext = pkgname.substring(dotdex+1)
445 def File pkgdir = file("$destdir/$basename-$ver")
446
447 if (!pkgdir.isDirectory()) {
448 rootProject.dependencies.add(fetchToolsConfig, "javafx:$basename:$ver", {
449 artifact {
450 name = basename
451 version = ver
452 type = ext
453 }
454 })
455 println "adding $pkgname as a downloadable item did not find $pkgdir"
456 fetchedPackages.add(pkgname)
457 fetchCount++
458 }
459 }
460
461 //fetch all the missing packages
462 if (fetchedPackages.size > 0) {
463 destdir.mkdirs()
464
465 logger.quiet "fetching missing packages $fetchedPackages"
466 copy {
467 from rootProject.configurations[fetchToolsConfig]
468 into destdir
469 }
470
471 // unpack the fetched packages
472 fetchedPackages.each { pkgname->
473 logger.quiet "expanding the package $pkgname"
474 def srcball = file("${destdir}/${pkgname}")
475
476 if (!srcball.exists()) {
477 throw new GradleException("Failed to fetch $pkgname");
478 }
479
480 def String basename = pkgname.substring(0,pkgname.lastIndexOf("."))
481 def File pkgdir = file("$destdir/$basename")
482
483 if (pkgname.endsWith(".tgz")) {
484 if (IS_LINUX || IS_MAC) {
485 // use native tar to support symlinks
486 pkgdir.mkdirs()
487 exec {
488 workingDir pkgdir
489 commandLine "tar", "zxf", "${srcball}"
490 }
491 } else {
492 copy {
493 from tarTree(resources.gzip("${srcball}"))
494 into pkgdir
495 }
496 }
497 } else if (pkgname.endsWith(".zip")) {
498 copy {
499 from zipTree("${srcball}")
500 into pkgdir
501 }
502 } else {
503 throw new GradleException("Unhandled pacakge type for compile package ${pkgname}")
504 }
505 srcball.deleteOnExit();
506 }
507 } else {
508 logger.quiet "all tool packages are present $packages"
509 }
510 } else { // !doFetch - so just check they are present
511 // check that all the dirs are really there
512 def List<String> errors = []
513 packages.each { pkgname->
514 def String basename = pkgname.substring(0,pkgname.lastIndexOf("."))
515 def File pkgdir = file("$destdir/$basename")
516
517 if (!pkgdir.isDirectory()) {
518 errors.add(pkgname)
519 }
520 }
521 if (errors.size > 0) {
522 throw new GradleException("Error: missing tool packages: $errors")
523 } else {
524 logger.quiet "all tool packages are present $packages"
525 }
526 }
527 }
528
529 // Now we need to define the native compilation tasks. The set of parameters to
530 // native compilation depends on the target platform (and also to some extent what platform
531 // you are compiling on). These settings are contained in various gradle files
532 // such as mac.gradle and linux.gradle and armhf.gradle. Additionally, the developer
533 // can specify COMPILE_FLAGS_FILE to be a URL or path to a different gradle file
534 // that will contain the appropriate flags.
535 defineProperty("COMPILE_FLAGS_FILES", COMPILE_TARGETS.split(",").collect {"buildSrc/${it.trim()}.gradle"}.join(","))
536 if (COMPILE_TARGETS == "all") {
537 def tmp = []
538 File buildSrcDir = file("buildSrc")
539 buildSrcDir.listFiles().each { File f ->
540 if (f.isFile() && f.name.endsWith(".gradle") && !f.name.equals("build.gradle")) {
541 def target = f.name.substring(0, f.name.lastIndexOf('.gradle')).toUpperCase(Locale.ROOT)
542 apply from: f
543 if (project.ext["${target}"].canBuild) {
544 tmp.add(target)
545 }
546 }
547 }
548 COMPILE_FLAGS_FILES = tmp.collect { "buildSrc/${it}.gradle"}.join(",")
549 COMPILE_TARGETS = tmp.collect { "${it.toLowerCase()}"}.join(",")
550 } else {
551 COMPILE_FLAGS_FILES.split(",").each {
552 logger.info("Applying COMPILE_FLAGS_FILE '$it'")
553 apply from: it
554 }
555 }
556
557 if (COMPILE_TARGETS != "") {
558 def tmp = []
559 COMPILE_TARGETS.split(",").each {target ->
560 if (project.ext["${target.toUpperCase(Locale.ROOT)}"].canBuild) {
561 tmp.add(target)
562 }
563 }
564 COMPILE_TARGETS = tmp.collect { "${it.toLowerCase()}"}.join(",")
565 }
566
567 // Sanity check the expected properties all exist
568 compileTargets { t ->
569 // Every platform must define these variables
570 if (!project.hasProperty(t.upper)) throw new Exception("ERROR: Incorrectly configured compile flags file, missing ${t.name} property")
571 def props = project.ext[t.upper];
572 ["jfxrtJarExcludes", "compileSwing", "compileSWT", "compileFXPackager", "compileDesignTime", "libDest"].each { prop ->
573 if (!props.containsKey(prop)) throw new Exception("ERROR: Incorrectly configured compile flags file, missing ${prop} property on ${t.name}")
574 }
575 }
576
577 // Various build flags may be set by the different target files, such as
578 // whether to build Swing, SWT, FXPackager, etc. We iterate over all
579 // compile targets and look for these settings in our properties. Note that
580 // these properties cannot be set from the command line, but are set by
581 // the target build files such as armv6hf.gradle or mac.gradle.
582 ext.COMPILE_SWING = false;
583 ext.COMPILE_SWT = false;
584 ext.COMPILE_FXPACKAGER = false;
585 ext.COMPILE_DESIGN_TIME = false;
586 compileTargets { t ->
587 if (project.ext[t.upper].compileSwing) COMPILE_SWING = true
588 if (project.ext[t.upper].compileSWT) COMPILE_SWT = true
589 if (project.ext[t.upper].compileFXPackager) COMPILE_FXPACKAGER = true
590 if (project.ext[t.upper].compileDesignTime) COMPILE_DESIGN_TIME = true
591 }
592
593 /******************************************************************************
594 * *
595 * Build Setup Sanity Checks *
596 * *
597 * Here we do a variety of checks so that if the version of Java you are *
598 * building with is misconfigured, or you are using the wrong version of *
599 * gradle, etc you will get some kind of helpful error / warning message *
600 * *
601 *****************************************************************************/
602
603 // Verify that the architecture & OS are supported configurations. Note that
604 // at present building on PI is not supported, but we would only need to make
605 // some changes on assumptions on what should be built (like SWT / Swing) and
606 // such and we could probably make it work.
607 if (!IS_MAC && !IS_WINDOWS && !IS_LINUX) logger.error("Unsupported build OS ${OS_NAME}")
608 if (IS_WINDOWS && OS_ARCH != "x86" && OS_ARCH != "amd64") {
609 throw new Exception("Unknown and unsupported build architecture: $OS_ARCH")
610 } else if (IS_MAC && OS_ARCH != "x86_64") {
611 throw new Exception("Unknown and unsupported build architecture: $OS_ARCH")
612 } else if (IS_LINUX && OS_ARCH != "i386" && OS_ARCH != "amd64") {
613 throw new Exception("Unknown and unsupported build architecture: $OS_ARCH")
614 }
615
616 // Sanity check that we actually have a list of compile targets to execute
617 if (COMPILE_TARGETS == null || COMPILE_TARGETS == "") {
618 throw new Exception("Unable to determine compilation platform, must specify valid COMPILE_TARGETS!")
619 }
620
621 // Make sure JDK_HOME/bin/java exists
622 if (!file(JAVA).exists()) throw new Exception("Missing or incorrect path to 'java': '$JAVA'. Perhaps bad JDK_HOME? $JDK_HOME")
623 if (!file(JAVAC).exists()) throw new Exception("Missing or incorrect path to 'javac': '$JAVAC'. Perhaps bad JDK_HOME? $JDK_HOME")
624 if (!file(JAVAH).exists()) throw new Exception("Missing or incorrect path to 'javah': '$JAVAH'. Perhaps bad JDK_HOME? $JDK_HOME")
625 if (!file(JAVADOC).exists()) throw new Exception("Missing or incorrect path to 'javadoc': '$JAVADOC'. Perhaps bad JDK_HOME? $JDK_HOME")
626
627
628 // Determine the verion of Java in JDK_HOME. It looks like this:
629 //
630 // $ java -version
631 // java version "1.7.0_45"
632 // Java(TM) SE Runtime Environment (build 1.7.0_45-b18)
633 // Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode)
634 //
635 // We need to parse the second line
636 def inStream = new java.io.BufferedReader(new java.io.InputStreamReader(new java.lang.ProcessBuilder(JAVA, "-version").start().getErrorStream()));
637 try {
638 if (inStream.readLine() != null) {
639 String v = inStream.readLine();
640 if (v != null) {
641 int ib = v.indexOf(" (build ");
642 if (ib != -1) {
643 String ver = v.substring(ib + 8, v.size() - 1);
644
645 defineProperty("jdkRuntimeVersion", ver)
646 defineProperty("jdkVersion", jdkRuntimeVersion.split("[_\\-]")[0])
647 defineProperty("jdkBuildNumber", jdkRuntimeVersion.substring(jdkRuntimeVersion.lastIndexOf("-b") + 2))
648 }
649 }
650 }
651 } finally {
652 inStream.close();
653 }
654 if (!project.hasProperty("jdkRuntimeVersion")) throw new Exception("Unable to determine the version of Java in JDK_HOME at $JDK_HOME");
655
656
657
658 // Verify that CONF is something useful
659 if (CONF != "Release" && CONF != "Debug") logger.warn("Unknown configuration CONF='$CONF'. Treating as 'Release'")
660
661 // If the number of compile threads is less than 1 then we have a problem!
662 if (Integer.parseInt(NUM_COMPILE_THREADS.toString()) < 1) {
663 logger.warn("NUM_COMPILE_THREADS was specified as '$NUM_COMPILE_THREADS' which is less than the minimum value of 1. " +
664 "Building with a value of 1 instead.")
665 NUM_COMPILE_THREADS = 1
666 }
667
668 // Check that Gradle 1.8 is in use.
669 if (gradle.gradleVersion != "1.8") {
670 logger.warn("Unsupported gradle version $gradle.gradleVersion in use. Only 1.8 is supported")
671 }
672
673 /******************************************************************************
674 * *
675 * Logging of Properties and Settings *
676 * *
677 * Log some of the settings we've determined. We could log more here, it *
678 * doesn't really hurt. *
679 * *
680 *****************************************************************************/
681
682 logger.quiet("OS_NAME: $OS_NAME")
683 logger.quiet("OS_ARCH: $OS_ARCH")
684 logger.quiet("JAVA_HOME: $JAVA_HOME")
685 logger.quiet("JDK_HOME: $JDK_HOME")
686 logger.quiet("java.runtime.version: ${javaRuntimeVersion}")
687 logger.quiet("java version: ${javaVersion}")
688 logger.quiet("java build number: ${javaBuildNumber}")
689 logger.quiet("jdk.runtime.version: ${jdkRuntimeVersion}")
690 logger.quiet("jdk version: ${jdkVersion}")
691 logger.quiet("jdk build number: ${jdkBuildNumber}")
692 logger.quiet("minimum java build number: ${jfxBuildJdkBuildnumMin}")
693 logger.quiet("COMPILE_TARGETS: $COMPILE_TARGETS")
694 logger.quiet("COMPILE_FLAGS_FILES: $COMPILE_FLAGS_FILES")
695 logger.quiet("HUDSON_JOB_NAME: $HUDSON_JOB_NAME")
696 logger.quiet("HUDSON_BUILD_NUMBER: $HUDSON_BUILD_NUMBER")
697 logger.quiet("PROMOTED_BUILD_NUMBER: $PROMOTED_BUILD_NUMBER")
698 logger.quiet("PRODUCT_NAME: $PRODUCT_NAME")
699 logger.quiet("RAW_VERSION: $RAW_VERSION")
700 logger.quiet("RELEASE_NAME: $RELEASE_NAME")
701 logger.quiet("RELEASE_MILESTONE: $RELEASE_MILESTONE")
702
703 if (UPDATE_STUB_CACHE) {
704 logger.quiet("UPDATE_STUB_CACHE: $UPDATE_STUB_CACHE")
705 }
706
707 /******************************************************************************
708 * *
709 * Definition of Native Code Compilation Tasks *
710 * *
711 * - JavaHeaderTask is used to run javah. The JAVAH property will point at *
712 * the version of javah to be used (i.e.: a path to javah) *
713 * - CCTask compiles native code. Specifically it will compile .m, .c, *
714 * .cpp, or .cc files. It uses the headers provided by the *
715 * JavaHeaderTask plus additional platform specific headers. It will *
716 * compile into .obj files. *
717 * - LinkTask will perform native linking and create the .dll / .so / *
718 * .dylib as necessary. *
719 * *
720 *****************************************************************************/
721
722 // Save a reference to the buildSrc.jar file because we need it for actually
723 // compiling things, not just for the sake of this build script
724 // (such as generating the builders, JSL files, etc)
725 ext.BUILD_SRC = rootProject.files("buildSrc/build/libs/buildSrc.jar")
726
727 /**
728 * Convenience method for creating javah, cc, link, and "native" tasks in the given project. These
729 * tasks are parameterized by name, so that we can produce, for example, javahGlass, ccGlass, etc
730 * named tasks.
731 *
732 * @param project The project to add tasks to
733 * @param name The name of the project, such as "prism-common". This name is used
734 * in the name of the generated task, such as ccPrismCommon, and also
735 * in the name of the final library, such as libprism-common.dylib.
736 */
737 void addNative(Project project, String name) {
738 addNative(project, name, null)
739 }
740
741 /**
742 * Convenience method for creating javah, cc, link, and "native" tasks in the given project. These
743 * tasks are parameterized by name, so that we can produce, for example, javahGlass, ccGlass, etc
744 * named tasks.
745 *
746 * @param project The project to add tasks to
747 * @param name The name of the project, such as "prism-common". This name is used
748 * in the name of the generated task, such as ccPrismCommon, and also
749 * in the name of the final library, such as libprism-common.dylib.
750 * @param list of compile targets. Library is applicable only for these targets.
751 */
752 void addNative(Project project, String name, List<String> includeTargets) {
753 // TODO if we want to handle 32/64 bit windows in the same build,
754 // Then we will need to modify the win compile target to be win32 or win64
755 def capitalName = name.split("-").collect{it.capitalize()}.join()
756 def nativeTask = project.task("native$capitalName", group: "Build") {
757 description = "Generates JNI headers, compiles, and builds native dynamic library for $name for all compile targets"
758 }
759 def cleanTask = project.task("cleanNative$capitalName", type: Delete, group: "Build") {
760 description = "Clean native objects for $name"
761 }
762 if (project.hasProperty("nativeAllTask")) project.nativeAllTask.dependsOn nativeTask
763 project.assemble.dependsOn(nativeTask)
764 if (project.hasProperty("cleanNativeAllTask")) project.cleanNativeAllTask.dependsOn cleanTask
765
766 // Each of the different compile targets will be placed in a sub directory
767 // of these root dirs, with the name of the dir being the name of the target
768 def headerRootDir = project.file("$project.buildDir/generated-src/headers/$name")
769 def nativeRootDir = project.file("$project.buildDir/native/$name")
770 def libRootDir = project.file("$project.buildDir/libs/$name")
771 // For each compile target, create a javah / cc / link triplet
772 compileTargets { t ->
773 if (includeTargets != null && !includeTargets.contains(t.name)) {
774 return
775 }
776 def targetProperties = project.rootProject.ext[t.upper]
777 def library = targetProperties.library
778 def properties = targetProperties.get(name)
779 def nativeDir = file("$nativeRootDir/${t.name}")
780 def headerDir = file("$headerRootDir/${t.name}")
781
782 def javahTask = project.task("javah${t.capital}${capitalName}", type: JavaHeaderTask, dependsOn: project.classes, group: "Build") {
783 description = "Generates JNI Headers for ${name} for ${t.name}"
784 if (properties.javahSource == null) {
785 source(project.sourceSets.main.output.classesDir)
786 } else {
787 source(properties.javahSource)
788 }
789 if (properties.javahClasspath == null) {
790 classpath = project.files(project.sourceSets.main.output.classesDir)
791 } else {
792 classpath = project.files(properties.javahClasspath)
793 }
794 output = headerDir
795 include(properties.javahInclude)
796 cleanTask.delete headerDir
797 }
798
799 def variants = properties.containsKey("variants") ? properties.variants : [""];
800 variants.each { variant ->
801 def variantProperties = variant == "" ? properties : properties.get(variant)
802 def capitalVariant = variant.capitalize()
803 def ccOutput = variant == "" ? nativeDir : file("$nativeDir/$variant")
804 def ccTask = project.task("cc${t.capital}$capitalName$capitalVariant", type: CCTask, dependsOn: javahTask, group: "Build") {
805 description = "Compiles native sources for ${name} for ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}"
806 matches = ".*\\.c|.*\\.cpp|.*\\.m|.*\\.cc"
807 headers = headerDir
808 output(ccOutput)
809 params.addAll(variantProperties.ccFlags)
810 compiler = variantProperties.compiler
811 source(variantProperties.nativeSource)
812 cleanTask.delete ccOutput
813 }
814 def linkTask = project.task("link${t.capital}$capitalName$capitalVariant", type: LinkTask, dependsOn: ccTask, group: "Build") {
815 description = "Creates native dynamic library for $name for ${t.name}${capitalVariant != '' ? ' for variant ' + capitalVariant : ''}"
816 objectDir = ccOutput
817 linkParams.addAll(variantProperties.linkFlags)
818 lib = file("$libRootDir/${t.name}/${variant == '' ? library(properties.lib) : library(variantProperties.lib)}")
819 linker = variantProperties.linker
820 cleanTask.delete "$libRootDir/${t.name}"
821 }
822 nativeTask.dependsOn(linkTask)
823 if (IS_WINDOWS && t.name == "win") {
824 def rcTask = project.task("rc$capitalName$capitalVariant", type: CompileResourceTask, dependsOn: javahTask, group: "Build") {
825 description = "Compiles native sources for $name"
826 matches = ".*\\.rc"
827 compiler = variantProperties.rcCompiler
828 source(variantProperties.rcSource)
829 if (variantProperties.rcFlags) {
830 rcParams.addAll(variantProperties.rcFlags)
831 }
832 output(ccOutput)
833 }
834 linkTask.dependsOn rcTask;
835 }
836 }
837
838 def useLipo = targetProperties.containsKey('useLipo') ? targetProperties.useLipo : false
839 if (useLipo) {
840 def lipoTask = project.task("lipo${t.capital}$capitalName", type: LipoTask, dependsOn: javahTask, group: "Build") {
841 description = "Creates native fat library for $name for ${t.name}"
842 libDir = file("$libRootDir/${t.name}")
843 lib = file("$libRootDir/${t.name}/${library(properties.lib)}")
844 }
845 nativeTask.dependsOn(lipoTask)
846 }
847 }
848 }
849
850 void addJSL(Project project, String name, String pkg, Closure compile) {
851 def lowerName = name.toLowerCase()
852
853 def compileCompilers = project.task("compile${name}Compilers", type: JavaCompile, dependsOn: project.compileJava) {
854 description = "Compile the $name JSL Compilers"
855 classpath = project.files(project.sourceSets.main.output.classesDir) +
856 rootProject.BUILD_SRC +
857 project.configurations.antlr3
858 source = [project.file("src/main/jsl-$lowerName")]
859 destinationDir = project.file("$project.buildDir/classes/jsl-compilers/$lowerName")
860 }
861
862 def generateShaders = project.task("generate${name}Shaders", dependsOn: compileCompilers) {
863 description = "Generate $name shaders from JSL"
864 def sourceDir = project.file("src/main/jsl-$lowerName")
865 def destinationDir = project.file("$project.buildDir/generated-src/jsl-$lowerName")
866 inputs.dir sourceDir
867 outputs.dir destinationDir
868 doLast {
869 compile(sourceDir, destinationDir)
870 }
871 }
872
873 project.task("compile${name}JavaShaders", type: JavaCompile, dependsOn: generateShaders) {
874 description = "Compile the Java $name JSL shaders"
875 classpath = project.files(project.sourceSets.main.output.classesDir) + rootProject.BUILD_SRC
876 source = [project.file("$project.buildDir/generated-src/jsl-$lowerName")]
877 destinationDir = project.file("$project.buildDir/classes/jsl-$lowerName")
878 }
879
880 def compileHLSLShaders = project.task("compile${name}HLSLShaders", dependsOn: generateShaders, type: CompileHLSLTask) {
881 enabled = IS_WINDOWS
882 description = "Compile $name HLSL files into .obj files"
883 matches = ".*\\.hlsl"
884 output project.file("$project.buildDir/hlsl/$name/$pkg")
885 source project.file("$project.buildDir/generated-src/jsl-$lowerName/$pkg")
886 }
887
888 project.task("process${name}Shaders", dependsOn: [generateShaders, compileHLSLShaders], type: Copy, description: "Copy hlsl / frag shaders to build/resources/jsl-$lowerName") {
889 from("$project.buildDir/hlsl/$name") {
890 include "**/*.obj"
891 }
892 from("$project.buildDir/generated-src/jsl-$lowerName") {
893 include("**/*.frag")
894 }
895 into "$project.buildDir/resources/jsl-$lowerName"
896 }
897 }
898
899 // Task to verify the minimum level of Java needed to build JavaFX
900 task verifyJava() {
901 doLast {
902 if (jdkVersion != jfxBuildJdkVersion) {
903 fail("java version mismatch: ${jdkVersion} must be ${jfxBuildJdkVersion}")
904 }
905 def buildNum = Integer.parseInt(jdkBuildNumber)
906 def minBuildNum = Integer.parseInt(jfxBuildJdkBuildnumMin)
907 if (buildNum < minBuildNum) {
908 fail("java build number ($buildNum) < minimum build number ($minBuildNum)")
909 }
910 }
911 }
912
913 // Task to check whether jfxrt.jar is present in the JDK
914 task checkJfxrtJar {
915 doLast {
916 def jfxrtFile = new File("$JDK_HOME/jre/lib/ext/jfxrt.jar");
917 if (jfxrtFile.exists()) {
918 if (BUILD_CLOSED) {
919 fail("$jfxrtFile must be removed before building closed sdk")
920 } else {
921 logger.warn("****************************************************************")
922 logger.warn("$jfxrtFile may interfere with testing or running applications against locally build jfxrt.jar")
923 logger.warn("****************************************************************")
924 }
925 }
926 }
927 }
928
929 task updateCacheIfNeeded() {
930 // an empty task we can add to as needed for UPDATE_STUB_CACHE
931 }
932
933 /*****************************************************************************
934 * Project definitions (dependencies, etc) *
935 *****************************************************************************/
936
937 void addJCov(p, test) {
938 test.doFirst {
939 def jcovJVMArgument =
940 "include=javafx," +
941 "include=com.sun.javafx," +
942 "include=com.sun.glass," +
943 "include=com.sun.openpisces," +
944 "include=com.sun.pisces," +
945 "include=com.sun.prism," +
946 "include=com.sun.scenario," +
947 "include=com.sun.webkit," +
948 "exclude=com," +
949 "exclude=java," +
950 "exclude=javax," +
951 "exclude=\"**.test\"," +
952 "exclude=\"**.*Test\"," +
953 "file=build/reports/jcov/report.xml," +
954 "merge=merge";
955 test.jvmArgs("-javaagent:${p.configurations.testCompile.files.find { it.name.startsWith('jcov') }}=$jcovJVMArgument");
956 p.mkdir p.file("build/reports/jcov")
957 }
958 test.doLast {
959 def reportFile = p.file("build/reports/jcov/report.xml")
960 if (reportFile.exists()) {
961 p.javaexec {
962 workingDir = p.file("build/reports/jcov")
963 classpath = p.files(p.configurations.testCompile.files.find { it.name.startsWith('jcov') })
964 main = "com.sun.tdk.jcov.Helper"
965 args = [
966 "RepGen",
967 "-exclude", "\"**.test\"",
968 "-exclude", "\"**.*Test\"",
969 "-output", ".",
970 "-source", p.sourceSets.main.java.srcDirs.collect{p.file(it)}.join(":"),
971 "report.xml"
972 ]
973 }
974 }
975 }
976 }
977
978 allprojects {
979 // We want to configure all projects as java projects and use the same compile settings
980 // etc, except for the root project which we just want to ignore (and for now media)
981 if (project == rootProject) {
982 return
983 }
984 if (project.path.startsWith(":apps")) {
985 // Lets handle the apps tree differently, as it is a collection of ant builds,
986 // and the ant importer collides with the 'apply plugin:java'
987 return
988 }
989 // All of our projects are java projects
990 apply plugin: "java"
991 sourceCompatibility = 1.8
992
993 // Setup the repositories that we'll download libraries from. Maven Central is
994 // just easy for most things. The custom "ivy" repo is for downloading SWT. The way it
995 // works is to setup the download URL such that it will resolve to the actual jar file
996 // to download. See SWT_FILE_NAME for the name of the jar that will be used as the
997 // "artifact" in the pattern below. Note that the closed builds use different repositories
998 // so if you are debugging a closed-build artifact related build issue, check out the
999 // closed gradle file instead.
1000 if (!BUILD_CLOSED) {
1001 repositories {
1002 mavenCentral()
1003 ivy {
1004 url "http://download.eclipse.org/eclipse/updates/3.7/R-3.7.2-201202080800/plugins/"
1005 layout "pattern", {
1006 artifact "[artifact].[ext]"
1007 }
1008 }
1009 }
1010 }
1011
1012 // By default all of our projects require junit for testing so we can just
1013 // setup this dependency here.
1014 dependencies {
1015 testCompile group: "junit", name: "junit", version: "4.8.2"
1016 if (BUILD_CLOSED && DO_JCOV) {
1017 testCompile name: "jcov"
1018 }
1019 }
1020
1021 // Compile and run tests against the jfxrt.jar in the built sdk of the host machine
1022 def sdkDir = "${rootProject.buildDir}/${defaultHostTarget}-sdk"
1023 def jfxrtJar = "$sdkDir/rt/lib/ext/jfxrt.jar"
1024
1025 // At the moment the ASM library shipped with Gradle that is used to
1026 // discover the different test classes fails on Java 8, so in order
1027 // to have sourceCompatibility set to 1.8 I have to also turn scanForClasses off
1028 // and manually specify the includes / excludes. At the moment we use
1029 // Java 7 but when we switch to 8 this will be needed, and probably again when
1030 // we start building with Java 9.
1031 test {
1032 jvmArgs("-Djava.ext.dirs=");
1033 executable = JAVA;
1034 enableAssertions = true;
1035 testLogging.exceptionFormat = "full";
1036 scanForTestClasses = false;
1037 include("**/*Test.*");
1038 if (BUILD_CLOSED && DO_JCOV) {
1039 addJCov(project, test)
1040 }
1041 classpath = files("$jfxrtJar") + classpath
1042 }
1043
1044 compileTestJava {
1045 classpath = files("$jfxrtJar") + classpath
1046 }
1047
1048 // Exclude any non-public-API classes from having javadoc generated. This block is used
1049 // when generating JavaDocs for a specific project. When generating the JavaDocs for the
1050 // entire SDK, a different javadoc command is used (see the javadoc task on the top level)
1051 javadoc {
1052 enabled = IS_BUILD_JAVADOC
1053 exclude("com/**/*", "javafx/scene/ParentDesignInfo*", "Compile*", "javafx/builder/**/*");
1054 executable = JAVADOC;
1055 options.windowTitle("JavaFX Project ${project.name} ${RELEASE_NAME}")
1056 options.links(JDK_DOCS);
1057 options.addBooleanOption("XDignore.symbol.file").setValue(true);
1058 options.addBooleanOption("Xdoclint:none").setValue(!IS_DOC_LINT);
1059 options.addBooleanOption("javafx").setValue(true);
1060 // All doc-files are located in src/main/docs because Gradle's javadoc doesn't copy
1061 // over the doc-files if they are embedded with the sources. I find this arrangement
1062 // somewhat cleaner anyway (never was a fan of mixing javadoc files with the sources)
1063 doLast {
1064 copy {
1065 from "src/main/docs"
1066 into "$buildDir/docs/javadoc"
1067 }
1068 }
1069 }
1070 }
1071
1072 // The "base" project is our first module and the most basic one required for
1073 // all other modules. It is useful even for non-GUI applications.
1074 project(":base") {
1075 dependencies {
1076 compile BUILD_SRC
1077 }
1078
1079 // We need to take the VersionInfo.java file and replace the various
1080 // properties within it
1081 def replacements = [
1082 "BUILD_TIMESTAMP": new java.util.Date(),
1083 "HUDSON_JOB_NAME": HUDSON_JOB_NAME,
1084 "HUDSON_BUILD_NUMBER": HUDSON_BUILD_NUMBER,
1085 "PROMOTED_BUILD_NUMBER": PROMOTED_BUILD_NUMBER,
1086 "PRODUCT_NAME": PRODUCT_NAME,
1087 "RAW_VERSION": RAW_VERSION,
1088 "RELEASE_NAME": RELEASE_NAME,
1089 "RELEASE_MILESTONE": RELEASE_MILESTONE];
1090 task processVersionInfo(type: Copy, description: "Replace params in VersionInfo and copy file to destination") {
1091 doFirst { mkdir "$buildDir/generated-src/version-info" }
1092 from "src/main/version-info"
1093 into "$buildDir/generated-src/version-info/com/sun/javafx/runtime"
1094 filter {line->
1095 replacements.each() {k, v ->
1096 line = line.replace("@$k@", v.toString());
1097 }
1098 line
1099 }
1100 }
1101
1102 compileJava.dependsOn updateCacheIfNeeded
1103 compileJava.dependsOn verifyJava
1104
1105 // Make sure to include $buildDir/generated-src/version-info that we previously created.
1106 // We DO NOT want to include src/main/version-info
1107 sourceSets.main.java.srcDirs = ["src/main/java", "$buildDir/generated-src/version-info"]
1108 compileJava.dependsOn processVersionInfo
1109 }
1110
1111 // The graphics module is needed for any graphical JavaFX application. It requires
1112 // the base module and includes the scene graph, layout, css, prism, windowing, etc.
1113 // This is a fairly complicated module. There are many different types of native components
1114 // that all need to be compiled.
1115 project(":graphics") {
1116 // Workaround for lack of Antlr 3 support in Gradle. By defining a configuration,
1117 // we can then give it a class path and use that classpath to execute a java command
1118 getConfigurations().add("antlr3");
1119
1120 sourceSets {
1121 main
1122 test
1123 stub
1124 }
1125
1126 dependencies {
1127 compile project(":base"), BUILD_SRC
1128 compile name: SWT_FILE_NAME
1129 stubCompile group: "junit", name: "junit", version: "4.8.2",
1130 project(":base").sourceSets.test.output, sourceSets.main.output
1131 antlr3 group: "org.antlr", name: "antlr", version: "3.1.3"
1132 antlr3 group: "org.antlr", name: "antlr-runtime", version: "3.1.3"
1133 antlr3 group: "org.antlr", name: "stringtemplate", version: "3.2"
1134 }
1135
1136 // Create a single "native" task which will depend on all the individual native tasks for graphics
1137 project.ext.nativeAllTask = task("native", group: "Build", description: "Compiles and Builds all native libraries for Graphics");
1138 project.ext.cleanNativeAllTask = task("cleanNative", group: "Build", description: "Clean all native libraries and objects for Graphics");
1139
1140 // Add tasks for native compilation
1141 addNative(project, "glass");
1142 addNative(project, "prism")
1143 addNative(project, "prismSW")
1144 addNative(project, "font")
1145 addNative(project, "iio")
1146 addNative(project, "prismES2")
1147
1148 if (IS_COMPILE_PANGO) {
1149 // TODO: embedded support
1150 addNative(project, "fontFreetype", ["linux"])
1151 addNative(project, "fontPango", ["linux"])
1152 }
1153
1154 if (IS_WINDOWS) {
1155 addNative(project, "prismD3D")
1156 // TODO need to hook this up to be executed only if PassThroughVS.h is missing or PassThroughVS.hlsl is changed
1157 task generateD3DHeaders(group: "Build") {
1158 enabled = IS_WINDOWS
1159 dependsOn javahWinPrismD3D
1160 inputs.file "src/main/native-prism-d3d/hlsl/Mtl1PS.hlsl"
1161 inputs.file "src/main/native-prism-d3d/hlsl/Mtl1VS.hlsl"
1162 inputs.file "src/main/native-prism-d3d/PassThroughVS.hlsl"
1163 outputs.dir "$buildDir/headers/PrismD3D/"
1164 outputs.dir "$buildDir/headers/PrismD3D/hlsl/"
1165 description = "Generate headers by compiling hlsl files"
1166 doLast {
1167 mkdir file("$buildDir/headers/PrismD3D/hlsl")
1168 def PS_3D_SRC = file("src/main/native-prism-d3d/hlsl/Mtl1PS.hlsl")
1169 def VS_3D_SRC = file("src/main/native-prism-d3d/hlsl/Mtl1VS.hlsl")
1170 def PASSTHROUGH_VS_SRC = file("src/main/native-prism-d3d/PassThroughVS.hlsl")
1171 def jobs = [
1172 ["$FXC", "/nologo", "/T", "vs_3_0", "/Fh", "$buildDir/headers/PrismD3D/PassThroughVS.h", "/E", "passThrough", "$PASSTHROUGH_VS_SRC"],
1173 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS.h", "/DSpec=0", "/DSType=0", "$PS_3D_SRC"],
1174 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_i.h", "/DSpec=0", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"],
1175 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1n.h", "/DSpec=1", "/DSType=0", "$PS_3D_SRC"],
1176 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2n.h", "/DSpec=2", "/DSType=0", "$PS_3D_SRC"],
1177 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3n.h", "/DSpec=3", "/DSType=0", "$PS_3D_SRC"],
1178 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1t.h", "/DSpec=1", "/DSType=1", "$PS_3D_SRC"],
1179 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2t.h", "/DSpec=2", "/DSType=1", "$PS_3D_SRC"],
1180 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3t.h", "/DSpec=3", "/DSType=1", "$PS_3D_SRC"],
1181 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1c.h", "/DSpec=1", "/DSType=2", "$PS_3D_SRC"],
1182 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2c.h", "/DSpec=2", "/DSType=2", "$PS_3D_SRC"],
1183 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3c.h", "/DSpec=3", "/DSType=2", "$PS_3D_SRC"],
1184 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1m.h", "/DSpec=1", "/DSType=3", "$PS_3D_SRC"],
1185 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2m.h", "/DSpec=2", "/DSType=3", "$PS_3D_SRC"],
1186 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3m.h", "/DSpec=3", "/DSType=3", "$PS_3D_SRC"],
1187 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1n.h", "/DSpec=1", "/DSType=0", "/DBump=1", "$PS_3D_SRC"],
1188 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2n.h", "/DSpec=2", "/DSType=0", "/DBump=1", "$PS_3D_SRC"],
1189 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3n.h", "/DSpec=3", "/DSType=0", "/DBump=1", "$PS_3D_SRC"],
1190 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1t.h", "/DSpec=1", "/DSType=1", "/DBump=1", "$PS_3D_SRC"],
1191 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2t.h", "/DSpec=2", "/DSType=1", "/DBump=1", "$PS_3D_SRC"],
1192 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3t.h", "/DSpec=3", "/DSType=1", "/DBump=1", "$PS_3D_SRC"],
1193 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1c.h", "/DSpec=1", "/DSType=2", "/DBump=1", "$PS_3D_SRC"],
1194 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2c.h", "/DSpec=2", "/DSType=2", "/DBump=1", "$PS_3D_SRC"],
1195 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3c.h", "/DSpec=3", "/DSType=2", "/DBump=1", "$PS_3D_SRC"],
1196 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b1m.h", "/DSpec=1", "/DSType=3", "/DBump=1", "$PS_3D_SRC"],
1197 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b2m.h", "/DSpec=2", "/DSType=3", "/DBump=1", "$PS_3D_SRC"],
1198 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_b3m.h", "/DSpec=3", "/DSType=3", "/DBump=1", "$PS_3D_SRC"],
1199 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ni.h", "/DSpec=1", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"],
1200 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ni.h", "/DSpec=2", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"],
1201 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ni.h", "/DSpec=3", "/DSType=0", "/DIllumMap=1", "$PS_3D_SRC"],
1202 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ti.h", "/DSpec=1", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"],
1203 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ti.h", "/DSpec=2", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"],
1204 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ti.h", "/DSpec=3", "/DSType=1", "/DIllumMap=1", "$PS_3D_SRC"],
1205 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1ci.h", "/DSpec=1", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"],
1206 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2ci.h", "/DSpec=2", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"],
1207 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3ci.h", "/DSpec=3", "/DSType=2", "/DIllumMap=1", "$PS_3D_SRC"],
1208 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s1mi.h", "/DSpec=1", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"],
1209 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s2mi.h", "/DSpec=2", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"],
1210 ["$FXC", "/nologo", "/T", "ps_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1PS_s3mi.h", "/DSpec=3", "/DSType=3", "/DIllumMap=1", "$PS_3D_SRC"],
1211 ["$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"],
1212 ["$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"],
1213 ["$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"],
1214 ["$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"],
1215 ["$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"],
1216 ["$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"],
1217 ["$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"],
1218 ["$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"],
1219 ["$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"],
1220 ["$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"],
1221 ["$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"],
1222 ["$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"],
1223 ["$FXC", "/nologo", "/T", "vs_2_0", "/Fh", "$buildDir/headers/PrismD3D/hlsl/Mtl1VS_Obj.h", "/DVertexType=ObjVertex", "$VS_3D_SRC"]
1224 ]
1225 final ExecutorService executor = Executors.newFixedThreadPool(Integer.parseInt(project.NUM_COMPILE_THREADS.toString()));
1226 final CountDownLatch latch = new CountDownLatch(jobs.size());
1227 List futures = new ArrayList<Future>();
1228 jobs.each { cmd ->
1229 futures.add(executor.submit(new Runnable() {
1230 @Override public void run() {
1231 try {
1232 exec {
1233 commandLine cmd
1234 }
1235 } finally {
1236 latch.countDown();
1237 }
1238 }
1239 }));
1240 }
1241 latch.await();
1242 // Looking for whether an exception occurred while executing any of the futures.
1243 // By calling "get()" on each future an exception will be thrown if one had occurred
1244 // on the background thread.
1245 futures.each {it.get();}
1246 }
1247 }
1248
1249 ccWinPrismD3D.dependsOn generateD3DHeaders
1250 }
1251
1252 // The Decora and Prism JSL files have to be generated in a very specific set of steps.
1253 // 1) Compile the *Compile.java classes. These live in src/main/jsl-* and will be
1254 // output to $buildDir/classes/jsl-compilers/* (where * == decora or prism).
1255 // 2) Generate source files from the JSL files contained in src/main/jsl-*. These
1256 // will be output to $buildDir/generated-src/jsl-*
1257 // 3) Compile the JSL Java sources in $buildDir/generated-src/jsl-* and put the output
1258 // into classes/jsl-*
1259 // 4) Compile the native JSL sources in $buildDir/generated-src/jsl-* and put the obj
1260 // files into native/jsl-* and the resulting library into libs/jsl-*.dll|so|dylib
1261 // 5) Modify the jar step to include classes/jsl-*
1262 // The native library must be copied over during SDK creation time in the "sdk" task. In
1263 // addition to these steps, the clean task is created. Note that I didn't bother to create
1264 // a new task for each of the decora files, preferring instead just to create a rule?? Also
1265 // need "clean" tasks for each compile task.
1266
1267 addJSL(project, "Decora", "com/sun/scenario/effect/impl/hw/d3d/hlsl") { sourceDir, destinationDir ->
1268 [[fileName: "ColorAdjust", generator: "CompileJSL", outputs: "-all"],
1269 [fileName: "Brightpass", generator: "CompileJSL", outputs: "-all"],
1270 [fileName: "SepiaTone", generator: "CompileJSL", outputs: "-all"],
1271 [fileName: "PerspectiveTransform", generator: "CompileJSL", outputs: "-all"],
1272 [fileName: "DisplacementMap", generator: "CompileJSL", outputs: "-all"],
1273 [fileName: "InvertMask", generator: "CompileJSL", outputs: "-all"],
1274 [fileName: "Blend", generator: "CompileBlend", outputs: "-all"],
1275 [fileName: "PhongLighting", generator: "CompilePhong", outputs: "-all"],
1276 [fileName: "LinearConvolve", generator: "CompileLinearConvolve", outputs: "-hw"],
1277 [fileName: "LinearConvolveShadow", generator: "CompileLinearConvolve", outputs: "-hw"]].each { settings ->
1278 javaexec {
1279 executable = JAVA
1280 workingDir = "modules/graphics"
1281 main = settings.generator
1282 classpath = configurations.compile + configurations.antlr3
1283 classpath += files("$buildDir/classes/main")
1284 classpath += files("$buildDir/classes/jsl-compilers/decora")
1285 args = ["-i", sourceDir, "-o", destinationDir, "-t", "-pkg", "com/sun/scenario/effect", "$settings.outputs", "$settings.fileName"]
1286 jvmArgs "-Djava.ext.dirs="
1287 }
1288 }
1289 }
1290
1291 task generateDecoraNativeHeaders(type: JavaHeaderTask, dependsOn: compileDecoraJavaShaders) {
1292 description = "Generates JNI Headers for Decora SSE Natives"
1293 source file("$buildDir/classes/jsl-decora")
1294 source file("$buildDir/classes/main")
1295 include("com/sun/scenario/effect/impl/sw/sse/*");
1296 classpath = files("$buildDir/classes/main", "$buildDir/classes/jsl-decora")
1297 output = file("$buildDir/generated-src/headers/jsl-decora")
1298 }
1299
1300 task nativeDecora(dependsOn: compileDecoraHLSLShaders, group: "Build") {
1301 description = "Generates JNI headers, compiles, and builds native dynamic library for Decora"
1302 }
1303 task cleanNativeDecora(type: Delete, group: "Build") {
1304 description = "Clean native objects for Decora"
1305 }
1306
1307 def headerDir = file("$buildDir/generated-src/headers/jsl-decora")
1308 def nativeRootDir = project.file("$project.buildDir/native/jsl-decora")
1309 def libRootDir = project.file("$project.buildDir/libs/jsl-decora")
1310 // For each compile target, create cc and link tasks
1311 compileTargets { t ->
1312 def target = t.name
1313 def upperTarget = t.upper
1314 def capitalTarget = t.capital
1315 def properties = rootProject.ext[upperTarget];
1316 def library = properties.library
1317 def ccOutput = file("$nativeRootDir/$target");
1318
1319 def ccTask = task("compileDecoraNativeShaders$capitalTarget", type: CCTask, dependsOn: generateDecoraNativeHeaders) {
1320 description = "Compiles Decora SSE natives"
1321 matches = ".*\\.cc"
1322 source file("$buildDir/generated-src/jsl-decora")
1323 source file("modules/graphics/src/main/native-decora")
1324 headers = headerDir
1325 params.addAll(properties.decora.ccFlags)
1326 output(ccOutput)
1327 compiler = properties.decora.compiler
1328 cleanNativeDecora.delete ccOutput
1329 }
1330
1331 def linkTask = task("linkDecoraNativeShaders$capitalTarget", type: LinkTask, dependsOn: ccTask) {
1332 description = "Creates native dynamic library for Decora SSE"
1333 objectDir = file("$nativeRootDir/$target")
1334 linkParams.addAll(properties.decora.linkFlags)
1335 lib = file("$libRootDir/$t.name/${library(properties.decora.lib)}")
1336 linker = properties.decora.linker
1337 cleanNativeDecora.delete "$libRootDir/$t.name/"
1338 }
1339
1340 if (IS_WINDOWS && target == "win") {
1341 def rcTask = project.task("rcDecoraNativeShaders$capitalTarget", type: CompileResourceTask, dependsOn: generateDecoraNativeHeaders) {
1342 description = "Compiles native sources for Decora SSE"
1343 matches = ".*\\.rc"
1344 compiler = properties.decora.rcCompiler
1345 source(properties.decora.rcSource)
1346 if (properties.decora.rcFlags) {
1347 rcParams.addAll(properties.decora.rcFlags)
1348 }
1349 output(ccOutput)
1350 }
1351 linkTask.dependsOn rcTask;
1352 }
1353
1354 nativeDecora.dependsOn(linkTask)
1355 }
1356
1357 // Prism JSL
1358 addJSL(project, "Prism", "com/sun/prism/d3d/hlsl") { sourceDir, destinationDir ->
1359 def inputFiles = fileTree(dir: sourceDir)
1360 inputFiles.include "**/*.jsl"
1361 inputFiles.each { file ->
1362 javaexec {
1363 executable = JAVA
1364 workingDir = "modules/graphics"
1365 main = "CompileJSL"
1366 classpath = configurations.compile + configurations.antlr3
1367 classpath += files("$buildDir/classes/jsl-compilers/prism", "modules/graphics/src/main/jsl-prism") // for the .stg
1368 args = ["-i", sourceDir, "-o", destinationDir, "-t", "-pkg", "com/sun/prism", "-d3d", "-es2", "-name", "$file"]
1369 jvmArgs "-Djava.ext.dirs="
1370 }
1371 }
1372 }
1373
1374 classes.dependsOn compilePrismJavaShaders;
1375 nativePrism.dependsOn compilePrismHLSLShaders;
1376
1377 project.nativeAllTask.dependsOn nativeDecora
1378 project.cleanNativeAllTask.dependsOn cleanNativeDecora
1379 assemble.dependsOn nativeDecora
1380 processResources.dependsOn processDecoraShaders, processPrismShaders
1381
1382 test {
1383 jvmArgs "-Djava.ext.dirs=", "-Djavafx.toolkit=com.sun.javafx.pgstub.StubToolkit", "-DCSS_META_DATA_TEST_DIR=${file('$buildDir/classes/main/javafx')}"
1384 enableAssertions = true
1385 testLogging.exceptionFormat = "full"
1386 scanForTestClasses = false
1387 include "**/*Test.*"
1388 if (BUILD_CLOSED && DO_JCOV) {
1389 addJCov(project, test)
1390 }
1391 }
1392
1393 // To enable the IDEs to all be happy (no red squiggles) we need to have the libraries
1394 // available in some known location. Maybe in the future the Gradle plugins to each
1395 // of the IDEs will be good enough that we won't need this hack anymore.
1396 classes << {
1397 // Copy all of the download libraries to the libs directory for the sake of the IDEs
1398 File libsDir = rootProject.file("build/libs");
1399 libsDir.mkdirs();
1400 for (File f : [configurations.compile.files, configurations.antlr3.files].flatten()) {
1401 copy {
1402 into libsDir
1403 from f.getParentFile()
1404 include "**/antlr-3.1.3.jar"
1405 include "**/stringtemplate-3.2.jar"
1406 include "**/antlr-runtime-3.1.3.jar"
1407 includeEmptyDirs = false
1408 }
1409 // Have to rename the swt jar because it is some platform specific name but
1410 // for the sake of the IDEs we need to have a single stable name that works
1411 // on every platform
1412 copy {
1413 into libsDir
1414 from f.getParentFile()
1415 include "**/*swt*.jar"
1416 includeEmptyDirs = false
1417 rename ".*swt.*jar", "swt-debug\\.jar"
1418 }
1419 }
1420 }
1421 }
1422
1423 project(":controls") {
1424 dependencies {
1425 compile BUILD_SRC, project(":base"), project(":graphics"), project(":designTime")
1426 // TODO not sure how to specify this? processResources project(":base"), project(":graphics")
1427 testCompile project(":graphics").sourceSets.test.output
1428 testCompile project(":base").sourceSets.test.output
1429 }
1430
1431 test {
1432 jvmArgs "-Djavafx.toolkit=com.sun.javafx.pgstub.StubToolkit"
1433 }
1434
1435 // TODO Css2Bin really should be moved out and put into buildSrc if it can be
1436 // TODO could change script to dynamically locate all .css files and create bss for them, probably better
1437 // TODO also not sure there is any benefit to having css files in the jfxrt.jar at all
1438 processResources << {
1439 ["$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/caspian.css",
1440 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/caspian-no-transparency.css",
1441 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/embedded-qvga.css",
1442 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/embedded.css",
1443 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/fxvk.css",
1444 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/caspian/highcontrast.css",
1445 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/modena/modena.css",
1446 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/modena/modena-no-transparency.css",
1447 "$buildDir/resources/main/com/sun/javafx/scene/control/skin/modena/touch.css"].each { css ->
1448 javaexec {
1449 executable = JAVA
1450 workingDir = "modules/controls"
1451 classpath files("$buildDir/classes/main",
1452 project(":graphics").sourceSets.main.output,
1453 project(":base").sourceSets.main.output)
1454 main = "com.sun.javafx.css.parser.Css2Bin"
1455 args css
1456 jvmArgs "-Djava.ext.dirs="
1457 }
1458 }
1459 }
1460 }
1461
1462 project(":extensions") {
1463 dependencies {
1464 compile BUILD_SRC, project(":base"), project(":graphics")
1465 }
1466 }
1467
1468 project(":swing") {
1469 /* should not be built, but needed in builders and JMX
1470 tasks.all {
1471 if (!COMPILE_SWING) it.enabled = false
1472 }
1473 */
1474 dependencies {
1475 compile BUILD_SRC, project(":base"), project(":graphics")
1476 }
1477 }
1478
1479 project(":swt") {
1480 tasks.all {
1481 if (!COMPILE_SWT) it.enabled = false
1482 }
1483 dependencies {
1484 compile BUILD_SRC, project(":base"), project(":graphics")
1485 compile name: SWT_FILE_NAME
1486 }
1487 }
1488
1489 project(":fxml") {
1490 dependencies {
1491 compile BUILD_SRC, project(":base"), project(":graphics"),
1492 project(":controls"), project(":swt"), project(":swing")
1493 testCompile project(":graphics").sourceSets.test.output
1494 }
1495 test {
1496 // StubToolkit is not *really* needed here, but because some code inadvertently invokes performance
1497 // tracker and this attempts to fire up the toolkit and this looks for native libraries and fails,
1498 // we have to use the stub toolkit for now.
1499 jvmArgs "-Djavafx.toolkit=com.sun.javafx.pgstub.StubToolkit"
1500 classpath += files("$JDK_HOME/jre/lib/ext/nashorn.jar")
1501 }
1502 }
1503
1504 project(":builders") {
1505 sourceCompatibility = 1.7
1506
1507 if (!COMPILE_SWING) sourceSets.main.java.exclude ("**/swing/**")
1508 if (!COMPILE_SWT) sourceSets.main.java.exclude ("**/swt/**")
1509 if (!IS_COMPILE_WEBKIT) sourceSets.main.java.exclude ("**/web/**")
1510
1511 dependencies {
1512 compile BUILD_SRC, project(":base"), project(":graphics"),
1513 project(":controls"), project(":swt"), project(":swing"), project(":media"), project(":web")
1514 testCompile project(":graphics").sourceSets.test.output
1515 }
1516 test {
1517 // StubToolkit is not *really* needed here, but because some code inadvertently invokes performance
1518 // tracker and this attempts to fire up the toolkit and this looks for native libraries and fails,
1519 // we have to use the stub toolkit for now.
1520 jvmArgs "-Djavafx.toolkit=com.sun.javafx.pgstub.StubToolkit"
1521 }
1522 }
1523
1524 project(":designTime") {
1525 tasks.all {
1526 if (!COMPILE_DESIGN_TIME) it.enabled = false
1527 }
1528 dependencies {
1529 compile project(":graphics")
1530 }
1531 }
1532
1533 project(":jmx") {
1534 dependencies {
1535 compile project(":base")
1536 compile project(":graphics")
1537 compile project(":swing")
1538 compile project(":media")
1539 }
1540
1541 // Tests are disabled until RT-33926 can be fixed
1542 test.enabled = false
1543 }
1544
1545 // This project is for system tests that need to run with a full SDK.
1546 // Most of them display a stage or do other things that preclude running
1547 // them in a shared JVM or as part of the "smoke test" run (which must
1548 // not pop up any windows or use audio). As such, they are only enabled
1549 // when FULL_TEST is specified, and each test runs in its own JVM
1550 project(":systemTests") {
1551 test {
1552 enabled = IS_FULL_TEST
1553 if (!IS_USE_ROBOT) {
1554 // Disable all robot-based visual tests
1555 exclude("**/helloworld/*.*");
1556 exclude("**/javafx/embed/swing/*.*");
1557 exclude("**/javafx/scene/layout/*.*");
1558 exclude("**/test3d/*.*");
1559 exclude("**/painttest/*.*");
1560 }
1561 if (!IS_AWT_TEST) {
1562 // Disable all AWT-based tests
1563 exclude("**/javafx/embed/swing/*.*");
1564 exclude("**/com/sun/javafx/application/Swing*.*");
1565 }
1566 forkEvery = 1
1567 }
1568 }
1569
1570 project(":fxpackager") {
1571 tasks.all {
1572 if (!COMPILE_FXPACKAGER) it.enabled = false
1573 }
1574 // fxpackager has a dependency on ant in order to build the ant jar,
1575 // and as such needs to point to the apache binary repository
1576 if (!BUILD_CLOSED) {
1577 repositories {
1578 maven {
1579 url "https://repository.apache.org"
1580 }
1581 }
1582 }
1583
1584 dependencies {
1585 compile group: "org.apache.ant", name: "ant", version: "1.8.2"
1586 }
1587
1588 // When producing the jar, we need to relocate a few class files
1589 // from their normal location to a resources/classes or resources/web-files
1590 // location
1591 jar {
1592 includeEmptyDirs = false
1593 archiveName = "ant-javafx.jar"
1594 eachFile { FileCopyDetails details ->
1595 if (details.path.startsWith("com/javafx/main")) {
1596 details.path = "resources/classes/$details.path"
1597 } else if (details.path.startsWith("web-files")) {
1598 details.path = "resources/$details.path"
1599 }
1600 }
1601 }
1602
1603 // The "man" task will create a $buildDir/man containing the man
1604 // files for the system being built
1605 task man(type: Copy) {
1606 includeEmptyDirs = false
1607 enabled = (IS_LINUX || IS_MAC) && COMPILE_FXPACKAGER
1608 from "src/main/man"
1609 into "$buildDir/man"
1610 exclude "**/*.html"
1611 if (IS_MAC) exclude "**/ja_JP.UTF-8/**"
1612 }
1613 processResources.dependsOn man
1614
1615 // Compile the native launchers. These are included in ant-javafx.jar
1616 // TODO should teach this to know 32 / 64 bit
1617 if (IS_WINDOWS && COMPILE_FXPACKAGER) {
1618 task compileWinLauncher(type: CCTask, group: "Build") {
1619 description = "Compiles native sources for the application co-bundle launcher";
1620 matches = "WinLauncher\\.cpp";
1621 params.addAll(WIN.launcher.ccFlags);
1622 output(file("$buildDir/native/WinLauncher"));
1623 source(file("src/main/native/launcher/win"));
1624 compiler = WIN.launcher.compiler
1625 exe = true;
1626 linkerOptions.addAll(WIN.launcher.linkFlags);
1627 doLast {
1628 copy {
1629 from "$buildDir/native/WinLauncher/WinLauncher.exe"
1630 into "$buildDir/classes/main/com/sun/javafx/tools/resource/windows"
1631 }
1632 }
1633 }
1634 task compileIconSwap(type: CCTask, group: "Build") {
1635 description = "Compiles native sources for the application co-bundle launcher"
1636 matches = "IconSwap\\.cpp"
1637 params.addAll(WIN.iconLauncher.ccFlags)
1638 output(file("$buildDir/native/IconSwap"))
1639 source file("src/main/native/launcher/win")
1640 compiler = WIN.launcher.compiler
1641 exe = true
1642 linkerOptions.addAll(WIN.iconLauncher.linkFlags)
1643 doLast {
1644 copy {
1645 from "$buildDir/native/IconSwap/IconSwap.exe"
1646 into "$buildDir/classes/main/com/sun/javafx/tools/resource/windows"
1647 }
1648 }
1649 }
1650 task compileLauncher(dependsOn: [compileWinLauncher, compileIconSwap])
1651 jar.dependsOn compileLauncher;
1652 } else if (COMPILE_FXPACKAGER) {
1653 if (IS_MAC) {
1654 task compileLauncher(type: CCTask, group: "Build") {
1655 description = "Compiles native sources for the application co-bundle launcher"
1656 matches = ".*\\.m"
1657 output(file("$buildDir/classes/main/com/sun/javafx/tools/resource/mac"))
1658 params.addAll(MAC.launcher.ccFlags)
1659 source file("src/main/native/launcher/mac")
1660 compiler = MAC.launcher.compiler
1661 eachOutputFile = { f ->
1662 return new File(f.getParent(), "JavaAppLauncher")
1663 }
1664 }
1665 jar.dependsOn compileLauncher;
1666 } else {
1667 def ccTask = project.task("compileLauncher", type: CCTask, group: "Build") {
1668 description = "Compiles native sources for the application co-bundle launcher"
1669 matches = ".*\\.c"
1670 output(file("$buildDir/native/launcher"))
1671 params.addAll(LINUX.launcher.ccFlags)
1672 compiler = LINUX.launcher.compiler
1673 source file("src/main/native/launcher/linux")
1674 }
1675 def linkTask = project.task("linkLauncher", type: LinkTask, dependsOn: ccTask, group: "Build") {
1676 description = "Creates native dynamic library for the application co-bundle launcher"
1677 linker = LINUX.launcher.linker
1678 linkParams.addAll(LINUX.launcher.linkFlags)
1679 objectDir = file("$buildDir/native/launcher")
1680 lib = file("$buildDir/classes/main/com/sun/javafx/tools/resource/linux/JavaAppLauncher")
1681 }
1682 jar.dependsOn linkTask;
1683 }
1684 }
1685
1686 // Builds the javafxpackager executable. For everything other than windows,
1687 // this is simply moving the existing shell script and ensuring it has proper
1688 // permissions. For Windows, this includes compiling the native executable
1689 if (IS_WINDOWS && COMPILE_FXPACKAGER){
1690 task buildJavaFXPackager(type: CCTask, group: "Build") {
1691 description = "Compiles native sources for javafxpackager.exe"
1692 matches = "javafxpackager\\.cpp"
1693 params.addAll(WIN.fxpackager.ccFlags)
1694 compiler = WIN.fxpackager.compiler
1695 output(file("$buildDir/native/javafxpackager"))
1696 source WIN.fxpackager.nativeSource
1697 doFirst {
1698 copy {
1699 mkdir "$buildDir/native"
1700 mkdir "$buildDir/native/javafxpackager"
1701 from file("src/main/native/javafxpackager/win/javafxpackager.manifest")
1702 into file("$buildDir/native/javafxpackager")
1703 filter { line->
1704 line = line.replace("FXVERSION", "${RAW_VERSION}.${HUDSON_BUILD_NUMBER}");
1705 }
1706 }
1707 }
1708 doLast {
1709 mkdir "$buildDir/native"
1710 exec({
1711 commandLine("$RC", "/nologo", "/l", "0x409", "/r", "/dJFX_DVERSION=8", "/dJFX_VERSION=8",
1712 "/fo$buildDir/native/javafxpackager/javafxpackager.res",
1713 "src/main/native/javafxpackager/win/javafxpackager.rc");
1714 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT);
1715 });
1716 }
1717 doLast {
1718 mkdir "$buildDir/javafxpackager"
1719 exec({
1720 commandLine("$WIN.fxpackager.linker", "/nologo", "/opt:REF", "/incremental:no", "/manifest", "kernel32.lib", "advapi32.lib",
1721 "/out:$buildDir/native/javafxpackager/javafxpackager.exe",
1722 "$buildDir/native/javafxpackager/javafxpackager.obj",
1723 "$buildDir/native/javafxpackager/javafxpackager.res")
1724 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1725 })
1726 }
1727 doLast {
1728 exec({
1729 commandLine("$MC", "-manifest",
1730 "$buildDir/native/javafxpackager/javafxpackager.manifest",
1731 "-outputresource:$buildDir/native/javafxpackager/javafxpackager.exe")
1732 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1733 })
1734 copy {
1735 from file("$buildDir/native/javafxpackager/javafxpackager.exe")
1736 into file("$buildDir/javafxpackager")
1737 }
1738 }
1739 }
1740 } else {
1741 task buildJavaFXPackager(group: "Build") {
1742 enabled = COMPILE_FXPACKAGER
1743 doLast {
1744 copy {
1745 from "src/main/native/javafxpackager/shell"
1746 into "$buildDir/javafxpackager"
1747 fileMode = 0755
1748 }
1749 }
1750 }
1751 }
1752
1753 jar.dependsOn buildJavaFXPackager
1754
1755 classes << {
1756 // Copy all of the download libraries to libs directory for the sake of the IDEs
1757 File libsDir = rootProject.file("build/libs");
1758 File antLib = new File(libsDir, "ant-1.8.2.jar")
1759 libsDir.mkdirs();
1760 for (File f : configurations.compile.files) {
1761 copy {
1762 into libsDir
1763 from f.getParentFile()
1764 include "**/ant-1.8.2.jar"
1765 includeEmptyDirs = false
1766 }
1767 }
1768 }
1769 }
1770
1771 project(":media") {
1772 configurations {
1773 media
1774 }
1775
1776 dependencies {
1777 compile BUILD_SRC, project(":base"), project(":graphics")
1778 }
1779
1780 sourceSets {
1781 tools {
1782 java.srcDir "src/tools/java"
1783 }
1784 }
1785
1786 compileToolsJava {
1787 enabled = IS_COMPILE_MEDIA
1788 classpath = sourceSets.main.output;
1789 }
1790
1791 project.ext.makeJobsFlag = IS_WINDOWS && IS_DEBUG_NATIVE ? "-j1" : "-j5";
1792 project.ext.buildType = IS_DEBUG_NATIVE ? "Debug" : "Release";
1793
1794 def nativeSrcDir = file("${projectDir}/src/main/native")
1795 def generatedHeadersDir = file("${buildDir}/generated-src/headers")
1796
1797 task generateHeaders(dependsOn: compileJava) {
1798 enabled = IS_COMPILE_MEDIA
1799 doLast {
1800 def classpath = sourceSets.main.output;
1801 mkdir generatedHeadersDir;
1802
1803 def classesList = ["com.sun.media.jfxmedia.logging.Logger",
1804 "com.sun.media.jfxmedia.track.AudioTrack",
1805 "com.sun.media.jfxmedia.control.VideoDataBuffer",
1806 "com.sun.media.jfxmedia.control.VideoFormat\$FormatTypes",
1807 "com.sun.media.jfxmediaimpl.NativeAudioClip",
1808 "com.sun.media.jfxmediaimpl.NativeMediaPlayer",
1809 "com.sun.media.jfxmediaimpl.NativeVideoBuffer",
1810 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTPlatform",
1811 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTMedia",
1812 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTMediaPlayer",
1813 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTAudioEqualizer",
1814 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTEqualizerBand",
1815 "com.sun.media.jfxmediaimpl.platform.gstreamer.GSTAudioSpectrum"]
1816 if (IS_MAC) {
1817 classesList.addAll( ["com.sun.media.jfxmediaimpl.platform.osx.OSXPlatform",
1818 "com.sun.media.jfxmediaimpl.platform.osx.OSXMedia",
1819 "com.sun.media.jfxmediaimpl.platform.osx.OSXMediaPlayer"] );
1820 }
1821 exec {
1822 commandLine ("${JAVAH}", "-J-Djava.ext.dirs=", "-d", "${generatedHeadersDir}", "-classpath", "${classpath.asPath}");
1823 args classesList;
1824 }
1825 }
1826 }
1827
1828 task generateMediaErrorHeader(dependsOn: [compileToolsJava, compileJava]) {
1829 enabled = IS_COMPILE_MEDIA
1830 doLast {
1831 def classpath = files(sourceSets.main.output, sourceSets.tools.output);
1832 def sourcepath = sourceSets.main.java.srcDirs;
1833 def headerpath = file("$generatedHeadersDir/jfxmedia_errors.h");
1834 def srcRoot = (sourcepath.toArray())[0];
1835
1836 mkdir generatedHeadersDir;
1837
1838 exec {
1839 commandLine("$JAVA", "-Djava.ext.dirs=", "-classpath", "${classpath.asPath}");
1840 args("headergen.HeaderGen", "$headerpath", "$srcRoot");
1841 }
1842 }
1843 }
1844
1845 task buildNativeTargets {
1846 enabled = IS_COMPILE_MEDIA
1847 }
1848
1849 compileTargets { t->
1850 def nativeOutputDir = file("${buildDir}/native/${t.name}")
1851 def projectDir = t.name.startsWith("arm") ? "linux" : t.name
1852 def mediaProperties = project.rootProject.ext[t.upper].media
1853
1854 def buildNative = task("build${t.capital}Native", dependsOn: [generateHeaders, generateMediaErrorHeader]) {
1855 enabled = IS_COMPILE_MEDIA
1856 doLast {
1857 exec {
1858 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/jfxmedia/projects/${projectDir}")
1859 args("JAVA_HOME=${JDK_HOME}", "GENERATED_HEADERS_DIR=${generatedHeadersDir}",
1860 "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=jfxmedia")
1861
1862 if (t.name == "win") {
1863 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1864 args(IS_64 ? "ARCH=x64" : "ARCH=x32", "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.jfxmediaRcFile}")
1865 } else {
1866 args ("CC=${mediaProperties.compiler}", "LINK=${mediaProperties.linker}", "LIB=${mediaProperties.lib}")
1867
1868 if (t.name.startsWith("arm"))
1869 args("EXTRA_CFLAGS=${mediaProperties.extra_cflags}", "EXTRA_LDFLAGS=${mediaProperties.extra_ldflags}")
1870 else
1871 args("HOST_COMPILE=1")
1872 }
1873 }
1874 }
1875 }
1876
1877 if (!t.name.startsWith("arm")) {
1878 // Building GStreamer
1879 def buildGStreamer = task("build${t.capital}GStreamer") {
1880 enabled = IS_COMPILE_MEDIA
1881 doLast {
1882 exec {
1883 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/gstreamer-lite")
1884 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=gstreamer-lite")
1885
1886 if (t.name == "win") {
1887 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1888 args(IS_64 ? "ARCH=x64" : "ARCH=x32", "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.gstreamerRcFile}")
1889 } else
1890 args ("CC=${mediaProperties.compiler}", "LINK=${mediaProperties.linker}", "LIB=${mediaProperties.lib}")
1891 }
1892 }
1893 }
1894
1895 def buildPlugins = task("build${t.capital}Plugins", dependsOn: buildGStreamer) {
1896 enabled = IS_COMPILE_MEDIA
1897
1898 if (!project.ext.properties.containsKey("ON2_SRCDIR"))
1899 project.ext.ON2_SRCDIR = "";
1900
1901 if (!project.ext.properties.containsKey("ON2_LIB"))
1902 project.ext.ON2_LIB = "";
1903
1904 doLast {
1905 exec {
1906 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/fxplugins")
1907 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=fxplugins",
1908 "ON2_SRCDIR=${project.ext.ON2_SRCDIR}", "ON2_LIB=${project.ext.ON2_LIB}")
1909
1910 if (t.name == "win") {
1911 Map winEnv = new HashMap(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1912
1913 String sdkDir = System.getenv("BASECLASSES_SDK_DIR");
1914 if (sdkDir == null)
1915 {
1916 sdkDir = "C:/Program Files/Microsoft SDKs/Windows/v7.1" // Default value
1917 winEnv["BASECLASSES_SDK_DIR"] = sdkDir
1918 }
1919 environment(winEnv)
1920
1921 args(IS_64 ? "ARCH=x64" : "ARCH=x32", "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.fxpluginsRcFile}")
1922 } else
1923 args ("CC=${mediaProperties.compiler}", "LINK=${mediaProperties.linker}", "LIB=${mediaProperties.lib}")
1924 }
1925 }
1926 }
1927
1928 buildNative.dependsOn buildPlugins
1929
1930 if (t.name == "linux") {
1931 def buildAVPlugin = task( "buildAVPlugin", dependsOn: [buildPlugins]) {
1932 enabled = IS_COMPILE_MEDIA
1933
1934 if (!project.ext.properties.containsKey("LIBAV"))
1935 project.ext.LIBAV = "";
1936
1937 doLast {
1938 // Building fxavcodec plugin (libav plugin)
1939 exec {
1940 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/linux/avplugin")
1941 args("CC=${mediaProperties.compiler}", "OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}",
1942 "BASE_NAME=avplugin", "LIBAV_DIR=${project.ext.LIBAV}")
1943 }
1944 }
1945 }
1946 buildNative.dependsOn buildAVPlugin
1947 }
1948
1949 if (t.name == "win") {
1950 def buildResources = task("buildResources") << {
1951 def rcOutputDir = "${nativeOutputDir}/${buildType}"
1952 mkdir rcOutputDir
1953 exec {
1954 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1955 commandLine (WIN.media.rcCompiler)
1956 args(WIN.media.glibRcFlags)
1957 args("/Fo${rcOutputDir}/${WIN.media.glibRcFile}", WIN.media.rcSource)
1958 }
1959
1960 exec {
1961 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1962 commandLine (WIN.media.rcCompiler)
1963 args(WIN.media.gstreamerRcFlags)
1964 args("/Fo${rcOutputDir}/${WIN.media.gstreamerRcFile}", WIN.media.rcSource)
1965 }
1966
1967 exec {
1968 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1969 commandLine (WIN.media.rcCompiler)
1970 args(WIN.media.fxpluginsRcFlags)
1971 args("/Fo${rcOutputDir}/${WIN.media.fxpluginsRcFile}", WIN.media.rcSource)
1972 }
1973
1974 exec {
1975 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1976 commandLine (WIN.media.rcCompiler)
1977 args(WIN.media.jfxmediaRcFlags)
1978 args("/Fo${rcOutputDir}/${WIN.media.jfxmediaRcFile}", WIN.media.rcSource)
1979 }
1980 }
1981
1982 def buildGlib = task("build${t.capital}Glib", dependsOn: [buildResources]) {
1983 enabled = IS_COMPILE_MEDIA
1984 doLast {
1985 exec {
1986 environment(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
1987 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/glib-lite")
1988 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=glib-lite",
1989 IS_64 ? "ARCH=x64" : "ARCH=x32", "RESOURCE=${nativeOutputDir}/${buildType}/${WIN.media.glibRcFile}")
1990 }
1991 }
1992 }
1993 buildGStreamer.dependsOn buildGlib
1994
1995 } else if (t.name == "mac") {
1996 def buildGlib = task("build${t.capital}Glib") {
1997 enabled = IS_COMPILE_MEDIA
1998 doLast {
1999 exec {
2000 commandLine ("make", "${makeJobsFlag}", "-C", "${nativeSrcDir}/gstreamer/projects/${projectDir}/glib-lite")
2001 args("OUTPUT_DIR=${nativeOutputDir}", "BUILD_TYPE=${buildType}", "BASE_NAME=glib-lite")
2002 args ("CC=${mediaProperties.compiler}", "LINK=${mediaProperties.linker}", "LIB=${mediaProperties.lib}")
2003 }
2004 }
2005 }
2006 buildGStreamer.dependsOn buildGlib
2007 }
2008 }
2009
2010 buildNativeTargets.dependsOn buildNative
2011 }
2012
2013 jar {
2014 exclude("headergen/**")
2015
2016 dependsOn compileJava
2017 if (IS_COMPILE_MEDIA)
2018 dependsOn buildNativeTargets
2019 }
2020 }
2021
2022 project(":web") {
2023 configurations {
2024 webkit
2025 }
2026 dependencies {
2027 compile project(":base"), project(":graphics"), project(":controls"), project(":media")
2028 }
2029
2030 compileJava {
2031 if (IS_COMPILE_WEBKIT) {
2032 // These classes will be generated by native build
2033 sourceSets.main.java.exclude("com/sun/webkit/dom/**")
2034 }
2035 }
2036
2037 task generateHeaders(dependsOn: compileJava) {
2038 doLast {
2039 def classpath = files("$buildDir/classes/main",
2040 project(":graphics").sourceSets.main.output.classesDir)
2041 def dest = file("$buildDir/generated-src/headers");
2042 mkdir dest;
2043 exec {
2044 commandLine("$JAVAH", "-J-Djava.ext.dirs=", "-d", "$dest",
2045 "-classpath", "${classpath.asPath}");
2046 args("java.lang.Character",
2047 "java.net.IDN",
2048 "com.sun.webkit.ContextMenu",
2049 "com.sun.webkit.ContextMenuItem",
2050 "com.sun.webkit.CursorManager",
2051 "com.sun.webkit.PageCache",
2052 "com.sun.webkit.PopupMenu",
2053 "com.sun.webkit.SharedBuffer",
2054 "com.sun.webkit.WatchdogTimer",
2055 "com.sun.webkit.WebPage",
2056 "com.sun.webkit.LoadListenerClient",
2057 "com.sun.webkit.event.WCFocusEvent",
2058 "com.sun.webkit.event.WCKeyEvent",
2059 "com.sun.webkit.event.WCMouseEvent",
2060 "com.sun.webkit.event.WCMouseWheelEvent",
2061 "com.sun.webkit.graphics.GraphicsDecoder",
2062 "com.sun.webkit.graphics.RenderMediaControls",
2063 "com.sun.webkit.graphics.RenderTheme",
2064 "com.sun.webkit.graphics.ScrollBarTheme",
2065 "com.sun.webkit.graphics.WCMediaPlayer",
2066 "com.sun.webkit.graphics.WCGraphicsManager",
2067 "com.sun.webkit.graphics.WCRenderQueue",
2068 "com.sun.webkit.graphics.WCPath",
2069 "com.sun.webkit.graphics.WCPathIterator",
2070 "com.sun.webkit.Timer",
2071 "com.sun.webkit.WCFrameView",
2072 "com.sun.webkit.WCPasteboard",
2073 "com.sun.webkit.WCPluginWidget",
2074 "com.sun.webkit.dom.JSObject",
2075 "com.sun.webkit.network.SocketStreamHandle",
2076 "com.sun.webkit.network.URLLoader",
2077 "com.sun.webkit.text.TextBreakIterator",
2078 "com.sun.webkit.text.TextNormalizer");
2079 }
2080 }
2081 }
2082
2083 task compileGenerated()
2084
2085 compileTargets { t ->
2086 def classifier = (t.name != "linux" && t.name != "win") ? t.name :
2087 IS_64 ? "${t.name}-amd64" : "${t.name}-i586"
2088 dependencies {
2089 webkit group: "com.sun.webkit", name: "webview-deps",
2090 version: "1.2", classifier: "$classifier", ext: "zip"
2091 }
2092
2093 def webkitOutputDir = "$buildDir/${t.name}"
2094 def webkitConfig = IS_DEBUG_NATIVE ? "Debug" : "Release"
2095
2096 def compileNativeTask = task("compileNative${t.capital}", dependsOn: generateHeaders) << {
2097 println "Building Webkit configuration /$webkitConfig/ into $webkitOutputDir"
2098
2099 def dependencyFile = configurations.webkit.filter(
2100 { File f -> f.getName().contains(classifier) }
2101 ).getSingleFile()
2102 ant.unzip(src: dependencyFile,
2103 dest: webkitOutputDir)
2104
2105 exec {
2106 workingDir("$projectDir/src/main/native")
2107 commandLine("perl", "Tools/Scripts/set-webkit-configuration", "--$webkitConfig")
2108 environment(["WEBKITOUTPUTDIR" : webkitOutputDir])
2109 }
2110
2111 exec {
2112 workingDir("$projectDir/src/main/native")
2113 if (t.name == "win") {
2114 String qtDir = cygpath(System.getenv().get("QTSDK_DIR"))
2115 String parfaitPath = IS_COMPILE_PARFAIT ? System.getenv().get("PARFAIT_PATH") + ";" : "";
2116 Map environmentSettings = new HashMap(WINDOWS_NATIVE_COMPILE_ENVIRONMENT)
2117 environmentSettings["PATH"] = parfaitPath + "$WINDOWS_VS_PATH;$qtDir/bin;$qtDir/qt/bin"
2118 environmentSettings["QMAKESPEC"] = "win32-msvc2008"
2119 environment(environmentSettings)
2120 /* To build with ICU:
2121 1. Download http://javaweb.us.oracle.com/jcg/fx-webrevs/RT-17164/WebKitLibrariesICU.zip
2122 and unzip it to WebKitLibraries folder.
2123 2. Copy DLLs from
2124 WebKitLibrariesICU.zip\WebKitLibraries\import\runtime
2125 to %windir%\system32
2126 3. Uncomment the line below
2127 */
2128 // args("--icu-unicode")
2129 } else if (t.name == "mac") {
2130 environment([
2131 "QMAKESPEC" : "macx-g++",
2132 "QMAKE_CFLAGS" : "-m64",
2133 "QMAKE_LFLAGS" : "-m64",
2134 ])
2135 } else if (t.name.startsWith("arm")) {
2136 // ARM cross build
2137 def webkitProperties = project.rootProject.ext[t.upper].webkit
2138 def qmakeSpecDir = "$webkitOutputDir/qws/linux-cross-${t.name}-g++"
2139 mkdir qmakeSpecDir
2140 File qmakeSpec = new File("$qmakeSpecDir/qmake.conf")
2141 qmakeSpec.append(
2142 """TARGET_PLATFORM = unix
2143 include(/usr/share/qt4/mkspecs/common/linux.conf)
2144 include(/usr/share/qt4/mkspecs/common/g++.conf)
2145 include(/usr/share/qt4/mkspecs/common/qws.conf)
2146 QMAKE_CC = $webkitProperties.compiler
2147 QMAKE_CXX = $webkitProperties.linker
2148 QMAKE_LINK = $webkitProperties.linker
2149 QMAKE_LINK_SHLIB = $webkitProperties.linker
2150 QMAKE_AR = $webkitProperties.ar cqs
2151 QMAKE_OBJCOPY = $webkitProperties.objcopy
2152 QMAKE_STRIP = $webkitProperties.strip
2153 QMAKE_CXXFLAGS = $webkitProperties.ccFlags
2154 QMAKE_LFLAGS = $webkitProperties.linkFlags
2155 load(qt_config)""")
2156 environment([
2157 "QMAKESPEC" : file(qmakeSpecDir).getAbsolutePath(),
2158 "PATH" : "$System.env.PATH:$webkitProperties.binDir",
2159 ])
2160 args("--nocache")
2161 }
2162 environment([
2163 "JAVA_HOME" : JDK_HOME,
2164 "WEBKITOUTPUTDIR" : webkitOutputDir,
2165 ])
2166
2167 if (IS_COMPILE_PARFAIT) {
2168 environment([
2169 "CC" : "parfait-gcc",
2170 "QMAKE_CC" : "parfait-gcc",
2171 "CXX" : "parfait-g++",
2172 "QMAKE_CXX" : "parfait-g++",
2173 "CPP" : "parfait-g++",
2174 "cc" : "parfait-gcc",
2175 "LINK" : "parfait-g++",
2176 "QMAKE_LINK": "parfait-g++",
2177 ])
2178 }
2179 commandLine("perl", "Tools/Scripts/build-webkit", "--java", "--imageio")
2180 }
2181
2182 def library = rootProject.ext[t.upper].library
2183 copy {
2184 from "$webkitOutputDir/$webkitConfig/lib/${library('jfxwebkit')}"
2185 into "$buildDir/libs/${t.name}"
2186 }
2187 copy {
2188 from "$webkitOutputDir/$webkitConfig/lib/${library('DumpRenderTreeJava')}"
2189 into "$buildDir/test/${t.name}"
2190 }
2191 }
2192
2193 if (IS_WINDOWS && t.name == "win") {
2194 def webkitProperties = project.rootProject.ext[t.upper].webkit
2195 def rcTask = project.task("rc${t.capital}", type: CompileResourceTask) {
2196 compiler = webkitProperties.rcCompiler
2197 source(webkitProperties.rcSource)
2198 if (webkitProperties.rcFlags) {
2199 rcParams.addAll(webkitProperties.rcFlags)
2200 }
2201 output(file("$webkitOutputDir/$webkitConfig/WebCore/obj"))
2202 }
2203 compileNativeTask.dependsOn rcTask
2204 }
2205
2206 def compileGeneratedTask = task("compileGenerated${t.capital}", type: JavaCompile, dependsOn: compileNativeTask) {
2207 def gensrcDir = "$webkitOutputDir/$webkitConfig/WebCore/generated/java"
2208 doFirst {
2209 copy {
2210 from "$projectDir/src/main/java/com/sun/webkit/dom/EventListenerImpl.java"
2211 into "$gensrcDir/com/sun/webkit/dom"
2212 }
2213 }
2214 classpath = files(project(":graphics").sourceSets.main.output) // for JSObject
2215 source gensrcDir
2216 destinationDir = file("$buildDir/classes/main")
2217 }
2218
2219 compileGenerated.dependsOn compileGeneratedTask
2220 }
2221
2222 def drtClasses = "com/sun/javafx/webkit/drt/**"
2223 jar.exclude(drtClasses)
2224 task drtJar(type: Jar, dependsOn: compileJava) {
2225 archiveName = "drt.jar"
2226 destinationDir = file("$buildDir/test")
2227 from "$buildDir/classes/main"
2228 include drtClasses
2229 }
2230
2231 if (IS_COMPILE_WEBKIT) {
2232 jar.dependsOn compileGenerated, drtJar
2233 }
2234 }
2235
2236 allprojects {
2237 // The following block is a workaround for the fact that presently Gradle
2238 // can't set the -XDignore.symbol.file flag, because it appears that the
2239 // javac API is lacking support for it. So what we'll do is find any Compile
2240 // task and manually provide the options necessary to fire up the
2241 // compiler with the right settings.
2242 //
2243 // Also, we need to remove jfxrt.jar from the ext classpath (if it is there)
2244 tasks.withType(Compile) { compile ->
2245 // It looks like we have to use ant to compile instead of the built-in gradle
2246 // compiler stuff because otherwise it won't compile on CYGWIN
2247 // TODO need to file issue with Gradle
2248 compile.options.useAnt = true
2249 compile.options.debug = true // we always generate debugging info in the class files
2250 compile.options.debugOptions.debugLevel = IS_DEBUG_JAVA ? "source,lines,vars" : "source,lines"
2251 compile.options.fork = true
2252 compile.options.forkOptions.executable = JAVAC
2253 compile.options.warnings = IS_LINT
2254 compile.options.useDepend = IS_USE_DEPEND
2255 compile.options.compilerArgs = ["-Djava.ext.dirs=", "-XDignore.symbol.file", "-encoding", "UTF-8"]
2256
2257 // Add in the -Xlint options
2258 if (IS_LINT) {
2259 LINT.split("[, ]").each { s ->
2260 compile.options.compilerArgs += "-Xlint:$s"
2261 }
2262 }
2263 }
2264 }
2265
2266 /******************************************************************************
2267 * *
2268 * Top Level Tasks *
2269 * *
2270 * These are the tasks which are defined only for the top level project and *
2271 * not for any sub projects. These are generally the entry point that is *
2272 * used by Hudson and by the continuous build system. *
2273 * *
2274 *****************************************************************************/
2275
2276 task clean() {
2277 group = "Basic"
2278 description = "Deletes the build directory and the build directory of all sub projects"
2279 getSubprojects().each { subProject ->
2280 dependsOn(subProject.getTasksByName("clean", true));
2281 }
2282 doLast {
2283 delete(buildDir);
2284 }
2285 }
2286
2287
2288 task javadoc(type: Javadoc) {
2289 enabled = IS_BUILD_JAVADOC
2290 group = "Basic"
2291 description = "Generates the JavaDoc for all the public API"
2292 executable = JAVADOC
2293 def projectsToDocument = [
2294 project(":base"), project(":graphics"), project(":controls"), project(":media"),
2295 project(":swing"), project(":swt"), project(":fxml"), project(":web")]
2296 source(projectsToDocument.collect({
2297 [it.sourceSets.main.java, "$it.buildDir/generated-src/builders"]
2298 }));
2299 setDestinationDir(new File(buildDir, 'javadoc'));
2300 // Might need a classpath
2301 classpath = files(projectsToDocument.collect { project ->
2302 project.sourceSets.main.compileClasspath
2303 });
2304 classpath += files(projectsToDocument.collect { project ->
2305 project.sourceSets.main.output
2306 });
2307 exclude("com/**/*", "javafx/scene/ParentDesignInfo*", "Compile*", "javafx/builder/**/*");
2308 options.windowTitle("${javadocTitle}")
2309 options.header("${javadocHeader}")
2310 options.bottom("${javadocBottom}")
2311 options.links(JDK_DOCS);
2312 options.addBooleanOption("XDignore.symbol.file").setValue(true);
2313 options.addBooleanOption("Xdoclint:none").setValue(!IS_DOC_LINT);
2314 options.addBooleanOption("javafx").setValue(true);
2315 doLast {
2316 projectsToDocument.each { p ->
2317 copy {
2318 from "$p.projectDir/src/main/docs"
2319 into "$buildDir/javadoc"
2320 }
2321 }
2322 }
2323
2324 dependsOn(projectsToDocument.collect { project -> project.getTasksByName("classes", true)});
2325 }
2326
2327 task jfxrt() {
2328 rootProject.getTasksByName("compileTestJava", true).each { t ->
2329 if (t.enabled) t.dependsOn(jfxrt)
2330 }
2331 }
2332
2333 task sdk() {
2334 dependsOn(checkJfxrtJar)
2335
2336 rootProject.getTasksByName("test", true).each { t ->
2337 if (t.enabled) t.dependsOn(sdk)
2338 }
2339 }
2340
2341 task appsjar() {
2342 dependsOn(sdk)
2343 // Note: the jar dependencies get added elsewhere see project(":apps")
2344 }
2345
2346 // these are empty tasks, allowing us to depend on the task, which may have other
2347 // real work items added later.
2348 task copyAppsArtifacts() {
2349 dependsOn(appsjar)
2350 }
2351
2352 task apps() {
2353 dependsOn(sdk)
2354 dependsOn(appsjar)
2355 dependsOn(copyAppsArtifacts)
2356 }
2357
2358 task findbugs() {
2359 dependsOn(sdk)
2360
2361 // TODO: implement this
2362 doLast {
2363 if (!BUILD_CLOSED) {
2364 println "findbugs task is not implemented"
2365 }
2366 }
2367 }
2368
2369 // The following tasks are for the closed build only. They are a no-op for the open build
2370
2371 task checkCache() {
2372 dependsOn(updateCacheIfNeeded)
2373 }
2374
2375 // TODO: consider moving the "public-sdk" portion of this task here
2376 task publicExports() {
2377 doFirst {
2378 if (!IS_BUILD_JAVADOC) {
2379 fail("publicExports task requires: -PBUILD_JAVADOC=true")
2380 }
2381 }
2382 dependsOn(sdk)
2383 doLast {
2384 if (!BUILD_CLOSED) {
2385 println "publicExports task is only run for a closed build"
2386 }
2387 }
2388 }
2389
2390 task perf() {
2391 dependsOn(sdk,apps)
2392 doLast {
2393 if (!BUILD_CLOSED) {
2394 println "perf task is only run for a closed build"
2395 }
2396 }
2397 }
2398
2399 task zips() {
2400 doFirst {
2401 if (!IS_BUILD_JAVADOC) {
2402 fail("zips task requires: -PBUILD_JAVADOC=true")
2403 }
2404 }
2405 dependsOn(sdk,publicExports,apps,perf)
2406 doLast {
2407 if (!BUILD_CLOSED) {
2408 println "zips task is only run for a closed build"
2409 }
2410 }
2411 }
2412
2413 task copySources(type: Copy) {
2414 enabled = IS_BUILD_SRC_ZIP
2415 def projectsToCopy = [
2416 project(":base"), project(":graphics"), project(":controls"),
2417 project(":swing"), project(":swt"), project(":fxml"),
2418 project(":builders"), project(":web")]
2419 from(projectsToCopy.collect({
2420 ["${it.projectDir}/src/main/java"]
2421 }))
2422 include "**/*.java"
2423 into "${buildDir}/javafx-src"
2424 }
2425
2426 task zipSources(type: Zip) {
2427 enabled = IS_BUILD_SRC_ZIP
2428 dependsOn(copySources)
2429 archiveName = "javafx-src.zip"
2430 destinationDir = file("$buildDir")
2431 includeEmptyDirs = false
2432 from "${buildDir}/javafx-src"
2433 }
2434
2435 task src {
2436 enabled = IS_BUILD_SRC_ZIP
2437 description = "Created the javafx-src.zip bundle"
2438 dependsOn(zipSources)
2439 }
2440
2441 task all() {
2442 dependsOn(sdk,publicExports,apps,perf,zips)
2443 }
2444
2445 compileTargets { t ->
2446 def targetProperties = project.ext[t.upper]
2447 def library = targetProperties.library
2448 // The jfxrt task is responsible for creating the jfxrt.jar. A developer may
2449 // have multiple SDK's on their system at any one time, depending on which
2450 // cross compiles they have done. For example, I might have:
2451 // build/mac-sdk/rt/lib/ext/jfxrt.jar
2452 // build/ios-sdk/rt/lib/ext/jfxrt.jar
2453 // build/win-sdk/rt/lib/ext/jfxrt.jar
2454 // build/armhf-sdk/rt/lib/ext/jfxrt.jar
2455 //
2456 // and so forth. This arrangement allows for multiple independent SDKs to
2457 // exist on a developer's system.
2458 def jfxrtTask = task("jfxrt$t.capital", type: Jar) {
2459 group = "Basic"
2460 description = "Creates the jfxrt.jar for the $t.name target"
2461 archiveName = "build/${t.name}-sdk/rt/lib/ext/jfxrt.jar";
2462 includeEmptyDirs = false
2463 from("modules/base/build/classes/main",
2464 "modules/base/build/resources/main",
2465 "modules/builders/build/classes/main",
2466 "modules/graphics/build/classes/main",
2467 "modules/graphics/build/resources/main",
2468 "modules/controls/build/classes/main",
2469 "modules/controls/build/resources/main",
2470 "modules/fxml/build/classes/main",
2471 "modules/fxml/build/resources/main",
2472 "modules/graphics/build/classes/jsl-decora",
2473 "modules/graphics/build/resources/jsl-decora",
2474 "modules/graphics/build/classes/jsl-prism",
2475 "modules/graphics/build/resources/jsl-prism",
2476 "modules/media/build/classes/main",
2477 "modules/media/build/resources/main")
2478 if (COMPILE_SWING) from ("modules/swing/build/classes/main", "modules/swing/build/resources/main")
2479
2480 if (t.name != 'mac')
2481 exclude ("modules/media/build/classes/main/com/sun/media/jfxmediaimpl/platform/osx/**")
2482 if (t.name != 'ios')
2483 exclude ("modules/media/build/classes/main/com/sun/media/jfxmediaimpl/platform/ios/**")
2484
2485 if (t.name == 'android') {
2486 from ("modules/web/build/classes/android",
2487 "modules/web/build/resources/android",
2488 "modules/controls/build/classes/android",
2489 "modules/controls/build/resources/android")
2490 } else if (t.name == 'ios') {
2491 from ("modules/web/build/classes/ios",
2492 "modules/web/build/resources/ios",
2493 "modules/extensions/build/classes/ios")
2494 } else {
2495 from ("modules/web/build/classes/main", "modules/web/build/resources/main")
2496 }
2497 exclude("**/javafx/embed/swt/**")
2498 exclude("js/**/*", // er...
2499 "PrismLoaderBackend*", // More decora stuff
2500 "**/*.stg", // any glue files for decora must be excluded
2501 "**/*.java"); // Builder java files are in build/classes and should be excluded
2502
2503 // Filter out platform specific Java sources (glass) when compiling for other targets
2504 exclude(targetProperties.jfxrtJarExcludes)
2505
2506 dependsOn(subprojects.collect { project -> project.getTasksByName("assemble", true)});
2507 }
2508 def jfxrtIndexTask = task("jfxrtIndex$t.capital") {
2509 //the following is a workaround for the lack of indexing in gradle 1.4 through 1.7
2510 dependsOn(jfxrtTask)
2511
2512 doLast() {
2513 ant.jar (update: true, index: true, destfile: jfxrtTask.archiveName)
2514 }
2515 }
2516 jfxrt.dependsOn(jfxrtIndexTask)
2517
2518 def jfxswtTask = task("jfxswt$t.capital", type: Jar) {
2519 enabled = COMPILE_SWT
2520 group = "Basic"
2521 description = "Creates the jfxswt.jar for the $t.name target"
2522 archiveName = "build/${t.name}-sdk/rt/lib/jfxswt.jar";
2523 includeEmptyDirs = false
2524 from("modules/swt/build/classes/main");
2525 from("modules/builders/build/classes/main");
2526 include("**/javafx/embed/swt/**")
2527 exclude("**/*.java"); // Builder java files are in build/classes and should be excluded
2528
2529 dependsOn(subprojects.collect { project -> project.getTasksByName("assemble", true)});
2530 }
2531 def jfxswtIndexTask = task("jfxswtIndex$t.capital") {
2532 //the following is a workaround for the lack of indexing in gradle 1.4 through 1.7
2533 dependsOn(jfxswtTask)
2534
2535 doLast() {
2536 ant.jar (update: true, index: true, destfile: jfxswtTask.archiveName)
2537 }
2538 }
2539 jfxrt.dependsOn(jfxswtIndexTask)
2540
2541 def jmxTask = task ("jmx${t.capital}", type: Jar) {
2542 group = "Basic"
2543 description = "Creates the javafx-mx.jar"
2544 archiveName = "build/${t.name}-sdk/lib/javafx-mx.jar";
2545 includeEmptyDirs = false
2546 from "modules/jmx/build/classes/main"
2547 from "modules/jmx/build/resources/main"
2548 dependsOn project(":jmx").assemble
2549 }
2550
2551 // The 'sdk' task will build the rest of the SDK, and depends on the 'jfxrtTask' task. After
2552 // executing this task the sdk bundle for the current COMPILE_TARGETS will be fully created.
2553 def sdkTask = task("sdk$t.capital") {
2554 group = "Basic"
2555 description = "Creates the SDK for $t.name"
2556 doLast {
2557 // TODO instead of using copy everywhere, I probably want to use "sync" instead?
2558 // Copy all of the .dll / .so / .dylib native libraries into build/sdk/rt/lib/
2559 copy {
2560 def useLipo = targetProperties.containsKey('useLipo') ? targetProperties.useLipo : false
2561 from("modules/graphics/build/libs/jsl-decora/${t.name}/${library(targetProperties.decora.lib)}")
2562 def libs = ['font', 'prism', 'prismSW', 'prismES2', 'glass', 'iio']
2563 if (IS_COMPILE_PANGO) {
2564 // TODO: embedded support
2565 if ("${defaultHostTarget}" == "${t.name}") {
2566 libs += ['fontFreetype', 'fontPango'];
2567 }
2568 }
2569 libs.each { lib ->
2570 def variants = targetProperties[lib].containsKey('variants') && !useLipo ? targetProperties[lib].variants : [null]
2571 variants.each { variant ->
2572 def variantProperties = variant ? targetProperties[lib][variant] : targetProperties[lib]
2573 println "modules/graphics/build/libs/$lib/$t.name/${library(variantProperties.lib)}"
2574 from ("modules/graphics/build/libs/$lib/$t.name/${library(variantProperties.lib)}")
2575 }
2576 }
2577 if (IS_WINDOWS) {
2578 from ("modules/graphics/build/libs/prismD3D/${t.name}/${library(targetProperties.prismD3D.lib)}");
2579 }
2580 if (IS_COMPILE_WEBKIT) {
2581 from ("modules/web/build/libs/${t.name}/${library('jfxwebkit')}")
2582 } else {
2583 if (t.name != "android" && t.name != "ios") {
2584 from ("$LIBRARY_STUB/${library('jfxwebkit')}")
2585 }
2586 }
2587
2588 def mediaBuildType = project(":media").ext.buildType
2589 if (IS_COMPILE_MEDIA) {
2590 [ "fxplugins", "gstreamer-lite", "jfxmedia" ].each { name ->
2591 from ("modules/media/build/native/${t.name}/${mediaBuildType}/${library(name)}") }
2592
2593 if (t.name == "linux") from ("modules/media/build/native/${t.name}/${mediaBuildType}/${library("avplugin")}")
2594 else from ("modules/media/build/native/${t.name}/${mediaBuildType}/${library("glib-lite")}")
2595 } else {
2596 [ "fxplugins", "gstreamer-lite", "jfxmedia" ].each { name ->
2597 from ("$LIBRARY_STUB/${library(name)}") }
2598
2599 if (t.name == "linux") from ("$LIBRARY_STUB/${library("avplugin")}")
2600 else from ("$LIBRARY_STUB/${library("glib-lite")}")
2601 }
2602
2603 def libDest = targetProperties.libDest
2604 into ("build/${t.name}-sdk/rt/$libDest")
2605 }
2606
2607 // Create the javafx.properties file
2608 final File javafxProperties = file("build/${t.name}-sdk/rt/lib/javafx.properties")
2609 javafxProperties.delete()
2610 javafxProperties << "javafx.runtime.version=$RAW_VERSION";
2611 // Include any properties that have been defined (most likely in
2612 // one of the various platform gradle files)
2613 if (targetProperties.containsKey("javafxProperties")) {
2614 javafxProperties << "\n"
2615 javafxProperties << targetProperties.javafxProperties
2616 }
2617
2618 // Embedded builds define this file as well
2619 if (targetProperties.containsKey("javafxPlatformProperties")) {
2620 final File javafxPlatformProperties = file("build/${t.name}-sdk/rt/lib/javafx.platform.properties")
2621 javafxPlatformProperties.delete()
2622 javafxPlatformProperties << targetProperties.javafxPlatformProperties
2623 }
2624
2625 // Copy over the javadocs that were generated. This is done rather than just generating
2626 // the docs into the "right place" because for a cross-compile you only need one set of
2627 // docs but need to have a copy in each created sdk
2628 if (IS_BUILD_JAVADOC) {
2629 copy {
2630 from "build/javadoc"
2631 into "build/${t.name}-sdk/docs/api"
2632 }
2633 }
2634
2635 // Copy over the javafx-src bundle
2636 if (IS_BUILD_SRC_ZIP) {
2637 copy {
2638 from "build/javafx-src.zip"
2639 into "build/${t.name}-sdk"
2640 }
2641 }
2642
2643 // Copy over the fxpackager and rename as ant-javafx.jar
2644 copy {
2645 from "modules/fxpackager/build/libs"
2646 into "build/${t.name}-sdk/lib"
2647 }
2648
2649 // Copy over the FXPackager man files
2650 copy {
2651 from "modules/fxpackager/build/man"
2652 into "build/${t.name}-sdk/man"
2653 }
2654
2655 // Copy over the javafxpackager executable
2656 if (t.name == "win" || t.name == "linux" || t.name == "mac") {
2657 copy {
2658 from "modules/fxpackager/build/javafxpackager"
2659 into "build/${t.name}-sdk/bin"
2660 }
2661 }
2662 }
2663 dependsOn(jmxTask);
2664 dependsOn(jfxrtIndexTask)
2665 dependsOn(jfxswtIndexTask)
2666 dependsOn(javadoc)
2667 dependsOn(src)
2668 }
2669
2670 def generateSymbols = targetProperties.containsKey('generateSymbols') ? targetProperties.generateSymbols : false
2671 if (generateSymbols) {
2672 def exportedSymbolsTask = project.task("exportedSymbols${t.capital}", type: ExportedSymbolsTask, dependsOn: sdkTask, group: "Build") {
2673 description = "Generates exported symbols file for iOS build (from .a libraries)"
2674 def libDirName = "build/${t.name}-sdk/rt/$targetProperties.libDest"
2675 libDir = file("$libDirName")
2676 outputFile = file("$libDirName/exported.symbols")
2677 excludes = targetProperties.generateSymbolsExcludes
2678 }
2679 sdk.dependsOn(exportedSymbolsTask)
2680 }
2681
2682 sdk.dependsOn(sdkTask)
2683 }
2684
2685 //task integrationCheck {
2686 // group = "Basic"
2687 // description = "Performs all the tasks necessary to ensure that the current build is ready for integration."
2688 // dependsOn sdk
2689 // dependsOn subprojects.collect { project -> project.getTasksByName("check", true)}
2690 //}
2691
2692 /*
2693 * This clause changes the way we handle a build.gradle within ./apps
2694 * It does a few things:
2695 * modifies the classpath used to include the built runttime classes
2696 * provides for copying the build applications to the artifacts tree
2697 *
2698 * The applications to be built will be under ./apps, but also must
2699 * be listed in the applications listed in the setting variable: JFXApplications
2700 */
2701 ext.JFXRT_CP =
2702 files(
2703 project(":base").sourceSets.main.output.classesDir,
2704 project(":graphics").sourceSets.main.output.classesDir,
2705 project(":controls").sourceSets.main.output.classesDir,
2706 project(":fxml").sourceSets.main.output.classesDir,
2707 project(":swing").sourceSets.main.output.classesDir, //NOTE - used by 3Dviewer
2708 project(":builders").sourceSets.main.output.classesDir,
2709 "modules/media/build/classes/main",
2710 "modules/web/build/classes/main",
2711 )
2712
2713 project(":apps") {
2714 // The apps build is Ant based, and gradle lets us "import" ant build.xml
2715 // into our configuration.
2716
2717 ant.importBuild 'build.xml'
2718
2719 compileTargets { t ->
2720 // The apps build is Ant based, and gradle lets us "import" ant apps/build.xml
2721 // into our configuration.
2722
2723 // override the apps build.xml with an explicit pointer to our jar.
2724 def jfxrtJar = "${rootProject.buildDir}/${t.name}-sdk/rt/lib/ext/jfxrt.jar"
2725
2726 def appsJar = project.task("appsJar${t.capital}") {
2727 doLast() {
2728 ant.properties['targetBld'] = "$t.name"
2729 if (!rootProject.ext[t.upper].compileSwing) {
2730 ant.properties['JFX_CORE_ONLY'] = 'true'
2731 }
2732 ant.properties['jfxbuild.jfxrt.jar'] = jfxrtJar
2733 ant.properties['platforms.JDK_1.8.home'] = "${rootProject.ext.JDK_HOME}"
2734 ant.project.executeTarget("sampleAppsJar")
2735 }
2736 }
2737 rootProject.appsjar.dependsOn(appsJar)
2738
2739 def appsClean = project.task("appsClean${t.capital}") {
2740 doLast() {
2741 ant.properties['targetBld'] = "$t.name"
2742 ant.properties['platforms.JDK_1.8.home'] = "${rootProject.ext.JDK_HOME}"
2743 ant.project.executeTarget("sampleAppsClean")
2744 }
2745 }
2746 rootProject.clean.dependsOn(appsClean)
2747 }
2748 }
2749
2750 /******************************************************************************
2751 * *
2752 * BUILD_CLOSED *
2753 * *
2754 * This next section should remain at the end of the build script. It allows *
2755 * for a "supplemental" gradle file to be used to extend the normal build *
2756 * structure. For example, this is used for passing a supplemental gradle *
2757 * file for producing official JavaFX builds. *
2758 * *
2759 *****************************************************************************/
2760
2761 if (BUILD_CLOSED) {
2762 apply from: supplementalBuildFile
2763 }
2764
2765 task showFlags {
2766 }
2767
2768 compileTargets { t ->
2769 // Every platform must define these variables
2770 def props = project.ext[t.upper];
2771 showFlags.dependsOn(
2772 project.task("showFlags$t.upper") {
2773 doLast() {
2774 println "Properties set for $t.upper"
2775 props.each { println it }
2776 }
2777 }
2778 )
2779 }