| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| package org.openoffice.setup.Util; |
| |
| import java.io.File; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| import org.openoffice.setup.InstallData; |
| import org.openoffice.setup.Installer.Installer; |
| import org.openoffice.setup.Installer.InstallerFactory; |
| import org.openoffice.setup.Panel.ChooseDirectory; |
| import org.openoffice.setup.ResourceManager; |
| import org.openoffice.setup.SetupData.PackageDescription; |
| import org.openoffice.setup.SetupData.SetupDataProvider; |
| import org.openoffice.setup.Util.Informer; |
| |
| public class ModuleCtrl { |
| |
| private ModuleCtrl() { |
| } |
| |
| static public void setModuleSize(PackageDescription packageData) { |
| // Setting the package size for visible node modules, that have hidden children |
| // -> Java module has three hidden children and 0 byte size |
| |
| if (( ! packageData.isLeaf() ) && ( ! packageData.isHidden() )) { |
| boolean setNewSize = false; |
| int size = packageData.getSize(); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| // if (( child.isHidden() ) && ( child.getSelectionState() == PackageDescription.DONT_KNOW )) { |
| if ( child.isHidden() ) { |
| setNewSize = true; |
| size = size + child.getSize(); |
| } |
| } |
| |
| if ( setNewSize ) { |
| packageData.setSize(size); |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setModuleSize(child); |
| } |
| |
| } |
| |
| static public void setDefaultModuleSettings(PackageDescription data) { |
| // Setting default module settings for modules, that are not hidden |
| // Hidden modules do not get a defined state now |
| boolean isInstalled = false; |
| InstallData installdata = InstallData.getInstance(); |
| boolean isUninstall = installdata.isUninstallationMode(); |
| |
| if (isUninstall) { |
| isInstalled = true; |
| } |
| |
| if (isUninstall) { |
| if (isInstalled) { |
| data.setSelectionState(PackageDescription.REMOVE); |
| } else { |
| data.setSelectionState(PackageDescription.IGNORE); |
| System.err.println("NEVER"); |
| } |
| } else { |
| if (isInstalled) { |
| data.setSelectionState(PackageDescription.IGNORE); |
| System.err.println("NEVER"); |
| } else if (data.isDefault()) { |
| data.setSelectionState(PackageDescription.INSTALL); |
| } else if ( ! data.isDefault()) { |
| data.setSelectionState(PackageDescription.DONT_INSTALL); |
| } else { |
| data.setSelectionState(PackageDescription.DONT_INSTALL); |
| } |
| } |
| } |
| |
| static public void setParentDefaultModuleSettings(PackageDescription packageData) { |
| // Setting the module states of parent modules. |
| // Called after ChooseDirectoryCtrl.java, because |
| // the database has to be known. In user installation it is important, |
| // that the installation directory is known, to find the database. |
| // Called during uninstallation in UninstallationPrologueCtrl.java |
| |
| // Iteration before setting the module states. Because of this, all children |
| // get their final setting before the parent. |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setParentDefaultModuleSettings(child); |
| } |
| |
| if ( ! packageData.isLeaf() ) { |
| // System.err.println("setParentDefaultModuleSettings: " + packageData.getName()); |
| int state = packageData.getSelectionState(); |
| InstallData installdata = InstallData.getInstance(); |
| boolean allChildrenIgnored = true; |
| boolean atLeastOneInstalled = false; |
| boolean allChildrenHidden = true; |
| |
| // System.err.println(" STATE before iterating over children: " + state); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements();) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| int childState = child.getSelectionState(); |
| |
| // System.err.println(" Child: " + child.getName() + " : " + childState); |
| |
| if ( childState != PackageDescription.IGNORE) { |
| allChildrenIgnored = false; |
| } |
| |
| if (( childState == PackageDescription.INSTALL) || ( childState == PackageDescription.INSTALL_SOME)) { |
| atLeastOneInstalled = true; |
| } |
| |
| if ( ! child.isHidden() ) { |
| allChildrenHidden = false; |
| } |
| |
| if ((state == PackageDescription.DONT_KNOW) || (state == PackageDescription.IGNORE)) { |
| state = childState; |
| // } else if ((state != childState) && (childState != PackageDescription.IGNORE)) { |
| } else if ((state != childState) && (childState != PackageDescription.IGNORE) && (childState != PackageDescription.DONT_KNOW)) { |
| if ( installdata.isUninstallationMode() ) { |
| state = PackageDescription.REMOVE_SOME; |
| } else { |
| state = PackageDescription.INSTALL_SOME; |
| } |
| } |
| |
| // System.err.println(" NEW state after child: " + state); |
| } |
| |
| if ( allChildrenIgnored ) { |
| state = PackageDescription.IGNORE; |
| } |
| |
| if ( installdata.isInstallationMode() ) { |
| if (( state == PackageDescription.INSTALL_SOME ) && ( ! atLeastOneInstalled )) { |
| state = PackageDescription.DONT_INSTALL; |
| } |
| } |
| |
| if ( allChildrenHidden ) { |
| packageData.setAllChildrenHidden(true); |
| // System.err.println("Setting allChildrenHidden for module " + packageData.getName() ); |
| } |
| |
| // If older version exist, only modules without packages shall be updated, |
| // because all packages are already determined by querying the database. |
| if ( installdata.olderVersionExists() ) { |
| if ( packageData.getPackageName().equals("") ) { |
| packageData.setSelectionState(state); |
| } |
| } else { |
| packageData.setSelectionState(state); |
| } |
| } |
| } |
| |
| static public void setHiddenModuleSettingsInstall(PackageDescription packageData) { |
| // update selection states for hidden modules during installation |
| if (( packageData.isHidden() ) && ( packageData.getSelectionState() != packageData.IGNORE )) { |
| PackageDescription parent = (PackageDescription)packageData.getParent(); |
| if ( parent != null ) { |
| packageData.setSelectionState(parent.getSelectionState()); |
| // hidden modules at root module always have to be installed, if they are not already installed |
| if ( parent.getName() == "" ) { |
| packageData.setSelectionState(packageData.INSTALL); |
| // System.err.println("Setting 1 INSTALL flag to: " + packageData.getName()); |
| } |
| } |
| |
| // INSTALL_SOME is not valid for leaves |
| if (( packageData.getSelectionState() == packageData.INSTALL_SOME ) && ( packageData.isLeaf() )) { |
| packageData.setSelectionState(packageData.INSTALL); |
| // System.err.println("Setting 2 INSTALL flag to: " + packageData.getName()); |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setHiddenModuleSettingsInstall(child); |
| } |
| } |
| |
| static public void setHiddenModuleSettingsUninstall(PackageDescription packageData) { |
| InstallData data = InstallData.getInstance(); |
| // update selection states for hidden modules during uninstallation |
| if (( packageData.isHidden() ) && ( packageData.getSelectionState() != packageData.IGNORE )) { |
| // System.err.println("Package name: " + packageData.getName()); |
| // System.err.println("Selection: " + packageData.getSelectionState()); |
| |
| PackageDescription parent = (PackageDescription)packageData.getParent(); |
| if ( parent != null ) { |
| packageData.setSelectionState(parent.getSelectionState()); |
| // Hidden modules at root module have to be uninstalled at complete uninstallation |
| // In Uninstallation the complete is the typical installation type |
| if (( parent.getName() == "" ) && ( data.isTypicalInstallation() )) { |
| packageData.setSelectionState(packageData.REMOVE); |
| } |
| // Hidden modules at root module must not be uninstalled at custom uninstallation |
| // But if all visible modules are selected for uninstallation, this shall be handled |
| // as complete uninstallation. |
| if ( ! data.isMaskedCompleteUninstallation() ) |
| { |
| if (( parent.getName() == "" ) && ( data.isCustomInstallation() )) { |
| packageData.setSelectionState(packageData.IGNORE); |
| } |
| } |
| } |
| |
| // REMOVE_SOME is not valid for leaves |
| // if ( data.isTypicalInstallation() ) { |
| if (( packageData.getSelectionState() == packageData.REMOVE_SOME ) && ( packageData.isLeaf() )) { |
| packageData.setSelectionState(packageData.REMOVE); |
| } |
| // } |
| |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setHiddenModuleSettingsUninstall(child); |
| } |
| } |
| |
| static private boolean checkRequiredCoreModule(PackageDescription packageData) { |
| |
| // This function uses a similar mechanism to determine |
| // core modules as function "setHiddenModuleSettingsInstall" |
| // -> only hidden parents, until there is a module without name (getName) |
| // Only searching until grandpa. |
| |
| boolean requiredCoreModule = false; |
| |
| // if packageData.getSelectionState() DONT_KNOW && parent auch DONT_KNOW |
| if (( packageData.isHidden() ) && |
| ( packageData.getSelectionState() != packageData.IGNORE ) && |
| ( packageData.getPackageName() != null )) { |
| //( packageData.isLeaf() )) { |
| PackageDescription parent = (PackageDescription)packageData.getParent(); |
| if ( parent != null ) { |
| if (( parent.getName().equals("") ) || ( parent.getName() == null )) { |
| requiredCoreModule = true; |
| } else { |
| if ( parent.isHidden() ) { |
| PackageDescription grandpa = (PackageDescription)parent.getParent(); |
| if ( grandpa != null ) { |
| if (( grandpa.getName().equals("") ) || ( grandpa.getName() == null )) { |
| requiredCoreModule = true; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return requiredCoreModule; |
| } |
| |
| static public void setDatabaseSettings(PackageDescription packageData, InstallData installData, Installer installer) { |
| // Analyzing the system database and setting the module states. |
| // Called during installation in ChooseInstallationTypeCtrl.java, because |
| // the database has to be known. In user installation it is important, |
| // the the installation directory is known, to find the database. |
| // Called during uninstallation in UninstallationPrologueCtrl.java |
| |
| boolean isUninstall = installData.isUninstallationMode(); |
| boolean isInstalled = installer.isPackageInstalled(packageData, installData); |
| |
| if (isUninstall) { |
| if (isInstalled) { |
| packageData.setSelectionState(PackageDescription.REMOVE); |
| // The following is no longer required !? (IS, 06/05/08) |
| // PackageDescription parent = packageData.getParent(); |
| // if ( parent != null ) { |
| // if ( parent.getSelectionState() != PackageDescription.REMOVE ) { |
| // parent.setSelectionState(PackageDescription.REMOVE); |
| // System.err.println("Setting remove to " + parent.getName()); |
| // } |
| // } |
| } else { |
| // Attention: Setting all nodes to ignore! If a children gets REMOVE, |
| // then REMOVE is also set to the parent. Setting REMOVE happens after |
| // setting IGNORE, because children are evaluated after the parents. |
| // The default for uninstallation is set in setDefaultModuleSettings to REMOVE. |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } |
| } else { |
| boolean goodDepends = true; |
| if ( installData.getOSType().equalsIgnoreCase("SunOS") ) { |
| if (( installData.isRootInstallation() ) && ( packageData.getCheckSolaris() != null ) && ( ! packageData.getCheckSolaris().equals("") )) { |
| // the package has to be installed. Creating a new package with only packagename |
| if ( ! installer.isPackageNameInstalled(packageData.getCheckSolaris(), installData) ) { |
| goodDepends = false; |
| } |
| } |
| } |
| |
| if ( ! goodDepends ) { |
| // The package dependencies are not valid -> ignoring package. |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| // too late to hide the module |
| // packageData.setIsHidden(true); |
| } |
| else { |
| if ( isInstalled ) { |
| // Maybe a required core module is installed in an older version from another product |
| boolean isRequiredCoreModule = checkRequiredCoreModule(packageData); |
| if (( packageData.isJavaPackage() ) || ( isRequiredCoreModule )) { // only selected checks, because of performance reasons |
| boolean installedPackageIsOlder = installer.isInstalledPackageOlder(packageData, installData); |
| if ( ! installedPackageIsOlder ) { |
| // The package is already installed in the same or in a newer version |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } else { |
| // This is also something like migrating feature states |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| LogManager.addLogfileComment("<b>Adding required older installed package:</b> " + packageData.getPackageName() + "</br>"); |
| } |
| } else { // no version check done -> so what is a good setting for already installed packages? |
| if ( installData.olderVersionExists() ) { // should never be the case in this function |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| } else { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } |
| } |
| } |
| else { |
| // Special handling for core modules, which are required, but not installed. |
| // This can be deinstalled by hand for example. |
| boolean isRequiredCoreModule = checkRequiredCoreModule(packageData); |
| if ( isRequiredCoreModule ) { |
| if ( packageData.getSelectionState() != PackageDescription.INSTALL ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| LogManager.addLogfileComment("<b>Adding required package:</b> " + packageData.getPackageName() + "</br>"); |
| } |
| // This package has to exist! |
| if ( ! packageExists(packageData, installData) ) { |
| |
| String packagePath = installData.getPackagePath(); |
| if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { |
| File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); |
| packagePath = completePackageFile.getPath(); |
| } |
| String packageName = packageData.getPackageName(); |
| File packageFile = new File(packagePath, packageName); |
| |
| String log = "<b>Error: Missing required package " + packageFile.getPath() + "</b><br>"; |
| System.err.println(log); |
| String message = ResourceManager.getString("String_File_Not_Found") + ": " + packageFile.getPath(); |
| String title = ResourceManager.getString("String_Error"); |
| Informer.showErrorMessage(message, title); |
| System.exit(1); |
| } |
| } |
| } |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setDatabaseSettings(child, installData, installer); |
| } |
| } |
| |
| static public void setShowInUserInstallFlags(PackageDescription packageData) { |
| |
| // This function is not needed during deinstallation, because a |
| // module that could not be selected during installation, is always |
| // not installed during deinstallation and therefore gets "IGNORE" |
| // in function setDatabaseSettings |
| |
| if ( ! packageData.showInUserInstall() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| // too late to hide the module |
| // packageData.setIsHidden(true); |
| // packageData.setAllChildrenHidden(true); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setShowInUserInstallFlags(child); |
| } |
| } |
| |
| static public void setForcedUpdateProductSettings(PackageDescription packageData) { |
| |
| if ( packageData.forceIntoUpdate() ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setForcedUpdateProductSettings(child); |
| } |
| } |
| |
| static public void setShowInUserInstallOnlyFlags(PackageDescription packageData) { |
| |
| // This function is not needed during deinstallation, because a |
| // module that could not be selected during installation, is always |
| // not installed during deinstallation and therefore gets "IGNORE" |
| // in function setDatabaseSettings |
| |
| if ( packageData.showInUserInstallOnly() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| // too late to hide the module |
| // packageData.setIsHidden(true); |
| // packageData.setAllChildrenHidden(true); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setShowInUserInstallOnlyFlags(child); |
| } |
| } |
| |
| static public void setIgnoreNonRelocatablePackages(PackageDescription packageData) { |
| if ( ! packageData.isRelocatable() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| System.err.println("Ignoring package " + packageData.getName() + " " + packageData.getPackageName()); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setIgnoreNonRelocatablePackages(child); |
| } |
| } |
| |
| static public void setHiddenLanguageModuleDefaultSettings(PackageDescription packageData) { |
| |
| // This function is needed during installation for the language modules, |
| // if there is only one language in the installation set. In this case the language |
| // modules are hidden (no selection possible) and therefore get no value in |
| // setDefaultModuleSettings(). This default value is set now. |
| |
| if ( packageData.showMultiLingualOnly() ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setHiddenLanguageModuleDefaultSettings(child); |
| } |
| } |
| |
| static private boolean packageExists(PackageDescription packageData, InstallData installData) { |
| boolean fileExists = false; |
| String packagePath = installData.getPackagePath(); |
| |
| if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { |
| File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); |
| packagePath = completePackageFile.getPath(); |
| } |
| |
| String packageName = packageData.getPackageName(); |
| File packageFile = new File(packagePath, packageName); |
| |
| if ( packageFile.exists() ) { |
| fileExists = true; |
| } |
| |
| return fileExists; |
| } |
| |
| static public void disableNonExistingPackages(PackageDescription packageData, InstallData installData) { |
| if ((( packageData.getPackageName() == null ) || ( packageData.getPackageName().equals("") )) |
| && packageData.isLeaf() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } else if ( ! packageExists(packageData, installData) ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| disableNonExistingPackages(child, installData); |
| } |
| } |
| |
| static public void setDontUninstallFlags(PackageDescription packageData) { |
| if ( packageData.dontUninstall() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setDontUninstallFlags(child); |
| } |
| } |
| |
| static public void setDontUninstallUserInstallOnylFlags(PackageDescription packageData) { |
| if ( packageData.showInUserInstallOnly() ) { |
| packageData.setSelectionState(PackageDescription.IGNORE); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setDontUninstallUserInstallOnylFlags(child); |
| } |
| } |
| |
| static public void checkVisibleModulesInstall(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| if (( ! packageData.isHidden() ) && ( packageData.getSelectionState() == packageData.INSTALL )) { |
| setToTrue = true; |
| data.setVisibleModulesChecked(true); |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkVisibleModulesInstall(child, data); |
| } |
| } |
| } |
| |
| static public void checkApplicationSelection(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| if (( packageData.isApplicationPackage() ) && |
| ( ! packageData.isHidden() ) && |
| ( packageData.getSelectionState() == packageData.INSTALL )) { |
| setToTrue = true; |
| data.setApplicationModulesChecked(true); |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkApplicationSelection(child, data); |
| } |
| } |
| } |
| |
| static public void checkLanguageSelection(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| if (( packageData.showMultiLingualOnly() ) && |
| ( ! packageData.isHidden() ) && |
| ( packageData.getSelectionState() == packageData.INSTALL )) { |
| setToTrue = true; |
| data.setLanguageModulesChecked(true); |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkLanguageSelection(child, data); |
| } |
| } |
| } |
| |
| static public void checkVisibleModulesUninstall(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| if (( ! packageData.isHidden() ) && ( packageData.getSelectionState() == packageData.REMOVE )) { |
| // ignoring the top level module, that has the state REMOVE (but no name) |
| if (( packageData.getName() != null ) && ( ! packageData.getName().equals("") )) { |
| setToTrue = true; |
| data.setVisibleModulesChecked(true); |
| } |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkVisibleModulesUninstall(child, data); |
| } |
| } |
| } |
| |
| static public void checkApplicationModulesUninstall(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| // At least one language module should not be uninstalled. Then this function returns true. |
| // An exeption is the complete uninstallation or the masked complete uninstallation. |
| |
| if (( packageData.isApplicationPackage() ) && |
| ( ! packageData.isHidden() ) && |
| ( packageData.getSelectionState() != packageData.IGNORE ) && |
| ( packageData.getSelectionState() != packageData.REMOVE )) { |
| setToTrue = true; |
| data.setApplicationModulesChecked(true); |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkApplicationModulesUninstall(child, data); |
| } |
| } |
| } |
| |
| static public void checkLanguageModulesUninstall(PackageDescription packageData, InstallData data) { |
| boolean setToTrue = false; |
| |
| // At least one language module should not be uninstalled. Then this function returns true. |
| // An exeption is the complete uninstallation or the masked complete uninstallation. |
| |
| if (( packageData.showMultiLingualOnly() ) && |
| ( ! packageData.isHidden() ) && |
| ( packageData.getSelectionState() != packageData.IGNORE ) && |
| ( packageData.getSelectionState() != packageData.REMOVE )) { |
| setToTrue = true; |
| data.setLanguageModulesChecked(true); |
| } |
| |
| if ( ! setToTrue ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkLanguageModulesUninstall(child, data); |
| } |
| } |
| } |
| |
| static public void checkMaskedCompleteUninstallation(PackageDescription packageData, InstallData data) { |
| boolean setToFalse = false; |
| |
| // If there is at least one visible module, that is not selected for removal |
| // this is no masked complete uninstallation |
| |
| if (( ! packageData.isHidden() ) |
| && ( packageData.getSelectionState() != packageData.REMOVE ) |
| && ( packageData.getSelectionState() != packageData.IGNORE )) { |
| // ignoring the top level module, that has no name |
| if (( packageData.getName() != null ) && ( ! packageData.getName().equals("") )) { |
| setToFalse = true; |
| data.setMaskedCompleteUninstallation(false); |
| // System.err.println("This is no masked complete uninstallation!"); |
| // System.err.println("Caused by: " + packageData.getName() + " with " + packageData.getSelectionState()); |
| } |
| } |
| |
| if ( ! setToFalse ) { |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkMaskedCompleteUninstallation(child, data); |
| } |
| } |
| } |
| |
| static public void saveTypicalSelectionStates(PackageDescription packageData) { |
| packageData.setTypicalSelectionState(packageData.getSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| saveTypicalSelectionStates(child); |
| } |
| } |
| |
| static public void saveCustomSelectionStates(PackageDescription packageData) { |
| packageData.setCustomSelectionState(packageData.getSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| saveCustomSelectionStates(child); |
| } |
| } |
| |
| static public void saveStartSelectionStates(PackageDescription packageData) { |
| packageData.setStartSelectionState(packageData.getSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| saveStartSelectionStates(child); |
| } |
| } |
| |
| static public void restoreTypicalSelectionStates(PackageDescription packageData) { |
| packageData.setSelectionState(packageData.getTypicalSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| restoreTypicalSelectionStates(child); |
| } |
| } |
| |
| static public void restoreCustomSelectionStates(PackageDescription packageData) { |
| packageData.setSelectionState(packageData.getCustomSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| restoreCustomSelectionStates(child); |
| } |
| } |
| |
| static public void restoreStartSelectionStates(PackageDescription packageData) { |
| packageData.setSelectionState(packageData.getStartSelectionState()); |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| restoreStartSelectionStates(child); |
| } |
| } |
| |
| static public void setUpdateOlderProductSettings(PackageDescription packageData, InstallData data, Installer installer) { |
| if (( packageData.getPackageName() != null ) && ( ! packageData.getPackageName().equals(""))) { |
| if ( installer.isPackageInstalled(packageData, data) ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| |
| // Special handling for jre package, because this is not necessarily older, if an older product is updated. |
| if ( packageData.isJavaPackage() ) { |
| if ( ! installer.isInstalledPackageOlder(packageData, data) ) { |
| packageData.setSelectionState(PackageDescription.DONT_INSTALL); |
| } |
| } |
| } else { |
| packageData.setSelectionState(PackageDescription.DONT_INSTALL); |
| // Special handling for Major Upgrade |
| if ( data.isMajorUpgrade() ) { |
| String basis = "ooobasis3"; |
| if ( data.getOSType().equalsIgnoreCase("Linux") ) { basis = basis + "."; } |
| String search = basis + data.getProductMinor(); |
| String replacestring = basis + data.getInstalledProductMinor(); |
| int pos = packageData.getPackageName().indexOf(search); |
| if ( pos > -1 ) { |
| // Check if this package is installed with a lower product minor |
| // Creating new package for removal, very simple PackageDescription |
| PackageDescription localPackage = new PackageDescription(); |
| localPackage.setUninstallCanFail(true); |
| localPackage.setIsRelocatable(packageData.isRelocatable()); |
| String localName = packageData.getPackageName(); |
| localName = localName.replace(search, replacestring); |
| localPackage.setPackageName(localName); |
| |
| if ( ( packageData.getPkgRealName() != null ) && ( ! packageData.getPkgRealName().equals("") )) { |
| localName = packageData.getPkgRealName(); |
| localName = localName.replace(search, replacestring); |
| localPackage.setPkgRealName(localName); |
| } |
| |
| if (( packageData.getName() != null ) && ( ! packageData.getName().equals("") )) { |
| localName = packageData.getName(); |
| localName = localName.replace(search, replacestring); |
| localPackage.setName(localName); |
| } |
| |
| // saving also the order, needed for order of uninstallation |
| localPackage.setOrder(packageData.getOrder()); |
| |
| // If the old package is installed, the new package can be installed, too, |
| // and the old package can be marked for removal (with dependency check). |
| if ( installer.isPackageInstalled(localPackage, data) ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| |
| // Collecting all installed older packages for uninstallation |
| Vector oldPackages = data.getOldPackages(); |
| oldPackages.add(localPackage); |
| data.setOldPackages(oldPackages); |
| } |
| } |
| } |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setUpdateOlderProductSettings(child, data, installer); |
| } |
| } |
| |
| static public void checkLanguagesPackages(PackageDescription packageData, InstallData installData) { |
| if (( packageData.getPkgLanguage() != null ) && ( ! packageData.getPkgLanguage().equals(""))) { |
| // This is a package with a specific language. |
| // pkgLanguage can be a comma separated list, for example "ja,ja_JP.PCK,ja_JP.UTF-8" |
| String allLang = packageData.getPkgLanguage(); |
| String[] allLangs = allLang.split(","); |
| |
| Vector systemLanguages = installData.getSystemLanguages(); |
| |
| boolean foundLang = false; |
| for (int i = 0; i < allLangs.length; i++) { |
| String oneLang = allLangs[i]; |
| oneLang = oneLang.trim(); |
| if ( systemLanguages.contains(oneLang)) { |
| foundLang = true; |
| int count = installData.getPreselectedLanguages(); |
| count++; |
| installData.setPreselectedLanguages(count); |
| break; |
| } |
| } |
| |
| if ( ! foundLang ) { |
| packageData.setSelectionState(PackageDescription.DONT_INSTALL); |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| checkLanguagesPackages(child, installData); |
| } |
| } |
| |
| static public void setLanguagesPackages(PackageDescription packageData) { |
| if (( packageData.getPkgLanguage() != null ) && ( ! packageData.getPkgLanguage().equals(""))) { |
| // This is a package with a specific language. |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setLanguagesPackages(child); |
| } |
| } |
| |
| static public void setRequiredNewCoreModules(PackageDescription packageData, InstallData installData) { |
| // Special handling for core modules, which are required, but not installed. |
| boolean isRequiredCoreModule = checkRequiredCoreModule(packageData); |
| if ( isRequiredCoreModule ) { |
| if ( packageData.getSelectionState() != PackageDescription.INSTALL ) { |
| packageData.setSelectionState(PackageDescription.INSTALL); |
| LogManager.addLogfileComment("<b>Adding required package:</b> " + packageData.getPackageName() + "</br>"); |
| } |
| // This package has to exist! |
| if ( ! packageExists(packageData, installData) ) { |
| |
| String packagePath = installData.getPackagePath(); |
| if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { |
| File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); |
| packagePath = completePackageFile.getPath(); |
| } |
| String packageName = packageData.getPackageName(); |
| File packageFile = new File(packagePath, packageName); |
| |
| String log = "<b>Error: Missing required package " + packageFile.getPath() + "</b><br>"; |
| System.err.println(log); |
| String message = ResourceManager.getString("String_File_Not_Found") + ": " + packageFile.getPath(); |
| String title = ResourceManager.getString("String_Error"); |
| Informer.showErrorMessage(message, title); |
| System.exit(1); |
| } |
| } |
| |
| for (Enumeration e = packageData.children(); e.hasMoreElements(); ) { |
| PackageDescription child = (PackageDescription) e.nextElement(); |
| setRequiredNewCoreModules(child, installData); |
| } |
| } |
| |
| static public void defaultDatabaseAnalysis(InstallData data) { |
| |
| PackageDescription packageData = SetupDataProvider.getPackageDescription(); |
| Installer installer = InstallerFactory.getInstance(); |
| |
| // restore default settings |
| if ( data.startSelectionStateSaved() ) { |
| // System.err.println("Restoring start selection states"); |
| ModuleCtrl.restoreStartSelectionStates(packageData); |
| } else { |
| ModuleCtrl.saveStartSelectionStates(packageData); |
| data.setStartSelectionStateSaved(true); |
| } |
| |
| // Special ToDos, if this is an update installation of an older product. |
| // In this case, "chooseInstallationType" and "chooseComponents" are not called. |
| // Is it necessary to call "analyzeDatabase" ? |
| if ( data.olderVersionExists() ) { |
| // Calculation of size is not necessary, because only |
| // already installed packages will be updated. |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: Before setUpdateOlderProductSettings"); |
| } |
| |
| // Updating only those packages that are installed. |
| ModuleCtrl.setUpdateOlderProductSettings(packageData, data, installer); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setUpdateOlderProductSettings"); |
| } |
| |
| // Setting packages that are forced into update, because they did not exist in older version. |
| ModuleCtrl.setForcedUpdateProductSettings(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setForcedUpdateProductSettings"); |
| } |
| |
| // Setting required root module packages (that are new in the update product). |
| ModuleCtrl.setRequiredNewCoreModules(packageData, data); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setRequiredNewCoreModules"); |
| } |
| |
| // Checking, if all packages are available |
| ModuleCtrl.disableNonExistingPackages(packageData, data); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After disableNonExistingPackages"); |
| } |
| |
| // disable packages, that are not valid in user installation |
| if ( data.isUserInstallation() ) { |
| ModuleCtrl.setShowInUserInstallFlags(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setShowInUserInstallFlags"); |
| } |
| } |
| else { // disable packages, that are not valid in root installation |
| ModuleCtrl.setShowInUserInstallOnlyFlags(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setShowInUserInstallOnlyFlags"); |
| } |
| } |
| |
| // Setting parent module settings. Only required for displaying correct module settings before starting installation. |
| ModuleCtrl.setParentDefaultModuleSettings(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setParentDefaultModuleSettings"); |
| } |
| |
| // Collecting packages to install |
| // This has to be done here, because "ChooseInstallationType" and "ChooseComponents" |
| // are not called. |
| Vector installPackages = new Vector(); |
| PackageCollector.collectInstallPackages(packageData, installPackages); |
| data.setInstallPackages(installPackages); |
| |
| } else { // same version exists or no version exists |
| |
| // database changed -> ignore saved states |
| data.setTypicalSelectionStateSaved(false); |
| data.setCustomSelectionStateSaved(false); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "analyzeDatabase: Start"); |
| } |
| |
| // searching in the database for already installed packages |
| LogManager.setCommandsHeaderLine("Analyzing system database"); |
| ModuleCtrl.setDatabaseSettings(packageData, data, installer); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "analyzeDatabase: After setDatabaseSettings"); |
| } |
| |
| // ModuleCtrl.analyzeDatabase(); |
| ModuleCtrl.disableNonExistingPackages(packageData, data); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After disableNonExistingPackages"); |
| } |
| |
| // disable packages, that are not valid in user installation |
| if ( data.isUserInstallation() ) { |
| ModuleCtrl.setShowInUserInstallFlags(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setShowInUserInstallFlags"); |
| } |
| } else { // disable packages, that are not valid in root installation |
| ModuleCtrl.setShowInUserInstallOnlyFlags(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setShowInUserInstallOnlyFlags"); |
| } |
| } |
| |
| // Problem: If all submodules have flag IGNORE, the parent can also get IGNORE |
| // That is interesting for language packs with three submodules. |
| ModuleCtrl.setParentDefaultModuleSettings(packageData); |
| |
| if ( data.logModuleStates() ) { |
| Dumper.logModuleStates(packageData, "ChooseDirectory: After setParentDefaultModuleSettings"); |
| } |
| } |
| } |
| |
| } |
