Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
Version 0.08 release
[xestiacalendar/.git] / objects / calendartask / CalendarTask-Save.cpp
1 #include "CalendarTask.h"
3 using namespace std;
5 void CalendarTaskObject::SaveObjectData(string *SaveData){
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 {
23                         DataLine += "UID";
24                         
25                 }
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 {
51                         DataLine += "DTSTAMP";
52                         
53                 }
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 {
79                         DataLine += "CLASS";
80                         
81                 }
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 {
107                         DataLine += "COMPLETED";
108                         
109                 }
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         }
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 {
135                         DataLine += "CREATED";
136                         
137                 }
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                 }
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                 }
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 {
245                         DataLine += "GEO";
246                         
247                 }
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 {
273                         DataLine += "LAST-MODIFIED";
274                         
275                 }
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.
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;
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                 }
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;
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 {
398                         DataLine += "PERCENT-COMPLETE";
399                         
400                 }
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";
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;
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;
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";
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;
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;
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;
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;
609                 DataLine.clear();
610                 DataLineProcessed.clear();
611                 
612         }
613         
614         // Process the URL value.
615         
616         if (URLData.size() > 0){
617                 
618                 DataLine += "URL";
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;
635                 DataLine.clear();
636                 DataLineProcessed.clear();
637                 
638         }
639         
640         // Process the RRULE value.
641         
642         if (RecurranceRuleData.size() > 0){
643                 
644                 DataLine += "RRULE";
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;
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;
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";
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;
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";
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                         }
783                         if (AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
784                 
785                                 DataLine += ";DELEGATED-TO=\"";
786                                 DataLine += AttendeeListDelegatedTo[AttendeeListSeek];
787                                 DataLine += "\"";
788                         
789                         }
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                         }
821                         if (AttendeeListCommonName[AttendeeListSeek].size() > 0){
822                                 
823                                 DataLine += ";CN=\"";
824                                 DataLine += AttendeeListCommonName[AttendeeListSeek];
825                                 DataLine += "\"";
826                                 
827                         }
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;
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;
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;
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;
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;
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;
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;
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;
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;
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";
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;
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;
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;
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";
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;
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";
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;
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;
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";
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                                         }
1444                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
1445                 
1446                                                 DataLine += ";DELEGATED-TO=\"";
1447                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek];
1448                                                 DataLine += "\"";
1449                         
1450                                         }
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                                         }
1482                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek].size() > 0){
1483                                 
1484                                                 DataLine += ";CN=\"";
1485                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek];
1486                                                 DataLine += "\"";
1487                                 
1488                                         }
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;
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;
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;
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;
1630                         DataLine.clear();
1631                         DataLineProcessed.clear();
1632                                         
1633                 }
1634                                 
1635         }
1636         
1637         *SaveData += "END:VTODO\n";
1638         
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy