/*
 * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


/**
 * Gets the most recent android platform installed, relative to the given path.
 * The path will either be ANDROID_SDK or ANDROID_NDK
 * TODO Shouldn't we instead just ask people to point to the one they want to use?
 *
 * @param path The path to the Android SDK or NDK
 * @return The name of the most recent platform
 */
String getLatestPlatform(String path) {
    def max = 0
    println("$path")
    file(cygpath("$path/platforms")).eachFile() {file->
        def pname = file.getName() - "android-"
        def ptf = pname?.isInteger() ? pname.toInteger() : 0
        if (max < ptf) {
            max = ptf
        }
    }
    if (max == 0) {
        return null;
    }
    return "android-" + max
}

int compareVersions(String s1, String s2) {
    def v1t = s1.tokenize(".")
    def v2t = s2.tokenize(".")
    for(int i = 0; i < v1t.size(); i++) {
        if (i == v2t.size()) {
            return 1
        }
        int n1 = v1t[i].isInteger() ? v1t[i].toInteger() : 0
        int n2 = v2t[i].isInteger() ? v2t[i].toInteger() : 0
        if (n1 == n2) {
            continue
        } else if (n1 > n2) {
            return 1;
        } else {
            return -1
        }
    }
    return (v2t.size() > v1t.size()) ? -1 : 0
}

String getLatestToolchain(String ndk, String tch) {
    def max = "0.0"
    def matchFile = null
    file(cygpath("$ndk/toolchains")).eachFile() {file->
        def filename = file.getName()
        if (filename.startsWith(tch)) {
            def p = filename - "$tch-"
            if (compareVersions(p, max) > 0) {
                max = p
                matchFile = file
            }
        }
    }
    return matchFile.getAbsolutePath()
}

boolean assertDir(File dir) {
    return dir != null && dir.exists() && dir.isDirectory() && dir.canRead();
}

boolean assertDir(String dir) {
    return assertDir(file(dir))
}

def closedDir = file("$projectDir/../rt-closed")

def toolchainArchs = ["arm-linux-androideabi", "mipsel-linux-android", "x86"]
def armArchs = ["armeabi", "armeabiv-7a"]

ext.DALVIK = [:]
DALVIK.compileSwing = false;
DALVIK.compileSWT = false;
DALVIK.compileDesignTime = false;
DALVIK.glassPlatform = "android"
DALVIK.armArch = armArchs[0]
DALVIK.libDest = "lib"
DALVIK.jfxdvklib = "jfxdvk.jar"
DALVIK.library = { name -> return "lib${name}.so" as String }
DALVIK.includeMonocole = true
DALVIK.includeLens = false

def sdk = project.hasProperty("ANDROID_SDK") ? "${ANDROID_SDK}" : null;
def ndk = project.hasProperty("ANDROID_NDK") ? "${ANDROID_NDK}" : null;
DALVIK.canBuild = sdk != null && ndk != null
if (!DALVIK.canBuild) {
    logger.error("Can't build Android. Path to SDK or NDK was not set or is invalid!")
    return;
}

DALVIK.canBuild = assertDir(sdk) && assertDir(ndk)
if (!DALVIK.canBuild) {
    if (!assertDir(sdk)) {
        logger.error("Path to ANDROID_SDK is invalid! [$sdk]")
    }
    if (!assertDir(ndk)) {
        logger.error("Path to ANDROID_NDK is invalid! [$ndk]")
    }
    return
}

def sdk_target = project.hasProperty("ANDROID_SDK_TARGET") ?  "${ANDROID_SDK_TARGET}" : getLatestPlatform(sdk);
if (!assertDir(file("$sdk/platforms/$sdk_target"))) {
    sdk_target = getLatestPlatform(sdk);
    logger.warn("Redefine ANDROID_SDK_TARGET to: [$sdk_target]")
}

def ndk_target = project.hasProperty("ANDROID_NDK_TARGET") ? "${ANDROID_NDK_TARGET}" : getLatestPlatform(ndk);
if (!assertDir(file("$ndk/platforms/$ndk_target"))) {
    ndk_target = getLatestPlatform(ndk);
    logger.warn("Redefine ANDROID_NDK_TARGET to: [$ndk_target]")
}

