mirror of
https://github.com/reactos/CMake.git
synced 2024-11-29 22:40:25 +00:00
584 lines
17 KiB
C++
584 lines
17 KiB
C++
/*============================================================================
|
|
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 "cmCPackDragNDropGenerator.h"
|
|
#include "cmCPackLog.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
|
|
#include <cmsys/RegularExpression.hxx>
|
|
|
|
static const char* SLAHeader =
|
|
"data 'LPic' (5000) {\n"
|
|
" $\"0002 0011 0003 0001 0000 0000 0002 0000\"\n"
|
|
" $\"0008 0003 0000 0001 0004 0000 0004 0005\"\n"
|
|
" $\"0000 000E 0006 0001 0005 0007 0000 0007\"\n"
|
|
" $\"0008 0000 0047 0009 0000 0034 000A 0001\"\n"
|
|
" $\"0035 000B 0001 0020 000C 0000 0011 000D\"\n"
|
|
" $\"0000 005B 0004 0000 0033 000F 0001 000C\"\n"
|
|
" $\"0010 0000 000B 000E 0000\"\n"
|
|
"};\n"
|
|
"\n";
|
|
|
|
static const char* SLASTREnglish =
|
|
"resource 'STR#' (5002, \"English\") {\n"
|
|
" {\n"
|
|
" \"English\",\n"
|
|
" \"Agree\",\n"
|
|
" \"Disagree\",\n"
|
|
" \"Print\",\n"
|
|
" \"Save...\",\n"
|
|
" \"You agree to the License Agreement terms when you click \"\n"
|
|
" \"the \\\"Agree\\\" button.\",\n"
|
|
" \"Software License Agreement\",\n"
|
|
" \"This text cannot be saved. This disk may be full or locked, "
|
|
"or the \"\n"
|
|
" \"file may be locked.\",\n"
|
|
" \"Unable to print. Make sure you have selected a printer.\"\n"
|
|
" }\n"
|
|
"};\n"
|
|
"\n";
|
|
|
|
//----------------------------------------------------------------------
|
|
cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
|
|
{
|
|
// default to one package file for components
|
|
this->componentPackageMethod = ONE_PACKAGE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
cmCPackDragNDropGenerator::~cmCPackDragNDropGenerator()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int cmCPackDragNDropGenerator::InitializeInternal()
|
|
{
|
|
const std::string hdiutil_path = cmSystemTools::FindProgram("hdiutil",
|
|
std::vector<std::string>(), false);
|
|
if(hdiutil_path.empty())
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Cannot locate hdiutil command"
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
this->SetOptionIfNotSet("CPACK_COMMAND_HDIUTIL", hdiutil_path.c_str());
|
|
|
|
const std::string setfile_path = cmSystemTools::FindProgram("SetFile",
|
|
std::vector<std::string>(1, "/Developer/Tools"), false);
|
|
if(setfile_path.empty())
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Cannot locate SetFile command"
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
this->SetOptionIfNotSet("CPACK_COMMAND_SETFILE", setfile_path.c_str());
|
|
|
|
const std::string rez_path = cmSystemTools::FindProgram("Rez",
|
|
std::vector<std::string>(1, "/Developer/Tools"), false);
|
|
if(rez_path.empty())
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Cannot locate Rez command"
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str());
|
|
|
|
return this->Superclass::InitializeInternal();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const char* cmCPackDragNDropGenerator::GetOutputExtension()
|
|
{
|
|
return ".dmg";
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int cmCPackDragNDropGenerator::PackageFiles()
|
|
{
|
|
// gather which directories to make dmg files for
|
|
// multiple directories occur if packaging components or groups separately
|
|
|
|
// monolith
|
|
if(this->Components.empty())
|
|
{
|
|
return this->CreateDMG(toplevel, packageFileNames[0]);
|
|
}
|
|
|
|
// component install
|
|
std::vector<std::string> package_files;
|
|
|
|
std::map<std::string, cmCPackComponent>::iterator compIt;
|
|
for (compIt=this->Components.begin();
|
|
compIt!=this->Components.end(); ++compIt )
|
|
{
|
|
std::string name = GetComponentInstallDirNameSuffix(compIt->first);
|
|
package_files.push_back(name);
|
|
}
|
|
std::sort(package_files.begin(), package_files.end());
|
|
package_files.erase(std::unique(package_files.begin(),
|
|
package_files.end()),
|
|
package_files.end());
|
|
|
|
|
|
// loop to create dmg files
|
|
packageFileNames.clear();
|
|
for(size_t i=0; i<package_files.size(); i++)
|
|
{
|
|
std::string full_package_name = std::string(toplevel) + std::string("/");
|
|
if(package_files[i] == "ALL_IN_ONE")
|
|
{
|
|
full_package_name += this->GetOption("CPACK_PACKAGE_FILE_NAME");
|
|
}
|
|
else
|
|
{
|
|
full_package_name += package_files[i];
|
|
}
|
|
full_package_name += std::string(GetOutputExtension());
|
|
packageFileNames.push_back(full_package_name);
|
|
|
|
std::string src_dir = toplevel;
|
|
src_dir += "/";
|
|
src_dir += package_files[i];
|
|
|
|
if(0 == this->CreateDMG(src_dir, full_package_name))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool cmCPackDragNDropGenerator::CopyFile(cmOStringStream& source,
|
|
cmOStringStream& target)
|
|
{
|
|
if(!cmSystemTools::CopyFileIfDifferent(
|
|
source.str().c_str(),
|
|
target.str().c_str()))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error copying "
|
|
<< source.str()
|
|
<< " to "
|
|
<< target.str()
|
|
<< std::endl);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool cmCPackDragNDropGenerator::RunCommand(cmOStringStream& command,
|
|
std::string* output)
|
|
{
|
|
int exit_code = 1;
|
|
|
|
bool result = cmSystemTools::RunSingleCommand(
|
|
command.str().c_str(),
|
|
output,
|
|
&exit_code,
|
|
0,
|
|
this->GeneratorVerbose,
|
|
0);
|
|
|
|
if(!result || exit_code)
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error executing: "
|
|
<< command.str()
|
|
<< std::endl);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
|
|
const std::string& output_file)
|
|
{
|
|
// Get optional arguments ...
|
|
const std::string cpack_package_icon = this->GetOption("CPACK_PACKAGE_ICON")
|
|
? this->GetOption("CPACK_PACKAGE_ICON") : "";
|
|
|
|
const std::string cpack_dmg_volume_name =
|
|
this->GetOption("CPACK_DMG_VOLUME_NAME")
|
|
? this->GetOption("CPACK_DMG_VOLUME_NAME")
|
|
: this->GetOption("CPACK_PACKAGE_FILE_NAME");
|
|
|
|
const std::string cpack_dmg_format =
|
|
this->GetOption("CPACK_DMG_FORMAT")
|
|
? this->GetOption("CPACK_DMG_FORMAT") : "UDZO";
|
|
|
|
// Get optional arguments ...
|
|
std::string cpack_license_file =
|
|
this->GetOption("CPACK_RESOURCE_FILE_LICENSE") ?
|
|
this->GetOption("CPACK_RESOURCE_FILE_LICENSE") : "";
|
|
|
|
const std::string cpack_dmg_background_image =
|
|
this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
|
|
? this->GetOption("CPACK_DMG_BACKGROUND_IMAGE") : "";
|
|
|
|
const std::string cpack_dmg_ds_store =
|
|
this->GetOption("CPACK_DMG_DS_STORE")
|
|
? this->GetOption("CPACK_DMG_DS_STORE") : "";
|
|
|
|
// only put license on dmg if is user provided
|
|
if(!cpack_license_file.empty() &&
|
|
cpack_license_file.find("CPack.GenericLicense.txt") != std::string::npos)
|
|
{
|
|
cpack_license_file = "";
|
|
}
|
|
|
|
// The staging directory contains everything that will end-up inside the
|
|
// final disk image ...
|
|
cmOStringStream staging;
|
|
staging << src_dir;
|
|
|
|
// Add a symlink to /Applications so users can drag-and-drop the bundle
|
|
// into it
|
|
cmOStringStream application_link;
|
|
application_link << staging.str() << "/Applications";
|
|
cmSystemTools::CreateSymlink("/Applications",
|
|
application_link.str().c_str());
|
|
|
|
// Optionally add a custom volume icon ...
|
|
if(!cpack_package_icon.empty())
|
|
{
|
|
cmOStringStream package_icon_source;
|
|
package_icon_source << cpack_package_icon;
|
|
|
|
cmOStringStream package_icon_destination;
|
|
package_icon_destination << staging.str() << "/.VolumeIcon.icns";
|
|
|
|
if(!this->CopyFile(package_icon_source, package_icon_destination))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error copying disk volume icon. "
|
|
"Check the value of CPACK_PACKAGE_ICON."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Optionally add a custom .DS_Store file
|
|
// (e.g. for setting background/layout) ...
|
|
if(!cpack_dmg_ds_store.empty())
|
|
{
|
|
cmOStringStream package_settings_source;
|
|
package_settings_source << cpack_dmg_ds_store;
|
|
|
|
cmOStringStream package_settings_destination;
|
|
package_settings_destination << staging.str() << "/.DS_Store";
|
|
|
|
if(!this->CopyFile(package_settings_source, package_settings_destination))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error copying disk volume settings file. "
|
|
"Check the value of CPACK_DMG_DS_STORE."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Optionally add a custom background image ...
|
|
if(!cpack_dmg_background_image.empty())
|
|
{
|
|
cmOStringStream package_background_source;
|
|
package_background_source << cpack_dmg_background_image;
|
|
|
|
cmOStringStream package_background_destination;
|
|
package_background_destination << staging.str() << "/background.png";
|
|
|
|
if(!this->CopyFile(package_background_source,
|
|
package_background_destination))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error copying disk volume background image. "
|
|
"Check the value of CPACK_DMG_BACKGROUND_IMAGE."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
cmOStringStream temp_background_hiding_command;
|
|
temp_background_hiding_command << this->GetOption("CPACK_COMMAND_SETFILE");
|
|
temp_background_hiding_command << " -a V \"";
|
|
temp_background_hiding_command << package_background_destination.str();
|
|
temp_background_hiding_command << "\"";
|
|
|
|
if(!this->RunCommand(temp_background_hiding_command))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error setting attributes on disk volume background image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Create a temporary read-write disk image ...
|
|
std::string temp_image = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
|
temp_image += "/temp.dmg";
|
|
|
|
cmOStringStream temp_image_command;
|
|
temp_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
temp_image_command << " create";
|
|
temp_image_command << " -ov";
|
|
temp_image_command << " -srcfolder \"" << staging.str() << "\"";
|
|
temp_image_command << " -volname \""
|
|
<< cpack_dmg_volume_name << "\"";
|
|
temp_image_command << " -format UDRW";
|
|
temp_image_command << " \"" << temp_image << "\"";
|
|
|
|
if(!this->RunCommand(temp_image_command))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error generating temporary disk image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Optionally set the custom icon flag for the image ...
|
|
if(!cpack_package_icon.empty())
|
|
{
|
|
cmOStringStream temp_mount;
|
|
|
|
cmOStringStream attach_command;
|
|
attach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
attach_command << " attach";
|
|
attach_command << " \"" << temp_image << "\"";
|
|
|
|
std::string attach_output;
|
|
if(!this->RunCommand(attach_command, &attach_output))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error attaching temporary disk image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
cmsys::RegularExpression mountpoint_regex(".*(/Volumes/[^\n]+)\n.*");
|
|
mountpoint_regex.find(attach_output.c_str());
|
|
temp_mount << mountpoint_regex.match(1);
|
|
|
|
cmOStringStream setfile_command;
|
|
setfile_command << this->GetOption("CPACK_COMMAND_SETFILE");
|
|
setfile_command << " -a C";
|
|
setfile_command << " \"" << temp_mount.str() << "\"";
|
|
|
|
if(!this->RunCommand(setfile_command))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error assigning custom icon to temporary disk image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
cmOStringStream detach_command;
|
|
detach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
detach_command << " detach";
|
|
detach_command << " \"" << temp_mount.str() << "\"";
|
|
|
|
if(!this->RunCommand(detach_command))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error detaching temporary disk image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if(!cpack_license_file.empty())
|
|
{
|
|
std::string sla_r = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
|
sla_r += "/sla.r";
|
|
|
|
std::ifstream ifs;
|
|
ifs.open(cpack_license_file.c_str());
|
|
if(ifs.is_open())
|
|
{
|
|
cmGeneratedFileStream osf(sla_r.c_str());
|
|
osf << SLAHeader;
|
|
osf << "\n";
|
|
osf << "data 'TEXT' (5002, \"English\") {\n";
|
|
while(ifs.good())
|
|
{
|
|
std::string line;
|
|
std::getline(ifs, line);
|
|
// escape quotes
|
|
std::string::size_type pos = line.find('\"');
|
|
while(pos != std::string::npos)
|
|
{
|
|
line.replace(pos, 1, "\\\"");
|
|
pos = line.find('\"', pos+2);
|
|
}
|
|
osf << " \"" << line << "\\n\"\n";
|
|
}
|
|
osf << "};\n";
|
|
osf << "\n";
|
|
osf << SLASTREnglish;
|
|
ifs.close();
|
|
osf.close();
|
|
}
|
|
|
|
// convert to UDCO
|
|
std::string temp_udco = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
|
temp_udco += "/temp-udco.dmg";
|
|
|
|
cmOStringStream udco_image_command;
|
|
udco_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
udco_image_command << " convert \"" << temp_image << "\"";
|
|
udco_image_command << " -format UDCO";
|
|
udco_image_command << " -o \"" << temp_udco << "\"";
|
|
|
|
std::string error;
|
|
if(!this->RunCommand(udco_image_command, &error))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error converting to UDCO dmg for adding SLA." << std::endl
|
|
<< error
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
|
|
// unflatten dmg
|
|
cmOStringStream unflatten_command;
|
|
unflatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
unflatten_command << " unflatten ";
|
|
unflatten_command << "\"" << temp_udco << "\"";
|
|
|
|
if(!this->RunCommand(unflatten_command, &error))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error unflattening dmg for adding SLA." << std::endl
|
|
<< error
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
|
|
// Rez the SLA
|
|
cmOStringStream embed_sla_command;
|
|
embed_sla_command << "/bin/bash -c \""; // need expansion of "*.r"
|
|
embed_sla_command << this->GetOption("CPACK_COMMAND_REZ");
|
|
embed_sla_command << " /Developer/Headers/FlatCarbon/*.r ";
|
|
embed_sla_command << "'" << sla_r << "'";
|
|
embed_sla_command << " -a -o ";
|
|
embed_sla_command << "'" << temp_udco << "'\"";
|
|
|
|
if(!this->RunCommand(embed_sla_command, &error))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error adding SLA." << std::endl
|
|
<< error
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
|
|
// flatten dmg
|
|
cmOStringStream flatten_command;
|
|
flatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
flatten_command << " flatten ";
|
|
flatten_command << "\"" << temp_udco << "\"";
|
|
|
|
if(!this->RunCommand(flatten_command, &error))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error flattening dmg for adding SLA." << std::endl
|
|
<< error
|
|
<< std::endl);
|
|
return 0;
|
|
}
|
|
|
|
temp_image = temp_udco;
|
|
}
|
|
|
|
|
|
// Create the final compressed read-only disk image ...
|
|
cmOStringStream final_image_command;
|
|
final_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
|
|
final_image_command << " convert \"" << temp_image << "\"";
|
|
final_image_command << " -format ";
|
|
final_image_command << cpack_dmg_format;
|
|
final_image_command << " -imagekey";
|
|
final_image_command << " zlib-level=9";
|
|
final_image_command << " -o \"" << output_file << "\"";
|
|
|
|
if(!this->RunCommand(final_image_command))
|
|
{
|
|
cmCPackLogger(cmCPackLog::LOG_ERROR,
|
|
"Error compressing disk image."
|
|
<< std::endl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool cmCPackDragNDropGenerator::SupportsComponentInstallation() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
std::string
|
|
cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
|
|
const std::string& componentName)
|
|
{
|
|
// we want to group components together that go in the same dmg package
|
|
std::string package_file_name = this->GetOption("CPACK_PACKAGE_FILE_NAME");
|
|
|
|
// we have 3 mutually exclusive modes to work in
|
|
// 1. all components in one package
|
|
// 2. each group goes in its own package with left over
|
|
// components in their own package
|
|
// 3. ignore groups - if grouping is defined, it is ignored
|
|
// and each component goes in its own package
|
|
|
|
if(this->componentPackageMethod == ONE_PACKAGE)
|
|
{
|
|
return "ALL_IN_ONE";
|
|
}
|
|
|
|
if(this->componentPackageMethod == ONE_PACKAGE_PER_GROUP)
|
|
{
|
|
// We have to find the name of the COMPONENT GROUP
|
|
// the current COMPONENT belongs to.
|
|
std::string groupVar = "CPACK_COMPONENT_" +
|
|
cmSystemTools::UpperCase(componentName) + "_GROUP";
|
|
const char* _groupName = GetOption(groupVar.c_str());
|
|
if (_groupName)
|
|
{
|
|
std::string groupName = _groupName;
|
|
|
|
groupName = GetComponentPackageFileName(package_file_name,
|
|
groupName, true);
|
|
return groupName;
|
|
}
|
|
}
|
|
|
|
return GetComponentPackageFileName(package_file_name, componentName, false);
|
|
}
|