summaryrefslogtreecommitdiff
path: root/Source/CPack/IFW
diff options
context:
space:
mode:
Diffstat (limited to 'Source/CPack/IFW')
-rw-r--r--Source/CPack/IFW/cmCPackIFWGenerator.cxx552
-rw-r--r--Source/CPack/IFW/cmCPackIFWGenerator.h135
-rw-r--r--Source/CPack/IFW/cmCPackIFWInstaller.cxx406
-rw-r--r--Source/CPack/IFW/cmCPackIFWInstaller.h95
-rw-r--r--Source/CPack/IFW/cmCPackIFWPackage.cxx540
-rw-r--r--Source/CPack/IFW/cmCPackIFWPackage.h133
6 files changed, 1861 insertions, 0 deletions
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
new file mode 100644
index 0000000000..7f06e2d8a7
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
@@ -0,0 +1,552 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWGenerator.h"
+
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWInstaller.h"
+
+#include <CPack/cmCPackLog.h>
+#include <CPack/cmCPackComponentGroup.h>
+
+#include <cmsys/SystemTools.hxx>
+#include <cmsys/Glob.hxx>
+#include <cmsys/Directory.hxx>
+#include <cmsys/RegularExpression.hxx>
+
+#include <cmGlobalGenerator.h>
+#include <cmLocalGenerator.h>
+#include <cmSystemTools.h>
+#include <cmMakefile.h>
+#include <cmGeneratedFileStream.h>
+#include <cmXMLSafe.h>
+
+//----------------------------------------------------------------------------
+cmCPackIFWGenerator::cmCPackIFWGenerator()
+{
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWGenerator::~cmCPackIFWGenerator()
+{
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWGenerator::PackageFiles()
+{
+ cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl);
+
+ // Installer configuragion
+ Installer.GenerateInstallerFile();
+
+ // Packages configuration
+ Installer.GeneratePackageFiles();
+
+ std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+ std::string ifwTmpFile = ifwTLD;
+ ifwTmpFile += "/IFWOutput.log";
+
+ // Run repogen
+ if (!Installer.Repositories.empty())
+ {
+ std::string ifwCmd = RepoGen;
+ ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+ ifwCmd += " -p " + this->toplevel + "/packages";
+
+ if(!PkgsDirsVector.empty())
+ {
+ for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+ it != PkgsDirsVector.end(); ++it)
+ {
+ ifwCmd += " -p " + *it;
+ }
+ }
+
+ if (!OnlineOnly && !DownloadedPackages.empty())
+ {
+ ifwCmd += " -i ";
+ std::set<cmCPackIFWPackage*>::iterator it
+ = DownloadedPackages.begin();
+ ifwCmd += (*it)->Name;
+ ++it;
+ while(it != DownloadedPackages.end())
+ {
+ ifwCmd += "," + (*it)->Name;
+ ++it;
+ }
+ }
+ ifwCmd += " " + this->toplevel + "/repository";
+ cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
+ << std::endl);
+ std::string output;
+ int retVal = 1;
+ cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+ "- Generate repository" << std::endl);
+ bool res = cmSystemTools::RunSingleCommand(
+ ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
+ if ( !res || retVal )
+ {
+ cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+ ofs << "# Run command: " << ifwCmd << std::endl
+ << "# Output:" << std::endl
+ << output << std::endl;
+ cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
+ << ifwCmd << std::endl
+ << "Please check " << ifwTmpFile << " for errors"
+ << std::endl);
+ return 0;
+ }
+ cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: " << this->toplevel
+ << "/repository generated" << std::endl);
+ }
+
+ // Run binary creator
+ {
+ std::string ifwCmd = BinCreator;
+ ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+ ifwCmd += " -p " + this->toplevel + "/packages";
+
+ if(!PkgsDirsVector.empty())
+ {
+ for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+ it != PkgsDirsVector.end(); ++it)
+ {
+ ifwCmd += " -p " + *it;
+ }
+ }
+
+ if (OnlineOnly)
+ {
+ ifwCmd += " --online-only";
+ }
+ else if (!DownloadedPackages.empty() && !Installer.Repositories.empty())
+ {
+ ifwCmd += " -e ";
+ std::set<cmCPackIFWPackage*>::iterator it
+ = DownloadedPackages.begin();
+ ifwCmd += (*it)->Name;
+ ++it;
+ while(it != DownloadedPackages.end())
+ {
+ ifwCmd += "," + (*it)->Name;
+ ++it;
+ }
+ }
+ else if (!DependentPackages.empty())
+ {
+ ifwCmd += " -i ";
+ // Binary
+ std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
+ while(bit != BinaryPackages.end())
+ {
+ ifwCmd += (*bit)->Name + ",";
+ ++bit;
+ }
+ // Depend
+ DependenceMap::iterator it = DependentPackages.begin();
+ ifwCmd += it->second.Name;
+ ++it;
+ while(it != DependentPackages.end())
+ {
+ ifwCmd += "," + it->second.Name;
+ ++it;
+ }
+ }
+ // TODO: set correct name for multipackages
+ if (this->packageFileNames.size() > 0)
+ {
+ ifwCmd += " " + packageFileNames[0];
+ }
+ else
+ {
+ ifwCmd += " installer";
+ }
+ cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
+ << std::endl);
+ std::string output;
+ int retVal = 1;
+ cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
+ bool res = cmSystemTools::RunSingleCommand(
+ ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
+ if ( !res || retVal )
+ {
+ cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+ ofs << "# Run command: " << ifwCmd << std::endl
+ << "# Output:" << std::endl
+ << output << std::endl;
+ cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
+ << ifwCmd << std::endl
+ << "Please check " << ifwTmpFile << " for errors"
+ << std::endl);
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
+{
+ const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
+
+ std::string tmpPref = defPrefix ? defPrefix : "";
+
+ if(this->Components.empty())
+ {
+ tmpPref += "packages/" + GetRootPackageName() + "/data";
+ }
+
+ this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
+
+ return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWGenerator::GetOutputExtension()
+{
+ const char *suffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX");
+ return suffix ? suffix : cmCPackGenerator::GetOutputExtension();
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWGenerator::InitializeInternal()
+{
+ // Search Qt Installer Framework tools
+
+ const std::string BinCreatorOpt = "CPACK_IFW_BINARYCREATOR_EXECUTABLE";
+ const std::string RepoGenOpt = "CPACK_IFW_REPOGEN_EXECUTABLE";
+
+ if(!this->IsSet(BinCreatorOpt) ||
+ !this->IsSet(RepoGenOpt))
+ {
+ this->ReadListFile("CPackIFW.cmake");
+ }
+
+ // Look 'binarycreator' executable (needs)
+
+ const char *BinCreatorStr = this->GetOption(BinCreatorOpt);
+ if(!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr))
+ {
+ BinCreator = "";
+ }
+ else
+ {
+ BinCreator = BinCreatorStr;
+ }
+
+ if (BinCreator.empty())
+ {
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
+ "Cannot find QtIFW compiler \"binarycreator\": "
+ "likely it is not installed, or not in your PATH"
+ << std::endl);
+ return 0;
+ }
+
+ // Look 'repogen' executable (optional)
+
+ const char *RepoGenStr = this->GetOption(RepoGenOpt);
+ if(!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr))
+ {
+ RepoGen = "";
+ }
+ else
+ {
+ RepoGen = RepoGenStr;
+ }
+
+ // Variables that Change Behavior
+
+ // Resolve duplicate names
+ ResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
+
+ // Additional packages dirs
+ PkgsDirsVector.clear();
+ if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES"))
+ {
+ cmSystemTools::ExpandListArgument(dirs,
+ PkgsDirsVector);
+ }
+
+ // Installer
+ Installer.Generator = this;
+ Installer.ConfigureFromOptions();
+
+ if (const char* ifwDownloadAll =
+ this->GetOption("CPACK_IFW_DOWNLOAD_ALL"))
+ {
+ OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
+ }
+ else if (const char* cpackDownloadAll =
+ this->GetOption("CPACK_DOWNLOAD_ALL"))
+ {
+ OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
+ }
+ else
+ {
+ OnlineOnly = false;
+ }
+
+ if (!Installer.Repositories.empty() && RepoGen.empty()) {
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
+ "Cannot find QtIFW repository generator \"repogen\": "
+ "likely it is not installed, or not in your PATH"
+ << std::endl);
+ return 0;
+ }
+
+ return this->Superclass::InitializeInternal();
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
+ const std::string& componentName)
+{
+ const std::string prefix = "packages/";
+ const std::string suffix = "/data";
+
+ if (componentPackageMethod == ONE_PACKAGE) {
+ return std::string(prefix + GetRootPackageName() + suffix);
+ }
+
+ return prefix
+ + GetComponentPackageName(&Components[componentName])
+ + suffix;
+}
+
+//----------------------------------------------------------------------------
+cmCPackComponent*
+cmCPackIFWGenerator::GetComponent(const std::string &projectName,
+ const std::string &componentName)
+{
+ ComponentsMap::iterator cit = Components.find(componentName);
+ if ( cit != Components.end() ) return &(cit->second);
+
+ cmCPackComponent* component
+ = cmCPackGenerator::GetComponent(projectName, componentName);
+ if(!component) return component;
+
+ std::string name = GetComponentPackageName(component);
+ PackagesMap::iterator pit = Packages.find(name);
+ if(pit != Packages.end()) return component;
+
+ cmCPackIFWPackage *package = &Packages[name];
+ package->Name = name;
+ package->Generator = this;
+ if(package->ConfigureFromComponent(component))
+ {
+ package->Installer = &Installer;
+ Installer.Packages.insert(
+ std::pair<std::string, cmCPackIFWPackage*>(
+ name, package));
+ ComponentPackages.insert(
+ std::pair<cmCPackComponent*, cmCPackIFWPackage*>(
+ component, package));
+ if(component->IsDownloaded)
+ {
+ DownloadedPackages.insert(package);
+ }
+ else
+ {
+ BinaryPackages.insert(package);
+ }
+ }
+ else
+ {
+ Packages.erase(name);
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
+ "Cannot configure package \"" << name <<
+ "\" for component \"" << component->Name << "\""
+ << std::endl);
+ }
+
+ return component;
+}
+
+//----------------------------------------------------------------------------
+cmCPackComponentGroup*
+cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
+ const std::string &groupName)
+{
+ cmCPackComponentGroup* group
+ = cmCPackGenerator::GetComponentGroup(projectName, groupName);
+ if(!group) return group;
+
+ std::string name = GetGroupPackageName(group);
+ PackagesMap::iterator pit = Packages.find(name);
+ if(pit != Packages.end()) return group;
+
+ cmCPackIFWPackage *package = &Packages[name];
+ package->Name = name;
+ package->Generator = this;
+ if(package->ConfigureFromGroup(group))
+ {
+ package->Installer = &Installer;
+ Installer.Packages.insert(
+ std::pair<std::string, cmCPackIFWPackage*>(
+ name, package));
+ GroupPackages.insert(
+ std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(
+ group, package));
+ BinaryPackages.insert(package);
+ }
+ else
+ {
+ Packages.erase(name);
+ cmCPackLogger(cmCPackLog::LOG_ERROR,
+ "Cannot configure package \"" << name <<
+ "\" for component group \"" << group->Name << "\""
+ << std::endl);
+ }
+ return group;
+}
+
+//----------------------------------------------------------------------------
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackIFWGenerator::SupportsSetDestdir() const
+{
+ return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const
+{
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::SupportsComponentInstallation() const
+{
+ return true;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::IsOnePackage() const
+{
+ return componentPackageMethod == ONE_PACKAGE;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWGenerator::GetRootPackageName()
+{
+ // Default value
+ std::string name = "root";
+ if (const char* optIFW_PACKAGE_GROUP =
+ this->GetOption("CPACK_IFW_PACKAGE_GROUP"))
+ {
+ // Configure from root group
+ cmCPackIFWPackage package;
+ package.Generator = this;
+ package.ConfigureFromGroup(optIFW_PACKAGE_GROUP);
+ name = package.Name;
+ }
+ else if (const char* optIFW_PACKAGE_NAME =
+ this->GetOption("CPACK_IFW_PACKAGE_NAME"))
+ {
+ // Configure from root package name
+ name = optIFW_PACKAGE_NAME;
+ }
+ else if (const char* optPACKAGE_NAME =
+ this->GetOption("CPACK_PACKAGE_NAME"))
+ {
+ // Configure from package name
+ name = optPACKAGE_NAME;
+ }
+ return name;
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
+{
+ std::string name;
+ if (!group) return name;
+ if (cmCPackIFWPackage* package = GetGroupPackage(group))
+ {
+ return package->Name;
+ }
+ const char* option = GetOption(
+ "CPACK_IFW_COMPONENT_GROUP_"
+ + cmsys::SystemTools::UpperCase(group->Name)
+ + "_NAME");
+ name = option ? option : group->Name;
+ if(group->ParentGroup)
+ {
+ cmCPackIFWPackage* package = GetGroupPackage(group->ParentGroup);
+ bool dot = !ResolveDuplicateNames;
+ if(dot && name.substr(0, package->Name.size()) == package->Name)
+ {
+ dot = false;
+ }
+ if(dot)
+ {
+ name = package->Name + "." + name;
+ }
+ }
+ return name;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWGenerator::GetComponentPackageName(
+ cmCPackComponent *component) const
+{
+ std::string name;
+ if (!component) return name;
+ if (cmCPackIFWPackage* package = GetComponentPackage(component))
+ {
+ return package->Name;
+ }
+ std::string prefix = "CPACK_IFW_COMPONENT_"
+ + cmsys::SystemTools::UpperCase(component->Name)
+ + "_";
+ const char* option = GetOption(prefix + "NAME");
+ name = option ? option : component->Name;
+ if(component->Group)
+ {
+ cmCPackIFWPackage* package = GetGroupPackage(component->Group);
+ if((componentPackageMethod == ONE_PACKAGE_PER_GROUP)
+ || IsOn(prefix + "COMMON"))
+ {
+ return package->Name;
+ }
+ bool dot = !ResolveDuplicateNames;
+ if(dot && name.substr(0, package->Name.size()) == package->Name)
+ {
+ dot = false;
+ }
+ if(dot)
+ {
+ name = package->Name + "." + name;
+ }
+ }
+ return name;
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
+ cmCPackComponentGroup *group) const
+{
+ std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit
+ = GroupPackages.find(group);
+ return pit != GroupPackages.end() ? pit->second : 0;
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
+ cmCPackComponent *component) const
+{
+ std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit
+ = ComponentPackages.find(component);
+ return pit != ComponentPackages.end() ? pit->second : 0;
+}
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
new file mode 100644
index 0000000000..1d4d67bf17
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -0,0 +1,135 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWGenerator_h
+#define cmCPackIFWGenerator_h
+
+#include <CPack/cmCPackGenerator.h>
+
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWInstaller.h"
+
+/** \class cmCPackIFWGenerator
+ * \brief A generator for Qt Installer Framework tools
+ *
+ * http://qt-project.org/doc/qtinstallerframework/index.html
+ */
+class cmCPackIFWGenerator : public cmCPackGenerator
+{
+public:
+ cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator);
+
+ typedef std::map<std::string, cmCPackIFWPackage> PackagesMap;
+ typedef std::map<std::string, cmCPackComponent> ComponentsMap;
+ typedef std::map<std::string, cmCPackComponentGroup> ComponentGoupsMap;
+ typedef std::map<std::string, cmCPackIFWPackage::DependenceStruct>
+ DependenceMap;
+
+ /**
+ * Construct IFW generator
+ */
+ cmCPackIFWGenerator();
+
+ /**
+ * Destruct IFW generator
+ */
+ virtual ~cmCPackIFWGenerator();
+
+protected: // cmCPackGenerator reimplementation
+
+ /**
+ * @brief Initialize generator
+ * @return 0 on failure
+ */
+ virtual int InitializeInternal();
+ virtual int PackageFiles();
+ virtual const char* GetPackagingInstallPrefix();
+
+ /**
+ * @brief Extension of binary installer
+ * @return Executable suffix or value from default implementation
+ */
+ virtual const char* GetOutputExtension();
+
+ virtual std::string GetComponentInstallDirNameSuffix(
+ const std::string& componentName);
+
+ /**
+ * @brief Get Component
+ * @param projectName Project name
+ * @param componentName Component name
+ *
+ * This method calls the base implementation.
+ *
+ * @return Pointer to component
+ */
+ virtual cmCPackComponent* GetComponent(
+ const std::string& projectName,
+ const std::string& componentName);
+
+ /**
+ * @brief Get group of component
+ * @param projectName Project name
+ * @param groupName Component group name
+ *
+ * This method calls the base implementation.
+ *
+ * @return Pointer to component group
+ */
+ virtual cmCPackComponentGroup* GetComponentGroup(
+ const std::string& projectName,
+ const std::string& groupName);
+
+ enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
+ virtual bool SupportsAbsoluteDestination() const;
+ virtual bool SupportsComponentInstallation() const;
+
+protected: // Methods
+
+ bool IsOnePackage() const;
+
+ std::string GetRootPackageName();
+
+ std::string GetGroupPackageName(cmCPackComponentGroup *group) const;
+ std::string GetComponentPackageName(cmCPackComponent *component) const;
+
+ cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const;
+ cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const;
+
+protected: // Data
+
+ friend class cmCPackIFWPackage;
+ friend class cmCPackIFWInstaller;
+
+ // Installer
+ cmCPackIFWInstaller Installer;
+ // Collection of packages
+ PackagesMap Packages;
+ // Collection of binary packages
+ std::set<cmCPackIFWPackage*> BinaryPackages;
+ // Collection of downloaded packages
+ std::set<cmCPackIFWPackage*> DownloadedPackages;
+ // Dependent packages
+ DependenceMap DependentPackages;
+ std::map<cmCPackComponent*, cmCPackIFWPackage*> ComponentPackages;
+ std::map<cmCPackComponentGroup*, cmCPackIFWPackage*> GroupPackages;
+
+private:
+ std::string RepoGen;
+ std::string BinCreator;
+
+ bool OnlineOnly;
+ bool ResolveDuplicateNames;
+ std::vector<std::string> PkgsDirsVector;
+};
+
+#endif
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
new file mode 100644
index 0000000000..0644ecbd39
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -0,0 +1,406 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWInstaller.h"
+
+#include "cmCPackIFWGenerator.h"
+
+#include <CPack/cmCPackLog.h>
+
+#include <cmGeneratedFileStream.h>
+#include <cmXMLSafe.h>
+
+#ifdef cmCPackLogger
+# undef cmCPackLogger
+#endif
+#define cmCPackLogger(logType, msg) \
+ do { \
+ cmOStringStream cmCPackLog_msg; \
+ cmCPackLog_msg << msg; \
+ if(Generator) { \
+ Generator->Logger->Log(logType, __FILE__, __LINE__, \
+ cmCPackLog_msg.str().c_str()); \
+ } \
+ } while ( 0 )
+
+//----------------------------------------------------------------------------
+cmCPackIFWInstaller::cmCPackIFWInstaller() :
+ Generator(0)
+{
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWInstaller::GetOption(const std::string &op) const
+{
+ return Generator ? Generator->GetOption(op) : 0;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWInstaller::IsOn(const std::string &op) const
+{
+ return Generator ? Generator->IsOn(op) : false;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::ConfigureFromOptions()
+{
+ // Name;
+ if (const char* optIFW_PACKAGE_NAME =
+ this->GetOption("CPACK_IFW_PACKAGE_NAME"))
+ {
+ Name = optIFW_PACKAGE_NAME;
+ }
+ else if (const char* optPACKAGE_NAME =
+ this->GetOption("CPACK_PACKAGE_NAME"))
+ {
+ Name = optPACKAGE_NAME;
+ }
+ else
+ {
+ Name = "Your package";
+ }
+
+ // Title;
+ if (const char* optIFW_PACKAGE_TITLE =
+ GetOption("CPACK_IFW_PACKAGE_TITLE"))
+ {
+ Title = optIFW_PACKAGE_TITLE;
+ }
+ else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
+ GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
+ {
+ Title = optPACKAGE_DESCRIPTION_SUMMARY;
+ }
+ else
+ {
+ Title = "Your package description";
+ }
+
+ // Version;
+ if (const char* option = GetOption("CPACK_PACKAGE_VERSION"))
+ {
+ Version = option;
+ }
+ else
+ {
+ Version = "1.0.0";
+ }
+
+ // Publisher
+ if(const char* optIFW_PACKAGE_PUBLISHER =
+ GetOption("CPACK_IFW_PACKAGE_PUBLISHER"))
+ {
+ Publisher = optIFW_PACKAGE_PUBLISHER;
+ }
+ else if(const char* optPACKAGE_VENDOR = GetOption("CPACK_PACKAGE_VENDOR"))
+ {
+ Publisher = optPACKAGE_VENDOR;
+ }
+
+ // ProductUrl
+ if(const char* option = GetOption("CPACK_IFW_PRODUCT_URL"))
+ {
+ ProductUrl = option;
+ }
+
+ // ApplicationIcon
+ if(const char* option = GetOption("CPACK_IFW_PACKAGE_ICON"))
+ {
+ if(cmSystemTools::FileExists(option))
+ {
+ InstallerApplicationIcon = option;
+ }
+ else
+ {
+ // TODO: implement warning
+ }
+ }
+
+ // WindowIcon
+ if(const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON"))
+ {
+ if(cmSystemTools::FileExists(option))
+ {
+ InstallerWindowIcon = option;
+ }
+ else
+ {
+ // TODO: implement warning
+ }
+ }
+
+ // Logo
+ if(const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO"))
+ {
+ if(cmSystemTools::FileExists(option))
+ {
+ Logo = option;
+ }
+ else
+ {
+ // TODO: implement warning
+ }
+ }
+
+ // Default target directory for installation
+ if (const char* optIFW_TARGET_DIRECTORY =
+ GetOption("CPACK_IFW_TARGET_DIRECTORY"))
+ {
+ TargetDir = optIFW_TARGET_DIRECTORY;
+ }
+ else if (const char *optPACKAGE_INSTALL_DIRECTORY =
+ GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY"))
+ {
+ TargetDir = "@ApplicationsDir@/";
+ TargetDir += optPACKAGE_INSTALL_DIRECTORY;
+ }
+ else
+ {
+ TargetDir = "@RootDir@/usr/local";
+ }
+
+ // Default target directory for installation with administrator rights
+ if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY"))
+ {
+ AdminTargetDir = option;
+ }
+
+ // Repositories
+ Repositories.clear();
+ RepositoryStruct Repo;
+ if (const char *site = this->GetOption("CPACK_DOWNLOAD_SITE"))
+ {
+ Repo.Url = site;
+ Repositories.push_back(Repo);
+ }
+ if(const char *RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL"))
+ {
+ std::vector<std::string> RepoAllVector;
+ cmSystemTools::ExpandListArgument(RepoAllStr,
+ RepoAllVector);
+ for(std::vector<std::string>::iterator
+ rit = RepoAllVector.begin(); rit != RepoAllVector.end(); ++rit)
+ {
+ std::string prefix = "CPACK_IFW_REPOSITORY_"
+ + cmsys::SystemTools::UpperCase(*rit)
+ + "_";
+ // Url
+ if (const char* url = GetOption(prefix + "URL"))
+ {
+ Repo.Url = url;
+ }
+ else
+ {
+ Repo.Url = "";
+ }
+ // Enabled
+ if (IsOn(prefix + "DISABLED"))
+ {
+ Repo.Enabled = "0";
+ }
+ else
+ {
+ Repo.Enabled = "";
+ }
+ // Username
+ if (const char* username = GetOption(prefix + "USERNAME"))
+ {
+ Repo.Username = username;
+ }
+ else
+ {
+ Repo.Username = "";
+ }
+ // Password
+ if (const char* password = GetOption(prefix + "PASSWORD"))
+ {
+ Repo.Password = password;
+ }
+ else
+ {
+ Repo.Password = "";
+ }
+ // DisplayName
+ if (const char* displayName = GetOption(prefix + "DISPLAY_NAME"))
+ {
+ Repo.DisplayName = displayName;
+ }
+ else
+ {
+ Repo.DisplayName = "";
+ }
+
+ if(!Repo.Url.empty())
+ {
+ Repositories.push_back(Repo);
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::GenerateInstallerFile()
+{
+ // Lazy directory initialization
+ if(Directory.empty() && Generator)
+ {
+ Directory = Generator->toplevel;
+ }
+
+ // Output stream
+ cmGeneratedFileStream xout((Directory + "/config/config.xml").data());
+
+ xout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+ xout << "<Installer>" << std::endl;
+
+ xout << " <Name>" << cmXMLSafe(Name).str() << "</Name>" << std::endl;
+
+ xout << " <Version>" << Version << "</Version>" << std::endl;
+
+ xout << " <Title>" << cmXMLSafe(Title).str() << "</Title>"
+ << std::endl;
+
+ if(!Publisher.empty())
+ {
+ xout << " <Publisher>" << cmXMLSafe(Publisher).str()
+ << "</Publisher>" << std::endl;
+ }
+
+ if(!ProductUrl.empty())
+ {
+ xout << " <ProductUrl>" << ProductUrl << "</ProductUrl>" << std::endl;
+ }
+
+ // ApplicationIcon
+ if(!InstallerApplicationIcon.empty())
+ {
+ std::string name =
+ cmSystemTools::GetFilenameName(InstallerApplicationIcon);
+ std::string path = Directory + "/config/" + name;
+ name = cmSystemTools::GetFilenameWithoutExtension(name);
+ cmsys::SystemTools::CopyFileIfDifferent(
+ InstallerApplicationIcon.data(), path.data());
+ xout << " <InstallerApplicationIcon>" << name
+ << "</InstallerApplicationIcon>" << std::endl;
+ }
+
+ // WindowIcon
+ if(!InstallerWindowIcon.empty())
+ {
+ std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon);
+ std::string path = Directory + "/config/" + name;
+ cmsys::SystemTools::CopyFileIfDifferent(
+ InstallerWindowIcon.data(), path.data());
+ xout << " <InstallerWindowIcon>" << name
+ << "</InstallerWindowIcon>" << std::endl;
+ }
+
+ // Logo
+ if(!Logo.empty())
+ {
+ std::string name = cmSystemTools::GetFilenameName(Logo);
+ std::string path = Directory + "/config/" + name;
+ cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data());
+ xout << " <Logo>" << name << "</Logo>" << std::endl;
+ }
+
+ if(!TargetDir.empty())
+ {
+ xout << " <TargetDir>" << TargetDir << "</TargetDir>" << std::endl;
+ }
+
+ if(!AdminTargetDir.empty())
+ {
+ xout << " <AdminTargetDir>" << AdminTargetDir
+ << "</AdminTargetDir>" << std::endl;
+ }
+
+ // Remote repositories
+ if (!Repositories.empty())
+ {
+ xout << " <RemoteRepositories>" << std::endl;
+ for(std::vector<RepositoryStruct>::iterator
+ rit = Repositories.begin(); rit != Repositories.end(); ++rit)
+ {
+ xout << " <Repository>" << std::endl;
+ // Url
+ xout << " <Url>" << rit->Url
+ << "</Url>" << std::endl;
+ // Enabled
+ if(!rit->Enabled.empty())
+ {
+ xout << " <Enabled>" << rit->Enabled
+ << "</Enabled>" << std::endl;
+ }
+ // Username
+ if(!rit->Username.empty())
+ {
+ xout << " <Username>" << rit->Username
+ << "</Username>" << std::endl;
+ }
+ // Password
+ if(!rit->Password.empty())
+ {
+ xout << " <Password>" << rit->Password
+ << "</Password>" << std::endl;
+ }
+ // DisplayName
+ if(!rit->DisplayName.empty())
+ {
+ xout << " <DisplayName>" << rit->DisplayName
+ << "</DisplayName>" << std::endl;
+ }
+ xout << " </Repository>" << std::endl;
+ }
+ xout << " </RemoteRepositories>" << std::endl;
+ }
+
+ // CPack IFW default policy
+ xout << " <!-- CPack IFW default policy -->" << std::endl;
+ xout << " <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>"
+ << std::endl;
+ xout << " <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl;
+
+ xout << "</Installer>" << std::endl;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::GeneratePackageFiles()
+{
+ if (Packages.empty() || Generator->IsOnePackage())
+ {
+ // Generate default package
+ cmCPackIFWPackage package;
+ package.Generator = Generator;
+ package.Installer = this;
+ // Check package group
+ if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP"))
+ {
+ package.ConfigureFromGroup(option);
+ package.ForcedInstallation = "true";
+ }
+ else
+ {
+ package.ConfigureFromOptions();
+ }
+ package.GeneratePackageFile();
+ return;
+ }
+
+ // Generate packages meta information
+ for(PackagesMap::iterator pit = Packages.begin();
+ pit != Packages.end(); ++pit)
+ {
+ cmCPackIFWPackage* package = pit->second;
+ package->GeneratePackageFile();
+ }
+}
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.h b/Source/CPack/IFW/cmCPackIFWInstaller.h
new file mode 100644
index 0000000000..5824d334a8
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.h
@@ -0,0 +1,95 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWInstaller_h
+#define cmCPackIFWInstaller_h
+
+#include <cmStandardIncludes.h>
+
+class cmCPackIFWPackage;
+class cmCPackIFWGenerator;
+
+/** \class cmCPackIFWInstaller
+ * \brief A binary installer to be created CPack IFW generator
+ */
+class cmCPackIFWInstaller
+{
+public: // Types
+
+ typedef std::map<std::string, cmCPackIFWPackage*> PackagesMap;
+
+ struct RepositoryStruct
+ {
+ std::string Url;
+ std::string Enabled;
+ std::string Username;
+ std::string Password;
+ std::string DisplayName;
+ };
+
+public: // Constructor
+
+ /**
+ * Construct installer
+ */
+ cmCPackIFWInstaller();
+
+public: // Configuration
+
+ /// Name of the product being installed
+ std::string Name;
+
+ /// Version number of the product being installed
+ std::string Version;
+
+ /// Name of the installer as displayed on the title bar
+ std::string Title;
+
+ /// Publisher of the software (as shown in the Windows Control Panel)
+ std::string Publisher;
+
+ /// URL to a page that contains product information on your web site
+ std::string ProductUrl;
+
+ /// Filename for a custom installer icon
+ std::string InstallerApplicationIcon;
+
+ /// Filename for a custom window icon
+ std::string InstallerWindowIcon;
+
+ /// Filename for a logo
+ std::string Logo;
+
+ /// Default target directory for installation
+ std::string TargetDir;
+
+ /// Default target directory for installation with administrator rights
+ std::string AdminTargetDir;
+
+public: // Internal implementation
+
+ const char* GetOption(const std::string& op) const;
+ bool IsOn(const std::string& op) const;
+
+ void ConfigureFromOptions();
+
+ void GenerateInstallerFile();
+
+ void GeneratePackageFiles();
+
+ cmCPackIFWGenerator* Generator;
+ PackagesMap Packages;
+ std::vector<RepositoryStruct> Repositories;
+ std::string Directory;
+};
+
+#endif // cmCPackIFWInstaller_h
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
new file mode 100644
index 0000000000..3c45639ef6
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -0,0 +1,540 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWPackage.h"
+
+#include "cmCPackIFWGenerator.h"
+
+#include <CPack/cmCPackLog.h>
+
+#include <cmGeneratedFileStream.h>
+#include <cmTimestamp.h>
+
+//----------------------------------------------------------------- Logger ---
+#ifdef cmCPackLogger
+# undef cmCPackLogger
+#endif
+#define cmCPackLogger(logType, msg) \
+ do { \
+ cmOStringStream cmCPackLog_msg; \
+ cmCPackLog_msg << msg; \
+ if(Generator) { \
+ Generator->Logger->Log(logType, __FILE__, __LINE__, \
+ cmCPackLog_msg.str().c_str()); \
+ } \
+ } while ( 0 )
+
+//---------------------------------------------------------- CompareStruct ---
+cmCPackIFWPackage::CompareStruct::CompareStruct() :
+ Type(CompareNone)
+{
+}
+
+//------------------------------------------------------- DependenceStruct ---
+cmCPackIFWPackage::DependenceStruct::DependenceStruct()
+{
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage::DependenceStruct::DependenceStruct(
+ const std::string &dependence)
+{
+ // Search compare section
+ size_t pos = std::string::npos;
+ if((pos = dependence.find("<=")) != std::string::npos)
+ {
+ Compare.Type = CompareLessOrEqual;
+ Compare.Value = dependence.substr(pos + 2);
+ }
+ else if((pos = dependence.find(">=")) != std::string::npos)
+ {
+ Compare.Type = CompareGreaterOrEqual;
+ Compare.Value = dependence.substr(pos + 2);
+ }
+ else if((pos = dependence.find("<")) != std::string::npos)
+ {
+ Compare.Type = CompareLess;
+ Compare.Value = dependence.substr(pos + 1);
+ }
+ else if((pos = dependence.find("=")) != std::string::npos)
+ {
+ Compare.Type = CompareEqual;
+ Compare.Value = dependence.substr(pos + 1);
+ }
+ else if((pos = dependence.find(">")) != std::string::npos)
+ {
+ Compare.Type = CompareGreater;
+ Compare.Value = dependence.substr(pos + 1);
+ }
+ Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
+{
+ if (Compare.Type == CompareNone) return Name;
+
+ std::string result = Name;
+
+ if (Compare.Type == CompareLessOrEqual)
+ {
+ result += "<=";
+ }
+ else if (Compare.Type == CompareGreaterOrEqual)
+ {
+ result += ">=";
+ }
+ else if (Compare.Type == CompareLess)
+ {
+ result += "<";
+ }
+ else if (Compare.Type == CompareEqual)
+ {
+ result += "=";
+ }
+ else if (Compare.Type == CompareGreater)
+ {
+ result += ">";
+ }
+
+ result += Compare.Value;
+
+ return result;
+}
+
+//------------------------------------------------------ cmCPackIFWPackage ---
+cmCPackIFWPackage::cmCPackIFWPackage() :
+ Generator(0),
+ Installer(0)
+{
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWPackage::GetOption(const std::string &op) const
+{
+ const char *option = Generator ? Generator->GetOption(op) : 0;
+ return option && *option ? option : 0;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWPackage::IsOn(const std::string &op) const
+{
+ return Generator ? Generator->IsOn(op) : false;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
+{
+ if (!component) return "";
+ const char* option = GetOption(
+ "CPACK_IFW_COMPONENT_"
+ + cmsys::SystemTools::UpperCase(component->Name)
+ + "_NAME");
+ return option ? option : component->Name;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWPackage::DefaultConfiguration()
+{
+ DisplayName = "";
+ Description = "";
+ Version = "";
+ ReleaseDate = "";
+ Script = "";
+ Licenses.clear();
+ SortingPriority = "";
+ Default = "";
+ Virtual = "";
+ ForcedInstallation = "";
+}
+
+//----------------------------------------------------------------------------
+// Defaul configuration (all in one package)
+int cmCPackIFWPackage::ConfigureFromOptions()
+{
+ // Restore defaul configuration
+ DefaultConfiguration();
+
+ // Name
+ Name = Generator->GetRootPackageName();
+
+ // Display name
+ if (const char *option = this->GetOption("CPACK_PACKAGE_NAME"))
+ {
+ DisplayName = option;
+ }
+ else
+ {
+ DisplayName = "Your package";
+ }
+
+ // Description
+ if (const char* option =
+ this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
+ {
+ Description = option;
+ }
+ else
+ {
+ Description = "Your package description";
+ }
+
+ // Version
+ if(const char* option = GetOption("CPACK_PACKAGE_VERSION"))
+ {
+ Version = option;
+ }
+ else
+ {
+ Version = "1.0.0";
+ }
+
+ ForcedInstallation = "true";
+
+ return 1;
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
+{
+ if(!component) return 0;
+
+ // Restore defaul configuration
+ DefaultConfiguration();
+
+ std::string prefix = "CPACK_IFW_COMPONENT_"
+ + cmsys::SystemTools::UpperCase(component->Name)
+ + "_";
+
+ // Display name
+ DisplayName = component->DisplayName;
+
+ // Description
+ Description = component->Description;
+
+ // Version
+ if(const char* optVERSION = GetOption(prefix + "VERSION"))
+ {
+ Version = optVERSION;
+ }
+ else if(const char* optPACKAGE_VERSION =
+ GetOption("CPACK_PACKAGE_VERSION"))
+ {
+ Version = optPACKAGE_VERSION;
+ }
+ else
+ {
+ Version = "1.0.0";
+ }
+
+ // Script
+ if (const char* option = GetOption(prefix + "SCRIPT"))
+ {
+ Script = option;
+ }
+
+ // CMake dependencies
+ if (!component->Dependencies.empty())
+ {
+ std::vector<cmCPackComponent*>::iterator dit;
+ for(dit = component->Dependencies.begin();
+ dit != component->Dependencies.end();
+ ++dit)
+ {
+ Dependencies.insert(Generator->ComponentPackages[*dit]);
+ }
+ }
+
+ // QtIFW dependencies
+ if(const char* option = this->GetOption(prefix + "DEPENDS"))
+ {
+ std::vector<std::string> deps;
+ cmSystemTools::ExpandListArgument(option,
+ deps);
+ for(std::vector<std::string>::iterator
+ dit = deps.begin(); dit != deps.end(); ++dit)
+ {
+ DependenceStruct dep(*dit);
+ if (!Generator->Packages.count(dep.Name))
+ {
+ bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
+ DependenceStruct &depRef =
+ Generator->DependentPackages[dep.Name];
+ if(!hasDep)
+ {
+ depRef = dep;
+ }
+ AlienDependencies.insert(&depRef);
+ }
+ }
+ }
+
+ // Licenses
+ if (const char* option = this->GetOption(prefix + "LICENSES"))
+ {
+ Licenses.clear();
+ cmSystemTools::ExpandListArgument( option, Licenses );
+ if ( Licenses.size() % 2 != 0 )
+ {
+ cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
+ << " should contain pairs of <display_name> and <file_path>."
+ << std::endl);
+ Licenses.clear();
+ }
+ }
+
+ // Priority
+ if(const char* option = this->GetOption(prefix + "PRIORITY"))
+ {
+ SortingPriority = option;
+ }
+
+ // Default
+ Default = component->IsDisabledByDefault ? "false" : "true";
+
+ // Virtual
+ Virtual = component->IsHidden ? "true" : "";
+
+ // ForcedInstallation
+ ForcedInstallation = component->IsRequired ? "true" : "false";
+
+ return 1;
+}
+
+//----------------------------------------------------------------------------
+int
+cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
+{
+ if(!group) return 0;
+
+ // Restore defaul configuration
+ DefaultConfiguration();
+
+ std::string prefix = "CPACK_IFW_COMPONENT_GROUP_"
+ + cmsys::SystemTools::UpperCase(group->Name)
+ + "_";
+
+ DisplayName = group->DisplayName;
+ Description = group->Description;
+
+ // Version
+ if(const char* optVERSION = GetOption(prefix + "VERSION"))
+ {
+ Version = optVERSION;
+ }
+ else if(const char* optPACKAGE_VERSION =
+ GetOption("CPACK_PACKAGE_VERSION"))
+ {
+ Version = optPACKAGE_VERSION;
+ }
+ else
+ {
+ Version = "1.0.0";
+ }
+
+ // Script
+ if (const char* option = GetOption(prefix + "SCRIPT"))
+ {
+ Script = option;
+ }
+
+ // Licenses
+ if (const char* option = this->GetOption(prefix + "LICENSES"))
+ {
+ Licenses.clear();
+ cmSystemTools::ExpandListArgument( option, Licenses );
+ if ( Licenses.size() % 2 != 0 )
+ {
+ cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
+ << " should contain pairs of <display_name> and <file_path>."
+ << std::endl);
+ Licenses.clear();
+ }
+ }
+
+ // Priority
+ if(const char* option = this->GetOption(prefix + "PRIORITY"))
+ {
+ SortingPriority = option;
+ }
+
+ return 1;
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
+{
+ // Group configuration
+
+ cmCPackComponentGroup group;
+ std::string prefix = "CPACK_COMPONENT_GROUP_"
+ + cmsys::SystemTools::UpperCase(groupName)
+ + "_";
+
+ if (const char *option = GetOption(prefix + "DISPLAY_NAME"))
+ {
+ group.DisplayName = option;
+ }
+ else
+ {
+ group.DisplayName = group.Name;
+ }
+
+ if (const char* option = GetOption(prefix + "DESCRIPTION"))
+ {
+ group.Description = option;
+ }
+ group.IsBold = IsOn(prefix + "BOLD_TITLE");
+ group.IsExpandedByDefault = IsOn(prefix + "EXPANDED");
+
+ // Package configuration
+
+ group.Name = groupName;
+
+ if(Generator)
+ {
+ Name = Generator->GetGroupPackageName(&group);
+ }
+ else
+ {
+ Name = group.Name;
+ }
+
+ return ConfigureFromGroup(&group);
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWPackage::GeneratePackageFile()
+{
+ // Lazy directory initialization
+ if (Directory.empty())
+ {
+ if(Installer)
+ {
+ Directory = Installer->Directory + "/packages/" + Name;
+ }
+ else if (Generator)
+ {
+ Directory = Generator->toplevel + "/packages/" + Name;
+ }
+ }
+
+ // Output stream
+ cmGeneratedFileStream xout((Directory + "/meta/package.xml").data());
+
+ xout << "<?xml version=\"1.0\"?>" << std::endl;
+ xout << "<Package>" << std::endl;
+
+ xout << " <DisplayName>" << DisplayName
+ << "</DisplayName>" << std::endl;
+
+ xout << " <Description>" << Description
+ << "</Description>" << std::endl;
+
+ xout << " <Name>" << Name << "</Name>" << std::endl;
+
+ xout << " <Version>" << Version
+ << "</Version>" << std::endl;
+
+ xout << " <ReleaseDate>";
+ if(ReleaseDate.empty())
+ {
+ xout << cmTimestamp().CurrentTime("%Y-%m-%d", true);
+ }
+ else
+ {
+ xout << ReleaseDate;
+ }
+ xout << "</ReleaseDate>" << std::endl;
+
+ // Script (copy to meta dir)
+ if(!Script.empty())
+ {
+ std::string name = cmSystemTools::GetFilenameName(Script);
+ std::string path = Directory + "/meta/" + name;
+ cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
+ xout << " <Script>" << name << "</Script>" << std::endl;
+ }
+
+ // Dependencies
+ std::set<DependenceStruct> compDepSet;
+ for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
+ ait != AlienDependencies.end(); ++ait)
+ {
+ compDepSet.insert(*(*ait));
+ }
+ for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
+ it != Dependencies.end(); ++it)
+ {
+ compDepSet.insert(DependenceStruct((*it)->Name));
+ }
+ // Write dependencies
+ if (!compDepSet.empty())
+ {
+ xout << " <Dependencies>";
+ std::set<DependenceStruct>::iterator it = compDepSet.begin();
+ xout << it->NameWithCompare();
+ ++it;
+ while(it != compDepSet.end())
+ {
+ xout << "," << it->NameWithCompare();
+ ++it;
+ }
+ xout << "</Dependencies>" << std::endl;
+ }
+
+ // Licenses (copy to meta dir)
+ std::vector<std::string> licenses = Licenses;
+ for(size_t i = 1; i < licenses.size(); i += 2)
+ {
+ std::string name = cmSystemTools::GetFilenameName(licenses[i]);
+ std::string path = Directory + "/meta/" + name;
+ cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
+ licenses[i] = name;
+ }
+ if(!licenses.empty())
+ {
+ xout << " <Licenses>" << std::endl;
+ for(size_t i = 0; i < licenses.size(); i += 2)
+ {
+ xout << " <License "
+ << "name=\"" << licenses[i] << "\" "
+ << "file=\"" << licenses[i + 1] << "\" "
+ << "/>" <<std::endl;
+ }
+ xout << " </Licenses>" << std::endl;
+ }
+
+ if (!ForcedInstallation.empty())
+ {
+ xout << " <ForcedInstallation>" << ForcedInstallation
+ << "</ForcedInstallation>" << std::endl;
+ }
+
+ if (!Virtual.empty())
+ {
+ xout << " <Virtual>" << Virtual << "</Virtual>" << std::endl;
+ }
+ else if (!Default.empty())
+ {
+ xout << " <Default>" << Default << "</Default>" << std::endl;
+ }
+
+ // Priority
+ if(!SortingPriority.empty())
+ {
+ xout << " <SortingPriority>" << SortingPriority
+ << "</SortingPriority>" << std::endl;
+ }
+
+ xout << "</Package>" << std::endl;
+}
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h
new file mode 100644
index 0000000000..9fc9bd0006
--- /dev/null
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -0,0 +1,133 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWPackage_h
+#define cmCPackIFWPackage_h
+
+#include <cmStandardIncludes.h>
+
+class cmCPackComponent;
+class cmCPackComponentGroup;
+class cmCPackIFWInstaller;
+class cmCPackIFWGenerator;
+
+/** \class cmCPackIFWPackage
+ * \brief A single component to be installed by CPack IFW generator
+ */
+class cmCPackIFWPackage
+{
+public: // Types
+ enum CompareTypes
+ {
+ CompareNone = 0x0,
+ CompareEqual = 0x1,
+ CompareLess = 0x2,
+ CompareLessOrEqual = 0x3,
+ CompareGreater = 0x4,
+ CompareGreaterOrEqual = 0x5
+ };
+
+ struct CompareStruct
+ {
+ CompareStruct();
+
+ unsigned int Type;
+ std::string Value;
+ };
+
+ struct DependenceStruct
+ {
+ DependenceStruct();
+ DependenceStruct(const std::string &dependence);
+
+ std::string Name;
+ CompareStruct Compare;
+
+ std::string NameWithCompare() const;
+
+ bool operator < (const DependenceStruct &other) const
+ {
+ return Name < other.Name;
+ }
+ };
+
+public: // [Con|De]structor
+
+ /**
+ * Construct package
+ */
+ cmCPackIFWPackage();
+
+public: // Configuration
+
+ /// Human-readable name of the component
+ std::string DisplayName;
+
+ /// Human-readable description of the component
+ std::string Description;
+
+ /// Version number of the component
+ std::string Version;
+
+ /// Date when this component version was released
+ std::string ReleaseDate;
+
+ /// Domain-like identification for this component
+ std::string Name;
+
+ /// File name of a script being loaded
+ std::string Script;
+
+ /// List of license agreements to be accepted by the installing user
+ std::vector<std::string> Licenses;
+
+ /// Priority of the component in the tree
+ std::string SortingPriority;
+
+ /// Set to true to preselect the component in the installer
+ std::string Default;
+
+ /// Set to true to hide the component from the installer
+ std::string Virtual;
+
+ /// Determines that the package must always be installed
+ std::string ForcedInstallation;
+
+public: // Internal implementation
+
+ const char* GetOption(const std::string& op) const;
+ bool IsOn(const std::string& op) const;
+
+ std::string GetComponentName(cmCPackComponent *component);
+
+ void DefaultConfiguration();
+
+ int ConfigureFromOptions();
+ int ConfigureFromComponent(cmCPackComponent *component);
+ int ConfigureFromGroup(cmCPackComponentGroup *group);
+ int ConfigureFromGroup(const std::string &groupName);
+
+ void GeneratePackageFile();
+
+ // Pointer to generator
+ cmCPackIFWGenerator* Generator;
+ // Pointer to installer
+ cmCPackIFWInstaller* Installer;
+ // Collection of dependencies
+ std::set<cmCPackIFWPackage*> Dependencies;
+ // Collection of unresolved dependencies
+ std::set<DependenceStruct*> AlienDependencies;
+ // Patch to package directory
+ std::string Directory;
+};
+
+#endif // cmCPackIFWPackage_h
View Lorry Controller Status