DALVIK.canBuild = sdk_target != null && ndk_target != null
if (!DALVIK.canBuild) {
    logger.error("Can't determine sdk or ndk target platform!")
    return
}

def toolchainHome = project.hasProperty("ANDROID_CROSS_TOOLS_VER") ?
    "$ndk/toolchains/${ANDROID_CROSS_TOOLS_VER}" : getLatestToolchain(ndk, toolchainArchs[0])
if (!assertDir(toolchainHome)) {
    toolchainHome = getLatestToolchain(ndk, toolchainArchs[0])
    logger.warn("Redefine toolchain to [$toolchainHome]")
}

// Look for the the Android SDK & NDK to use, as well as the compiler stuff
def compilerHome = null
file("$toolchainHome/prebuilt").eachDir() {subdir ->
    compilerHome = subdir.getAbsolutePath()
    return
}

DALVIK.canBuild = compilerHome != null
if (!DALVIK.canBuild) {
    logger.error("Failed to access toolchain [$toolchainHome/prebuilt/$toolsPlatform]!")
    return
}

def freetypeDir = project.hasProperty("FREETYPE_DIR") ? "${FREETYPE_DIR}" : null
if (!assertDir(freetypeDir)) {
    logger.warn("FREETYPE_DIR $freetypeDir doesn't exists! Build continues without native text support.")
    freetypeDir = null
}
def compileNativeText = freetypeDir != null

def compiler = file("$compilerHome/bin/${toolchainArchs[0]}-gcc").getAbsolutePath()
def linker = file("$compilerHome/bin/${toolchainArchs[0]}-g++").getAbsolutePath()

// Log the settings we're building with
logger.quiet("ANDROID_SDK: $sdk")
logger.quiet("ANDROID_SDK_TARGET: $sdk_target")
logger.quiet("ANDROID_NDK: $ndk")
logger.quiet("ANDROID_NDK_TARGET: $ndk_target")
logger.quiet("FREETYPE_DIR: $freetypeDir")
logger.quiet("Compile native text: $compileNativeText")
logger.quiet("Android Compiler: $compiler")
logger.quiet("Android Linker: $linker")

//exclude from build
project(":swing") {
    apply plugin: 'java'

    compileJava {
        enabled = false
    }
}

project(":fxml") {
    apply plugin: 'java'

    jar.dependsOn("retroClass");

    compileJava {
        enabled = true
    }
}

allprojects() {
    repositories {
        mavenCentral()
    }
    configurations {
        retroconfig
    }

    dependencies {
        retroconfig 'net.orfjackal.retrolambda:retrolambda:1.1.4'
    }
    task retroClass() <<{
            file classdirs = file ("$buildDir/classes");
            lf = classdirs.listFiles();
            classdirs.eachDir{t ->
                javaexec {
                    inputdir = t
                    basecp = files(lf, "${project("base").buildDir}/classes/main", "${project("graphics").buildDir}/classes/main", "${project("controls").buildDir}/classes/main").asPath
                    myconfig = configurations.retroconfig;
                    lambdaloc = myconfig.resolve().toArray()[0];
                    classpath = configurations.retroconfig
                    main = 'net.orfjackal.retrolambda.Main'
                    jvmArgs = [
                               "-Xbootclasspath:$JDK_HOME/jre/lib/rt.jar",
                                "-Dretrolambda.inputDir=$inputdir",
                                "-Dretrolambda.classpath=$basecp",
                                "-Dretrolambda.bytecodeVersion=51",
                                "-javaagent:$lambdaloc"
                   ]
            }
        }
    }
}


project(":base") {
    apply plugin: 'java'
    jar.dependsOn("retroClass");
}

