cmCPackDragNDropGenerator.cxx 29.9 KB
Newer Older
1
2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
3
#include "cmCPackDragNDropGenerator.h"
Brad King's avatar
Brad King committed
4

Daniel Pfeifer's avatar
Daniel Pfeifer committed
5
#include "cmCPackGenerator.h"
6
#include "cmCPackLog.h"
7
#include "cmGeneratedFileStream.h"
8
#include "cmSystemTools.h"
9

10
11
#include "cmsys/FStream.hxx"
#include "cmsys/RegularExpression.hxx"
12
#include <algorithm>
13
#include <iomanip>
Daniel Pfeifer's avatar
Daniel Pfeifer committed
14
15
#include <map>
#include <stdlib.h>
16

17
18
#include <CoreFoundation/CoreFoundation.h>

19
#ifdef HAVE_CoreServices
20
21
22
23
// 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>
24
#endif
25

26
static const char* SLAHeader =
27
28
29
30
31
32
33
34
35
36
  "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";
37

38
static const char* SLASTREnglish =
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
  "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";
56

57
cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
58
  : singleLicense(false)
59
{
60
61
  // default to one package file for components
  this->componentPackageMethod = ONE_PACKAGE;
62
63
64
65
66
67
68
69
}

cmCPackDragNDropGenerator::~cmCPackDragNDropGenerator()
{
}

int cmCPackDragNDropGenerator::InitializeInternal()
{
70
71
72
73
74
75
  // 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");

76
77
78
79
80
  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);
81
    return 0;
82
  }
83
84
  this->SetOptionIfNotSet("CPACK_COMMAND_HDIUTIL", hdiutil_path.c_str());

85
86
87
88
89
  const std::string setfile_path =
    cmSystemTools::FindProgram("SetFile", paths, false);
  if (setfile_path.empty()) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate SetFile command"
                    << std::endl);
90
    return 0;
91
  }
92
  this->SetOptionIfNotSet("CPACK_COMMAND_SETFILE", setfile_path.c_str());
93

94
95
96
97
  const std::string rez_path = cmSystemTools::FindProgram("Rez", paths, false);
  if (rez_path.empty()) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate Rez command"
                    << std::endl);
98
    return 0;
99
  }
100
  this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str());
101

102
  if (this->IsSet("CPACK_DMG_SLA_DIR")) {
103
    slaDirectory = this->GetOption("CPACK_DMG_SLA_DIR");
104
    if (!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE")) {
105
106
      std::string license_file =
        this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
107
108
109
110
111
      if (!license_file.empty() &&
          (license_file.find("CPack.GenericLicense.txt") ==
           std::string::npos)) {
        cmCPackLogger(
          cmCPackLog::LOG_OUTPUT,
112
          "Both CPACK_DMG_SLA_DIR and CPACK_RESOURCE_FILE_LICENSE specified, "
113
          "using CPACK_RESOURCE_FILE_LICENSE as a license for all languages."
114
            << std::endl);
115
        singleLicense = true;
116
      }
117
118
    }
    if (!this->IsSet("CPACK_DMG_SLA_LANGUAGES")) {
119
      cmCPackLogger(cmCPackLog::LOG_ERROR,
120
121
122
                    "CPACK_DMG_SLA_DIR set but no languages defined "
                    "(set CPACK_DMG_SLA_LANGUAGES)"
                      << std::endl);
123
      return 0;
124
125
126
127
    }
    if (!cmSystemTools::FileExists(slaDirectory, false)) {
      cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_DMG_SLA_DIR does not exist"
                      << std::endl);
128
      return 0;
129
    }
130
131

    std::vector<std::string> languages;
132
133
    cmSystemTools::ExpandListArgument(
      this->GetOption("CPACK_DMG_SLA_LANGUAGES"), languages);
134
    if (languages.empty()) {
135
      cmCPackLogger(cmCPackLog::LOG_ERROR,
136
                    "CPACK_DMG_SLA_LANGUAGES set but empty" << std::endl);
137
      return 0;
138
    }
139
140
    for (auto const& language : languages) {
      std::string license = slaDirectory + "/" + language + ".license.txt";
141
142
      if (!singleLicense && !cmSystemTools::FileExists(license)) {
        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing license file "
143
                        << language << ".license.txt" << std::endl);
144
        return 0;
145
      }
