CMake/Source/CPack/cmCPackDragNDropGenerator.cxx

/*============================================================================
  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>
#include <cmsys/FStream.hxx>

#include <iomanip>

#include <CoreFoundation/CoreFoundation.h>

#ifdef HAVE_CoreServices
// For the old LocaleStringToLangAndRegionCodes() function, to convert
// to the old Script Manager RegionCode values needed for the 'LPic' data
// structure used for generating multi-lingual SLAs.
#include <CoreServices/CoreServices.h>
#endif

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()
  : singleLicense(false)
{
  // default to one package file for components
  this->componentPackageMethod = ONE_PACKAGE;
}

//----------------------------------------------------------------------
cmCPackDragNDropGenerator::~cmCPackDragNDropGenerator()
{
}

//----------------------------------------------------------------------
int cmCPackDragNDropGenerator::InitializeInternal()
{
  // Starting with Xcode 4.3, look in "/Applications/Xcode.app" first:
  //
  std::vector<std::string> paths;
  paths.push_back("/Applications/Xcode.app/Contents/Developer/Tools");
  paths.push_back("/Developer/Tools");

  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",
    paths, 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",
    paths, 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());

  if(this->IsSet("CPACK_DMG_SLA_DIR"))
    {
    slaDirectory = this->GetOption("CPACK_DMG_SLA_DIR");
    if(!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE"))
      {
      std::string license_file =
        this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
      if(!license_file.empty() &&
         (license_file.find("CPack.GenericLicense.txt") == std::string::npos))
        {
        cmCPackLogger(cmCPackLog::LOG_OUTPUT,
          "Both CPACK_DMG_SLA_DIR and CPACK_RESOURCE_FILE_LICENSE specified, "
          "using CPACK_RESOURCE_FILE_LICENSE as a license for all languages."
          << std::endl);
        singleLicense = true;
        }
      }
    if(!this->IsSet("CPACK_DMG_SLA_LANGUAGES"))
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "CPACK_DMG_SLA_DIR set but no languages defined "
        "(set CPACK_DMG_SLA_LANGUAGES)"
        << std::endl);
      return 0;
      }
    if(!cmSystemTools::FileExists(slaDirectory, false))
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "CPACK_DMG_SLA_DIR does not exist"
        << std::endl);
      return 0;
      }

    std::vector<std::string> languages;
    cmSystemTools::ExpandListArgument(
      this->GetOption("CPACK_DMG_SLA_LANGUAGES"), languages);
    if(languages.empty())
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "CPACK_DMG_SLA_LANGUAGES set but empty"
        << std::endl);
      return 0;
      }
    for(size_t i = 0; i < languages.size(); ++i)
      {
      std::string license = slaDirectory + "/" + languages[i] + ".license.txt";
      if (!singleLicense && !cmSystemTools::FileExists(license))
        {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
          "Missing license file " << languages[i] << ".license.txt"
          << std::endl);
        return 0;
        }
      std::string menu = slaDirectory + "/" + languages[i] + ".menu.txt";
      if (!cmSystemTools::FileExists(menu))
        {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
          "Missing menu file " << languages[i] << ".menu.txt"
          << std::endl);
        return 0;
        }
      }
    }

  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(std::ostringstream& source,
  std::ostringstream& 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::CreateEmptyFile(std::ostringstream& target,
                                                size_t size)
{
  cmsys::ofstream fout(target.str().c_str(),
                       std::ios::out | std::ios::binary);
  if(!fout)
    {
    return false;
    }
  else
    {
    // Seek to desired size - 1 byte
    fout.seekp(size - 1, std::ios_base::beg);
    char byte = 0;
    // Write one byte to ensure file grows
    fout.write(&byte, 1);
    }

  return true;
}

//----------------------------------------------------------------------
bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
  std::string* output)
{
  int exit_code = 1;

  bool result = cmSystemTools::RunSingleCommand(
    command.str().c_str(),
    output, 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") : "";

  const std::string cpack_dmg_languages =
    this->GetOption("CPACK_DMG_SLA_LANGUAGES")
      ? this->GetOption("CPACK_DMG_SLA_LANGUAGES") : "";

  const std::string cpack_dmg_ds_store_setup_script =
    this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
    ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT") : "";

  // 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 = "";
    }

  // use sla_dir if both sla_dir and license_file are set
  if(!cpack_license_file.empty() &&
     !slaDirectory.empty() && !singleLicense)
    {
    cpack_license_file = "";
    }

  // The staging directory contains everything that will end-up inside the
  // final disk image ...
  std::ostringstream staging;
  staging << src_dir;

  // Add a symlink to /Applications so users can drag-and-drop the bundle
  // into it
  std::ostringstream 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())
    {
    std::ostringstream package_icon_source;
    package_icon_source << cpack_package_icon;

    std::ostringstream 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())
    {
    std::ostringstream package_settings_source;
    package_settings_source << cpack_dmg_ds_store;

    std::ostringstream 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 ...
  // Make sure the background file type is the same as the custom image
  // and that the file is hidden so it doesn't show up.
  if(!cpack_dmg_background_image.empty())
    {
    const std::string extension =
        cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image);
    std::ostringstream package_background_source;
    package_background_source << cpack_dmg_background_image;

    std::ostringstream package_background_destination;
    package_background_destination << staging.str()
                                   << "/.background/background" << extension;

    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;
      }
    }

  bool remount_image = !cpack_package_icon.empty() ||
                       !cpack_dmg_ds_store_setup_script.empty();

  // Create 1 MB dummy padding file in staging area when we need to remount
  // image, so we have enough space for storing changes ...
  if(remount_image)
    {
    std::ostringstream dummy_padding;
    dummy_padding << staging.str() << "/.dummy-padding-file";
    if(!this->CreateEmptyFile(dummy_padding, 1048576))
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "Error creating dummy padding file."
        << std::endl);

      return 0;
      }
    }

  // Create a temporary read-write disk image ...
  std::string temp_image = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
  temp_image += "/temp.dmg";

  std::ostringstream 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;
    }

  if(remount_image)
    {
    // Store that we have a failure so that we always unmount the image
    // before we exit.
    bool had_error = false;

    std::ostringstream 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());
    std::ostringstream temp_mount;
    temp_mount << mountpoint_regex.match(1);

    // Remove dummy padding file so we have enough space on RW image ...
    std::ostringstream dummy_padding;
    dummy_padding << temp_mount.str() << "/.dummy-padding-file";
    if(!cmSystemTools::RemoveFile(dummy_padding.str()))
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "Error removing dummy padding file."
        << std::endl);

      had_error = true;
      }

    // Optionally set the custom icon flag for the image ...
    if(!had_error && !cpack_package_icon.empty())
      {
      std::ostringstream 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);

        had_error = true;
        }
      }

    // Optionally we can execute a custom apple script to generate
    // the .DS_Store for the volume folder ...
    if(!had_error && !cpack_dmg_ds_store_setup_script.empty())
      {
      std::ostringstream setup_script_command;
      setup_script_command << "osascript"
                           << " \"" << cpack_dmg_ds_store_setup_script << "\""
                           << " \"" << cpack_dmg_volume_name << "\"";
      std::string error;
      if(!this->RunCommand(setup_script_command, &error))
        {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
          "Error executing custom script on disk image." << std::endl
          << error
          << std::endl);

        had_error = true;
        }
      }

    std::ostringstream 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(had_error)
      {
      return 0;
      }
    }

  if(!cpack_license_file.empty() || !slaDirectory.empty())
    {
    // Use old hardcoded style if sla_dir is not set
    bool oldStyle = slaDirectory.empty();
    std::string sla_r = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
    sla_r += "/sla.r";

    std::vector<std::string> languages;
    if(!oldStyle)
      {
      cmSystemTools::ExpandListArgument(cpack_dmg_languages, languages);
      }

    cmGeneratedFileStream ofs(sla_r.c_str());
    ofs << "#include <CoreServices/CoreServices.r>\n\n";
    if(oldStyle)
      {
      ofs << SLAHeader;
      ofs << "\n";
      }
    else
      {
      /*
       * LPic Layout
       * (https://github.com/pypt/dmg-add-license/blob/master/main.c)
       * as far as I can tell (no official documentation seems to exist):
       * struct LPic {
       *  uint16_t default_language; // points to a resid, defaulting to 0,
       *                             // which is the first set language
       *  uint16_t length;
       *  struct {
       *    uint16_t language_code;
       *    uint16_t resid;
       *    uint16_t encoding; // Encoding from TextCommon.h,
       *                       // forcing MacRoman (0) for now. Might need to
       *                       // allow overwrite per license by user later
       *  } item[1];
       * }
       */

      // Create vector first for readability, then iterate to write to ofs
      std::vector<uint16_t> header_data;
      header_data.push_back(0);
      header_data.push_back(languages.size());
      for(size_t i = 0; i < languages.size(); ++i)
        {
        CFStringRef language_cfstring = CFStringCreateWithCString(
          NULL, languages[i].c_str(), kCFStringEncodingUTF8);
        CFStringRef iso_language =
          CFLocaleCreateCanonicalLanguageIdentifierFromString(
            NULL, language_cfstring);
        if (!iso_language)
          {
          cmCPackLogger(cmCPackLog::LOG_ERROR,
            languages[i] << " is not a recognized language"
            << std::endl);
          }
        char *iso_language_cstr = (char *) malloc(65);
        CFStringGetCString(iso_language, iso_language_cstr, 64,
                           kCFStringEncodingMacRoman);
        LangCode lang = 0;
        RegionCode region = 0;
#ifdef HAVE_CoreServices
        OSStatus err = LocaleStringToLangAndRegionCodes(iso_language_cstr,
                                                        &lang, &region);
        if (err != noErr)
#endif
          {
          cmCPackLogger(cmCPackLog::LOG_ERROR,
            "No language/region code available for " << iso_language_cstr
            << std::endl);
          free(iso_language_cstr);
          return 0;
          }
#ifdef HAVE_CoreServices
        free(iso_language_cstr);
        header_data.push_back(region);
        header_data.push_back(i);
        header_data.push_back(0);
#endif
        }
      ofs << "data 'LPic' (5000) {\n";
      ofs << std::hex << std::uppercase << std::setfill('0');

      for(size_t i = 0; i < header_data.size(); ++i)
        {
        if(i % 8 == 0)
          {
          ofs << "    $\"";
          }

        ofs << std::setw(4) << header_data[i];

        if(i % 8 == 7 || i == header_data.size() - 1)
          {
          ofs << "\"\n";
          }
        else
          {
          ofs << " ";
          }
        }
      ofs << "};\n\n";
      // Reset ofs options
      ofs << std::dec << std::nouppercase << std::setfill(' ');
      }

    bool have_write_license_error = false;
    std::string error;

    if(oldStyle)
      {
      if(!this->WriteLicense(ofs, 0, "", cpack_license_file, &error))
        {
        have_write_license_error = true;
        }
      }
    else
      {
      for(size_t i = 0; i < languages.size() && !have_write_license_error; ++i)
        {
        if(singleLicense)
          {
          if(!this->WriteLicense(ofs, i + 5000, languages[i],
                                 cpack_license_file, &error))
            {
            have_write_license_error = true;
            }
          }
        else
          {
          if(!this->WriteLicense(ofs, i + 5000, languages[i], "", &error))
            {
            have_write_license_error = true;
            }
          }
        }
      }

    ofs.Close();

    if(have_write_license_error)
      {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
        "Error writing license file to SLA." << std::endl
        << error
        << std::endl);
      return 0;
      }

    // convert to UDCO
    std::string temp_udco = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
    temp_udco += "/temp-udco.dmg";

    std::ostringstream 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 << " -ov -o \"" << temp_udco << "\"";

    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
    std::ostringstream 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
    std::ostringstream embed_sla_command;
    embed_sla_command << this->GetOption("CPACK_COMMAND_REZ");
    const char* sysroot = this->GetOption("CPACK_OSX_SYSROOT");
    if(sysroot && sysroot[0] != '\0')
      {
      embed_sla_command << " -isysroot \"" << sysroot << "\"";
      }
    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
    std::ostringstream 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 ...
  std::ostringstream 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);
}