project(":web") {
    apply plugin: 'java'
    jar.dependsOn("retroClass");
    compileJava.dependsOn(":graphics:assemble");
    sourceSets.main.java.srcDirs = ['src/android/java'];
    sourceSets {
        main {
            java {
                srcDirs= ['src/android/java']
            }
        }
    }
    dependencies {
         compile files("../graphics/build/classes/dalvik");
    }

    afterEvaluate {
    sourceSets.main.java.srcDirs = ['src/android/java'];
        def compileWebJavaAndroid = task("compileWebJavaAndroid",
            type: JavaCompile, group: "Build") {

            dependsOn(project(":graphics").classes, project(":base").classes)
            description = "Task compiles web component for Android."
            classpath = files(
                project(":controls").sourceSets.main.java.outputDir,
                project(":graphics").sourceSets.main.java.outputDir,
                project(":base").sourceSets.main.java.outputDir,
                "${project("graphics").buildDir}/classes/dalvik"
            )
            destinationDir = file("${project("web").buildDir}/classes/android")
            dependencyCacheDir = file("${project("web").buildDir}/dependency-cache")
            source file("${project("web").projectDir}/src/android/java")
        }

        def jarWebJavaAndroid = task("jarWebJavaAndroid",
            type: Jar, group: "Build") {
            description = "Creates web.jar for Android."
            dependsOn(compileWebJavaAndroid)
            archiveName = "web.jar"
            includeEmptyDirs = false
            destinationDir = project.file("build/libs/android")
            from("build/classes/android")
        }
        addNative(project, "webview")
        // addNative(project, "dvkwebview")
        javahDalvikWebview.dependsOn(compileWebJavaAndroid)
        // javahDalvikDvkwebview.dependsOn(compileWebJavaAndroid)

        jfxrtDalvik {
            from "${project("web").buildDir}/classes/android"
        }

  sdkDalvik  {
            dependsOn(jarWebJavaAndroid)
            doLast {
                def props = project.ext["DALVIK"]
                copy {
                    from ("${project("web").buildDir}/libs/webview/dalvik/${props.library(props.webview.lib)}")
                    into ("build/dalvik-sdk/${props.libDest}")
                }
            }
        }
    }


    jar.dependsOn("retroClass");
}

project(":media") {
    apply plugin: 'java'
    jar.dependsOn("retroClass");
}


project(":graphics") {

    apply plugin: 'java'

    sourceSets.main.java {
        exclude "com/sun/glass/ui/swt/**"
    }

    assemble.dependsOn("retroClass");
    task compileDalvikLibs(type: JavaCompile, group: "Build") {
        description = "Task compiles dalvik vm based libraries."
        options.bootClasspath = "$sdk/platforms/$sdk_target/android.jar"
        classpath = files("build/classes/dalvik", "build/classes/main")
        destinationDir = file("build/classes/dalvik")
        dependencyCacheDir = file("build/dependency-cache")
        source fileTree(dir: 'src/dalvik/java').matching { include '**' }
    }

    task jarDalvikLibs(type: Jar, group: "Build", dependsOn: compileDalvikLibs) {
        description = "Creates jfxdvk.jar with all dalvik based classes."
        archiveName = "jfxdvk.jar"
        includeEmptyDirs = false
        from("build/classes/dalvik")
        include("javafxports/**/*")
        include("com/oracle/**/*")
        dependsOn(compileDalvikLibs)
    }

    jarDalvikLibs {
        eachFile {
                if (it.name.endsWith('.class')) {
                    RandomAccessFile raf = new RandomAccessFile(it.file.path, "rw");
                    raf.seek(7);
                    raf.writeByte(0x32); //make it jdk6
                    raf.close();
                }
            }
    }

    afterEvaluate {
        addNative(project, "activity")
        if (compileNativeText) {
            addNative(project, "fontNativeFreetype")
        }
        tasks["javahDalvikGlass"].dependsOn(compileDalvikLibs)
        tasks["javahDalvikActivity"].dependsOn(compileDalvikLibs)
        tasks["native"].dependsOn("nativeActivity")
        if (compileNativeText) {
            tasks["native"].dependsOn("nativeFontNativeFreetype")
        }
        tasks["javahDalvikPrismSW"].enabled = false
        tasks["ccDalvikPrismSW"].enabled = false;
        tasks["linkDalvikPrismSW"].enabled = false;

        sdkDalvik  {
            dependsOn(jarDalvikLibs)
            doLast {
                def props = project.ext["DALVIK"]
                copy {
                    from(
                         "${project("graphics").buildDir}/libs/activity/dalvik/${props.library(props.activity.lib)}"
                    )
                    into ("build/dalvik-sdk/${props.libDest}")
                }
                copy {
                    from ("${project("graphics").buildDir}/libs/${props.jfxdvklib}")
                    into ("build/dalvik-sdk/lib")
                }
/*
                copy {
                    from ("${project("compat").buildDir}/libs/compat.jar")
                    into ("build/dalvik-sdk/lib")
                }
*/
                if (compileNativeText) {
                    copy {
                        from ("${project("graphics").buildDir}/libs/fontNativeFreetype/dalvik")
                        into ("build/dalvik-sdk/${props.libDest}")
                    }
                }
            }
        }
    }
}