146
      std::string menu = slaDirectory + "/" + language + ".menu.txt";
147
148
      if (!cmSystemTools::FileExists(menu)) {
        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing menu file "
149
                        << language << ".menu.txt" << std::endl);
150
151
152
        return 0;
      }
    }
153
  }
154

155
156
157
158
159
160
161
162
  return this->Superclass::InitializeInternal();
}

const char* cmCPackDragNDropGenerator::GetOutputExtension()
{
  return ".dmg";
}

163
int cmCPackDragNDropGenerator::PackageFiles()
164
{
165
166
  // gather which directories to make dmg files for
  // multiple directories occur if packaging components or groups separately
167

168
  // monolith
169
  if (this->Components.empty()) {
170
    return this->CreateDMG(toplevel, packageFileNames[0]);
171
  }
172
173
174
175
176

  // component install
  std::vector<std::string> package_files;

  std::map<std::string, cmCPackComponent>::iterator compIt;
177
178
  for (compIt = this->Components.begin(); compIt != this->Components.end();
       ++compIt) {
179
180
    std::string name = GetComponentInstallDirNameSuffix(compIt->first);
    package_files.push_back(name);
181
  }
182
  std::sort(package_files.begin(), package_files.end());
183
  package_files.erase(std::unique(package_files.begin(), package_files.end()),
Eric Noulard's avatar
Eric Noulard committed
184
                      package_files.end());
185
186
187

  // loop to create dmg files
  packageFileNames.clear();
188
  for (auto const& package_file : package_files) {
189
    std::string full_package_name = std::string(toplevel) + std::string("/");
190
    if (package_file == "ALL_IN_ONE") {
191
      full_package_name += this->GetOption("CPACK_PACKAGE_FILE_NAME");
192
    } else {
193
      full_package_name += package_file;
194
    }
195
196
197
198
199
    full_package_name += std::string(GetOutputExtension());
    packageFileNames.push_back(full_package_name);

    std::string src_dir = toplevel;
    src_dir += "/";
200
    src_dir += package_file;
201

202
    if (0 == this->CreateDMG(src_dir, full_package_name)) {
203
204
      return 0;
    }
205
  }
206
  return 1;
207
208
}

209
bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
210
                                         std::ostringstream& target)
211
{
212
213
214
215
  if (!cmSystemTools::CopyFileIfDifferent(source.str().c_str(),
                                          target.str().c_str())) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error copying "
                    << source.str() << " to " << target.str() << std::endl);
216
217

    return false;
218
  }
219
220
221
222

  return true;
}

223
224
225
bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target,
                                                size_t size)
{
226
227
  cmsys::ofstream fout(target.str().c_str(), std::ios::out | std::ios::binary);
  if (!fout) {
228
    return false;
229
  }
230

231
232
233
234
235
236
  // Seek to desired size - 1 byte
  fout.seekp(size - 1, std::ios::beg);
  char byte = 0;
  // Write one byte to ensure file grows
  fout.write(&byte, 1);

237
238
239
  return true;
}

240
bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
241
                                           std::string* output)
242
243
244
{
  int exit_code = 1;

Matthias Männich's avatar
Matthias Männich committed
245
246
247
  bool result = cmSystemTools::RunSingleCommand(command.str().c_str(), output,
                                                output, &exit_code, nullptr,
                                                this->GeneratorVerbose, 0);
248

249
250
251
  if (!result || exit_code) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error executing: " << command.str()
                                                             << std::endl);
252
253

    return false;
254
  }
255
256
257

  return true;
}
258

Eric Noulard's avatar
Eric Noulard committed
259
260
int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
                                         const std::string& output_file)
