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