project(":controls") {

    apply plugin: 'java'
/*
    compileJava {
         options.bootClasspath="/home/johan/open-jfx/bitbucket/8u-dev-build/compat/build/libs/compat-1.0.0.jar:$sdk/platforms/$sdk_target/android.jar"
     }
*/


    sourceSets.main.java.srcDir('src/android/java')
/*
    sourceSets.main.java {
        exclude 'javafx/scene/control/Date*.java'
        exclude 'com/sun/javafx/scene/control/skin/Date*.java'
        exclude 'com/sun/javafx/scene/control/behavior/Date*.java'
    }
*/
    task copyResources() << {
        copy {
            from ("src/android/resources")
            into ("build/resources/dalvik")
        }
    }

    assemble.dependsOn("copyResources","retroClass");

    afterEvaluate {

        jfxrtDalvik {
            from ("${project("controls").buildDir}/classes/dalvik",
                  "${project("controls").buildDir}/resources/dalvik")
        }

    }
}

allprojects {
    afterEvaluate {
        sdkDalvik {
            doLast {
                ant.jar(update: "true", destfile: "build/dalvik-sdk/lib/jfxrt.jar",
                    basedir: "build/dalvik-sdk/lib", includes: "*.properties")
            }
        }
    }
}


DALVIK.jfxrtJarExcludes = [
    "**/*.hlsl",
    "com/sun/glass/ui/win",
    "com/sun/glass/ui/accessible/win",
    "com/sun/prism/j2d",
    "com/sun/prism/sw",
    "com/sun/glass/ui/accessible/mac",
    "com/sun/glass/ui/ios",
    "com/sun/glass/ui/swt", // SWT glass
    "com/oracle/dalvik",
    // "javafx/scene/media", //exclude all media for now
    // "com/sun/media",
    // "com/sun/javafx/media",
    "com/sun/javafx/font/directwrite", //exclude non freetype font support
    "com/sun/javafx/font/coretext",
    "com/sun/javafx/font/freetype/Pango*",
    "com/sun/javafx/font/freetype/OSPango*",
    // "com/sun/webkit",   //exclude all WebView for now
    // "com/sun/javafx/webkit",
    // "com/sun/javafx/scene/web",
    // "javafx/scene/web",
    // "com/sun/javafx/sg/prism/NGWeb*",
    // "com/sun/javafx/sg/prism/web*",
    "javafx/print", //exclude printing
    "com/sun/javafx/print",
    "com/sun/javafx/tk/Print*"
]

def text = (compileNativeText) ? "native" : ""

DALVIK.javafxPlatformProperties = """
javafx.platform=android
android.javax.xml.stream.XMLInputFactory=com.sun.xml.stream.ZephyrParserFactory
android.javax.xml.stream.XMLOutputFactory=com.sun.xml.stream.ZephyrWriterFactory
android.javax.xml.stream.XMLEventFactory=com.sun.xml.stream.events.ZephyrEventFactory
android.glass.platform=Monocle
android.glass.lens=eglfb
android.log.lens=FINEST
android.prism.verbose=true
DALVIK.prism.verbose=true
android.prism.glDepthSize=16
android.prism.lcdtext=false
android.prism.debugfonts=true
android.prism.text=$text
android.embedded=monocle
android.prism.allowhidpi=true
android.prism.maxTextureSize=2048
android.prism.dirtyopts=true
android.prism.vsync=false
android.use.egl=true
android.com.sun.javafx.isEmbedded=true
com.sun.javafx.gestures.zoom=true
com.sun.javafx.gestures.rotate=true
com.sun.javafx.gestures.scroll=true
"""
def sysroot = "$ndk/platforms/$ndk_target/arch-arm"

def ccFlags = ["--sysroot=$sysroot","-std=c99", "-DANDROID", "-c", "-nostdlib",
               "-DANDROID_NDK", "-DDALVIK_VM"]

def ccOptFlags = ["-fpic", "-ffunction-sections", "-funwind-tables","-fstack-protector",
                  "-Os", "-O2", "-fno-strict-aliasing", "-finline-limit=64", "-fomit-frame-pointer"]