261
{
262
  // Get optional arguments ...
Eric Noulard's avatar
Eric Noulard committed
263
  const std::string cpack_package_icon = this->GetOption("CPACK_PACKAGE_ICON")
264
265
    ? this->GetOption("CPACK_PACKAGE_ICON")
    : "";
266

267
268
269
  const std::string cpack_dmg_volume_name =
    this->GetOption("CPACK_DMG_VOLUME_NAME")
    ? this->GetOption("CPACK_DMG_VOLUME_NAME")
270
    : this->GetOption("CPACK_PACKAGE_FILE_NAME");
271

272
273
274
  const std::string cpack_dmg_format = this->GetOption("CPACK_DMG_FORMAT")
    ? this->GetOption("CPACK_DMG_FORMAT")
    : "UDZO";
275

276
  // Get optional arguments ...
277
  std::string cpack_license_file =
278
279
280
    this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
    ? this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
    : "";
281
282
283

  const std::string cpack_dmg_background_image =
    this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
284
285
    ? this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
    : "";
286

287
288
289
  const std::string cpack_dmg_ds_store = this->GetOption("CPACK_DMG_DS_STORE")
    ? this->GetOption("CPACK_DMG_DS_STORE")
    : "";
290

291
  const std::string cpack_dmg_languages =
292
    this->GetOption("CPACK_DMG_SLA_LANGUAGES")
293
294
    ? this->GetOption("CPACK_DMG_SLA_LANGUAGES")
    : "";
295

296
297
  const std::string cpack_dmg_ds_store_setup_script =
    this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
298
299
    ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
    : "";
300

301
302
303
  const bool cpack_dmg_disable_applications_symlink =
    this->IsOn("CPACK_DMG_DISABLE_APPLICATIONS_SYMLINK");

304
  // only put license on dmg if is user provided
305
306
307
  if (!cpack_license_file.empty() &&
      cpack_license_file.find("CPack.GenericLicense.txt") !=
        std::string::npos) {
308
    cpack_license_file = "";
309
  }
310
311

  // use sla_dir if both sla_dir and license_file are set
312
  if (!cpack_license_file.empty() && !slaDirectory.empty() && !singleLicense) {
313
    cpack_license_file = "";
314
  }
315
316
317

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

  // Add a symlink to /Applications so users can drag-and-drop the bundle
322
323
324
325
  // into it unless this behaviour was disabled
  if (!cpack_dmg_disable_applications_symlink) {
    std::ostringstream application_link;
    application_link << staging.str() << "/Applications";
326
    cmSystemTools::CreateSymlink("/Applications", application_link.str());
327
  }
328
329

  // Optionally add a custom volume icon ...
330
  if (!cpack_package_icon.empty()) {
331
    std::ostringstream package_icon_source;
332
333
    package_icon_source << cpack_package_icon;

334
    std::ostringstream package_icon_destination;
335
336
    package_icon_destination << staging.str() << "/.VolumeIcon.icns";

337
    if (!this->CopyFile(package_icon_source, package_icon_destination)) {
338
      cmCPackLogger(cmCPackLog::LOG_ERROR,
339
                    "Error copying disk volume icon.  "
340
                    "Check the value of CPACK_PACKAGE_ICON."
341
                      << std::endl);
342
343
344

      return 0;
    }
345
  }
346

347
348
  // Optionally add a custom .DS_Store file
  // (e.g. for setting background/layout) ...
349
  if (!cpack_dmg_ds_store.empty()) {
350
    std::ostringstream package_settings_source;
351
352
    package_settings_source << cpack_dmg_ds_store;

353
    std::ostringstream package_settings_destination;
354
355
    package_settings_destination << staging.str() << "/.DS_Store";

356
357
    if (!this->CopyFile(package_settings_source,
                        package_settings_destination)) {
358
      cmCPackLogger(cmCPackLog::LOG_ERROR,
359
                    "Error copying disk volume settings file.  "
360
                    "Check the value of CPACK_DMG_DS_STORE."
361
                      << std::endl);
362
363
364

      return 0;
    }
365
  }
366
367

  // Optionally add a custom background image ...
368
  // Make sure the background file type is the same as the custom image
369
  // and that the file is hidden so it doesn't show up.
370
  if (!cpack_dmg_background_image.empty()) {
371
    const std::string extension =
372
      cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image);
373
    std::ostringstream package_background_source;
374
375
    package_background_source << cpack_dmg_background_image;

376
    std::ostringstream package_background_destination;
377
    package_background_destination << staging.str()
378
                                   << "/.background/background" << extension;
379

380
381
    if (!this->CopyFile(package_background_source,
                        package_background_destination)) {
382
      cmCPackLogger(cmCPackLog::LOG_ERROR,
383
                    "Error copying disk volume background image.  "
384
                    "Check the value of CPACK_DMG_BACKGROUND_IMAGE."
385
                      << std::endl);
386
387
388

      return 0;
    }
389
  }
