source/objects/calendartask/CalendarTask-Save.cpp

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