1 /*
   2  * Copyright (c) 2011, 2016, 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 package com.sun.javafx.tools.packager;
  27 
  28 import com.oracle.tools.packager.*;
  29 import com.oracle.tools.packager.RelativeFileSet;
  30 import com.oracle.tools.packager.jnlp.JNLPBundler;
  31 import com.sun.javafx.tools.packager.bundlers.*;
  32 import com.sun.javafx.tools.packager.bundlers.Bundler.BundleType;
  33 import java.io.File;
  34 import java.util.ArrayList;
  35 import java.util.Arrays;
  36 import java.util.Collection;
  37 import java.util.LinkedHashMap;
  38 import java.util.LinkedHashSet;
  39 import java.util.LinkedList;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.Set;
  43 import java.util.TreeMap;
  44 import java.util.TreeSet;
  45 
  46 import jdk.packager.internal.JLinkBundlerHelper;
  47 
  48 import static com.oracle.tools.packager.jnlp.JNLPBundler.*;
  49 
  50 @Deprecated
  51 public class DeployParams extends CommonParams {
  52     public enum RunMode {
  53         WEBSTART, EMBEDDED, STANDALONE, ALL
  54     }
  55 
  56     final List<RelativeFileSet> resources = new ArrayList<>();
  57 
  58     String id;
  59     String title;
  60     String vendor;
  61     String email;
  62     String description;
  63     String category;
  64     String licenseType;
  65     String copyright;
  66     String version;
  67     Boolean systemWide;
  68     Boolean serviceHint;
  69     Boolean signBundle;
  70     Boolean installdirChooser;
  71 
  72     String applicationClass;
  73     String preloader;
  74 
  75     List<Param> params;
  76     List<HtmlParam> htmlParams;
  77     List<String> arguments; //unnamed arguments
  78 
  79     // Java 9 modules support
  80     Set<String> addModules = null;
  81     Set<String> limitModules = null;
  82     Boolean stripNativeCommands = null;
  83     Boolean detectmods = null;
  84     String modulePath = null;
  85     String module = null;
  86     String debugPort = null;
  87     String srcdir;
  88 
  89     int width;
  90     int height;
  91     String embeddedWidth = null;
  92     String embeddedHeight = null;
  93 
  94     String appName;
  95     String codebase;
  96 
  97     boolean embedJNLP = true;
  98     @Deprecated final boolean embedCertificates = false;
  99     boolean allPermissions = false;
 100     String updateMode = "background";
 101     boolean isExtension = false;
 102     boolean isSwingApp = false;
 103 
 104     Boolean needShortcut = null;
 105     Boolean needMenu = null;
 106     Boolean needInstall = null;
 107 
 108     String outfile;
 109     //if true then we cobundle js and image files needed
 110     // for web deployment with the application
 111     boolean includeDT;
 112 
 113     String placeholder = "'javafx-app-placeholder'";
 114     String appId = null;
 115 
 116     // didn't have a setter...
 117     boolean offlineAllowed = true;
 118 
 119     List<JSCallback> callbacks = null;
 120 
 121     //list of HTML templates to process
 122     List<Template> templates = new LinkedList<>();
 123 
 124     String jrePlatform = PackagerLib.JAVAFX_VERSION+"+";
 125     String fxPlatform = PackagerLib.JAVAFX_VERSION+"+";
 126     File javaRuntimeToUse = null;
 127     boolean javaRuntimeWasSet = false;
 128 
 129     //list of jvm args (in theory string can contain spaces and need to be escaped
 130     List<String> jvmargs = new LinkedList<>();
 131     Map<String, String> jvmUserArgs = new LinkedHashMap<>();
 132 
 133     //list of jvm properties (can also be passed as VM args
 134     // but keeping them separate make it a bit more convinient for JNLP generation)
 135     Map<String, String> properties = new LinkedHashMap<>();
 136 
 137     // raw arguments to the bundler
 138     Map<String, ? super Object> bundlerArguments = new LinkedHashMap<>();
 139 
 140     String fallbackApp = null;
 141 
 142     public void setJavaRuntimeSource(File src) {
 143         javaRuntimeToUse = src;
 144         javaRuntimeWasSet = true;
 145     }
 146 
 147     public void setCodebase(String codebase) {
 148         this.codebase = codebase;
 149     }
 150 
 151     public void setId(String id) {
 152         this.id = id;
 153     }
 154 
 155     public void setCategory(String category) {
 156         this.category = category;
 157     }
 158 
 159     public void setLicenseType(String licenseType) {
 160         this.licenseType = licenseType;
 161     }
 162 
 163     public void setCopyright(String copyright) {
 164         this.copyright = copyright;
 165     }
 166 
 167     public void setVersion(String version) {
 168         this.version = version;
 169     }
 170 
 171     public void setSystemWide(Boolean systemWide) {
 172         this.systemWide = systemWide;
 173     }
 174 
 175     public void setServiceHint(Boolean serviceHint) {
 176         this.serviceHint = serviceHint;
 177     }
 178 
 179     public void setInstalldirChooser(Boolean installdirChooser) {
 180         this.installdirChooser = installdirChooser;
 181     }
 182 
 183     public void setSignBundle(Boolean signBundle) {
 184         this.signBundle = signBundle;
 185     }
 186 
 187     public void setJRE(String v) {
 188         jrePlatform = v;
 189     }
 190 
 191     public void setSwingAppWithEmbeddedJavaFX(boolean v) {
 192         isSwingApp = v;
 193     }
 194 
 195     public void setNeedInstall(boolean b) {
 196         needInstall = b;
 197     }
 198 
 199     public void setOfflineAllowed(boolean b) {
 200         offlineAllowed = b;
 201     }
 202 
 203     public void setNeedShortcut(Boolean b) {
 204         needShortcut = b;
 205     }
 206 
 207     public void setNeedMenu(Boolean b) {
 208         needMenu = b;
 209     }
 210 
 211     public void setEmbeddedDimensions(String w, String h) {
 212         embeddedWidth = w;
 213         embeddedHeight = h;
 214     }
 215 
 216     public void setFallback(String v) {
 217         if (v == null) {
 218             return;
 219         }
 220 
 221         if ("none".equals(v) || "null".equals(v)) {
 222             fallbackApp = null;
 223         } else {
 224             fallbackApp = v;
 225         }
 226     }
 227 
 228     public void setJavafx(String v) {
 229         fxPlatform = v;
 230     }
 231 
 232     public void addJvmArg(String v) {
 233         jvmargs.add(v);
 234     }
 235 
 236     public void addJvmUserArg(String n, String v) {
 237         jvmUserArgs.put(n, v);
 238     }
 239 
 240     public void addJvmProperty(String n, String v) {
 241         properties.put(n, v);
 242     }
 243 
 244     public void setAllPermissions(boolean allPermissions) {
 245         this.allPermissions = allPermissions;
 246     }
 247 
 248     public void setAppName(String appName) {
 249         this.appName = appName;
 250     }
 251 
 252     public void setArguments(List<String> args) {
 253         this.arguments = args;
 254     }
 255 
 256     public void addAddModule(String module) {
 257         if (addModules == null) {
 258             addModules = new LinkedHashSet<>();
 259         }
 260 
 261         addModules.add(module);
 262     }
 263 
 264     public void addLimitModule(String module) {
 265         if (limitModules == null) {
 266             limitModules = new LinkedHashSet<>();
 267         }
 268 
 269         limitModules.add(module);
 270     }
 271 
 272     public void setModulePath(String value) {
 273         this.modulePath = value;
 274     }
 275 
 276     public void setModule(String value) {
 277         this.module = value;
 278     }
 279 
 280     public void setDebug(String value) {
 281         this.debugPort = value;
 282     }
 283 
 284     public void setStripNativeCommands(boolean value) {
 285         this.stripNativeCommands = value;
 286     }
 287 
 288     public void setDetectModules(boolean value) {
 289         this.detectmods = value;
 290     }
 291 
 292     public void setDescription(String description) {
 293         this.description = description;
 294     }
 295 
 296     public void setEmbedJNLP(boolean embedJNLP) {
 297         this.embedJNLP = embedJNLP;
 298     }
 299 
 300     @Deprecated
 301     public void setEmbedCertifcates(boolean v) {
 302         if (v) {
 303             System.out.println("JavaFX Packager no longer supports embedding certificates in JNLP files.  Setting will be ignored.");
 304         }
 305     }
 306 
 307     public void setPlaceholder(String p) {
 308         placeholder = p;
 309     }
 310 
 311     public void setAppId(String id) {
 312         appId = id;
 313     }
 314 
 315     public void setHeight(int height) {
 316         this.height = height;
 317     }
 318 
 319     public void setHtmlParams(List<HtmlParam> htmlParams) {
 320         this.htmlParams = htmlParams;
 321     }
 322 
 323     public void setOutfile(String outfile) {
 324         this.outfile = outfile;
 325     }
 326 
 327     public void setParams(List<Param> params) {
 328         this.params = params;
 329     }
 330 
 331     public void setPreloader(String preloader) {
 332         this.preloader = preloader;
 333     }
 334 
 335     public void setTitle(String title) {
 336         this.title = title;
 337     }
 338 
 339     public void setUpdateMode(String updateMode) {
 340         this.updateMode = updateMode;
 341     }
 342 
 343     public void setVendor(String vendor) {
 344         this.vendor = vendor;
 345     }
 346 
 347     public void setEmail(String email) {
 348         this.email = email;
 349     }
 350 
 351     public void setWidth(int width) {
 352         this.width = width;
 353     }
 354 
 355     public void setExtension(boolean isExtension) {
 356         this.isExtension = isExtension;
 357     }
 358 
 359     public void setApplicationClass(String applicationClass) {
 360         this.applicationClass = applicationClass;
 361     }
 362 
 363     public void setIncludeDT(boolean doEmbed) {
 364         includeDT = doEmbed;
 365     }
 366 
 367     public void setJSCallbacks(List<JSCallback> list) {
 368         callbacks = list;
 369     }
 370 
 371     public void addCallback(String name, String cmd) {
 372         if (callbacks == null) {
 373             callbacks = new ArrayList<>();
 374         }
 375 
 376         callbacks.add(new JSCallback(name, cmd));
 377     }
 378 
 379     static class Template {
 380         File in;
 381         File out;
 382 
 383         Template(File in, File out) {
 384             this.in = in;
 385             this.out = out;
 386         }
 387     }
 388 
 389     public void addTemplate(File in, File out) {
 390         templates.add(new Template(in, out));
 391     }
 392 
 393     //we need to expand as in some cases
 394     // (most notably javapackager)
 395     //we may get "." as filename and assumption is we include
 396     // everything in the given folder
 397     // (IOUtils.copyfiles() have recursive behavior)
 398     List<File> expandFileset(File root) {
 399         List<File> files = new LinkedList<>();
 400         if (com.oracle.tools.packager.IOUtils.isNotSymbolicLink(root)) {
 401             if (root.isDirectory()) {
 402                 File[] children = root.listFiles();
 403                 if (children != null) {
 404                     for (File f : children) {
 405                         files.addAll(expandFileset(f));
 406                     }
 407                 }
 408             } else {
 409                 files.add(root);
 410             }
 411         }
 412         return files;
 413     }
 414 
 415     @Override
 416     public void addResource(File baseDir, String path) {
 417         File file = new File(baseDir, path);
 418         //normalize top level dir
 419         // to strip things like "." in the path
 420         // or it can confuse symlink detection logic
 421         file = file.getAbsoluteFile();
 422 
 423         if (baseDir == null) {
 424             baseDir = file.getParentFile();
 425         }
 426         resources.add(new RelativeFileSet(baseDir, new LinkedHashSet<>(expandFileset(file))));
 427     }
 428 
 429     @Override
 430     public void addResource(File baseDir, File file) {
 431         //normalize initial file
 432         // to strip things like "." in the path
 433         // or it can confuse symlink detection logic
 434         file = file.getAbsoluteFile();
 435 
 436         if (baseDir == null) {
 437             baseDir = file.getParentFile();
 438         }
 439         resources.add(new RelativeFileSet(baseDir, new LinkedHashSet<>(expandFileset(file))));
 440     }
 441 
 442     public void addResource(File baseDir, String path, String type) {
 443         addResource(baseDir, createFile(baseDir, path), type);
 444     }
 445 
 446     public void addResource(File baseDir, File file, String type) {
 447         addResource(baseDir, file, "eager", type, null, null);
 448     }
 449 
 450     public void addResource(File baseDir, File file, String mode, String type, String os, String arch) {
 451         Set<File> singleFile = new LinkedHashSet<>();
 452         singleFile.add(file);
 453         if (baseDir == null) {
 454             baseDir = file.getParentFile();
 455         }
 456         RelativeFileSet rfs = new RelativeFileSet(baseDir, singleFile);
 457         rfs.setArch(arch);
 458         rfs.setMode(mode);
 459         rfs.setOs(os);
 460         rfs.setType(parseTypeFromString(type, file));
 461         resources.add(rfs);
 462     }
 463 
 464     private RelativeFileSet.Type parseTypeFromString(String type, File file) {
 465         if (type == null) {
 466             if (file.getName().endsWith(".jar")) {
 467                 return RelativeFileSet.Type.jar;
 468             } else if (file.getName().endsWith(".jnlp")) {
 469                 return RelativeFileSet.Type.jnlp;
 470             } else {
 471                 return RelativeFileSet.Type.UNKNOWN;
 472             }
 473         } else {
 474             return RelativeFileSet.Type.valueOf(type);
 475         }
 476     }
 477 
 478     private static File createFile(final File baseDir, final String path) {
 479         final File testFile = new File(path);
 480         return testFile.isAbsolute()
 481                 ? testFile
 482                 : new File(baseDir == null
 483                     ? null
 484                     : baseDir.getAbsolutePath(),
 485                       path);
 486     }
 487 
 488 
 489     @Override
 490     public void validate() throws PackagerException {
 491         if (outdir == null) {
 492             throw new PackagerException("ERR_MissingArgument", "-outdir");
 493         }
 494 
 495         if (outfile == null) {
 496             throw new PackagerException("ERR_MissingArgument", "-outfile");
 497         }
 498 
 499         if (module == null) {
 500             if (resources.isEmpty()) {
 501                 throw new PackagerException("ERR_MissingAppResources");
 502             }
 503             if (applicationClass == null) {
 504                 throw new PackagerException("ERR_MissingArgument", "-appclass");
 505             }
 506         }
 507     }
 508 
 509     public boolean validateForJNLP() {
 510         boolean result = false;
 511 
 512         // Success
 513         if (applicationClass != null && !applicationClass.isEmpty() &&
 514             (getBundleType() == BundleType.JNLP)) {
 515             result = true;
 516         }
 517 
 518         // Failed
 519         if ((module != null && !module.isEmpty()) ||
 520             (addModules != null && !addModules.isEmpty()) ||
 521             (limitModules != null && !limitModules.isEmpty()) |
 522             (modulePath != null && !modulePath.isEmpty()) ||
 523             getBundleType() == BundleType.INSTALLER ||
 524             getBundleType() == BundleType.NATIVE ||
 525             getBundleType() == BundleType.IMAGE) {
 526 
 527             result = false;
 528         }
 529 
 530         return result;
 531     }
 532 
 533     public boolean validateForBundle() {
 534         boolean result = false;
 535 
 536         // Success
 537         if (((applicationClass != null && !applicationClass.isEmpty()) ||
 538             (module != null && !module.isEmpty()))) {
 539             result = true;
 540         }
 541 
 542         return result;
 543     }
 544 
 545     //could be icon or splash
 546     static class Icon {
 547         final static int UNDEFINED = -1;
 548 
 549         String href;
 550         String kind;
 551         int width = UNDEFINED;
 552         int height = UNDEFINED;
 553         int depth = UNDEFINED;
 554         RunMode mode = RunMode.WEBSTART;
 555 
 556         Icon(String href, String kind, int w, int h, int d, RunMode m) {
 557             mode = m;
 558             this.href = href;
 559             this.kind = kind;
 560             if (w > 0) {
 561                 width = w;
 562             }
 563             if (h > 0) {
 564                 height = h;
 565             }
 566             if (d > 0) {
 567                 depth = d;
 568             }
 569         }
 570     }
 571 
 572     List<Icon> icons = new LinkedList<>();
 573 
 574     public void addIcon(String href, String kind, int w, int h, int d, RunMode m) {
 575         icons.add(new Icon(href, kind, w, h, d, m));
 576     }
 577 
 578     BundleType bundleType = BundleType.NONE;
 579     String targetFormat = null; //means any
 580 
 581     public void setBundleType(BundleType type) {
 582         bundleType = type;
 583     }
 584 
 585     public BundleType getBundleType() {
 586         return bundleType;
 587     }
 588 
 589     public void setTargetFormat(String t) {
 590         targetFormat = t;
 591     }
 592 
 593     public String getTargetFormat() {
 594         return targetFormat;
 595     }
 596 
 597     private String getArch() {
 598         String arch = System.getProperty("os.arch").toLowerCase();
 599 
 600         if ("x86".equals(arch) || "i386".equals(arch) || "i486".equals(arch)
 601                 || "i586".equals(arch) || "i686".equals(arch)) {
 602             arch = "x86";
 603         } else if ("x86_64".equals(arch) || "amd64".equals("arch")) {
 604             arch = "x86_64";
 605         }
 606 
 607         return arch;
 608     }
 609 
 610     static final Set<String> multi_args = new TreeSet<>(Arrays.asList(
 611             StandardBundlerParam.JVM_PROPERTIES.getID(),
 612             StandardBundlerParam.JVM_OPTIONS.getID(),
 613             StandardBundlerParam.USER_JVM_OPTIONS.getID(),
 614             StandardBundlerParam.ARGUMENTS.getID(),
 615             StandardBundlerParam.MODULE_PATH.getID(),
 616             StandardBundlerParam.ADD_MODULES.getID(),
 617             StandardBundlerParam.LIMIT_MODULES.getID(),
 618             StandardBundlerParam.STRIP_NATIVE_COMMANDS.getID(),
 619             JLinkBundlerHelper.DETECT_MODULES.getID()
 620     ));
 621 
 622     @SuppressWarnings("unchecked")
 623     public void addBundleArgument(String key, Object value) {
 624         // special hack for multi-line arguments
 625         if (multi_args.contains(key) && value instanceof String) {
 626             Object existingValue = bundlerArguments.get(key);
 627             if (existingValue instanceof String) {
 628                 bundlerArguments.put(key, existingValue + "\n\n" + value);
 629             } else if (existingValue instanceof List) {
 630                 ((List)existingValue).add(value);
 631             } else if (existingValue instanceof Map && ((String)value).contains("=")) {
 632                 String[] mapValues = ((String)value).split("=", 2);
 633                 ((Map)existingValue).put(mapValues[0], mapValues[1]);
 634             } else {
 635                 bundlerArguments.put(key, value);
 636             }
 637         } else {
 638             bundlerArguments.put(key, value);
 639         }
 640     }
 641 
 642     public BundleParams getBundleParams() {
 643         BundleParams bundleParams = new BundleParams();
 644 
 645         //construct app resources
 646         //  relative to output folder!
 647         String currentOS = System.getProperty("os.name").toLowerCase();
 648         String currentArch = getArch();
 649 
 650         for (RelativeFileSet rfs : resources) {
 651             String os = rfs.getOs();
 652             String arch = rfs.getArch();
 653             //skip resources for other OS
 654             // and nativelib jars (we are including raw libraries)
 655             if ((os == null || currentOS.contains(os.toLowerCase())) &&
 656                     (arch == null || currentArch.startsWith(arch.toLowerCase()))
 657                     && rfs.getType() != RelativeFileSet.Type.nativelib) {
 658                 if (rfs.getType() == RelativeFileSet.Type.license) {
 659                     for (String s : rfs.getIncludedFiles()) {
 660                         bundleParams.addLicenseFile(s);
 661                     }
 662                 }
 663             }
 664         }
 665 
 666         bundleParams.setAppResourcesList(resources);
 667 
 668         bundleParams.setIdentifier(id);
 669 
 670         if (javaRuntimeWasSet) {
 671             bundleParams.setRuntime(javaRuntimeToUse);
 672         }
 673         bundleParams.setApplicationClass(applicationClass);
 674         bundleParams.setPrelaoderClass(preloader);
 675         bundleParams.setName(this.appName);
 676         bundleParams.setAppVersion(version);
 677         bundleParams.setType(bundleType);
 678         bundleParams.setBundleFormat(targetFormat);
 679         bundleParams.setVendor(vendor);
 680         bundleParams.setEmail(email);
 681         bundleParams.setShortcutHint(needShortcut);
 682         bundleParams.setMenuHint(needMenu);
 683         putUnlessNull(INSTALL_HINT.getID(), needInstall);
 684         bundleParams.setSystemWide(systemWide);
 685         bundleParams.setServiceHint(serviceHint);
 686         bundleParams.setInstalldirChooser(installdirChooser);
 687         bundleParams.setSignBundle(signBundle);
 688         bundleParams.setCopyright(copyright);
 689         bundleParams.setApplicationCategory(category);
 690         bundleParams.setLicenseType(licenseType);
 691         bundleParams.setDescription(description);
 692         bundleParams.setTitle(title);
 693         if (verbose) bundleParams.setVerbose(true);
 694 
 695         bundleParams.setJvmProperties(properties);
 696         bundleParams.setJvmargs(jvmargs);
 697         bundleParams.setJvmUserArgs(jvmUserArgs);
 698         bundleParams.setArguments(arguments);
 699 
 700         if (addModules != null && !addModules.isEmpty()) {
 701             bundleParams.setAddModules(addModules);
 702         }
 703 
 704         if (limitModules != null && !limitModules.isEmpty()) {
 705             bundleParams.setLimitModules(limitModules);
 706         }
 707 
 708         if (stripNativeCommands != null) {
 709             bundleParams.setStripNativeCommands(stripNativeCommands);
 710         }
 711 
 712         bundleParams.setSrcDir(srcdir);
 713 
 714         if (modulePath != null && !modulePath.isEmpty()) {
 715             bundleParams.setModulePath(modulePath);
 716         }
 717 
 718         if (module != null && !module.isEmpty()) {
 719             bundleParams.setMainModule(module);
 720         }
 721 
 722         if (debugPort != null && !debugPort.isEmpty()) {
 723             bundleParams.setDebug(debugPort);
 724         }
 725 
 726         if (detectmods != null) {
 727             bundleParams.setDetectMods(detectmods);
 728         }
 729 
 730         File appIcon = null;
 731         List<Map<String, ? super Object>> bundlerIcons = new ArrayList<>();
 732         for (Icon ic: icons) {
 733             //NB: in theory we should be paying attention to RunMode but
 734             // currently everything is marked as webstart internally and runmode
 735             // is not publicly documented property
 736             if (/* (ic.mode == RunMode.ALL || ic.mode == RunMode.STANDALONE) && */
 737                 (ic.kind == null || ic.kind.equals("default")))
 738             {
 739                 //could be full path or something relative to the output folder
 740                 appIcon = new File(ic.href);
 741                 if (!appIcon.exists()) {
 742                     com.oracle.tools.packager.Log.debug("Icon [" + ic.href + "] is not valid absolute path. " +
 743                             "Assume it is relative to the output dir.");
 744                     appIcon = new File(outdir, ic.href);
 745                 }
 746             }
 747 
 748             Map<String, ? super Object> iconInfo = new TreeMap<>();
 749             if (ic.href != null) iconInfo.put(ICONS_HREF.getID(), ic.href);
 750             if (ic.kind != null) iconInfo.put(ICONS_KIND.getID(), ic.kind);
 751             if (ic.width > 0)    iconInfo.put(ICONS_WIDTH.getID(), Integer.toString(ic.width));
 752             if (ic.height > 0)   iconInfo.put(ICONS_HEIGHT.getID(), Integer.toString(ic.height));
 753             if (ic.depth > 0)    iconInfo.put(ICONS_DEPTH.getID(), Integer.toString(ic.depth));
 754 
 755             if (!iconInfo.isEmpty()) bundlerIcons.add(iconInfo);
 756         }
 757         putUnlessNullOrEmpty(ICONS.getID(), bundlerIcons);
 758 
 759         bundleParams.setIcon(appIcon);
 760 
 761         Map<String, String> paramsMap = new TreeMap<>();
 762         if (params != null) {
 763             for (Param p : params) {
 764                 paramsMap.put(p.name, p.value);
 765             }
 766         }
 767         putUnlessNullOrEmpty(JNLPBundler.APP_PARAMS.getID(), paramsMap);
 768 
 769         Map<String, String> unescapedHtmlParams = new TreeMap<>();
 770         Map<String, String> escapedHtmlParams = new TreeMap<>();
 771         if (htmlParams != null) {
 772             for (HtmlParam hp : htmlParams) {
 773                 if (hp.needEscape) {
 774                     escapedHtmlParams.put(hp.name, hp.value);
 775                 } else {
 776                     unescapedHtmlParams.put(hp.name, hp.value);
 777                 }
 778             }
 779         }
 780         putUnlessNullOrEmpty(JNLPBundler.APPLET_PARAMS.getID(), unescapedHtmlParams);
 781         putUnlessNullOrEmpty(ESCAPED_APPLET_PARAMS.getID(), escapedHtmlParams);
 782 
 783 
 784         putUnlessNull(WIDTH.getID(), width);
 785         putUnlessNull(HEIGHT.getID(), height);
 786         putUnlessNull(EMBEDDED_WIDTH.getID(), embeddedWidth);
 787         putUnlessNull(EMBEDDED_HEIGHT.getID(), embeddedHeight);
 788 
 789         putUnlessNull(CODEBASE.getID(), codebase);
 790         putUnlessNull(EMBED_JNLP.getID(), embedJNLP);
 791         // embedCertificates
 792         putUnlessNull(ALL_PERMISSIONS.getID(), allPermissions);
 793         putUnlessNull(UPDATE_MODE.getID(), updateMode);
 794         putUnlessNull(EXTENSION.getID(), isExtension);
 795         putUnlessNull(SWING_APP.getID(), isSwingApp);
 796 
 797         putUnlessNull(OUT_FILE.getID(), outfile);
 798         putUnlessNull(INCLUDE_DT.getID(), includeDT);
 799         putUnlessNull(PLACEHOLDER.getID(), placeholder);
 800         putUnlessNull(OFFLINE_ALLOWED.getID(), offlineAllowed);
 801 
 802         Map<String, String> callbacksMap = new TreeMap<>();
 803         if (callbacks != null) {
 804             for (JSCallback callback : callbacks) {
 805                 callbacksMap.put(callback.getName(), callback.getCmd());
 806             }
 807         }
 808         putUnlessNull(JS_CALLBACKS.getID(), callbacksMap);
 809 
 810         Map<File, File> templatesMap = new TreeMap<>();
 811         if (templates != null) {
 812             for (Template template : templates) {
 813                 templatesMap.put(template.in, template.out);
 814             }
 815         }
 816         putUnlessNull(TEMPLATES.getID(), templatesMap);
 817 
 818         putUnlessNull(FX_PLATFORM.getID(), fxPlatform);
 819         putUnlessNull(JRE_PLATFORM.getID(), jrePlatform);
 820 
 821         putUnlessNull(FALLBACK_APP.getID(), fallbackApp);
 822 
 823         // check for collisions
 824         TreeSet<String> keys = new TreeSet<>(bundlerArguments.keySet());
 825         keys.retainAll(bundleParams.getBundleParamsAsMap().keySet());
 826 
 827         if (!keys.isEmpty()) {
 828             throw new RuntimeException("Deploy Params and Bundler Arguments overlap in the following values:" + keys.toString());
 829         }
 830 
 831         bundleParams.addAllBundleParams(bundlerArguments);
 832 
 833         return bundleParams;
 834     }
 835 
 836     public void putUnlessNull(String param, Object value) {
 837         if (value != null) {
 838             bundlerArguments.put(param, value);
 839         }
 840     }
 841 
 842     public void putUnlessNullOrEmpty(String param, Map<?, ?> value) {
 843         if (value != null && !value.isEmpty()) {
 844             bundlerArguments.put(param, value);
 845         }
 846     }
 847 
 848     public void putUnlessNullOrEmpty(String param, Collection<?> value) {
 849         if (value != null && !value.isEmpty()) {
 850             bundlerArguments.put(param, value);
 851         }
 852     }
 853 }