390

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

394
395
  std::string temp_image_format = "UDZO";

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

      return 0;
    }
407
    temp_image_format = "UDRW";
408
  }
409

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

414
  std::ostringstream temp_image_command;
415
416
417
418
  temp_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
  temp_image_command << " create";
  temp_image_command << " -ov";
  temp_image_command << " -srcfolder \"" << staging.str() << "\"";
419
  temp_image_command << " -volname \"" << cpack_dmg_volume_name << "\"";
420
  temp_image_command << " -fs HFS+";
421
  temp_image_command << " -format " << temp_image_format;
422
  temp_image_command << " \"" << temp_image << "\"";
423

424
425
426
  if (!this->RunCommand(temp_image_command)) {
    cmCPackLogger(cmCPackLog::LOG_ERROR,
                  "Error generating temporary disk image." << std::endl);
427
428

    return 0;
429
  }
430

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

436
    std::ostringstream attach_command;
437
438
    attach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
    attach_command << " attach";
439
    attach_command << " \"" << temp_image << "\"";
440
441

    std::string attach_output;
442
    if (!this->RunCommand(attach_command, &attach_output)) {
443
      cmCPackLogger(cmCPackLog::LOG_ERROR,
444
                    "Error attaching temporary disk image." << std::endl);
445
446

      return 0;
447
    }
448
449
450

    cmsys::RegularExpression mountpoint_regex(".*(/Volumes/[^\n]+)\n.*");
    mountpoint_regex.find(attach_output.c_str());
451
    std::string const temp_mount = mountpoint_regex.match(1);
452
453
    std::string const temp_mount_name =
      temp_mount.substr(sizeof("/Volumes/") - 1);
454

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

462
      had_error = true;
463
    }
464
465

    // Optionally set the custom icon flag for the image ...
466
    if (!had_error && !cpack_package_icon.empty()) {
467
468
469
      std::ostringstream setfile_command;
      setfile_command << this->GetOption("CPACK_COMMAND_SETFILE");
      setfile_command << " -a C";
470
      setfile_command << " \"" << temp_mount << "\"";
471

472
      if (!this->RunCommand(setfile_command)) {
473
        cmCPackLogger(cmCPackLog::LOG_ERROR,
474
475
                      "Error assigning custom icon to temporary disk image."
                        << std::endl);
476
477
478

        had_error = true;
      }
479
    }
480
481
482

    // Optionally we can execute a custom apple script to generate
    // the .DS_Store for the volume folder ...
483
    if (!had_error && !cpack_dmg_ds_store_setup_script.empty()) {
484
485
486
      std::ostringstream setup_script_command;
      setup_script_command << "osascript"
                           << " \"" << cpack_dmg_ds_store_setup_script << "\""
487
                           << " \"" << temp_mount_name << "\"";
488
      std::string error;
489
      if (!this->RunCommand(setup_script_command, &error)) {
490
        cmCPackLogger(cmCPackLog::LOG_ERROR,
491
492
493
                      "Error executing custom script on disk image."
                        << std::endl
                        << error << std::endl);
494
495

        had_error = true;
496
      }
497
    }
498

499
    std::ostringstream detach_command;
500
501
    detach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
    detach_command << " detach";
502
    detach_command << " \"" << temp_mount << "\"";
503

504
    if (!this->RunCommand(detach_command)) {
505
      cmCPackLogger(cmCPackLog::LOG_ERROR,
506
                    "Error detaching temporary disk image." << std::endl);
507
508

      return 0;
509
    }
510

511
    if (had_error) {
512
      return 0;
513
    }
514
  }
515

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

522
    std::vector<std::string> languages;
523
    if (!oldStyle) {
524
      cmSystemTools::ExpandListArgument(cpack_dmg_languages, languages);
525
    }
526
527
528

    cmGeneratedFileStream ofs(sla_r.c_str());
    ofs << "#include <CoreServices/CoreServices.r>\n\n";