bool
cmCPackDragNDropGenerator::WriteLicense(cmGeneratedFileStream& outputStream,
  int licenseNumber, std::string licenseLanguage, std::string licenseFile,
  std::string *error)
{
  if(!licenseFile.empty() && !singleLicense)
    {
    licenseNumber = 5002;
    licenseLanguage = "English";
    }

  // License header
  outputStream << "data 'TEXT' (" << licenseNumber << ", \""
    << licenseLanguage << "\") {\n";
  // License body
  std::string actual_license = !licenseFile.empty() ? licenseFile :
    (slaDirectory + "/" + licenseLanguage + ".license.txt");
  cmsys::ifstream license_ifs;
  license_ifs.open(actual_license.c_str());
  if(license_ifs.is_open())
    {
    while(license_ifs.good())
      {
      std::string line;
      std::getline(license_ifs, line);
      if(!line.empty())
        {
        EscapeQuotesAndBackslashes(line);
        std::vector<std::string> lines;
        if(!this->BreakLongLine(line, lines, error))
          {
          return false;
          }
        for(size_t i = 0; i < lines.size(); ++i)
          {
          outputStream << "        \"" << lines[i] << "\"\n";
          }
        }
      outputStream << "        \"\\n\"\n";
      }
    license_ifs.close();
    }

  // End of License
  outputStream << "};\n\n";
  if(!licenseFile.empty() && !singleLicense)
    {
    outputStream << SLASTREnglish;
    }
  else
    {
    // Menu header
    outputStream << "resource 'STR#' (" << licenseNumber << ", \""
      << licenseLanguage << "\") {\n";
    outputStream << "    {\n";

    // Menu body
    cmsys::ifstream menu_ifs;
    menu_ifs.open((slaDirectory+"/"+licenseLanguage+".menu.txt").c_str());
    if(menu_ifs.is_open())
      {
      size_t lines_written = 0;
      while(menu_ifs.good())
        {
        // Lines written from original file, not from broken up lines
        std::string line;
        std::getline(menu_ifs, line);
        if(!line.empty())
          {
          EscapeQuotesAndBackslashes(line);
          std::vector<std::string> lines;
          if(!this->BreakLongLine(line, lines, error))
            {
            return false;
            }
          for(size_t i = 0; i < lines.size(); ++i)
            {
            std::string comma;
            // We need a comma after every complete string,
            // but not on the very last line
            if(lines_written != 8 && i == lines.size() - 1)
              {
              comma = ",";
              }
            else
              {
              comma = "";
              }
            outputStream << "        \"" << lines[i] << "\"" << comma << "\n";
            }
          ++lines_written;
          }
        }
      menu_ifs.close();
      }

    //End of menu
    outputStream << "    }\n";
    outputStream << "};\n";
    outputStream << "\n";
    }

  return true;
}

