From 681137b89c80b7e798d2ba8e4e158605b764f44d Mon Sep 17 00:00:00 2001 From: Ben Soares Date: Tue, 29 Oct 2024 18:46:13 +0000 Subject: [PATCH] JAL-4477 install4j 11 template --- utils/install4j/install4j11_template.install4j | 3171 ++++++++++++++++++++++++ 1 file changed, 3171 insertions(+) create mode 100644 utils/install4j/install4j11_template.install4j diff --git a/utils/install4j/install4j11_template.install4j b/utils/install4j/install4j11_template.install4j new file mode 100644 index 0000000..312ee1b --- /dev/null +++ b/utils/install4j/install4j11_template.install4j @@ -0,0 +1,3171 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *.dylib + *.so + *.jnilib + unpack200 + tnameserv + servertool + rmiregistry + rmid + policytool + pack200 + orbd + keytool + jjs + java + jspawnhelper + libfreetype.dylib.6 + applet + jaotc + jfr + jrunscript + libjli.dylib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + # Enter one VM parameter per line +# For example, to adjust the maximum memory usage to 512 MB, uncomment the following line: +# -Xmx512m +# To include another file, uncomment the following line: +# -include-options [path to other .vmoption file] + +# Jalview specific options below + + export LC_ALL=C.UTF-8 + ${compiler:file("${compiler:INFO_PLIST_FILE_ASSOCIATIONS_FILE}")} + + + + + + + + + + + + + + /* + +import java.beans.BeanInfo; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; +import java.beans.IntrospectionException; +import java.lang.reflect.Method; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Array; + + public static String printDataType(Object o) { + return printDataType("", o); + } + + public static String printDataType(String prefix, Object o) { + return printDataType(prefix, o, 1); + } + public static String printDataType(String prefix, Object o, int iter) { + StringBuilder stringRep = new StringBuilder(); + + try { + if (o != null) { + Class objectType = o.getClass(); + if (objectType.isPrimitive() || + objectType.equals(String.class) || + objectType.equals(Date.class)) { + stringRep.append(prefix + " (" + objectType.getSimpleName() + + ") = " + o.toString() + "\n"); + } else if (objectType.isArray()) { + if (Array.getLength(o) == 0) { + stringRep.append(prefix + " = empty array\n"); + } + if (objectType.getComponentType().isPrimitive() || + objectType.getComponentType().equals(String.class) || + objectType.getComponentType().equals(Date.class)) { + for (int i = 0; i < Array.getLength(o); i++) { + stringRep.append(prefix + "[" + i + "] = " + + Array.get(o, i).toString() + "\n"); + } + } else { + for (int i = 0; i < Array.getLength(o); i++) { + stringRep.append(printDataType(prefix + "[" + i + "]", + Array.get(o, i), iter + 1)); + } + } + } else if (o instanceof Iterable) { + int i = 0; + Iterator it = ((Iterable) o).iterator(); + if (!it.hasNext()) { + stringRep.append(prefix + " = empty set\n"); + } + while (it.hasNext()) { + stringRep.append(printDataType(prefix + "[" + i++ + "]", + it.next(), iter + 1)); + } + } else if (o instanceof Map) { + Set<Object> keys = ((Map) o).keySet(); + if (keys.isEmpty()) { + stringRep.append(prefix + " = empty map\n"); + } + for (Object key : keys) { + stringRep.append(printDataType(prefix + "[" + key.toString() + "]", + ((Map) o).get(key), iter + 1)); + } + } else if (o instanceof Class) { + // Do nothing otherwise the stack blows up + } else { + Method[] methods = objectType.getMethods(); + + for (Method method : methods) { + if (method.getName().startsWith("get") && + method.getParameterCount() == 0) { + String propertyName = method.getName().substring(3,4).toLowerCase() + + method.getName().substring(4); + Object value = method.invoke(o, new Object[] {} ); + // value.getClass().isPrimitive returns false, even if + // method.getReturnType().isPrimitive returns true + if (method.getReturnType().isPrimitive()) { + stringRep.append(prefix + "." + propertyName + " (" + + method.getReturnType().getSimpleName() + ") = " + + value.toString() + "\n"); + } else { + if (iter < 10) { + stringRep.append(printDataType(prefix + "." + propertyName, value, iter + 1)); + } else { + stringRep.append("..."); + } + } + } else if (method.getName().startsWith("is") && + method.getParameterCount() == 0 && + method.getReturnType().equals(boolean.class)) { + String propertyName = method.getName().substring(2,3).toLowerCase() + + method.getName().substring(3); + stringRep.append(prefix + "." + propertyName + " (boolean) = " + + (method.invoke(o, new Object[] {}).equals(true) ? "true" : "false") + "\n"); + } + } + } + } else { + return prefix + " = null\n"; + } + } catch (Exception e) { + //e.printStackTrace(); + //return e.toString(); + stringRep.append("Exception("+e.getMessage()+")"); + } + + return stringRep.toString(); + } + +*/ + +public static String getOsAppDataPath(Context context) { + Map<String, String> osAppDataPathMap = new HashMap<>(); + osAppDataPathMap.put("macos", "Library/Application Support/Jalview-Desktop"); + osAppDataPathMap.put("linux", ".local/share/jalview-desktop"); + osAppDataPathMap.put("windows", "AppData\\Local\\Jalview-Desktop"); + osAppDataPathMap.put("other", ".jalview-desktop"); + String appDataPath; + String append; + if (Util.isMacOS()) { + appDataPath = osAppDataPathMap.get("macos"); + append = context.getCompilerVariable("JALVIEW_APPLICATION_NAME"); + } else if (Util.isWindows()) { + appDataPath = osAppDataPathMap.get("windows"); + append = context.getCompilerVariable("APPLICATION_FOLDER"); + } else if (Util.isLinux()) { + appDataPath = osAppDataPathMap.get("linux"); + append = context.getCompilerVariable("APPLICATION_FOLDER").toLowerCase(Locale.ROOT); + } else { + appDataPath = osAppDataPathMap.get("other"); + append = context.getCompilerVariable("APPLICATION_FOLDER").toLowerCase(Locale.ROOT); + } + return "~" + File.separator + appDataPath + File.separator + append; +} + +// methods used in advanced options form validation +public static void validateUserSpaceAdvancedOptionsForm(FormEnvironment formEnvironment) { + FormComponent fc_advancedOptions = formEnvironment.getFormComponentById("US_ADVANCED_OPTIONS"); + FormComponent fc_notUsed = formEnvironment.getFormComponentById("US_NOT_USED"); + FormComponent fc_userUpdates = formEnvironment.getFormComponentById("US_ALLOW_USER_APPDIR_UPDATES"); + FormComponent fc_warning = formEnvironment.getFormComponentById("US_NO_UPDATES_WARNING"); + LayoutGroup lg_advancedOptions = formEnvironment.getLayoutGroupById("US_ADVANCED_OPTIONS_GROUP"); + + // get boolean status of "Enable advanced options" checkbox + JCheckBox jcb_advancedOptions = (JCheckBox) fc_advancedOptions.getConfigurationObject(); + boolean advancedOptions = jcb_advancedOptions.isSelected(); + + // set visibility of Advanced options layout group + lg_advancedOptions.setVisible(advancedOptions); + fc_notUsed.setVisible(!advancedOptions); + + if (!advancedOptions) { + return; + } + + JCheckBox jcb_userUpdates = (JCheckBox) fc_userUpdates.getConfigurationObject(); + boolean userUpdates = fc_userUpdates.isEnabled() && jcb_userUpdates.isSelected(); + + boolean showWarning = advancedOptions && (!userUpdates); + + fc_warning.setVisible(showWarning); +} + +public static void validateSystemSpaceAdvancedOptionsForm(Context context, FormEnvironment formEnvironment) { + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment, true); +} + +public static boolean validateSystemSpaceAdvancedOptionsForm(Context context, FormEnvironment formEnvironment, boolean ret) { + FormComponent fc_advancedOptions = formEnvironment.getFormComponentById("SS_ADVANCED_OPTIONS"); + FormComponent fc_notUsed = formEnvironment.getFormComponentById("SS_NOT_USED"); + FormComponent fc_userUpdates = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_UPDATES"); + FormComponent fc_installerUpdates = formEnvironment.getFormComponentById("SS_ALLOW_INSTALLER_APPDIR_UPDATES"); + FormComponent fc_allowUserAppdirPath = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_PATH"); + FormComponent fc_userAppdirPath = formEnvironment.getFormComponentById("SS_USER_APPDIR_PATH"); + LayoutGroup lg_advancedGroup = formEnvironment.getLayoutGroupById("SS_ADVANCED_OPTIONS_GROUP"); + LayoutGroup lg_setUserAppdirPath = formEnvironment.getLayoutGroupById("SS_SET_USER_APPDIR_PATH"); + + + + // get boolean status of "Enable advanced options" checkbox + JCheckBox jcb_advancedOptions = (JCheckBox) fc_advancedOptions.getConfigurationObject(); + boolean advancedOptions = jcb_advancedOptions.isSelected(); + + // set visibility of Advanced options layout group + lg_advancedGroup.setVisible(advancedOptions); + fc_notUsed.setVisible(!advancedOptions); + + if (!advancedOptions) { + return ret; + } + + + + // get boolean status of "Allow user-space updates" checkbox + JCheckBox jcb_user = (JCheckBox) fc_userUpdates.getConfigurationObject(); + boolean userUpdates = jcb_user.isSelected(); + + // set enabled of customised user appdir path group + lg_setUserAppdirPath.setEnabled(advancedOptions && userUpdates); + + // set enabled of allow installation updates checkbox + fc_installerUpdates.setEnabled(advancedOptions && !userUpdates); + + + + // get boolean status of "Customise the user-space path" checkbox + JCheckBox jcb_allowUserAppdirPath = (JCheckBox) fc_allowUserAppdirPath.getConfigurationObject(); + boolean allowUserAppdirPath = jcb_allowUserAppdirPath.isSelected(); + + // set enabled of userAppdirPath text field + fc_userAppdirPath.setEnabled(advancedOptions && allowUserAppdirPath && fc_allowUserAppdirPath.isEnabled()); + + // get String value of userAppdirPath text field + JTextField jtf_userAppdirPath = (JTextField) fc_userAppdirPath.getConfigurationObject(); + String userAppdirPath = jtf_userAppdirPath.getText(); + + + + // get boolean status of "Allow installation updates" checkbox + JCheckBox jcb_installer = (JCheckBox) fc_installerUpdates.getConfigurationObject(); + boolean installerUpdates = jcb_installer.isSelected(); + + + + // should we show the No updates warning? + boolean showNoUpdatesWarning = advancedOptions && !(userUpdates || installerUpdates); + FormComponent fc_noUpdatesWarning = formEnvironment.getFormComponentById("SS_NO_UPDATES_WARNING"); + fc_noUpdatesWarning.setVisible(advancedOptions && showNoUpdatesWarning); + + + + // should we show the invalid user-space path warning? + showInvalidUserAppdirPathWarning(context, formEnvironment); + + + + // set whether "Set defaults" button should be enabled + FormComponent fc_setDefaults = formEnvironment.getFormComponentById("SS_SET_DEFAULTS"); + JButton jb_setDefaults = (JButton) fc_setDefaults.getConfigurationObject(); + boolean enableSetDefaults = !( userUpdates && !allowUserAppdirPath && userAppdirPath.length() == 0 && !installerUpdates ); + jb_setDefaults.setEnabled(enableSetDefaults); + + + + return ret; +} + +public static boolean isUserAppdirPathValid(Context context) { // this is only valid when form is updated + return isUserAppdirPathValid(context, (String) context.getVariable("userAppdirPath")); +} + +public static boolean isUserAppdirPathValid(Context context, FormComponent fc_userAppdirPath) { + // get String value of userAppdirPath text field + JTextField jtf_userAppdirPath = (JTextField) fc_userAppdirPath.getConfigurationObject(); + String userAppdirPath = jtf_userAppdirPath.getText(); + return isUserAppdirPathValid(context, userAppdirPath); +} + +public static boolean isUserAppdirPathValid(Context context, String userAppdirPath) { + if (userAppdirPath == null || userAppdirPath.length() == 0) { + return true; // null will be switched to default + } + + boolean u = userAppdirPath.contains("%u"); + boolean U = userAppdirPath.contains("%U"); + boolean h = userAppdirPath.contains("%h"); + boolean t = userAppdirPath.startsWith("~" + (String)context.getVariable("sys.fileSeparator")); + + return u || U || h || t; +} + +public static void showInvalidUserAppdirPathWarning(Context context, FormEnvironment formEnvironment) { + FormComponent fc_advancedOptions = formEnvironment.getFormComponentById("SS_ADVANCED_OPTIONS"); + FormComponent fc_userUpdates = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_UPDATES"); + FormComponent fc_allowUserAppdirPath = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_PATH"); + FormComponent fc_userAppdirPath = formEnvironment.getFormComponentById("SS_USER_APPDIR_PATH"); + FormComponent fc_invalidPathWarning = formEnvironment.getFormComponentById("SS_INVALID_USER_APPDIR_PATH_WARNING"); + + // get boolean status of "Allow user-space updates" checkbox + boolean advancedOptions = ((JCheckBox) fc_advancedOptions.getConfigurationObject()).isSelected(); + + // get boolean status of "Allow user-space updates" checkbox + boolean userUpdates = ((JCheckBox) fc_userUpdates.getConfigurationObject()).isSelected(); + + // get boolean status of "Customise the user-space path" checkbox + boolean allowUserAppdirPath = ((JCheckBox) fc_allowUserAppdirPath.getConfigurationObject()).isSelected(); + + // show/hide warning + boolean showInvalidPathWarning = advancedOptions && userUpdates && allowUserAppdirPath && !isUserAppdirPathValid(context, fc_userAppdirPath); + fc_invalidPathWarning.setVisible(showInvalidPathWarning); +} + +// methods to get installer.appdir hash +protected static final String XLATE = "0123456789abcdef"; + +public static String hexlate (byte[] bytes, int count) +{ + if (bytes == null) { + return ""; + } + + count = Math.min(count, bytes.length); + char[] chars = new char[count*2]; + + for (int i = 0; i < count; i++) { + int val = bytes[i]; + if (val < 0) { + val += 256; + } + chars[2*i] = XLATE.charAt(val/16); + chars[2*i+1] = XLATE.charAt(val%16); + } + + return new String(chars); +} + +public static String hexlate (byte[] bytes) +{ + return (bytes == null) ? "" : hexlate(bytes, bytes.length); +} + +public static final String getFullPathToDirectoryHash(String install_app_dir) +{ + java.security.MessageDigest md; + try { + md = java.security.MessageDigest.getInstance("SHA-256"); + } catch (java.security.NoSuchAlgorithmException nsae) { + throw new RuntimeException("JVM does not support SHA-256. Gurp!"); + } + byte[] contents = install_app_dir.getBytes(java.nio.charset.StandardCharsets.UTF_8); + String hash = hexlate(md.digest(contents)); + return hash.substring(0,8); +} + +public static final String getCanonicalFullPathToDirectoryHash(String installerAppdir) { + try { + return getFullPathToDirectoryHash(new File(installerAppdir).getCanonicalPath()); + }catch (IOException ioex) { + System.err.println("Unable to resolve '"+installerAppdir+"' as a proper path on this system.\nNot generating an installer appdir hash"); + return ""; + } +} + + + + + + + + + + + + + + + + + + + 255 + 255 + 255 + 255 + + + 49 + 52 + 53 + 255 + + + + + + + + + + + 255 + 255 + 255 + 255 + + + + + + ${compiler:JALVIEW_DIR}/${compiler:BACKGROUND} + + + + + 5 + 10 + 10 + 10 + + + + + imageAnchor + imageEdgeBackgroundColor + imageFile + + + + + + + + + + labelText + + + + + + + + + + 255 + 255 + 255 + 255 + + + 49 + 52 + 53 + 255 + + + + + + + + + + + + + ${compiler:JALVIEW_DIR}/${compiler:TITLE_ICON} + + + + + + + + 5 + + + + + + + + 20 + + 10 + + + + + backgroundColor + foregroundColor + imageAnchor + imageFile + imageOverlap + + + + + ${compiler:file("${compiler:INFO_PLIST_FILE_ASSOCIATIONS_FILE}")} + + + + + + + + + + + + + + + + + + + Util.hasFullAdminRights() // this doesn't seem to work in some conditionals so creating our own boolean + + + isAdmin + + + + + + + Util.isLinux() || Util.isUnixInstaller() || ( Util.isMacosInstaller() && context.getBooleanVariable("isAdmin") ) + + + makeSymbolicLink + + + + + + + + ArrayList<String> tryPaths = new ArrayList<> (); + +if (Util.hasFullAdminRights()) { + tryPaths.add(File.separator + "opt" + File.separator + "bin"); + tryPaths.add(File.separator + "usr" + File.separator + "local" + File.separator + "bin"); +} else { + String userHome = (String)context.getVariable("sys.userHome"); + tryPaths.add(userHome + File.separator + "bin"); + tryPaths.add(userHome + File.separator + "local" + File.separator + "bin"); + tryPaths.add(userHome + File.separator + ".local" + File.separator + "bin"); + tryPaths.add(userHome + File.separator + "opt" + File.separator + "bin"); +} + +for (int i = 0; i < tryPaths.size(); i++) { + String tryPath = tryPaths.get(i); + File unixBinDir = new File(tryPath); + if (unixBinDir.exists()) { + return tryPath; + } +} + +return null; + + + + unixBinDir + + if (!context.getBooleanVariable("makeSymbolicLink")) { + return false; +} +String unixBinDir = (String) context.getVariable("unixBinDir"); +if (unixBinDir != null && unixBinDir.length() > 0) { + if (unixBinDir.startsWith("~/")) { + unixBinDir = (String)context.getVariable("sys.userHome") + unixBinDir.substring(1); + context.setVariable("unixBinDir", unixBinDir); + } + return false; +} +return true; + + + + + + String javaHome = System.getProperty("java.home"); +String appName = ((String)context.getCompilerVariable("JALVIEW_APPLICATION_NAME")) + ".app"; +int i = javaHome.indexOf(appName); +String MacOSDir = null; +if (i > -1) { + MacOSDir = javaHome.substring(0, i) + appName + File.separator + "Contents" + File.separator + "MacOS"; +} +return MacOSDir; + + + + MacOSDir + + Util.isMacOS() && !context.getBooleanVariable("isAdmin") // Admin on macOS will add path to /etc/paths.d in Create File action + + + + + + + + Boolean.FALSE + + + advancedOptions + + + + + + + + + Boolean.TRUE + + + allowUserDefaultAppdirUpdates + + + + + + + + + Boolean.FALSE + + + allowSetUserAppdirPath + + + + + + + + + "" + + + userAppdirPath + + + + + + + + + Boolean.FALSE + + + allowInstallerAppdirUpdates + + + + + + + getOsAppDataPath(context) + + + userDefaultAppdirBase + + + + + + + if (Util.isWindows()) { + return "Windows"; +} else if (Util.isMacOS()) { + return "macOS"; +} else if (Util.isLinux()) { + return "Linux"; +} +return context.getCompilerVariable("sys.platform"); + + + osName + + + + + + + Boolean.FALSE + + + consoleDisableUserAppdir + + + + + + + Boolean.FALSE + + + consoleDisableAllUpdates + + + + + + + Boolean.FALSE + + + consoleAllowUserAppdirPath + + + + + + + String[] args = context.getExtraCommandLineArguments(); + +for (int i = 0; i < args.length; i++) { + String arg = args[i]; + switch(arg) { + case "-a": + if (args.length - 1 < i + 1) { + System.out.println("Option " + arg + " requires a value. Ignoring."); + } + context.setInstallationDirectory(new File(args[i + 1])); + i++; + break; + case "-u": + if (args.length - 1 < i + 1) { + System.out.println("Option " + arg + " requires a value. Ignoring."); + } + context.setVariable("userAppdirPath", args[i + 1]); + context.setVariable("consoleAllowUserAppdirPath", true); + i++; + break; + case "-U": + context.setVariable("consoleDisableUserAppdir", true); + break; + case "-S": + context.setVariable("consoleDisableAllUpdates", true); + break; + default: + System.out.println("Option " + arg + " not recognised. Ignoring."); + break; + } +} + +return true; + + + + context.isConsole() || context.isUnattended() + + + + + + String[] extensions = (String[]) context.getVariable("sys.fileAssociation.extensions"); +if (extensions == null) { + return false; +} +int num = extensions.length; +String[] launchers = new String[num]; +for (int i = 0; i < num; i++) { + launchers[i] = "JALVIEW"; +} +context.setVariable("sys.fileAssociation.launchers", launchers); +return true; + + + + + + + + + + + + + + + + + 255 + 255 + 255 + 255 + + + 49 + 52 + 53 + 255 + + + + + + + + + + + + + 25 + 143 + 220 + 255 + + + + 74 + 151 + 255 + + + + + + + ${compiler:JALVIEW_DIR}/${compiler:BACKGROUND} + + + + + 5 + 10 + 10 + 10 + + + + + imageAnchor + imageEdgeBackgroundColor + imageFile + + + + + + + + + sys.installationDir + sys.adminRights$Boolean + sys.adminRightsUiRootUnix$Boolean + sys.component.1031$Boolean + sys.fileAssociation.launchers$StringArray + + + context.getBooleanVariable("sys.confirmedUpdateInstallation") + + + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${form:welcomeMessage} + + !context.isConsole() + + + + + + String message = context.getMessage("ConsoleWelcomeLabel", context.getApplicationName()); +return console.askOkCancel(message, true); + + + + + + + + updateCheck + + + + + ${i18n:ClickNext} + + + + + + !context.getBooleanVariable("sys.confirmedUpdateInstallation") + + + + + sys.installationDir + sys.adminRights$Boolean + sys.adminRightsUiRootUnix$Boolean + sys.component.1031$Boolean + sys.fileAssociation.launchers$StringArray + + + context.getVariable("sys.responseFile") == null + + + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${i18n:SelectDirLabel(${compiler:sys.fullName})} + + + + + + + + + + + allowSpacesOnUnix + checkFreeSpace + checkWritable + existingDirWarning + manualEntryAllowed + showFreeDiskSpace + showRequiredDiskSpace + standardValidation + suggestAppDir + validateApplicationId + validationScript + + + + + + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${i18n:SelectAssociationsLabel} + + + + + + + Screen s = formEnvironment.getScreen(); + +FormComponent fc = formEnvironment.getFormComponentById("FILE_ASSOCIATIONS_SELECTOR"); +com.install4j.api.actions.Action a0 = context.getActionById("FA_FILEASSOCIATION-CIF-false"); +Screen s2 = context.getScreenById("EXTENSIONS_REPLACED_BY_GRADLE_PARENT_GROUP"); + +for (com.install4j.api.actions.Action a : context.getActions(s2)) { + String aid = context.getId(a); + if (aid.startsWith("FA_FILEASSOCIATION-")) { + com.install4j.runtime.beans.actions.desktop.CreateFileAssociationAction aa = (com.install4j.runtime.beans.actions.desktop.CreateFileAssociationAction) a; + boolean set = aid.endsWith("-true"); + boolean got = aa.isSelected(); + aa.setSelected(set); + System.err.println("Setting '"+aid+"' from "+got+" to "+set); + } +} + +context.gotoScreen(s); +//formEnvironment.reinitializeFormComponents(); + + + Reset + + + + + + + + + + selectionButtonPosition + showSelectionButtons + + + + + + + Additional tasks for user installation (${installer:sys.userName}) + ${i18n:WizardSelectTasks} + + !context.getBooleanVariable("isAdmin") + + + + ${i18n:SelectTasksLabel2(${compiler:JALVIEW_APPLICATION_NAME})} + + + + + ${i18n:CreateDesktopIcon} + createDesktopLinkAction + + !Util.isMacOS() + + + + ${i18n:AddToDock} + addToDockAction + + Util.isMacOS() + + + + Add ${compiler:JALVIEW_APPLICATION_NAME}'s bin folder to your Path environment variable + + appendToPathAction + + Util.isWindows() + + + + Make a ${compiler:WRAPPER_LINK} symbolic link in ${installer:unixBinDir} + + makeSymbolicLinkAction + + context.getBooleanVariable("makeSymbolicLink") +&& context.getVariable("unixBinDir") != null +&& ( + Util.isLinux() + || Util.isUnixInstaller() + || ( + ( Util.isMacOS() && !Util.hasFullAdminRights() ) // Admin on macOS will add path to /etc/paths.d + && context.getVariable("MacOSDir") != null + ) + ) + + + + + Enable advanced options for user installation + + 2980 + 3014 + 2975 + 2989 + + + + validateUserSpaceAdvancedOptionsForm(formEnvironment) + + + advancedOptions + + + + + + + 128 + 128 + 128 + 255 + + + + + Advanced options will not be used + + !context.getBooleanVariable("advancedOptions") + + + + + + + FormComponent fc_advancedOptions = formEnvironment.getFormComponentById("US_ADVANCED_OPTIONS"); + +JCheckBox jcb_advancedOptions = (JCheckBox) fc_advancedOptions.getConfigurationObject(); +boolean advancedOptions = jcb_advancedOptions.isSelected(); + +return advancedOptions; + + + + + + + + + + + + + + + + + 4 + 4 + 4 + 4 + + + + + + + <html>The following option is <strong>strongly recommended</strong> +to be left as default unless there is a particular +reason to change it.</html> + + + + + + Allow user-space updates for ${compiler:JALVIEW_APPLICATION_NAME} components + <html>This option allows updates to ${compiler:JALVIEW_APPLICATION_NAME} +<br> +components to be automatically downloaded +<br> +under the user's home space, separately from +<br> +the installation location. +<br> +<strong>This option is strongly recommended.</strong> +<br> +<br> +On ${installer:osName}, user updates will be installed under +<br> +<pre>${installer:userDefaultAppdirBase}</pre> +</html> + + + + validateUserSpaceAdvancedOptionsForm(formEnvironment) + + + allowUserDefaultAppdirUpdates + + + + + + + ${compiler:JALVIEW_DIR}/${compiler:INSTALL4J_UTILS_DIR}/warning.png + + + No automatic updates will occur when Jalview is launched + + !( context.getBooleanVariable("allowUserDefaultAppdirUpdates") || context.getBooleanVariable("allowInstallerAppdirUpdates") ) + + + + + + + + + + Additional tasks for administrator installation + ${i18n:WizardSelectTasks} + + context.getBooleanVariable("isAdmin") + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${i18n:SelectTasksLabel2(${compiler:JALVIEW_APPLICATION_NAME})} + + + + + Add ${compiler:JALVIEW_APPLICATION_NAME}'s bin folder to the system Path environment variable + + appendToPathAction + + Util.isWindows() + + + + Make a ${compiler:WRAPPER_LINK} symbolic link in ${installer:unixBinDir} + + makeSymbolicLinkAction + + context.getBooleanVariable("makeSymbolicLink") +&& context.getVariable("unixBinDir") != null +&& ( + Util.isLinux() + || Util.isUnixInstaller() + || ( + ( Util.isMacOS() && !Util.hasFullAdminRights() ) // Admin on macOS will add path to /etc/paths.d + && context.getVariable("MacOSDir") != null + ) + ) + + + + + + Enable advanced options for system installation + + 3030 + 2985 + 3013 + 2986 + 2974 + 2988 + + + + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment) + + + advancedOptions + + + + + + + 128 + 128 + 128 + 255 + + + + + Advanced options will not be used + + !context.getBooleanVariable("advancedOptions") + + + + + + + context.getBooleanVariable("advancedOptions") + + + + + + + + + + + + + + + + + + 4 + 4 + 4 + 4 + + + + + + + + + + + + <html>The following options are <strong>strongly recommended</strong> to be left as default unless there is a particular reason to change them.</html> + + + + + + Allow user-space updates for ${compiler:JALVIEW_APPLICATION_NAME} components + + 3021 + + <html>This option allows updates to ${compiler:JALVIEW_APPLICATION_NAME} +<br> +components to be automatically downloaded +<br> +under the user's home space, separately from +<br> +the installation location. +<br> +<strong>This option is strongly recommended.</strong> +<br> +<br> +On ${installer:osName}, user updates will be installed under +<pre>${installer:userDefaultAppdirBase}</pre> +unless customised below. +</html> + + + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment) + + + allowUserDefaultAppdirUpdates + + + + + + + 0 + 32 + 0 + 0 + + + + + + + + + + + + Customise the user-space path + + + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment) + + + allowSetUserAppdirPath + + component.setEnabled( context.getBooleanVariable("allowUserDefaultAppdirUpdates") ) + + + + <html>The base path where individual users' updates +<br> +will be stored. +<br> +<strong>Only change this option if you need to!</strong> +<br> +The following substitutions will be made: +<table> +<tr><td>%u</td><td>The user's username</td></tr> +<tr><td>%U</td><td>An ASCII string of the user's username</td></tr> +<tr><td>%h</td><td>The user's home directory path</td></tr> +<tr><td>~${installer:sys.fileSeparator}</td><td>(at start) The user's home directory path${installer:sys.fileSeparator}</td></tr> +</table> +At least one of the above substitutions should be +<br> +used, e.g. <tt>/tmp/${compiler:UNIX_APPLICATION_FOLDER}/%u/app</tt> +<br> +The default value on ${installer:osName} is +<br> +<pre>${installer:userDefaultAppdirBase}</pre> +</html> + + + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment, true) + + + + + showInvalidUserAppdirPathWarning(context, formEnvironment) + + + + + + + + + userAppdirPath + + component.setEnabled( context.getBooleanVariable("allowUserDefaultAppdirUpdates") && context.getBooleanVariable("allowSetUserAppdirPath") ); + + + + + + + Allow installation updates for ${compiler:JALVIEW_APPLICATION_NAME} components + <html>This option allows updates to ${compiler:JALVIEW_APPLICATION_NAME} +<br> +components to be automatically downloaded +<br> +into the installation location. +<br> +If you are installing into a system location, +<br> +a non-administrator user may have problems +<br> +launching ${compiler:JALVIEW_APPLICATION_NAME}. +<br> +<strong> +It is strongly recommended to use the +<br> +user-space updates option above. +</strong> +<br> +<br> +Installation updates will be installed into +<br> +<pre>${installer:sys.contentDir}</pre> +</html> + + + validateSystemSpaceAdvancedOptionsForm(context, formEnvironment) + + + allowInstallerAppdirUpdates + + component.setEnabled( !context.getBooleanVariable("allowUserDefaultAppdirUpdates") ) + + + + + + FormComponent fc_userUpdates = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_UPDATES"); +FormComponent fc_installerUpdates = formEnvironment.getFormComponentById("SS_ALLOW_INSTALLER_APPDIR_UPDATES"); +FormComponent fc_allowUserAppdirPath = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_PATH"); +FormComponent fc_userAppdirPath = formEnvironment.getFormComponentById("SS_USER_APPDIR_PATH"); + +// set defaults +((JCheckBox) fc_userUpdates.getConfigurationObject()).setSelected(true); +((JCheckBox) fc_allowUserAppdirPath.getConfigurationObject()).setSelected(false); +((JTextField) fc_userAppdirPath.getConfigurationObject()).setText(""); +((JCheckBox) fc_installerUpdates.getConfigurationObject()).setSelected(false); + +// revalidate +validateSystemSpaceAdvancedOptionsForm(context, formEnvironment); + + + + Reset advanced options to defaults + + FormComponent fc_advancedOptions = formEnvironment.getFormComponentById("SS_ADVANCED_OPTIONS"); +FormComponent fc_userUpdates = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_UPDATES"); +FormComponent fc_userAppdirPath = formEnvironment.getFormComponentById("SS_USER_APPDIR_PATH"); +FormComponent fc_installerUpdates = formEnvironment.getFormComponentById("SS_ALLOW_INSTALLER_APPDIR_UPDATES"); +FormComponent fc_allowUserAppdirPath = formEnvironment.getFormComponentById("SS_ALLOW_USER_APPDIR_PATH"); + +JCheckBox jcb_user = (JCheckBox) fc_userUpdates.getConfigurationObject(); +boolean userUpdates = jcb_user.isSelected(); + +JCheckBox jcb_allowUserAppdirPath = (JCheckBox) fc_allowUserAppdirPath.getConfigurationObject(); +boolean allowUserAppdirPath = jcb_allowUserAppdirPath.isSelected(); + +JTextField jtf_userAppdirPath = (JTextField) fc_userAppdirPath.getConfigurationObject(); +String userAppdirPath = jtf_userAppdirPath.getText(); + +JCheckBox jcb_installer = (JCheckBox) fc_installerUpdates.getConfigurationObject(); +boolean installerUpdates = jcb_installer.isSelected(); + + +// set whether "Set defaults" button should be enabled +boolean enableSetDefaults = !( userUpdates && !allowUserAppdirPath && userAppdirPath.length() == 0 && !installerUpdates ); +component.setEnabled(enableSetDefaults); + + + + + + ${compiler:JALVIEW_DIR}/${compiler:INSTALL4J_UTILS_DIR}/warning.png + + + No automatic updates will occur when ${compiler:JALVIEW_APPLICATION_NAME} is launched + + !( context.getBooleanVariable("allowUserDefaultAppdirUpdates") || context.getBooleanVariable("allowInstallerAppdirUpdates") ) + + + + + + ${compiler:JALVIEW_DIR}/${compiler:INSTALL4J_UTILS_DIR}/warning.png + + + The user-space path should contain one of "~${installer:sys.fileSeparator}" (at the start), "%u", "%U" or "%h" + + String userAppdirPath = (String) context.getVariable("userAppdirPath"); + +if (userAppdirPath == null) { + return false; +} + +boolean u = userAppdirPath.contains("%u"); +boolean U = userAppdirPath.contains("%U"); +boolean h = userAppdirPath.contains("%h"); +boolean t = userAppdirPath.startsWith("~" + (String)context.getVariable("sys.fileSeparator")); + +boolean showInvalidPathWarning = !( userAppdirPath.length() == 0 || u || U || h || t ); + +return context.getBooleanVariable("allowUserDefaultAppdirUpdates") && context.getBooleanVariable("allowSetUserAppdirPath") && showInvalidPathWarning; + + + + + + + + + + + + + + + + + ${compiler:APPLICATION_CATEGORIES} + + + + Examples + + + examples + + + + + + ${compiler:JALVIEW_NAME} + ${i18n:UninstallerMenuEntry(${compiler:sys.fullName})} + + !context.getBooleanVariable("sys.programGroupDisabled") + + + + + + + + ${compiler:APPLICATION_CATEGORIES} + ${compiler:JALVIEW_NAME} + ${i18n:UninstallerMenuEntry(${compiler:sys.fullName})} + + !context.getBooleanVariable("sys.programGroupDisabled") + + + + ${compiler:sys.fullName} ${compiler:sys.version} + + + + + + + Creating file associations... + + + + + + + + + + + + + + This action, identified by its name "EXTENSIONS_REPLACED_BY_GRADLE", will be replaced by gradle with the contents of file 'file_associations_auto_install4j.xml'. + extensions_to_be_replaced_by_gradle + JALVIEW + + + + + + + Finished creating file associations + + + + + + + + + + + + + + ${i18n:FinishedHeadingLabel(${compiler:JALVIEW_APPLICATION_NAME})} + + + + + + + + + + + + + + 2823 + jalview + + + + + 2823 + jalviews + + + + + 2823 + jalviewhttp + + + + + 2823 + jalviewhttps + + + + + 2823 + ${compiler:EXTRA_SCHEME} + + + + + + + + + !context.getBooleanVariable("isAdmin") + + + + + + + + ${compiler:APPLICATION_CATEGORIES} + ${compiler:JALVIEW_APPLICATION_NAME} + + + ${installer:sys.contentDir}/${compiler:EXECUTABLE_NAME} + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:WINDOWS_ICONS_FILE} + + + ${compiler:JALVIEW_NAME} + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:PNG_ICON_FILE} + + + + !context.getBooleanVariable("sys.programGroupDisabled") + + + + + ${compiler:JALVIEW_APPLICATION_NAME} + + + ${installer:sys.contentDir}/${compiler:EXECUTABLE_NAME} + + + ${compiler:JALVIEW_APPLICATION_NAME} + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:PNG_ICON_FILE} + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:WINDOWS_ICONS_FILE} + + + + context.getBooleanVariable("createDesktopLinkAction") + + + + + + ${compiler:JALVIEW_APPLICATION_NAME}.app + + + + context.getBooleanVariable("addToDockAction") + + + + + ${installer:sys.contentDir}\${compiler:WRAPPER_SCRIPT_BIN_DIR} + Path + + context.getBooleanVariable("appendToPathAction") + + + + + + ../Resources/app/${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:BASH_WRAPPER_SCRIPT} + + + + + ${installer:MacOSDir}/${compiler:WRAPPER_LINK} + + + + Util.isMacOS() && +( + context.getBooleanVariable("makeSymbolicLinkAction") + && context.getVariable("unixBinDir") != null + && context.getVariable("MacOSDir") != null +) + + + + + + ../Resources/app/${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:BASH_UPDATE_SCRIPT} + + + + + ${installer:MacOSDir}/update_${compiler:WRAPPER_LINK} + + + + Util.isMacOS() && +( + context.getBooleanVariable("makeSymbolicLinkAction") + && context.getVariable("unixBinDir") != null + && context.getVariable("MacOSDir") != null +) + + + + + + ${installer:MacOSDir}/${compiler:WRAPPER_LINK} + + + + + ${installer:unixBinDir}/${compiler:WRAPPER_LINK} + + + + Util.isMacOS() && +( + context.getBooleanVariable("makeSymbolicLinkAction") + && context.getVariable("unixBinDir") != null + && context.getVariable("MacOSDir") != null +) + + + + + + ${installer:MacOSDir}/update_${compiler:WRAPPER_LINK} + + + + + ${installer:unixBinDir}/update_${compiler:WRAPPER_LINK} + + + + Util.isMacOS() && +( + context.getBooleanVariable("makeSymbolicLinkAction") + && context.getVariable("unixBinDir") != null + && context.getVariable("MacOSDir") != null +) + + + + + + + + context.getBooleanVariable("isAdmin") + + + + + + + ${compiler:APPLICATION_CATEGORIES} + ${compiler:JALVIEW_APPLICATION_NAME} + + + ${installer:sys.contentDir}/${compiler:EXECUTABLE_NAME} + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:WINDOWS_ICONS_FILE} + + + ${compiler:JALVIEW_NAME} + + + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:PNG_ICON_FILE} + + + + !context.getBooleanVariable("sys.programGroupDisabled") + + + + ${compiler:JALVIEW_APPLICATION_NAME} + + + ${installer:sys.contentDir}/${compiler:EXECUTABLE_NAME} + + + ${compiler:JALVIEW_APPLICATION_NAME} + + + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:PNG_ICON_FILE} + + + + + ${compiler:JALVIEW_DIR}/${compiler:ICONS_DIR}/${compiler:WINDOWS_ICONS_FILE} + + + + context.getBooleanVariable("createDesktopLinkAction") + + + + + + + + + ${installer:sys.contentDir}\${compiler:WRAPPER_SCRIPT_BIN_DIR} + Path + + context.getBooleanVariable("appendToPathAction") + + + + + + String dir = (String)context.getVariable("sys.installationDir"); +String hash = getCanonicalFullPathToDirectoryHash(dir); +return (Object) hash; + + + + installationAppdirHash + + + + + + + /etc/paths.d/${compiler:APPLICATION_FOLDER}-${installer:installationAppdirHash} + + + ${installer:sys.installationDir}/${installer:sys.contentDir}/${compiler:JALVIEW_APPLICATION_NAME}.app/Contents/MacOS + + Util.isMacOS() + + + + + + + + + + ${installer:sys.contentDir}/${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:BASH_WRAPPER_SCRIPT} + + + + + ${installer:unixBinDir}/${compiler:WRAPPER_LINK} + + + + context.getBooleanVariable("makeSymbolicLink") +&& context.getBooleanVariable("makeSymbolicLinkAction") +&& context.getVariable("unixBinDir") != null + + + + + + + + + + boolean advanced = context.getBooleanVariable("advancedOptions"); +boolean allowUser = context.getBooleanVariable("allowUserDefaultAppdirUpdates"); +boolean consoleDisableUserAppdir = context.getBooleanVariable("consoleDisableUserAppdir"); +if (consoleDisableUserAppdir) { + return true; +} +return advanced ? !allowUser : false; + + + disableUserDefaultAppdirUpdates + + + + + + + boolean advanced = context.getBooleanVariable("advancedOptions"); +boolean allowUser = context.getBooleanVariable("allowUserDefaultAppdirUpdates"); +boolean allowSetUserAppdirPath = context.getBooleanVariable("allowSetUserAppdirPath"); +String userAppdirPath = (String)context.getVariable("userAppdirPath"); +boolean saneValue = userAppdirPath != null && userAppdirPath.length() > 0; +boolean consoleAllowUserAppdirPath = context.getBooleanVariable("consoleAllowUserAppdirPath"); +if (consoleAllowUserAppdirPath && saneValue) { + return userAppdirPath; +} +return advanced && allowUser && allowSetUserAppdirPath && saneValue ? userAppdirPath : null; + + + setUserAppdirPath + + + + + + + boolean advanced = context.getBooleanVariable("advancedOptions"); +boolean allowUser = context.getBooleanVariable("allowUserDefaultAppdirUpdates"); +boolean allowInstaller = context.getBooleanVariable("allowInstallerAppdirUpdates"); +boolean consoleDisableAllUpdates = context.getBooleanVariable("consoleDisableAllUpdates"); +if (consoleDisableAllUpdates) { + return true; +} +return advanced ? !( allowUser || allowInstaller ) : false; + + + disableUpdates + + + + + + + String file = (String)context.getVariable("sys.mediaFile"); +int i = file.lastIndexOf(File.separator); +return file.substring(i+1); + + + installerFilename + + + + + + + String date = (String)context.getVariable("sys.date"); +String time = (String)context.getVariable("sys.time"); +StringBuilder sb = new StringBuilder(); +sb.append(date.substring(0,4)); +sb.append("-"); +sb.append(date.substring(4,6)); +sb.append("-"); +sb.append(date.substring(6,8)); +sb.append(" "); +sb.append(time.substring(0,2)); +sb.append(":"); +sb.append(time.substring(2,4)); +sb.append(":"); +sb.append(time.substring(4,6)); +return sb.toString(); + + + + installDateTime + + + + + 2823 + + # Jalview options added by ${installer:installerFilename} at ${installer:installDateTime} + + + + + + 2823 + + # + # Uncomment the following line to disable user-space updates + #-Dnouserdefaultappdir=true + + + !context.getBooleanVariable("disableUserDefaultAppdirUpdates") + + + + 2823 + + # + # Comment out the following line to allow user-space updates + -Dnouserdefaultappdir=true + + + context.getBooleanVariable("disableUserDefaultAppdirUpdates") + + + + 2823 + + # + # The below line sets a custom path for user-space updates -- use with caution. + # A leading ~/ or %h anywhere will be substituted with the user's home path, %u by the username, and %U by an ASCII string of the username. + # If unset, the default is ${installer:userDefaultAppdirBase} for ${installer:osName} + -Dsetuserappdirpath=${installer:setUserAppdirPath} + + + (String)context.getVariable("setUserAppdirPath") != null + + + + 2823 + + # + # Uncomment the below line to set a custom path for user-space updates -- use with caution. + # A leading ~/ or %h anywhere will be substituted with the user's home path, %u by the username, and %U by an ASCII string of the username. + # If not set, the default is ${installer:userDefaultAppdirBase} for ${installer:osName} + #-Dsetuserappdirpath=/tmp/jalview/%u + + + (String)context.getVariable("setUserAppdirPath") == null + + + + 2823 + + # + # Uncomment the following line to also disable all updates + #-Dsilent=noupdate + + + !context.getBooleanVariable("disableUpdates") + + + + 2823 + + # + # Comment out the following line to enable updates + -Dsilent=noupdate + + + context.getBooleanVariable("disableUpdates") + + + + + + + + + + ${compiler:JRE_DIR}/bin/java + + + + + ${compiler:JRE_DIR}/bin/${compiler:JALVIEW_NAME} + + + + + + + + Util.isLinux() || ( Util.isMacOS() && !Util.isUnixInstaller() ) + + + + + + ${compiler:JRE_DIR}/bin/java + + + + + ${compiler:JRE_DIR}/bin/${compiler:JALVIEW_APPLICATION_NAME} + + + + + + + + ( Util.isLinux() || ( Util.isMacOS() && !Util.isUnixInstaller() ) ) +&& !((String)context.getCompilerVariable("JALVIEW_APPLICATION_NAME")).equals((String)context.getCompilerVariable("JALVIEW_NAME")) + + + + + + + + + + ${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:BASH_WRAPPER_SCRIPT} + + + + + ${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:WRAPPER_LINK} + + + + Util.isLinux() || Util.isUnixInstaller() || Util.isMacOS() + + + + + + ${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:BASH_UPDATE_SCRIPT} + + + + + ${compiler:WRAPPER_SCRIPT_BIN_DIR}/${compiler:WRAPPER_LINK}_update + + + + Util.isLinux() || Util.isUnixInstaller() || Util.isMacOS() + + + + + + + + + + + + + + + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${i18n:WizardPreparing} + + + + + + + + + <strong>Administrator mode</strong> + + context.getBooleanVariable("isAdmin") + + + + ${form:finishedMessage} + + + + + + + + + ${i18n:UninstallerMenuEntry(${compiler:sys.fullName})} + + + + + + + + + + + + + + + 255 + 255 + 255 + 255 + + + 49 + 52 + 53 + 255 + + + + + + + + + + + 192 + 192 + 192 + 255 + + + + + + ${compiler:JALVIEW_DIR}/${compiler:BACKGROUND} + + + + + 5 + 10 + 10 + 10 + + + + + imageAnchor + imageEdgeBackgroundColor + imageFile + + + + + + + + + + + + + + + + + + ${form:welcomeMessage} + + !context.isConsole() + + + + + + String message = context.getMessage("ConfirmUninstall", context.getApplicationName()); +return console.askYesNo(message, true); + + + + + + + + + + + + + + + + + + + + + + + + + + jre + + + + + jre.jar + + + + + .install4j + + + + + getdown-launcher.jar + + + + + getdown-launcher-old.jar + + + + + getdown-launcher-new.jar + + + + + gettingdown.lock + + + + + jre.zip + + + + + digest.txt + + + + + digest2.txt + + + + + getdown-launcher.jarv + + + + + getdown-launcher-new.jarv + + + + + launcher.log + + + + + proxy.txt + + + + + build_properties + + + + + channel_launch*.jvl + + + + + jalview*.jvl + + + + + *.jarv + + + + + *.log + + + + + *.txt + + + + + *_new + + + + + hs_err_*.* + + + + + ${compiler:GETDOWN_DIST_DIR} + + + + + ${compiler:GETDOWN_ALT_DIR} + + + + + ${compiler:GETDOWN_RESOURCE_DIR} + + + + + META-INF + + + + + install + + + + + resource + + + + + dist + + + + + release + + + + + alt + + + + + dev + + + + + build + + + + + alt_* + + + + + dev_* + + + + + build_* + + + + + ${compiler:WRAPPER_SCRIPT_BIN_DIR} + + + + + bin + + + + + channel.props + + + + + channel.propsv + + + + + + + + + + + + + + + + + + + ${i18n:UninstallerPreparing} + + + + + + + + + + ${form:successMessage} + + + + + + + + + + + . + + + ${compiler:WRAPPER_LINK}_setup + + + ${compiler:sys.fullName} + + + + + + + + + + + + + Running ${i18n:SetupAppTitle} + + + + + ${i18n:FinishedLabel(${compiler:JALVIEW_APPLICATION_NAME})} + + + + + ${i18n:AddToDock} + + addToDockAction + + Util.isMacOS() + + + + Make a ${compiler:WRAPPER_LINK} symbolic link in ${installer:unixBinDir} + + makeSymbolicLinkAction + + + +( Util.isLinux() + || Util.isUnixInstaller() + || ( Util.isMacOS() + && context.getVariable("MacOSDir") != null + ) + ) + && context.getVariable("unixBinDir") != null + + + + +${i18n:ClickFinish} + +${compiler:JALVIEW_APPLICATION_NAME} will now launch. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- 1.7.10.2