529
    if (oldStyle) {
530
531
      ofs << SLAHeader;
      ofs << "\n";
532
    } else {
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
      /*
       * 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());
555
      for (size_t i = 0; i < languages.size(); ++i) {
556
        CFStringRef language_cfstring = CFStringCreateWithCString(
Matthias Männich's avatar
Matthias Männich committed
557
          nullptr, languages[i].c_str(), kCFStringEncodingUTF8);
558
559
        CFStringRef iso_language =
          CFLocaleCreateCanonicalLanguageIdentifierFromString(
Matthias Männich's avatar
Matthias Männich committed
560
            nullptr, language_cfstring);
561
562
563
564
        if (!iso_language) {
          cmCPackLogger(cmCPackLog::LOG_ERROR, languages[i]
                          << " is not a recognized language" << std::endl);
        }
565
566
567
        char iso_language_cstr[65];
        CFStringGetCString(iso_language, iso_language_cstr,
                           sizeof(iso_language_cstr) - 1,
568
569
570
                           kCFStringEncodingMacRoman);
        LangCode lang = 0;
        RegionCode region = 0;
571
#ifdef HAVE_CoreServices
572
573
        OSStatus err =
          LocaleStringToLangAndRegionCodes(iso_language_cstr, &lang, &region);
574
        if (err != noErr)
575
#endif
576
        {
577
          cmCPackLogger(cmCPackLog::LOG_ERROR,
578
579
                        "No language/region code available for "
                          << iso_language_cstr << std::endl);
580
          return 0;
581
        }
582
#ifdef HAVE_CoreServices
583
584
585
        header_data.push_back(region);
        header_data.push_back(i);
        header_data.push_back(0);
586
#endif
587
      }
588
589
590
      ofs << "data 'LPic' (5000) {\n";
      ofs << std::hex << std::uppercase << std::setfill('0');

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

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

598
        if (i % 8 == 7 || i == header_data.size() - 1) {
599
          ofs << "\"\n";
600
        } else {
601
602
          ofs << " ";
        }
603
      }
604
605
606
      ofs << "};\n\n";
      // Reset ofs options
      ofs << std::dec << std::nouppercase << std::setfill(' ');
607
    }
608

609
610
611
    bool have_write_license_error = false;
    std::string error;

612
613
    if (oldStyle) {
      if (!this->WriteLicense(ofs, 0, "", cpack_license_file, &error)) {
614
        have_write_license_error = true;
615
      }
616
617
618
619
620
621
    } 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)) {
622
            have_write_license_error = true;
623
          }
624
625
        } else {
          if (!this->WriteLicense(ofs, i + 5000, languages[i], "", &error)) {
626
            have_write_license_error = true;
627
          }
628
        }
629
      }
630
    }
631
632

    ofs.Close();
633

634
635
636
637
    if (have_write_license_error) {
      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error writing license file to SLA."
                      << std::endl
                      << error << std::endl);
638
      return 0;
639
    }
640

641
642
643
644
645
    if (temp_image_format != "UDZO") {
      temp_image_format = "UDZO";
      // convert to UDZO to enable unflatten/flatten
      std::string temp_udzo = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
      temp_udzo += "/temp-udzo.dmg";
646

647
648
649
650
651
      std::ostringstream udco_image_command;
      udco_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
      udco_image_command << " convert \"" << temp_image << "\"";
      udco_image_command << " -format UDZO";
      udco_image_command << " -ov -o \"" << temp_udzo << "\"";
652

653
654
655
656
657
658
659
660
      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;
      }
      temp_image = temp_udzo;
661
    }
662
663

    // unflatten dmg
664
    std::ostringstream unflatten_command;
665
666
    unflatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
    unflatten_command << " unflatten ";
667
    unflatten_command << "\"" << temp_image << "\"";
668

669
    if (!this->RunCommand(unflatten_command, &error)) {
670
      cmCPackLogger(cmCPackLog::LOG_ERROR,
671
672
673
                    "Error unflattening dmg for adding SLA." << std::endl
                                                             << error
                                                             << std::endl);
674
      return 0;
675
    }
676
677

    // Rez the SLA
678
    std::ostringstream embed_sla_command;
679
    embed_sla_command << this->GetOption("CPACK_COMMAND_REZ");
680
    const char* sysroot = this->GetOption("CPACK_OSX_SYSROOT");
681
    if (sysroot && sysroot[0] != '\0') {
682
      embed_sla_command << " -isysroot \"" << sysroot << "\"";
683
    }
684
    embed_sla_command << " \"" << sla_r << "\"";
685
    embed_sla_command << " -a -o ";
686
    embed_sla_command << "\"" << temp_image << "\"";
687

688
689
690
691
    if (!this->RunCommand(embed_sla_command, &error)) {
      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding SLA." << std::endl
                                                               << error
                                                               << std::endl);
692
      return 0;
693
    }
694
695

    // flatten dmg
696
    std::ostringstream flatten_command;
697
698
    flatten_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
    flatten_command << " flatten ";
699
    flatten_command << "\"" << temp_image << "\"";
700

701
    if (!this->RunCommand(flatten_command, &error)) {
702
      cmCPackLogger(cmCPackLog::LOG_ERROR,
703
704
705
                    "Error flattening dmg for adding SLA." << std::endl
                                                           << error
                                                           << std::endl);
706
      return 0;
707
    }
708
  }
709
710

  // Create the final compressed read-only disk image ...
711
  std::ostringstream final_image_command;
712
  final_image_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
713
  final_image_command << " convert \"" << temp_image << "\"";
714
715
  final_image_command << " -format ";
  final_image_command << cpack_dmg_format;
716
717
  final_image_command << " -imagekey";
  final_image_command << " zlib-level=9";
718
  final_image_command << " -o \"" << output_file << "\"";
719

720
721
722
  if (!this->RunCommand(final_image_command)) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error compressing disk image."
                    << std::endl);
723
724

    return 0;
725
  }
726
727
728

  return 1;
}
729
730
731
732
733
734

bool cmCPackDragNDropGenerator::SupportsComponentInstallation() const
{
  return true;
}

735
736
std::string cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
  const std::string& componentName)
737
738
739
740
741
742
{
  // 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
Eric Noulard's avatar
Eric Noulard committed
743
744
745
746
  // 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
747

748
  if (this->componentPackageMethod == ONE_PACKAGE) {
749
    return "ALL_IN_ONE";
750
  }
751

752
  if (this->componentPackageMethod == ONE_PACKAGE_PER_GROUP) {
753
754
    // We have to find the name of the COMPONENT GROUP
    // the current COMPONENT belongs to.
755
756
    std::string groupVar =
      "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
757
    const char* _groupName = GetOption(groupVar);
758
    if (_groupName) {
759
760
      std::string groupName = _groupName;

761
762
      groupName =
        GetComponentPackageFileName(package_file_name, groupName, true);
763
764
      return groupName;
    }
765
  }
766
767
768

  return GetComponentPackageFileName(package_file_name, componentName, false);
}
769

770
771
bool cmCPackDragNDropGenerator::WriteLicense(
  cmGeneratedFileStream& outputStream, int licenseNumber,
772
773
  std::string licenseLanguage, const std::string& licenseFile,
  std::string* error)
774
{
775
  if (!licenseFile.empty() && !singleLicense) {
776
777
    licenseNumber = 5002;
    licenseLanguage = "English";
778
  }
779
780

  // License header
781
782
  outputStream << "data 'TEXT' (" << licenseNumber << ", \"" << licenseLanguage
               << "\") {\n";
783
  // License body
784
785
786
  std::string actual_license = !licenseFile.empty()
    ? licenseFile
    : (slaDirectory + "/" + licenseLanguage + ".license.txt");
787
788
  cmsys::ifstream license_ifs;
  license_ifs.open(actual_license.c_str());
789
790
  if (license_ifs.is_open()) {
    while (license_ifs.good()) {
791
792
      std::string line;
      std::getline(license_ifs, line);
793
      if (!line.empty()) {
794
        EscapeQuotesAndBackslashes(line);
795
        std::vector<std::string> lines;
796
        if (!this->BreakLongLine(line, lines, error)) {
797
          return false;
798
        }
799
800
        for (auto const& l : lines) {
          outputStream << "        \"" << l << "\"\n";
801
802
        }
      }
803
      outputStream << "        \"\\n\"\n";
804
    }
805
806
    license_ifs.close();
  }
807
808