source/objects/calendarevent/CalendarEvent-Save.cpp

   1 // CalendarEvent.cpp - CalendarEventObject class save functions
   2 //
   3 // (c) 2016-2017 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   6 //
   7 // Xestia Calendar is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Calendar is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "CalendarEvent.h"
  20
  21 using namespace std;
  22
  23 void CalendarEventObject::SaveObjectData(string *SaveData){
  24
  25         string DataLine = "";
  26         string DataLineProcessed = "";
  27
  28         *SaveData += "BEGIN:VEVENT\n";
  29
  30         // Process the UID.
  31
  32         if (UniqueID.size() > 0){
  33
  34                 if (UniqueIDTokens.size() > 0){
  35
  36                         DataLine += "UID;";
  37                         DataLine += UniqueIDTokens;
  38
  39                 } else {
  40
  41                         DataLine += "UID";
  42
  43                 }
  44
  45                 DataLine += ":";
  46                 DataLine += UniqueID;
  47                 DataLine += "\n";
  48
  49                 DataLineProcessed = OutputText(&DataLine);
  50
  51                 *SaveData += DataLineProcessed;
  52
  53                 DataLine.clear();
  54                 DataLineProcessed.clear();
  55
  56         }
  57
  58         // Process the DTSTAMP.
  59
  60         if (DateTimeStampData.size() > 0){
  61
  62                 if (DateTimeStampTokens.size() > 0){
  63
  64                         DataLine += "DTSTAMP;";
  65                         DataLine += DateTimeStampTokens;
  66
  67                 } else {
  68
  69                         DataLine += "DTSTAMP";
  70
  71                 }
  72
  73                 DataLine += ":";
  74                 DataLine += DateTimeStampData;
  75                 DataLine += "\n";
  76
  77                 DataLineProcessed = OutputText(&DataLine);
  78
  79                 *SaveData += DataLineProcessed;
  80
  81                 DataLine.clear();
  82                 DataLineProcessed.clear();
  83
  84         }
  85
  86         // Process the DTSTART.
  87
  88         if (DateTimeStartData.size() > 0){
  89
  90                 DataLine += "DTSTART";
  91
  92                 if (DateTimeStartDataValue.size() > 0){
  93
  94                         DataLine += ";VALUE=";
  95                         DataLine += DateTimeStartDataValue;
  96
  97                 }
  98
  99                 if (DateTimeStartDataTimeZoneID.size() > 0){
 100
 101                         DataLine += ";TZID=";
 102                         DataLine += DateTimeStartDataTimeZoneID;
 103
 104                 }
 105
 106                 if (DateTimeStartDataTokens.size() > 0){
 107
 108                         DataLine += ";";
 109                         DataLine += DateTimeStartDataTokens;
 110
 111                 }
 112
 113                 DataLine += ":";
 114                 DataLine += DateTimeStartData;
 115                 DataLine += "\n";
 116
 117                 DataLineProcessed = OutputText(&DataLine);
 118
 119                 *SaveData += DataLineProcessed;
 120
 121                 DataLine.clear();
 122                 DataLineProcessed.clear();
 123
 124         }
 125
 126         // Process the DTEND.
 127
 128         if (DateTimeEndData.size() > 0){
 129
 130                 DataLine += "DTEND";
 131
 132                 if (DateTimeEndDataValue.size() > 0){
 133
 134                         DataLine += ";VALUE=";
 135                         DataLine += DateTimeEndDataValue;
 136
 137                 }
 138
 139                 if (DateTimeEndDataTimeZoneID.size() > 0){
 140
 141                         DataLine += ";TZID=";
 142                         DataLine += DateTimeEndDataTimeZoneID;
 143
 144                 }
 145
 146                 if (DateTimeEndDataTokens.size() > 0){
 147
 148                         DataLine += ";";
 149                         DataLine += DateTimeEndDataTokens;
 150
 151                 }
 152
 153                 DataLine += ":";
 154                 DataLine += DateTimeEndData;
 155                 DataLine += "\n";
 156
 157                 DataLineProcessed = OutputText(&DataLine);
 158
 159                 *SaveData += DataLineProcessed;
 160
 161                 DataLine.clear();
 162                 DataLineProcessed.clear();
 163
 164         }
 165
 166         // Process the SUMMARY.
 167
 168         if (SummaryData.size() > 0){
 169
 170                 DataLine += "SUMMARY";
 171
 172                 if (SummaryDataAltRep.size() > 0){
 173
 174                         DataLine += ";ALTREP=\"";
 175                         DataLine += SummaryDataAltRep;
 176                         DataLine += "\"";
 177
 178                 }
 179
 180                 if (SummaryDataLanguage.size() > 0){
 181
 182                         DataLine += ";LANGUAGE=";
 183                         DataLine += SummaryDataLanguage;
 184
 185                 }
 186
 187                 if (SummaryDataTokens.size() > 0){
 188
 189                         DataLine += ";";
 190                         DataLine += SummaryDataTokens;
 191
 192                 }
 193
 194                 DataLine += ":";
 195                 DataLine += SummaryData;
 196                 DataLine += "\n";
 197
 198                 DataLineProcessed = OutputText(&DataLine);
 199
 200                 *SaveData += DataLineProcessed;
 201
 202                 DataLine.clear();
 203                 DataLineProcessed.clear();
 204
 205         }
 206
 207         // Process the CLASS value.
 208
 209         if (ClassData.size() > 0){
 210
 211                 if (ClassDataTokens.size() > 0){
 212
 213                         DataLine += "CLASS;";
 214                         DataLine += ClassDataTokens;
 215
 216                 } else {
 217
 218                         DataLine += "CLASS";
 219
 220                 }
 221
 222                 DataLine += ":";
 223                 DataLine += ClassData;
 224                 DataLine += "\n";
 225
 226                 DataLineProcessed = OutputText(&DataLine);
 227
 228                 *SaveData += DataLineProcessed;
 229
 230                 DataLine.clear();
 231                 DataLineProcessed.clear();
 232
 233         }
 234
 235         // Process the CREATED value.
 236
 237         if (DateTimeCreatedData.size() > 0){
 238
 239                 if (DateTimeCreatedTokens.size() > 0){
 240
 241                         DataLine += "CREATED;";
 242                         DataLine += DateTimeCreatedTokens;
 243
 244                 } else {
 245
 246                         DataLine += "CREATED";
 247
 248                 }
 249
 250                 DataLine += ":";
 251                 DataLine += DateTimeCreatedData;
 252                 DataLine += "\n";
 253
 254                 DataLineProcessed = OutputText(&DataLine);
 255
 256                 *SaveData += DataLineProcessed;
 257
 258                 DataLine.clear();
 259                 DataLineProcessed.clear();
 260
 261         }
 262
 263         // Process the DESCRIPTION values. Write out the
 264         // first DESCRPITION only as per RFC5545 specifcation.
 265
 266         if (DescriptionList.size() > 0){
 267
 268                 DataLine += "DESCRIPTION";
 269
 270                 if (DescriptionListAltRep[0].size() > 0){
 271
 272                         DataLine += ";ALTREP=\"";
 273                         DataLine += DescriptionListAltRep[0];
 274                         DataLine += "\"";
 275
 276                 }
 277
 278                 if (DescriptionListLanguage[0].size() > 0){
 279
 280                         DataLine += ";LANGUAGE=";
 281                         DataLine += DescriptionListLanguage[0];
 282
 283                 }
 284
 285                 if (DescriptionListTokens[0].size() > 0){
 286
 287                         DataLine += ";";
 288                         DataLine += DescriptionListTokens[0];
 289
 290                 }
 291
 292                 DataLine += ":";
 293                 DataLine += DescriptionList[0];
 294                 DataLine += "\n";
 295
 296                 DataLineProcessed = OutputText(&DataLine);
 297
 298                 *SaveData += DataLineProcessed;
 299
 300                 DataLine.clear();
 301                 DataLineProcessed.clear();
 302
 303         }
 304
 305         // Process the GEO value.
 306
 307         if (GeographicData.size() > 0){
 308
 309                 if (GeographicTokens.size() > 0){
 310
 311                         DataLine += "GEO;";
 312                         DataLine += GeographicTokens;
 313
 314                 } else {
 315
 316                         DataLine += "GEO";
 317
 318                 }
 319
 320                 DataLine += ":";
 321                 DataLine += GeographicData;
 322                 DataLine += "\n";
 323
 324                 DataLineProcessed = OutputText(&DataLine);
 325
 326                 *SaveData += DataLineProcessed;
 327
 328                 DataLine.clear();
 329                 DataLineProcessed.clear();
 330
 331         }
 332
 333         // Process the LAST-MODIFIED value.
 334
 335         if (LastModifiedData.size() > 0){
 336
 337                 if (LastModifiedTokens.size() > 0){
 338
 339                         DataLine += "LAST-MODIFIED;";
 340                         DataLine += LastModifiedTokens;
 341
 342                 } else {
 343
 344                         DataLine += "LAST-MODIFIED";
 345
 346                 }
 347
 348                 DataLine += ":";
 349                 DataLine += LastModifiedData;
 350                 DataLine += "\n";
 351
 352                 DataLineProcessed = OutputText(&DataLine);
 353
 354                 *SaveData += DataLineProcessed;
 355
 356                 DataLine.clear();
 357                 DataLineProcessed.clear();
 358
 359         }
 360
 361         // Process the LOCATION value.
 362
 363         if (LocationData.size() > 0){
 364
 365                 DataLine += "LOCATION";
 366
 367                 if (LocationDataAltRep.size() > 0){
 368
 369                         DataLine += ";ALTREP=\"";
 370                         DataLine += LocationDataAltRep;
 371                         DataLine += "\"";
 372
 373                 }
 374
 375                 if (LocationDataLanguage.size() > 0){
 376
 377                         DataLine += ";LANGUAGE=";
 378                         DataLine += LocationDataLanguage;
 379
 380                 }
 381
 382                 if (LocationDataTokens.size() > 0){
 383
 384                         DataLine += ";";
 385                         DataLine += LocationDataTokens;
 386
 387                 }
 388
 389                 DataLine += ":";
 390                 DataLine += LocationData;
 391                 DataLine += "\n";
 392
 393                 DataLineProcessed = OutputText(&DataLine);
 394
 395                 *SaveData += DataLineProcessed;
 396
 397                 DataLine.clear();
 398                 DataLineProcessed.clear();
 399
 400         }
 401
 402         // Process the ORGANIZER value.
 403
 404         if (OrganiserData.size() > 0){
 405
 406                 DataLine += "ORGANIZER";
 407
 408                 if (OrganiserDataCommonName.size() > 0){
 409
 410                         DataLine += ";CN=";
 411                         DataLine += OrganiserDataCommonName;
 412
 413                 }
 414
 415                 if (OrganiserDataDirectoryEntry.size() > 0){
 416
 417                         DataLine += ";DIR=\"";
 418                         DataLine += OrganiserDataDirectoryEntry;
 419                         DataLine += "\"";
 420
 421                 }
 422
 423                 if (OrganiserDataSentByParam.size() > 0){
 424
 425                         DataLine += ";SENT-BY=\"";
 426                         DataLine += OrganiserDataSentByParam;
 427                         DataLine += "\"";
 428
 429                 }
 430
 431                 if (OrganiserDataLanguage.size() > 0){
 432
 433                         DataLine += ";LANGUAGE=";
 434                         DataLine += OrganiserDataLanguage;
 435
 436                 }
 437
 438                 if (OrganiserDataTokens.size() > 0){
 439
 440                         DataLine += ";";
 441                         DataLine += OrganiserDataTokens;
 442
 443                 }
 444
 445                 DataLine += ":";
 446                 DataLine += OrganiserData;
 447                 DataLine += "\n";
 448
 449                 DataLineProcessed = OutputText(&DataLine);
 450
 451                 *SaveData += DataLineProcessed;
 452
 453                 DataLine.clear();
 454                 DataLineProcessed.clear();
 455
 456         }
 457
 458         // Process the PRIORITY value.
 459
 460         if (PriorityData > -1 && PriorityData < 10){
 461
 462                 DataLine += "PRIORITY";
 463
 464                 if (PriorityTokens.size() > 0){
 465
 466                         DataLine += ";";
 467                         DataLine += PriorityTokens;
 468
 469                 }
 470
 471                 DataLine += ":";
 472                 DataLine += to_string(PriorityData);
 473                 DataLine += "\n";
 474
 475                 DataLineProcessed = OutputText(&DataLine);
 476
 477                 *SaveData += DataLineProcessed;
 478
 479                 DataLine.clear();
 480                 DataLineProcessed.clear();
 481
 482         }
 483
 484         // Process the SEQUENCE value.
 485
 486         if (SequenceData > -1 && SequenceData < 10){
 487
 488                 DataLine += "SEQUENCE";
 489
 490                 if (SequenceTokens.size() > 0){
 491
 492                         DataLine += ";";
 493                         DataLine += SequenceTokens;
 494
 495                 }
 496
 497                 DataLine += ":";
 498                 DataLine += to_string(SequenceData);
 499                 DataLine += "\n";
 500
 501                 DataLineProcessed = OutputText(&DataLine);
 502
 503                 *SaveData += DataLineProcessed;
 504
 505                 DataLine.clear();
 506                 DataLineProcessed.clear();
 507
 508         }
 509
 510         // Process the STATUS value.
 511
 512         if (StatusData.size() > 0){
 513
 514                 DataLine += "STATUS";
 515
 516                 if (StatusLanguage.size() > 0){
 517
 518                         DataLine += ";LANGUAGE=";
 519                         DataLine += StatusLanguage;
 520
 521                 }
 522
 523                 if (StatusTokens.size() > 0){
 524
 525                         DataLine += ";";
 526                         DataLine += StatusTokens;
 527
 528                 }
 529
 530                 DataLine += ":";
 531                 DataLine += StatusData;
 532                 DataLine += "\n";
 533
 534                 DataLineProcessed = OutputText(&DataLine);
 535
 536                 *SaveData += DataLineProcessed;
 537
 538                 DataLine.clear();
 539                 DataLineProcessed.clear();
 540
 541         }
 542
 543         // Process the TRANSP value.
 544
 545         if (TimeTransparencyData.size() > 0){
 546
 547                 DataLine += "TRANSP";
 548
 549                 if (TimeTransparencyDataTokens.size() > 0){
 550
 551                         DataLine += ";";
 552                         DataLine += TimeTransparencyDataTokens;
 553
 554                 }
 555
 556                 DataLine += ":";
 557                 DataLine += TimeTransparencyData;
 558                 DataLine += "\n";
 559
 560                 DataLineProcessed = OutputText(&DataLine);
 561
 562                 *SaveData += DataLineProcessed;
 563
 564                 DataLine.clear();
 565                 DataLineProcessed.clear();
 566
 567         }
 568
 569         // Process the URL value.
 570
 571         if (URLData.size() > 0){
 572
 573                 DataLine += "URL";
 574
 575                 if (URLDataTokens.size() > 0){
 576
 577                         DataLine += ";";
 578                         DataLine += URLDataTokens;
 579
 580                 }
 581
 582                 DataLine += ":";
 583                 DataLine += URLData;
 584                 DataLine += "\n";
 585
 586                 DataLineProcessed = OutputText(&DataLine);
 587
 588                 *SaveData += DataLineProcessed;
 589
 590                 DataLine.clear();
 591                 DataLineProcessed.clear();
 592
 593         }
 594
 595         // Process the RECURRENCE-ID value.
 596
 597         if (RecurranceIDData.size() > 0){
 598
 599                 DataLine += "RECURRENCE-ID";
 600
 601                 if (RecurranceIDDataTimeZoneParam.size() > 0){
 602
 603                         DataLine += ";TZID=";
 604                         DataLine += RecurranceIDDataTimeZoneParam;
 605
 606                 }
 607
 608                 if (RecurranceIDDataRangeParam.size() > 0){
 609
 610                         DataLine += ";RANGE=";
 611                         DataLine += RecurranceIDDataRangeParam;
 612
 613                 }
 614
 615                 if (RecurranceIDDataValue.size() > 0){
 616
 617                         DataLine += ";VALUE=";
 618                         DataLine += RecurranceIDDataValue;
 619
 620                 }
 621
 622                 if (RecurranceIDDataTokens.size() > 0){
 623
 624                         DataLine += ";";
 625                         DataLine += RecurranceIDDataTokens;
 626
 627                 }
 628
 629                 DataLine += ":";
 630                 DataLine += RecurranceIDData;
 631                 DataLine += "\n";
 632
 633                 DataLineProcessed = OutputText(&DataLine);
 634
 635                 *SaveData += DataLineProcessed;
 636
 637                 DataLine.clear();
 638                 DataLineProcessed.clear();
 639
 640         }
 641
 642         // Process the DURATION value.
 643
 644         if (DurationData.size() > 0){
 645
 646                 DataLine += "DURATION";
 647
 648                 if (DurationDataTokens.size() > 0){
 649
 650                         DataLine += ";";
 651                         DataLine += DurationDataTokens;
 652
 653                 }
 654
 655                 DataLine += ":";
 656                 DataLine += DurationData;
 657                 DataLine += "\n";
 658
 659                 DataLineProcessed = OutputText(&DataLine);
 660
 661                 *SaveData += DataLineProcessed;
 662
 663                 DataLine.clear();
 664                 DataLineProcessed.clear();
 665
 666         }
 667
 668         // Process the RRULE value.
 669
 670         if (RecurranceRuleData.size() > 0){
 671
 672                 DataLine += "RRULE";
 673
 674                 if (RecurranceRuleDataTokens.size() > 0){
 675
 676                         DataLine += ";";
 677                         DataLine += RecurranceRuleDataTokens;
 678
 679                 }
 680
 681                 DataLine += ":";
 682                 DataLine += RecurranceRuleData;
 683                 DataLine += "\n";
 684
 685                 DataLineProcessed = OutputText(&DataLine);
 686
 687                 *SaveData += DataLineProcessed;
 688
 689                 DataLine.clear();
 690                 DataLineProcessed.clear();
 691
 692         }
 693
 694         // Process the ATTACH values.
 695
 696         if (AttachList.size() > 0){
 697
 698                 for (int AttachListSeek = 0; AttachListSeek < AttachList.size();
 699                         AttachListSeek++){
 700
 701                         DataLine += "ATTACH";
 702
 703                         if (AttachListFormatType[AttachListSeek].size() > 0){
 704
 705                                 DataLine += ";FMTTYPE=";
 706                                 DataLine += AttachListFormatType[AttachListSeek];
 707
 708                         }
 709
 710                         if (AttachListValue[AttachListSeek].size() > 0){
 711
 712                                 DataLine += ";VALUE=";
 713                                 DataLine += AttachListValue[AttachListSeek];
 714
 715                         }
 716
 717                         if (AttachListEncoding[AttachListSeek].size() > 0){
 718
 719                                 DataLine += ";ENCODING=";
 720                                 DataLine += AttachListEncoding[AttachListSeek];
 721
 722                         }
 723
 724                         if (AttachListTokens[AttachListSeek].size() > 0){
 725
 726                                 DataLine += ";";
 727                                 DataLine += AttachListTokens[AttachListSeek];
 728
 729                         }
 730
 731                         DataLine += ":";
 732                         DataLine += AttachList[AttachListSeek];
 733                         DataLine += "\n";
 734
 735                         DataLineProcessed = OutputText(&DataLine);
 736
 737                         *SaveData += DataLineProcessed;
 738
 739                         DataLine.clear();
 740                         DataLineProcessed.clear();
 741
 742                 }
 743
 744         }
 745
 746         // Process the ATTENDEE value.
 747
 748         if (AttendeeList.size() > 0){
 749
 750                 for (int AttendeeListSeek = 0; AttendeeListSeek < AttendeeList.size();
 751                         AttendeeListSeek++){
 752
 753                         DataLine += "ATTENDEE";
 754
 755                         if (AttendeeListMember[AttendeeListSeek].size() > 0){
 756
 757                                 DataLine += ";MEMBER=\"";
 758                                 DataLine += AttendeeListMember[AttendeeListSeek];
 759                                 DataLine += "\"";
 760
 761                         }
 762
 763                         if (AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
 764
 765                                 DataLine += ";DELEGATED-FROM=\"";
 766                                 DataLine += AttendeeListDelegatedFrom[AttendeeListSeek];
 767                                 DataLine += "\"";
 768
 769                         }
 770
 771                         if (AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
 772
 773                                 DataLine += ";DELEGATED-TO=\"";
 774                                 DataLine += AttendeeListDelegatedTo[AttendeeListSeek];
 775                                 DataLine += "\"";
 776
 777                         }
 778
 779                         if (AttendeeListRole[AttendeeListSeek].size() > 0){
 780
 781                                 DataLine += ";ROLE=";
 782                                 DataLine += AttendeeListRole[AttendeeListSeek];
 783
 784                         }
 785
 786                         if (AttendeeListRSVP[AttendeeListSeek].size() > 0){
 787
 788                                 DataLine += ";RSVP=";
 789                                 DataLine += AttendeeListRSVP[AttendeeListSeek];
 790
 791                         }
 792
 793                         if (AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
 794
 795                                 DataLine += ";DIR=\"";
 796                                 DataLine += AttendeeListDirectoryEntry[AttendeeListSeek];
 797                                 DataLine += "\"";
 798
 799                         }
 800
 801                         if (AttendeeListSentBy[AttendeeListSeek].size() > 0){
 802
 803                                 DataLine += ";SENT-BY=\"";
 804                                 DataLine += AttendeeListSentBy[AttendeeListSeek];
 805                                 DataLine += "\"";
 806
 807                         }
 808
 809                         if (AttendeeListCommonName[AttendeeListSeek].size() > 0){
 810
 811                                 DataLine += ";CN=\"";
 812                                 DataLine += AttendeeListCommonName[AttendeeListSeek];
 813                                 DataLine += "\"";
 814
 815                         }
 816
 817                         if (AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
 818
 819                                 DataLine += ";CUTYPE=";
 820                                 DataLine += AttendeeListCalendarUserType[AttendeeListSeek];
 821
 822                         }
 823
 824                         if (AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
 825
 826                                 DataLine += ";PARTSTAT=";
 827                                 DataLine += AttendeeListParticipationStatus[AttendeeListSeek];
 828
 829                         }
 830
 831                         if (AttendeeListLanguage[AttendeeListSeek].size() > 0){
 832
 833                                 DataLine += ";LANGUAGE=";
 834                                 DataLine += AttendeeListLanguage[AttendeeListSeek];
 835
 836                         }
 837
 838                         if (AttendeeListTokens[AttendeeListSeek].size() > 0){
 839
 840                                 DataLine += ";";
 841                                 DataLine += AttendeeListTokens[AttendeeListSeek];
 842
 843                         }
 844
 845                         DataLine += ":";
 846                         DataLine += AttendeeList[AttendeeListSeek];
 847                         DataLine += "\n";
 848
 849                         DataLineProcessed = OutputText(&DataLine);
 850
 851                         *SaveData += DataLineProcessed;
 852
 853                         DataLine.clear();
 854                         DataLineProcessed.clear();
 855
 856                 }
 857
 858         }
 859
 860         // Process the CATEGORIES value.
 861
 862         if (CategoriesList.size() > 0){
 863
 864                 for (int CategoriesListSeek = 0; CategoriesListSeek < CategoriesList.size();
 865                         CategoriesListSeek++){
 866
 867                         DataLine += "CATEGORIES";
 868
 869                         if (CategoriesListLanguage[CategoriesListSeek].size() > 0){
 870
 871                                 DataLine += ";LANGUAGE=";
 872                                 DataLine += CategoriesListLanguage[CategoriesListSeek];
 873
 874                         }
 875
 876                         if (CategoriesListTokens[CategoriesListSeek].size() > 0){
 877
 878                                 DataLine += ";";
 879                                 DataLine += CategoriesListTokens[CategoriesListSeek];
 880
 881                         }
 882
 883                         DataLine += ":";
 884                         DataLine += CategoriesList[CategoriesListSeek];
 885                         DataLine += "\n";
 886
 887                         DataLineProcessed = OutputText(&DataLine);
 888
 889                         *SaveData += DataLineProcessed;
 890
 891                         DataLine.clear();
 892                         DataLineProcessed.clear();
 893
 894                 }
 895
 896         }
 897
 898         // Process the COMMENT value.
 899
 900         if (CommentList.size() > 0){
 901
 902                 for (int CommentListSeek = 0; CommentListSeek < CommentList.size();
 903                         CommentListSeek++){
 904
 905                         DataLine += "COMMENT";
 906
 907                         if (CommentListAltRep[CommentListSeek].size() > 0){
 908
 909                                 DataLine += ";ALTREP=\"";
 910                                 DataLine += CommentListAltRep[CommentListSeek];
 911                                 DataLine += "\"";
 912
 913                         }
 914
 915                         if (CommentListLanguage[CommentListSeek].size() > 0){
 916
 917                                 DataLine += ";LANGUAGE=";
 918                                 DataLine += CommentListLanguage[CommentListSeek];
 919
 920                         }
 921
 922                         if (CommentListTokens[CommentListSeek].size() > 0){
 923
 924                                 DataLine += ";";
 925                                 DataLine += CommentListTokens[CommentListSeek];
 926
 927                         }
 928
 929                         DataLine += ":";
 930                         DataLine += CommentList[CommentListSeek];
 931                         DataLine += "\n";
 932
 933                         DataLineProcessed = OutputText(&DataLine);
 934
 935                         *SaveData += DataLineProcessed;
 936
 937                         DataLine.clear();
 938                         DataLineProcessed.clear();
 939
 940                 }
 941
 942         }
 943
 944         // Process the CONTACT value.
 945
 946         if (ContactList.size() > 0){
 947
 948                 for (int ContactListSeek = 0; ContactListSeek < ContactList.size();
 949                         ContactListSeek++){
 950
 951                         DataLine += "CONTACT";
 952
 953                         if (ContactListAltRep[ContactListSeek].size() > 0){
 954
 955                                 DataLine += ";ALTREP=\"";
 956                                 DataLine += ContactListAltRep[ContactListSeek];
 957                                 DataLine += "\"";
 958
 959                         }
 960
 961                         if (ContactListLanguage[ContactListSeek].size() > 0){
 962
 963                                 DataLine += ";LANGUAGE=";
 964                                 DataLine += ContactListLanguage[ContactListSeek];
 965
 966                         }
 967
 968                         if (ContactListTokens[ContactListSeek].size() > 0){
 969
 970                                 DataLine += ";";
 971                                 DataLine += ContactListTokens[ContactListSeek];
 972
 973                         }
 974
 975                         DataLine += ":";
 976                         DataLine += ContactList[ContactListSeek];
 977                         DataLine += "\n";
 978
 979                         DataLineProcessed = OutputText(&DataLine);
 980
 981                         *SaveData += DataLineProcessed;
 982
 983                         DataLine.clear();
 984                         DataLineProcessed.clear();
 985
 986                 }
 987
 988         }
 989
 990         // Process the EXDATE value.
 991
 992         if (ExcludeDateData.size() > 0){
 993
 994                 for (int ExcludeDateDataSeek = 0; ExcludeDateDataSeek < ExcludeDateData.size();
 995                         ExcludeDateDataSeek++){
 996
 997                         DataLine += "EXDATE";
 998
 999                         if (ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek].size() > 0){
1000
1001                                 DataLine += ";TZID=";
1002                                 DataLine += ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek];
1003
1004                         }
1005
1006                         if (ExcludeDateDataValue[ExcludeDateDataSeek].size() > 0){
1007
1008                                 DataLine += ";VALUE=";
1009                                 DataLine += ExcludeDateDataValue[ExcludeDateDataSeek];
1010
1011                         }
1012
1013                         if (ExcludeDateDataTokens[ExcludeDateDataSeek].size() > 0){
1014
1015                                 DataLine += ";";
1016                                 DataLine += ExcludeDateDataTokens[ExcludeDateDataSeek];
1017
1018                         }
1019
1020                         DataLine += ":";
1021                         DataLine += ExcludeDateData[ExcludeDateDataSeek];
1022                         DataLine += "\n";
1023
1024                         DataLineProcessed = OutputText(&DataLine);
1025
1026                         *SaveData += DataLineProcessed;
1027
1028                         DataLine.clear();
1029                         DataLineProcessed.clear();
1030
1031                 }
1032
1033         }
1034
1035         // Process the REQUEST-STATUS value.
1036
1037         if (RequestStatusData.size() > 0){
1038
1039                 for (int RequestStatusDataSeek = 0; RequestStatusDataSeek < RequestStatusData.size();
1040                         RequestStatusDataSeek++){
1041
1042                         DataLine += "REQUEST-STATUS";
1043
1044                         if (RequestStatusLanguage[RequestStatusDataSeek].size() > 0){
1045
1046                                 DataLine += ";LANGUAGE=";
1047                                 DataLine += RequestStatusLanguage[RequestStatusDataSeek];
1048
1049                         }
1050
1051                         if (RequestStatusTokens[RequestStatusDataSeek].size() > 0){
1052
1053                                 DataLine += ";";
1054                                 DataLine += RequestStatusTokens[RequestStatusDataSeek];
1055
1056                         }
1057
1058                         DataLine += ":";
1059                         DataLine += RequestStatusData[RequestStatusDataSeek];
1060                         DataLine += "\n";
1061
1062                         DataLineProcessed = OutputText(&DataLine);
1063
1064                         *SaveData += DataLineProcessed;
1065
1066                         DataLine.clear();
1067                         DataLineProcessed.clear();
1068
1069                 }
1070
1071         }
1072
1073         // Process the RELATED-TO value.
1074
1075         if (RelatedToData.size() > 0){
1076
1077                 for (int RequestToDataSeek = 0; RequestToDataSeek < RelatedToData.size();
1078                         RequestToDataSeek++){
1079
1080                         DataLine += "RELATED-TO";
1081
1082                         if (RelatedToDataRelationType[RequestToDataSeek].size() > 0){
1083
1084                                 DataLine += ";RELTYPE=";
1085                                 DataLine += RelatedToDataRelationType[RequestToDataSeek];
1086
1087                         }
1088
1089                         if (RelatedToDataTokens[RequestToDataSeek].size() > 0){
1090
1091                                 DataLine += ";";
1092                                 DataLine += RelatedToDataTokens[RequestToDataSeek];
1093
1094                         }
1095
1096                         DataLine += ":";
1097                         DataLine += RelatedToData[RequestToDataSeek];
1098                         DataLine += "\n";
1099
1100                         DataLineProcessed = OutputText(&DataLine);
1101
1102                         *SaveData += DataLineProcessed;
1103
1104                         DataLine.clear();
1105                         DataLineProcessed.clear();
1106
1107                 }
1108
1109         }
1110
1111         // Process the RESOURCES value.
1112
1113         if (ResourcesData.size() > 0){
1114
1115                 for (int ResourcesDataSeek = 0; ResourcesDataSeek < ResourcesData.size();
1116                         ResourcesDataSeek++){
1117
1118                         DataLine += "RESOURCES";
1119
1120                         if (ResourcesDataAltRep[ResourcesDataSeek].size() > 0){
1121
1122                                 DataLine += ";ALTREP=\"";
1123                                 DataLine += ResourcesDataAltRep[ResourcesDataSeek];
1124                                 DataLine += "\"";
1125
1126                         }
1127
1128                         if (ResourcesDataLanguage[ResourcesDataSeek].size() > 0){
1129
1130                                 DataLine += ";LANGUAGE=";
1131                                 DataLine += ResourcesDataLanguage[ResourcesDataSeek];
1132
1133                         }
1134
1135                         if (ResourcesDataTokens[ResourcesDataSeek].size() > 0){
1136
1137                                 DataLine += ";";
1138                                 DataLine += ResourcesDataTokens[ResourcesDataSeek];
1139
1140                         }
1141
1142                         DataLine += ":";
1143                         DataLine += ResourcesData[ResourcesDataSeek];
1144                         DataLine += "\n";
1145
1146                         DataLineProcessed = OutputText(&DataLine);
1147
1148                         *SaveData += DataLineProcessed;
1149
1150                         DataLine.clear();
1151                         DataLineProcessed.clear();
1152
1153                 }
1154
1155         }
1156
1157         // Process the RDATE value.
1158
1159         if (RecurranceDateData.size() > 0){
1160
1161                 for (int RecurranceDateDataSeek = 0; RecurranceDateDataSeek < RecurranceDateData.size();
1162                         RecurranceDateDataSeek++){
1163
1164                         DataLine += "RDATE";
1165
1166                         if (RecurranceDateDataValue[RecurranceDateDataSeek].size() > 0){
1167
1168                                 DataLine += ";VALUE=";
1169                                 DataLine += RecurranceDateDataValue[RecurranceDateDataSeek];
1170
1171                         }
1172
1173                         if (RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek].size() > 0){
1174
1175                                 DataLine += ";TZID=";
1176                                 DataLine += RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek];
1177
1178                         }
1179
1180                         if (RecurranceDateDataTokens[RecurranceDateDataSeek].size() > 0){
1181
1182                                 DataLine += ";";
1183                                 DataLine += RecurranceDateDataTokens[RecurranceDateDataSeek];
1184
1185                         }
1186
1187                         DataLine += ":";
1188                         DataLine += RecurranceDateData[RecurranceDateDataSeek];
1189                         DataLine += "\n";
1190
1191                         DataLineProcessed = OutputText(&DataLine);
1192
1193                         *SaveData += DataLineProcessed;
1194
1195                         DataLine.clear();
1196                         DataLineProcessed.clear();
1197
1198                 }
1199
1200         }
1201
1202         // Process the VALARMS.
1203
1204         if (CalendarAlarmData.size() > 0){
1205
1206                 for (int CalendarAlarmDataSeek = 0; CalendarAlarmDataSeek < CalendarAlarmData.size();
1207                         CalendarAlarmDataSeek++){
1208
1209                         *SaveData += "BEGIN:VALARM\n";
1210
1211                         // Process the ACTION VALARM value.
1212
1213                         DataLine += "ACTION";
1214
1215                         if (CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens.size() > 0){
1216
1217                                 DataLine += ";";
1218                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens;
1219
1220                         }
1221
1222                         DataLine += ":";
1223                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmAction;
1224                         DataLine += "\n";
1225
1226                         DataLineProcessed = OutputText(&DataLine);
1227
1228                         *SaveData += DataLineProcessed;
1229
1230                         DataLine.clear();
1231                         DataLineProcessed.clear();
1232
1233                         // Process the TRIGGER VALARM value.
1234
1235                         if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerData.size() > 0){
1236
1237                                 DataLine += "TRIGGER";
1238
1239                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated.size() > 0){
1240
1241                                         DataLine += ";RELATED=";
1242                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated;
1243
1244                                 }
1245
1246                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue.size() > 0){
1247
1248                                         DataLine += ";VALUE=";
1249                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue;
1250
1251                                 }
1252
1253                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens.size() > 0){
1254
1255                                         DataLine += ";";
1256                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens;
1257
1258                                 }
1259
1260                                 DataLine += ":";
1261                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerData;
1262                                 DataLine += "\n";
1263
1264                                 DataLineProcessed = OutputText(&DataLine);
1265
1266                                 *SaveData += DataLineProcessed;
1267
1268                                 DataLine.clear();
1269                                 DataLineProcessed.clear();
1270
1271                         }
1272
1273                         // Process the DURATION VALARM value.
1274
1275                         if (CalendarAlarmData[CalendarAlarmDataSeek].DurationData.size() > 0){
1276
1277                                 DataLine += "DURATION";
1278
1279                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens.size() > 0){
1280
1281                                         DataLine += ";";
1282                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens;
1283
1284                                 }
1285
1286                                 DataLine += ":";
1287                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationData;
1288                                 DataLine += "\n";
1289
1290                                 DataLineProcessed = OutputText(&DataLine);
1291
1292                                 *SaveData += DataLineProcessed;
1293
1294                                 DataLine.clear();
1295                                 DataLineProcessed.clear();
1296
1297                         }
1298
1299                         // Process the DESCRIPTION VALARM value.
1300
1301                         if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData.size() > 0){
1302
1303                                 DataLine += "DESCRIPTION";
1304
1305                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep.size() > 0){
1306
1307                                         DataLine += ";ALTREP=\"";
1308                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep;
1309                                         DataLine += "\"";
1310
1311                                 }
1312
1313                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage.size() > 0){
1314
1315                                         DataLine += ";LANGUAGE=";
1316                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage;
1317
1318                                 }
1319
1320                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens.size() > 0){
1321
1322                                         DataLine += ";";
1323                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens;
1324
1325                                 }
1326
1327                                 DataLine += ":";
1328                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData;
1329                                 DataLine += "\n";
1330
1331                                 DataLineProcessed = OutputText(&DataLine);
1332
1333                                 *SaveData += DataLineProcessed;
1334
1335                                 DataLine.clear();
1336                                 DataLineProcessed.clear();
1337
1338                         }
1339
1340                         // Process the SUMMARY VALARM value.
1341
1342                         if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryData.size() > 0){
1343
1344                                 DataLine += "SUMMARY";
1345
1346                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep.size() > 0){
1347
1348                                         DataLine += ";ALTREP=\"";
1349                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep;
1350                                         DataLine += "\"";
1351
1352                                 }
1353
1354                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage.size() > 0){
1355
1356                                         DataLine += ";LANGUAGE=";
1357                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage;
1358
1359                                 }
1360
1361                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens.size() > 0){
1362
1363                                         DataLine += ";";
1364                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens;
1365
1366                                 }
1367
1368                                 DataLine += ":";
1369                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryData;
1370                                 DataLine += "\n";
1371
1372                                 DataLineProcessed = OutputText(&DataLine);
1373
1374                                 *SaveData += DataLineProcessed;
1375
1376                                 DataLine.clear();
1377                                 DataLineProcessed.clear();
1378
1379                         }
1380
1381                         // Process the REPEAT VALARM value.
1382
1383                         if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatData.size() > 0){
1384
1385                                 DataLine += "REPEAT";
1386
1387                                 if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens.size() > 0){
1388
1389                                         DataLine += ";";
1390                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens;
1391
1392                                 }
1393
1394                                 DataLine += ":";
1395                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatData;
1396                                 DataLine += "\n";
1397
1398                                 DataLineProcessed = OutputText(&DataLine);
1399
1400                                 *SaveData += DataLineProcessed;
1401
1402                                 DataLine.clear();
1403                                 DataLineProcessed.clear();
1404
1405                         }
1406
1407                         // Process the ATTENDEE VALARM values.
1408
1409                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size() > 0){
1410
1411                                 for (int AttendeeListSeek = 0; AttendeeListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size();
1412                                         AttendeeListSeek++){
1413
1414                                         DataLine += "ATTENDEE";
1415
1416                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek].size() > 0){
1417
1418                                                 DataLine += ";MEMBER=\"";
1419                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek];
1420                                                 DataLine += "\"";
1421
1422                                         }
1423
1424                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
1425
1426                                                 DataLine += ";DELEGATED-FROM=\"";
1427                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek];
1428                                                 DataLine += "\"";
1429
1430                                         }
1431
1432                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
1433
1434                                                 DataLine += ";DELEGATED-TO=\"";
1435                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek];
1436                                                 DataLine += "\"";
1437
1438                                         }
1439
1440                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek].size() > 0){
1441
1442                                                 DataLine += ";ROLE=";
1443                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek];
1444
1445                                         }
1446
1447                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek].size() > 0){
1448
1449                                                 DataLine += ";RSVP=";
1450                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek];
1451
1452                                         }
1453
1454                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
1455
1456                                                 DataLine += ";DIR=\"";
1457                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek];
1458                                                 DataLine += "\"";
1459
1460                                         }
1461
1462                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek].size() > 0){
1463
1464                                                 DataLine += ";SENT-BY=\"";
1465                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek];
1466                                                 DataLine += "\"";
1467
1468                                         }
1469
1470                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek].size() > 0){
1471
1472                                                 DataLine += ";CN=\"";
1473                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek];
1474                                                 DataLine += "\"";
1475
1476                                         }
1477
1478                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
1479
1480                                                 DataLine += ";CUTYPE=";
1481                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek];
1482
1483                                         }
1484
1485                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
1486
1487                                                 DataLine += ";PARTSTAT=";
1488                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek];
1489
1490                                         }
1491
1492                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek].size() > 0){
1493
1494                                                 DataLine += ";LANGUAGE=";
1495                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek];
1496
1497                                         }
1498
1499                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek].size() > 0){
1500
1501                                                 DataLine += ";";
1502                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek];
1503
1504                                         }
1505
1506                                         DataLine += ":";
1507                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList[AttendeeListSeek];
1508                                         DataLine += "\n";
1509
1510                                         DataLineProcessed = OutputText(&DataLine);
1511
1512                                         *SaveData += DataLineProcessed;
1513
1514                                         DataLine.clear();
1515                                         DataLineProcessed.clear();
1516
1517                                 }
1518
1519                         }
1520
1521                         // Process the ATTACH VALARM values.
1522
1523                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size() > 0){
1524
1525                                 for (int AttachListSeek = 0; AttachListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size();
1526                                         AttachListSeek++){
1527
1528                                         DataLine += "ATTACH";
1529
1530                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek].size() > 0){
1531
1532                                                 DataLine += ";FMTTYPE=";
1533                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek];
1534
1535                                         }
1536
1537                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek].size() > 0){
1538
1539                                                 DataLine += ";VALUE=";
1540                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek];
1541
1542                                         }
1543
1544                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek].size() > 0){
1545
1546                                                 DataLine += ";ENCODING=";
1547                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek];
1548
1549                                         }
1550
1551                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek].size() > 0){
1552
1553                                                 DataLine += ";";
1554                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek];
1555
1556                                         }
1557
1558                                         DataLine += ":";
1559                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachList[AttachListSeek];
1560                                         DataLine += "\n";
1561
1562                                         DataLineProcessed = OutputText(&DataLine);
1563
1564                                         *SaveData += DataLineProcessed;
1565
1566                                         DataLine.clear();
1567                                         DataLineProcessed.clear();
1568
1569                                 }
1570
1571                         }
1572
1573                         // Process the X-Token VALARM values.
1574
1575                         if (CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size() > 0){
1576
1577                                 for (int XTokenSeek = 0; XTokenSeek < CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size();
1578                                         XTokenSeek++){
1579
1580                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensDataTokens[XTokenSeek];
1581                                         DataLine += ":";
1582                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensData[XTokenSeek];
1583                                         DataLine += "\n";
1584
1585                                         DataLineProcessed = OutputText(&DataLine);
1586
1587                                         *SaveData += DataLineProcessed;
1588
1589                                         DataLine.clear();
1590                                         DataLineProcessed.clear();
1591
1592                                 }
1593
1594                         }
1595
1596                         *SaveData += "END:VALARM\n";
1597
1598                 }
1599
1600         }
1601
1602         // Process the X-Token values.
1603
1604         if (XTokensData.size() > 0){
1605
1606                 for (int XTokenSeek = 0; XTokenSeek < XTokensData.size();
1607                         XTokenSeek++){
1608
1609                         DataLine += XTokensDataTokens[XTokenSeek];
1610                         DataLine += ":";
1611                         DataLine += XTokensData[XTokenSeek];
1612                         DataLine += "\n";
1613
1614                         DataLineProcessed = OutputText(&DataLine);
1615
1616                         *SaveData += DataLineProcessed;
1617
1618                         DataLine.clear();
1619                         DataLineProcessed.clear();
1620
1621                 }
1622
1623         }
1624
1625         *SaveData += "END:VEVENT\n";
1626
1627 }