def ccWarnFlags = ["-Wa,--noexecstack", "-Wno-psabi"]
def ccArchFlags = ["-mthumb", "-msoft-float", "-D__ARM_ARCH_5__", "-D__ARM_ARCH_5T__", "-D__ARM_ARCH_5E__",
                   "-D__ARM_ARCH_5TE__", "-march=armv5te" , "-mtune=xscale"]
def ccDebugFlags = [IS_DEBUG_NATIVE ? "-DDEBUG" : "-DNDEBUG"]
def ccDefaultIncludeFlags = ["-I$ndk/platforms/$ndk_target/arch-arm/usr/include"]

def linkFlags = ["--sysroot=$sysroot",
                 "-Wl,--no-undefined", "-Wl,-z,noexecstack", "-lc", "-lm", "-shared",
                 "-L$ndk/platforms/$ndk_target/arch-arm/usr/lib"]

DALVIK.activity = [:]
DALVIK.activity.javahSource = files("${project("graphics").buildDir}/classes/dalvik")
DALVIK.activity.javahClasspath = files("${project("graphics").buildDir}/classes/dalvik", "$sdk/platforms/$sdk_target/android.jar")
DALVIK.activity.javahInclude = ["javafxports/android/**"]
DALVIK.activity.nativeSource = file("${project("graphics").projectDir}/src/dalvik/native")
DALVIK.activity.compiler = compiler
DALVIK.activity.linker = linker
DALVIK.activity.lib = "activity"
DALVIK.activity.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.activity.linkFlags = [linkFlags, "-landroid", "-llog"].flatten()

DALVIK.webview = [:]
DALVIK.webview.javahSource = files("${project("web").buildDir}/classes/android")
DALVIK.webview.javahClasspath = files("${project("web").buildDir}/classes/android")
DALVIK.webview.javahInclude = [
    "com/sun/webkit/NativeWebView.class"
]
DALVIK.webview.nativeSource = [
    files("${project("web").projectDir}/src/android/native/native_webview.c",
"${project("web").projectDir}/src/android/native/android_webview.c")
]
DALVIK.webview.compiler = compiler
DALVIK.webview.linker = linker
DALVIK.webview.lib = "webview"
DALVIK.webview.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.webview.linkFlags = [linkFlags, "-ldl", "-llog"].flatten()

DALVIK.dvkwebview = [:]
DALVIK.dvkwebview.javahSource = files("${project("web").buildDir}/classes/android")
DALVIK.dvkwebview.javahClasspath = files("${project("web").buildDir}/classes/android")
DALVIK.dvkwebview.javahInclude = [
    "com/sun/webkit/NativeWebView.class"
]
DALVIK.dvkwebview.nativeSource = [
    file("${project("web").projectDir}/src/android/native/android_webview.c")
]
DALVIK.dvkwebview.compiler = compiler
DALVIK.dvkwebview.linker = linker
DALVIK.dvkwebview.lib = "android_webview"
DALVIK.dvkwebview.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.dvkwebview.linkFlags = [linkFlags, "-ldl", "-llog"].flatten()

DALVIK.glass = [:]
// DALVIK.glass.variants = ["eglfb", "lensport"]
DALVIK.glass.variants = []
DALVIK.glass.variants = ["monocle"]
DALVIK.glass.javahSource = files("${project("graphics").buildDir}/classes/dalvik",
 "${project("graphics").buildDir}/classes/main")
DALVIK.glass.javahClasspath = files("${project("graphics").buildDir}/classes/main",
 "${project("graphics").buildDir}/classes/dalvik",
 "${project("base").buildDir}/classes/main",
 "$sdk/platforms/$sdk_target/android.jar")
DALVIK.glass.javahInclude = [
    "javafxports/android/**",
    "com/sun/glass/ui/monocle/*",
    "com/sun/glass/ui/monocle/util/*",
    "com/sun/glass/events/**",
    "com/sun/glass/ui/*",
    "com/sun/glass/ui/android/*",
    "com/sun/glass/ui/lens/*"]