bool
cmCPackDragNDropGenerator::BreakLongLine(const std::string& line,
  std::vector<std::string>& lines, std::string *error)
{
  const size_t max_line_length = 512;
  for(size_t i = 0; i < line.size(); i += max_line_length)
    {
    size_t line_length = max_line_length;
    if(i + line_length > line.size())
      {
      line_length = line.size() - i;
      }
    else while(line_length > 0 && line[i + line_length - 1] != ' ')
      {
      line_length = line_length - 1;
      }

    if(line_length == 0)
      {
      *error = "Please make sure there are no words "
               "(or character sequences not broken up by spaces or newlines) "
               "in your license file which are more than 512 characters long.";
      return false;
      }
    lines.push_back(line.substr(i, line_length));
    }
  return true;
}

void
cmCPackDragNDropGenerator::EscapeQuotesAndBackslashes(std::string& line)
{
  std::string::size_type backslash_pos = line.find('\\');
  while(backslash_pos != std::string::npos)
    {
    line.replace(backslash_pos, 1, "\\\\");
    backslash_pos = line.find('\\', backslash_pos + 2);
    }

  std::string::size_type quote_pos = line.find('\"');
  while(quote_pos != std::string::npos)
    {
    line.replace(quote_pos, 1, "\\\"");
    quote_pos = line.find('\"', quote_pos + 2);
    }
}