objects/calendartask/CalendarTask-Save.cpp

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