DALVIK.glass.lensport = [:]
DALVIK.glass.lensport.nativeSource = [
    file("${project("graphics").projectDir}/src/main/native-glass/lens/lensport/initPlatform.c"),
    file("${project("graphics").projectDir}/src/main/native-glass/lens/wrapped/wrapped_functions.c")
]
DALVIK.glass.lensport.compiler = compiler
DALVIK.glass.lensport.linker = linker
DALVIK.glass.lensport.lib = "lens_porting"
DALVIK.glass.lensport.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags, "-DISEGLFB", "-DLENSPORT",
    "-I", file("${project("graphics").projectDir}/src/main/native-glass/lens")].flatten()
DALVIK.glass.lensport.linkFlags = [linkFlags, "-ldl", "-llog"].flatten()

def monocleCFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags, "-DISEGLFB",
    "-I", file("${project("graphics").projectDir}/src/main/native-glass/monocle/"),
    "-I", file("${project("graphics").projectDir}/src/dalvik/native/")
].flatten()

DALVIK.glass.monocle = [:]
DALVIK.glass.monocle.nativeSource = [
        file("${project("graphics").projectDir}/src/main/native-glass/monocle"),
        file("${project("graphics").projectDir}/src/main/native-glass/monocle/android"),
        file("${project("graphics").projectDir}/src/main/native-glass/monocle/util") ]
DALVIK.glass.monocle.compiler = compiler
DALVIK.glass.monocle.ccFlags = monocleCFlags
DALVIK.glass.monocle.linker = linker
DALVIK.glass.monocle.linkFlags =  [linkFlags, "-ldl", "-llog", "-landroid", "-lGLESv2", "-lEGL"].flatten()

DALVIK.glass.monocle.lib = "glass_monocle"

DALVIK.javafxPlatformDefault="eglfb"

def monoclePlatformAdditions = """
monocle.glass.platform=Monocle
monocle.prism.order=es2,sw
monocle.prism.eglfb=true
monocle.prism.lcdtext=false
monocle.prism.maxvram=128m
monocle.prism.targetvram=112m
monocle.use.egl=true
monocle.use.gles2=true
monocle.embedded=monocle
monocle.com.sun.javafx.isEmbedded=true
monocle.doNativeComposite=true
monocle.com.sun.javafx.scene.control.skin.FXVK.cache=true
monocle.prism.glDepthSize=0
monocle.com.sun.javafx.gestures.zoom=true
monocle.com.sun.javafx.gestures.rotate=true
monocle.com.sun.javafx.gestures.scroll=true"""



DALVIK.glass.eglfb = [:]
DALVIK.glass.eglfb.nativeSource = [
    file("${project("graphics").projectDir}/src/main/native-glass/lens"),
    file("${project("graphics").projectDir}/src/main/native-glass/lens/wm"),
    file("${project("graphics").projectDir}/src/main/native-glass/lens/cursor/nullCursor"),
    file("${project("graphics").projectDir}/src/main/native-glass/lens/dalvik")
]
DALVIK.glass.eglfb.compiler = compiler
DALVIK.glass.eglfb.linker = linker
DALVIK.glass.eglfb.lib = "glass_lens_eglfb"
DALVIK.glass.eglfb.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.glass.eglfb.linkFlags = [linkFlags, "-ldl", "-landroid", "-llog"].flatten()

DALVIK.prism = [:]
DALVIK.prism.javahInclude = ["com/sun/prism/impl/**/*", "com/sun/prism/PresentableState*"]
DALVIK.prism.nativeSource = file("${project("graphics").projectDir}/src/main/native-prism")
DALVIK.prism.compiler = compiler
DALVIK.prism.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.prism.linker = linker
DALVIK.prism.linkFlags = [linkFlags].flatten()
DALVIK.prism.lib = "prism_common"

DALVIK.prismSW = [:]
DALVIK.prismSW.javahInclude = ["com/sun/pisces/**/*"]
DALVIK.prismSW.nativeSource = file("${project("graphics").projectDir}/src/main/native-prism-sw")
DALVIK.prismSW.compiler = compiler
DALVIK.prismSW.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.prismSW.linker = linker
DALVIK.prismSW.linkFlags = [linkFlags].flatten()
DALVIK.prismSW.lib = "prism_sw"

DALVIK.decora = [:]
DALVIK.decora.compiler = compiler
DALVIK.decora.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.decora.linker = linker
DALVIK.decora.linkFlags = [linkFlags].flatten()
DALVIK.decora.lib = "decora_sse"

DALVIK.iio = [:]
DALVIK.iio.javahInclude = ["com/sun/javafx/iio/**/*"]
DALVIK.iio.nativeSource = [
    file("${project("graphics").projectDir}/src/main/native-iio"),
    file("${project("graphics").projectDir}/src/main/native-iio/libjpeg9c")]
DALVIK.iio.compiler = compiler
DALVIK.iio.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.iio.linker = linker
DALVIK.iio.linkFlags = [linkFlags].flatten()
DALVIK.iio.lib = "javafx_iio"

DALVIK.prismES2 = [:]
DALVIK.prismES2.variants = ["monocle"]
DALVIK.prismES2.javahInclude = ["com/sun/prism/es2/**/*"]

DALVIK.prismES2.monocle= [:]
DALVIK.prismES2.monocle.nativeSource = [
    file("${project("graphics").projectDir}/src/main/native-prism-es2"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/GL"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/eglWrapper"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/monocle")
]
DALVIK.prismES2.monocle.compiler = compiler
DALVIK.prismES2.monocle.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags, "-DIS_EGLFB"].flatten()
DALVIK.prismES2.monocle.linker = linker
DALVIK.prismES2.monocle.linkFlags = [linkFlags, "-ldl", "-llog", "-lGLESv2", "-lEGL"].flatten()
DALVIK.prismES2.monocle.lib = "prism_es2_monocle"

DALVIK.prismES2.eglfb = [:]
DALVIK.prismES2.eglfb.nativeSource = [
    file("${project("graphics").projectDir}/src/main/native-prism-es2"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/GL"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/wrapped"),
    file("${project("graphics").projectDir}/src/main/native-prism-es2/eglfb")]
DALVIK.prismES2.eglfb.compiler = compiler
DALVIK.prismES2.eglfb.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags, "-DIS_EGLFB"].flatten()
DALVIK.prismES2.eglfb.linker = linker
DALVIK.prismES2.eglfb.linkFlags = [linkFlags, "-ldl", "-llog", "-lGLESv2", "-lEGL"].flatten()
DALVIK.prismES2.eglfb.lib = "prism_es2_eglfb"

DALVIK.font = [:]
DALVIK.font.javahInclude = [
        "com/sun/javafx/font/**/*",
        "com/sun/javafx/text/**/*"]
DALVIK.font.nativeSource = [file("$closedDir/javafx-font-native/src")]
DALVIK.font.compiler = compiler
DALVIK.font.ccFlags = [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
    ccDebugFlags, ccDefaultIncludeFlags].flatten()
DALVIK.font.linker = linker
DALVIK.font.linkFlags = [linkFlags].flatten()
DALVIK.font.lib = "javafx_font"

if (compileNativeText) {
    DALVIK.fontNativeFreetype = [:]
    DALVIK.fontNativeFreetype.javahInclude = [
        "com/sun/javafx/font/freetype/OSFreetype.class"
    ]
    DALVIK.fontNativeFreetype.nativeSource = [
        file("${project("graphics").projectDir}/src/main/native-font/freetype.c")
    ]
    DALVIK.fontNativeFreetype.compiler = compiler
    DALVIK.fontNativeFreetype.linker = linker
    DALVIK.fontNativeFreetype.lib = "javafx_font_freetype"

    ccFlags += ["-D_ENABLE_HARFBUZZ"]

    DALVIK.fontNativeFreetype.ccFlags =
        [ccFlags, ccWarnFlags, ccArchFlags, ccOptFlags,
        ccDebugFlags, ccDefaultIncludeFlags,
        "-I$freetypeDir/include", "-I$freetypeDir/include/freetype2"].flatten()

    DALVIK.fontNativeFreetype.linkFlags =
        [linkFlags, "-llog",
         "-L$freetypeDir/lib", "$freetypeDir/lib/libfreetype.a"].flatten()
}

DALVIK.media = [:]
DALVIK.media.compiler = compiler
DALVIK.media.linker = linker
DALVIK.media.lib = file("$compilerHome/bin/${toolchainArchs[0]}-ar").getAbsolutePath()
DALVIK.includeEGL = true
DALVIK.includeGTK = true
DALVIK.includeLens = true
ext.IS_COMPILE_PANGO = false