Back to index

lightning-sunbird  0.9+nobinonly
ical.h
Go to the documentation of this file.
00001 #ifdef __cplusplus
00002 extern "C" {
00003 #endif
00004 /* config.h.  Generated automatically by configure.  */
00005 /* config.h.in.  Generated automatically from configure.in by autoheader.  */
00006 
00007 /* Define to empty if the keyword does not work.  */
00008 /* #undef const */
00009 
00010 /* Define to `unsigned' if <sys/types.h> doesn't define.  */
00011 /* #undef size_t */
00012 
00013 /* Define if you have the ANSI C header files.  */
00014 #define STDC_HEADERS 1
00015 
00016 /* Define if your <sys/time.h> declares struct tm.  */
00017 /* #undef TM_IN_SYS_TIME */
00018 
00019 /* Define if lex declares yytext as a char * by default, not a char[].  */
00020 #define YYTEXT_POINTER 1
00021 
00022 /* Define if you have the gmtime_r function.  */
00023 #define HAVE_GMTIME_R 1
00024 
00025 /* Define if you have the iswspace function.  */
00026 #define HAVE_ISWSPACE 1
00027 
00028 /* Define if you have the snprintf function.  */
00029 #define HAVE_SNPRINTF 1
00030 
00031 /* Define if you have the strdup function.  */
00032 #define HAVE_STRDUP 1
00033 
00034 /* Define if you have the <assert.h> header file.  */
00035 #define HAVE_ASSERT_H 1
00036 
00037 /* Define if you have the <dlfcn.h> header file.  */
00038 #define HAVE_DLFCN_H 1
00039 
00040 /* Define if you have the <pthread.h> header file.  */
00041 #define HAVE_PTHREAD_H 1
00042 
00043 /* Define if you have the <sys/types.h> header file.  */
00044 #define HAVE_SYS_TYPES_H 1
00045 
00046 /* Define if you have the <time.h> header file.  */
00047 #define HAVE_TIME_H 1
00048 
00049 /* Define if you have the <unistd.h> header file.  */
00050 #define HAVE_UNISTD_H 1
00051 
00052 /* Define if you have the <wctype.h> header file.  */
00053 #define HAVE_WCTYPE_H 1
00054 
00055 /* Name of package */
00056 #define PACKAGE "libical"
00057 
00058 /* Version number of package */
00059 #define VERSION "0.24"
00060 
00061 /* Define if we want _REENTRANT */
00062 /* #undef ICAL_REENTRANT */
00063 
00064 /* Define to make icalerror_* calls abort instead of internally signalling an error */
00065 #define ICAL_ERRORS_ARE_FATAL 1
00066 
00067 /* Define to 1 if you DO NOT WANT to see deprecated messages */
00068 #define NO_WARN_DEPRECATED 1
00069 
00070 /* Define to 1 if you DO NO WANT to see the warning messages related to ICAL_MALFORMEDDATA_ERROR and parsing .ics zoneinfo files */
00071 #define NO_WARN_ICAL_MALFORMEDDATA_ERROR_HACK 1
00072 
00073 /* Define to terminate lines with n instead of rn */
00074 #undef ICAL_UNIX_NEWLINE
00075 
00076 /* Define if we have pthread. */
00077 #define HAVE_PTHREAD 
00078 
00079 /* Define if we have pthread. */
00080 #define HAVE_PTHREAD 
00081 
00082 #ifndef ICAL_VERSION_H
00083 #define ICAL_VERSION_H
00084 
00085 #define ICAL_PACKAGE "libical"
00086 #define ICAL_VERSION "0.24"
00087 
00088 #endif
00089 /* -*- Mode: C -*- */
00090 /*======================================================================
00091  FILE: icaltime.h
00092  CREATOR: eric 02 June 2000
00093 
00094 
00095  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
00096  $Locker:  $
00097 
00098  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00099 
00100  This program is free software; you can redistribute it and/or modify
00101  it under the terms of either: 
00102 
00103     The LGPL as published by the Free Software Foundation, version
00104     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00105 
00106   Or:
00107 
00108     The Mozilla Public License Version 1.0. You may obtain a copy of
00109     the License at http://www.mozilla.org/MPL/
00110 
00111  The Original Code is eric. The Initial Developer of the Original
00112  Code is Eric Busboom
00113 
00114 
00115 ======================================================================*/
00116 
00181 #ifndef ICALTIME_H
00182 #define ICALTIME_H
00183 
00184 #include <time.h>
00185 
00186 /* An opaque struct representing a timezone. We declare this here to avoid
00187    a circular dependancy. */
00188 #ifndef ICALTIMEONE_DEFINED
00189 #define ICALTIMEONE_DEFINED
00190 typedef struct _icaltimezone              icaltimezone;
00191 #endif
00192 
00194 struct icaltime_span {
00195        time_t start;   
00196        time_t end;     
00197        int is_busy;    
00198 };
00199 
00200 typedef struct icaltime_span icaltime_span;
00201 
00202 /*
00203  *     FIXME
00204  *
00205  *     is_utc is redundant, and might be considered a minor optimization.
00206  *     It might be deprecated, so you should use icaltime_is_utc() instead.
00207  */
00208 struct icaltimetype
00209 {
00210        int year;     
00211        int month;    
00212        int day;
00213        int hour;
00214        int minute;
00215        int second;
00216 
00217        int is_utc;     
00219        int is_date;    
00221        int is_daylight; 
00223        const icaltimezone *zone;   
00224 };     
00225 
00226 typedef struct icaltimetype icaltimetype;
00227 
00230 struct icaltimetype icaltime_null_time(void);
00231 
00233 struct icaltimetype icaltime_null_date(void);
00234 
00236 struct icaltimetype icaltime_current_time_with_zone(const icaltimezone *zone);
00237 
00239 struct icaltimetype icaltime_today(void);
00240 
00242 struct icaltimetype icaltime_from_timet(const time_t v, const int is_date);
00243 
00245 struct icaltimetype icaltime_from_timet_with_zone(const time_t tm,
00246        const int is_date, const icaltimezone *zone);
00247 
00249 struct icaltimetype icaltime_from_string(const char* str);
00250 
00252 struct icaltimetype icaltime_from_string_with_zone(const char* str,
00253        const icaltimezone *zone);
00254 
00256 struct icaltimetype icaltime_from_day_of_year(const short doy,
00257        const short year);
00258 
00261 struct icaltimetype icaltime_from_week_number(const short week_number,
00262        const short year);
00263 
00265 time_t icaltime_as_timet(const struct icaltimetype);
00266 
00268 time_t icaltime_as_timet_with_zone(const struct icaltimetype tt,
00269        const icaltimezone *zone);
00270 
00273 const char* icaltime_as_ical_string(const struct icaltimetype tt);
00274 
00276 const icaltimezone *icaltime_get_timezone(const struct icaltimetype t);
00277 
00279 char *icaltime_get_tzid(const struct icaltimetype t);
00280 
00282 struct icaltimetype icaltime_set_timezone(struct icaltimetype *t,
00283        const icaltimezone *zone);
00284 
00286 short icaltime_day_of_year(const struct icaltimetype t);
00287 
00289 short icaltime_day_of_week(const struct icaltimetype t);
00290 
00293 short icaltime_start_doy_of_week(const struct icaltimetype t);
00294 
00296 short icaltime_week_number(const struct icaltimetype t);
00297 
00299 int icaltime_is_null_time(const struct icaltimetype t);
00300 
00304 int icaltime_is_valid_time(const struct icaltimetype t);
00305 
00307 int icaltime_is_date(const struct icaltimetype t);
00308 
00310 int icaltime_is_utc(const struct icaltimetype t);
00311 
00313 int icaltime_is_floating(const struct icaltimetype t);
00314 
00316 int icaltime_compare_with_zone(const struct icaltimetype a,
00317         const struct icaltimetype b);
00318 
00320 int icaltime_compare(const struct icaltimetype a,
00321        const struct icaltimetype b);
00322 
00324 int icaltime_compare_date_only(const struct icaltimetype a,
00325        const struct icaltimetype b);
00326 
00328 void  icaltime_adjust(struct icaltimetype *tt, const int days,
00329        const int hours, const int minutes, const int seconds);
00330 
00332 struct icaltimetype icaltime_normalize(const struct icaltimetype t);
00333 
00336 struct icaltimetype icaltime_convert_to_zone(const struct icaltimetype tt,
00337        const icaltimezone *zone);
00338 
00340 short icaltime_days_in_month(const short month, const short year);
00341 
00342 
00344 struct icaltime_span icaltime_span_new(struct icaltimetype dtstart,
00345                                    struct icaltimetype dtend,
00346                                    int is_busy);
00347 
00349 int icaltime_span_overlaps(icaltime_span *s1, 
00350                         icaltime_span *s2);
00351 
00355 int icaltime_span_contains(icaltime_span *s,
00356                         icaltime_span *container);
00357 
00358 
00359 #endif /* !ICALTIME_H */
00360 
00361 
00362 /* -*- Mode: C -*- */
00363 /*======================================================================
00364  FILE: icalduration.h
00365  CREATOR: eric 26 Jan 2001
00366 
00367 
00368  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
00369  $Locker:  $
00370 
00371  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00372 
00373  This program is free software; you can redistribute it and/or modify
00374  it under the terms of either: 
00375 
00376     The LGPL as published by the Free Software Foundation, version
00377     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00378 
00379   Or:
00380 
00381     The Mozilla Public License Version 1.0. You may obtain a copy of
00382     the License at http://www.mozilla.org/MPL/
00383 
00384  The Original Code is eric. The Initial Developer of the Original
00385  Code is Eric Busboom
00386 
00387 
00388 ======================================================================*/
00389 
00390 #ifndef ICALDURATION_H
00391 #define ICALDURATION_H
00392 
00393 
00394 struct icaldurationtype
00395 {
00396        int is_neg;
00397        unsigned int days;
00398        unsigned int weeks;
00399        unsigned int hours;
00400        unsigned int minutes;
00401        unsigned int seconds;
00402 };
00403 
00404 struct icaldurationtype icaldurationtype_from_int(int t);
00405 struct icaldurationtype icaldurationtype_from_string(const char*);
00406 int icaldurationtype_as_int(struct icaldurationtype duration);
00407 char* icaldurationtype_as_ical_string(struct icaldurationtype d);
00408 struct icaldurationtype icaldurationtype_null_duration(void);
00409 int icaldurationtype_is_null_duration(struct icaldurationtype d);
00410 
00411 struct icaltimetype  icaltime_add(struct icaltimetype t,
00412                               struct icaldurationtype  d);
00413 
00414 struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
00415                                       struct icaltimetype t2);
00416 
00417 #endif /* !ICALDURATION_H */
00418 
00419 
00420 
00421 /* -*- Mode: C -*- */
00422 /*======================================================================
00423  FILE: icalperiod.h
00424  CREATOR: eric 26 Jan 2001
00425 
00426 
00427  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
00428  $Locker:  $
00429 
00430  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00431 
00432  This program is free software; you can redistribute it and/or modify
00433  it under the terms of either: 
00434 
00435     The LGPL as published by the Free Software Foundation, version
00436     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00437 
00438   Or:
00439 
00440     The Mozilla Public License Version 1.0. You may obtain a copy of
00441     the License at http://www.mozilla.org/MPL/
00442 
00443  The Original Code is eric. The Initial Developer of the Original
00444  Code is Eric Busboom
00445 
00446 
00447 ======================================================================*/
00448 
00449 #ifndef ICALPERIOD_H
00450 #define ICALPERIOD_H
00451 
00452 
00453 struct icalperiodtype 
00454 {
00455        struct icaltimetype start; 
00456        struct icaltimetype end; 
00457        struct icaldurationtype duration;
00458 };
00459 
00460 struct icalperiodtype icalperiodtype_from_string (const char* str);
00461 
00462 const char* icalperiodtype_as_ical_string(struct icalperiodtype p);
00463 
00464 struct icalperiodtype icalperiodtype_null_period(void);
00465 
00466 int icalperiodtype_is_null_period(struct icalperiodtype p);
00467 
00468 int icalperiodtype_is_valid_period(struct icalperiodtype p);
00469 
00470 #endif /* !ICALTIME_H */
00471 
00472 
00473 
00474 
00475 /* -*- Mode: C -*-*/
00476 /*======================================================================
00477  FILE: icalenums.h
00478 
00479  
00480 
00481  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00482 
00483  This program is free software; you can redistribute it and/or modify
00484  it under the terms of either: 
00485 
00486     The LGPL as published by the Free Software Foundation, version
00487     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00488 
00489   Or:
00490 
00491     The Mozilla Public License Version 1.0. You may obtain a copy of
00492     the License at http://www.mozilla.org/MPL/
00493 
00494   The original code is icalenums.h
00495 
00496   Contributions from:
00497      Graham Davison (g.m.davison@computer.org)
00498 
00499 ======================================================================*/
00500 
00501 #ifndef ICALENUMS_H
00502 #define ICALENUMS_H
00503 
00504 
00505 
00506 /***********************************************************************
00507  * Component enumerations
00508 **********************************************************************/
00509 
00510 typedef enum icalcomponent_kind {
00511     ICAL_NO_COMPONENT,
00512     ICAL_ANY_COMPONENT,     /* Used to select all components*/
00513     ICAL_XROOT_COMPONENT,
00514     ICAL_XATTACH_COMPONENT, /* MIME attached data, returned by parser. */
00515     ICAL_VEVENT_COMPONENT,
00516     ICAL_VTODO_COMPONENT,
00517     ICAL_VJOURNAL_COMPONENT,
00518     ICAL_VCALENDAR_COMPONENT,
00519     ICAL_VAGENDA_COMPONENT,
00520     ICAL_VFREEBUSY_COMPONENT,
00521     ICAL_VALARM_COMPONENT,
00522     ICAL_XAUDIOALARM_COMPONENT,  
00523     ICAL_XDISPLAYALARM_COMPONENT,
00524     ICAL_XEMAILALARM_COMPONENT,
00525     ICAL_XPROCEDUREALARM_COMPONENT,
00526     ICAL_VTIMEZONE_COMPONENT,
00527     ICAL_XSTANDARD_COMPONENT,
00528     ICAL_XDAYLIGHT_COMPONENT,
00529     ICAL_X_COMPONENT,
00530     ICAL_VSCHEDULE_COMPONENT,
00531     ICAL_VQUERY_COMPONENT,
00532     ICAL_VCAR_COMPONENT,
00533     ICAL_VCOMMAND_COMPONENT,
00534     ICAL_XLICINVALID_COMPONENT,
00535     ICAL_XLICMIMEPART_COMPONENT /* a non-stardard component that mirrors
00536                             structure of MIME data */
00537 
00538 } icalcomponent_kind;
00539 
00540 
00541 
00542 /***********************************************************************
00543  * Request Status codes
00544  **********************************************************************/
00545 
00546 typedef enum icalrequeststatus {
00547     ICAL_UNKNOWN_STATUS,
00548     ICAL_2_0_SUCCESS_STATUS,
00549     ICAL_2_1_FALLBACK_STATUS,
00550     ICAL_2_2_IGPROP_STATUS,
00551     ICAL_2_3_IGPARAM_STATUS,
00552     ICAL_2_4_IGXPROP_STATUS,
00553     ICAL_2_5_IGXPARAM_STATUS,
00554     ICAL_2_6_IGCOMP_STATUS,
00555     ICAL_2_7_FORWARD_STATUS,
00556     ICAL_2_8_ONEEVENT_STATUS,
00557     ICAL_2_9_TRUNC_STATUS,
00558     ICAL_2_10_ONETODO_STATUS,
00559     ICAL_2_11_TRUNCRRULE_STATUS,
00560     ICAL_3_0_INVPROPNAME_STATUS,
00561     ICAL_3_1_INVPROPVAL_STATUS,
00562     ICAL_3_2_INVPARAM_STATUS,
00563     ICAL_3_3_INVPARAMVAL_STATUS,
00564     ICAL_3_4_INVCOMP_STATUS,
00565     ICAL_3_5_INVTIME_STATUS,
00566     ICAL_3_6_INVRULE_STATUS,
00567     ICAL_3_7_INVCU_STATUS,
00568     ICAL_3_8_NOAUTH_STATUS,
00569     ICAL_3_9_BADVERSION_STATUS,
00570     ICAL_3_10_TOOBIG_STATUS,
00571     ICAL_3_11_MISSREQCOMP_STATUS,
00572     ICAL_3_12_UNKCOMP_STATUS,
00573     ICAL_3_13_BADCOMP_STATUS,
00574     ICAL_3_14_NOCAP_STATUS,
00575     ICAL_3_15_INVCOMMAND,
00576     ICAL_4_0_BUSY_STATUS,
00577     ICAL_4_1_STORE_ACCESS_DENIED,
00578     ICAL_4_2_STORE_FAILED,
00579     ICAL_4_3_STORE_NOT_FOUND,
00580     ICAL_5_0_MAYBE_STATUS,
00581     ICAL_5_1_UNAVAIL_STATUS,
00582     ICAL_5_2_NOSERVICE_STATUS,
00583     ICAL_5_3_NOSCHED_STATUS,
00584     ICAL_6_1_CONTAINER_NOT_FOUND,
00585        ICAL_9_0_UNRECOGNIZED_COMMAND
00586 } icalrequeststatus;
00587 
00588 
00589 const char* icalenum_reqstat_desc(icalrequeststatus stat);
00590 short icalenum_reqstat_major(icalrequeststatus stat);
00591 short icalenum_reqstat_minor(icalrequeststatus stat);
00592 icalrequeststatus icalenum_num_to_reqstat(short major, short minor);
00593 char* icalenum_reqstat_code(icalrequeststatus stat);
00594 
00595 /***********************************************************************
00596  * Conversion functions
00597 **********************************************************************/
00598 
00599 
00600 /* Thse routines used to be in icalenums.c, but were moved into the
00601    icalproperty, icalparameter, icalvalue, or icalcomponent modules. */
00602 
00603 /* const char* icalproperty_kind_to_string(icalproperty_kind kind);*/
00604 #define icalenum_property_kind_to_string(x) icalproperty_kind_to_string(x)
00605 
00606 /*icalproperty_kind icalproperty_string_to_kind(const char* string)*/
00607 #define icalenum_string_to_property_kind(x) icalproperty_string_to_kind(x)
00608 
00609 /*icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);*/
00610 #define icalenum_property_kind_to_value_kind(x) icalproperty_kind_to_value_kind(x)
00611 
00612 /*const char* icalenum_method_to_string(icalproperty_method);*/
00613 #define icalenum_method_to_string(x) icalproperty_method_to_string(x)
00614 
00615 /*icalproperty_method icalenum_string_to_method(const char* string);*/
00616 #define icalenum_string_to_method(x) icalproperty_string_to_method(x)
00617 
00618 /*const char* icalenum_status_to_string(icalproperty_status);*/
00619 #define icalenum_status_to_string(x) icalproperty_status_to_string(x)
00620 
00621 /*icalproperty_status icalenum_string_to_status(const char* string);*/
00622 #define icalenum_string_to_status(x) icalproperty_string_to_status(x)
00623 
00624 /*icalvalue_kind icalenum_string_to_value_kind(const char* str);*/
00625 #define icalenum_string_to_value_kind(x) icalvalue_string_to_kind(x)
00626 
00627 /*const char* icalenum_value_kind_to_string(icalvalue_kind kind);*/
00628 #define icalenum_value_kind_to_string(x) icalvalue_kind_to_string(x)
00629 
00630 /*const char* icalenum_component_kind_to_string(icalcomponent_kind kind);*/
00631 #define icalenum_component_kind_to_string(x) icalcomponent_kind_to_string(x)
00632 
00633 /*icalcomponent_kind icalenum_string_to_component_kind(const char* string);*/
00634 #define icalenum_string_to_component_kind(x) icalcomponent_string_to_kind(x)
00635 
00636 
00637 #endif /* !ICALENUMS_H */
00638 
00639 /* -*- Mode: C -*- */
00640 /*======================================================================
00641  FILE: icaltypes.h
00642  CREATOR: eric 20 March 1999
00643 
00644 
00645  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00646 
00647  This program is free software; you can redistribute it and/or modify
00648  it under the terms of either: 
00649 
00650     The LGPL as published by the Free Software Foundation, version
00651     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00652 
00653   Or:
00654 
00655     The Mozilla Public License Version 1.0. You may obtain a copy of
00656     the License at http://www.mozilla.org/MPL/
00657 
00658   The original code is icaltypes.h
00659 
00660 ======================================================================*/
00661 
00662 #ifndef ICALTYPES_H
00663 #define ICALTYPES_H
00664 
00665 #include <time.h>
00666 
00667 
00668 struct icalgeotype 
00669 {
00670        float lat;
00671        float lon;
00672 };
00673 
00674 
00675 struct icaldatetimeperiodtype 
00676 {
00677        struct icaltimetype time;
00678        struct icalperiodtype period;
00679 };
00680 
00681 
00682 struct icaltriggertype 
00683 {
00684        struct icaltimetype time; 
00685        struct icaldurationtype duration;
00686 };
00687 
00688 struct icaltriggertype icaltriggertype_from_int(const int reltime);
00689 struct icaltriggertype icaltriggertype_from_string(const char* str);
00690 
00691 int icaltriggertype_is_null_trigger(struct icaltriggertype tr);
00692 
00693 /* struct icalreqstattype. This struct contains two string pointers,
00694 but don't try to free either of them. The "desc" string is a pointer
00695 to a static table inside the library.  Don't try to free it. The
00696 "debug" string is a pointer into the string that the called passed
00697 into to icalreqstattype_from_string. Don't try to free it either, and
00698 don't use it after the original string has been freed.
00699 
00700 BTW, you would get that original string from
00701 *icalproperty_get_requeststatus() or icalvalue_get_text(), when
00702 operating on a the value of a request_status property. */
00703 
00704 struct icalreqstattype {
00705 
00706        icalrequeststatus code;
00707        const char* desc;
00708        const char* debug;
00709 };
00710 
00711 struct icalreqstattype icalreqstattype_from_string(const char* str);
00712 const char* icalreqstattype_as_string(struct icalreqstattype);
00713 
00714 
00715 
00716 struct icaltimezonephase {
00717     const char* tzname;
00718     int is_stdandard; /* 1 = standard tme, 0 = daylight savings time */
00719     struct icaltimetype dtstart;
00720     int offsetto;
00721     int tzoffsetfrom;
00722     const char* comment;
00723     struct icaldatetimeperiodtype rdate;
00724     const char* rrule;    
00725 };
00726 
00727 
00728 struct icaltimezonetype {
00729     const char* tzid;
00730     struct icaltimetype last_mod;
00731     const char* tzurl;
00732     
00733     /* Array of phases. The end of the array is a phase with tzname == 0 */
00734     struct icaltimezonephase *phases;
00735 };
00736 
00737 void icaltimezonetype_free(struct icaltimezonetype tzt);
00738 
00739 
00740 #endif /* !ICALTYPES_H */
00741 /* -*- Mode: C -*- */
00742 /*======================================================================
00743  FILE: icalrecur.h
00744  CREATOR: eric 20 March 2000
00745 
00746 
00747  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
00748 
00749  This program is free software; you can redistribute it and/or modify
00750  it under the terms of either: 
00751 
00752     The LGPL as published by the Free Software Foundation, version
00753     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00754 
00755   Or:
00756 
00757     The Mozilla Public License Version 1.0. You may obtain a copy of
00758     the License at http://www.mozilla.org/MPL/
00759 */
00760 
00808 #ifndef ICALRECUR_H
00809 #define ICALRECUR_H
00810 
00811 #include <time.h>
00812 
00813 /***********************************************************************
00814  * Recurrance enumerations
00815 **********************************************************************/
00816 
00817 typedef enum icalrecurrencetype_frequency
00818 {
00819     /* These enums are used to index an array, so don't change the
00820        order or the integers */
00821 
00822     ICAL_SECONDLY_RECURRENCE=0,
00823     ICAL_MINUTELY_RECURRENCE=1,
00824     ICAL_HOURLY_RECURRENCE=2,
00825     ICAL_DAILY_RECURRENCE=3,
00826     ICAL_WEEKLY_RECURRENCE=4,
00827     ICAL_MONTHLY_RECURRENCE=5,
00828     ICAL_YEARLY_RECURRENCE=6,
00829     ICAL_NO_RECURRENCE=7
00830 
00831 } icalrecurrencetype_frequency;
00832 
00833 typedef enum icalrecurrencetype_weekday
00834 {
00835     ICAL_NO_WEEKDAY,
00836     ICAL_SUNDAY_WEEKDAY,
00837     ICAL_MONDAY_WEEKDAY,
00838     ICAL_TUESDAY_WEEKDAY,
00839     ICAL_WEDNESDAY_WEEKDAY,
00840     ICAL_THURSDAY_WEEKDAY,
00841     ICAL_FRIDAY_WEEKDAY,
00842     ICAL_SATURDAY_WEEKDAY
00843 } icalrecurrencetype_weekday;
00844 
00845 enum {
00846     ICAL_RECURRENCE_ARRAY_MAX = 0x7f7f,
00847     ICAL_RECURRENCE_ARRAY_MAX_BYTE = 0x7f
00848 };
00849 
00850 
00851 
00852 /********************** Recurrence type routines **************/
00853 
00854 /* See RFC 2445 Section 4.3.10, RECUR Value, for an explanation of
00855    the values and fields in struct icalrecurrencetype */
00856 
00857 #define ICAL_BY_SECOND_SIZE 61
00858 #define ICAL_BY_MINUTE_SIZE 61
00859 #define ICAL_BY_HOUR_SIZE 25
00860 #define ICAL_BY_DAY_SIZE 364 /* 7 days * 52 weeks */
00861 #define ICAL_BY_MONTHDAY_SIZE 32
00862 #define ICAL_BY_YEARDAY_SIZE 367
00863 #define ICAL_BY_WEEKNO_SIZE 54
00864 #define ICAL_BY_MONTH_SIZE 13
00865 #define ICAL_BY_SETPOS_SIZE 367
00866 
00868 struct icalrecurrencetype 
00869 {
00870        icalrecurrencetype_frequency freq;
00871 
00872 
00873        /* until and count are mutually exclusive. */
00874               struct icaltimetype until; 
00875        int count;
00876 
00877        short interval;
00878        
00879        icalrecurrencetype_weekday week_start;
00880        
00881        /* The BY* parameters can each take a list of values. Here I
00882         * assume that the list of values will not be larger than the
00883         * range of the value -- that is, the client will not name a
00884         * value more than once. 
00885         
00886         * Each of the lists is terminated with the value
00887         * ICAL_RECURRENCE_ARRAY_MAX unless the the list is full.
00888         */
00889 
00890        short by_second[ICAL_BY_SECOND_SIZE];
00891        short by_minute[ICAL_BY_MINUTE_SIZE];
00892        short by_hour[ICAL_BY_HOUR_SIZE];
00893        short by_day[ICAL_BY_DAY_SIZE]; /* Encoded value, see below */
00894        short by_month_day[ICAL_BY_MONTHDAY_SIZE];
00895        short by_year_day[ ICAL_BY_YEARDAY_SIZE];
00896        short by_week_no[ICAL_BY_WEEKNO_SIZE];
00897        short by_month[ICAL_BY_MONTH_SIZE];
00898        short by_set_pos[ICAL_BY_SETPOS_SIZE];
00899 };
00900 
00901 
00902 void icalrecurrencetype_clear(struct icalrecurrencetype *r);
00903 
00914 enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day);
00915 
00917 short icalrecurrencetype_day_position(short day);
00918 
00919 
00920 /***********************************************************************
00921  * Recurrance rule parser
00922 **********************************************************************/
00923 
00925 struct icalrecurrencetype icalrecurrencetype_from_string(const char* str);
00926 char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur);
00927 
00928 
00929 /********** recurrence iteration routines ********************/
00930 
00931 typedef struct icalrecur_iterator_impl  icalrecur_iterator;
00932 
00934 icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule, 
00935                                            struct icaltimetype dtstart);
00936 
00938 struct icaltimetype icalrecur_iterator_next(icalrecur_iterator*);
00939 
00941 void icalrecur_iterator_free(icalrecur_iterator*);
00942 
00947 int icalrecur_expand_recurrence(char* rule, time_t start, 
00948                             int count, time_t* array);
00949 
00950 
00951 #endif
00952 /* -*- Mode: C -*- */
00953 /*======================================================================
00954  FILE: icalattach.h
00955  CREATOR: acampi 28 May 02
00956 
00957 
00958  (C) COPYRIGHT 2002, Andrea Campi
00959 
00960  This program is free software; you can redistribute it and/or modify
00961  it under the terms of either: 
00962 
00963     The LGPL as published by the Free Software Foundation, version
00964     2.1, available at: http://www.fsf.org/copyleft/lesser.html
00965 
00966   Or:
00967 
00968     The Mozilla Public License Version 1.0. You may obtain a copy of
00969     the License at http://www.mozilla.org/MPL/
00970 
00971   The original code is icalattach.h
00972 
00973 ======================================================================*/
00974 
00975 #ifndef ICALATTACH_H
00976 #define ICALATTACH_H
00977 
00978 
00979 typedef struct icalattach_impl icalattach;
00980 
00981 typedef void (* icalattach_free_fn_t) (unsigned char *data, void *user_data);
00982 
00983 icalattach *icalattach_new_from_url (const char *url);
00984 icalattach *icalattach_new_from_data (const unsigned char *data,
00985        icalattach_free_fn_t free_fn, void *free_fn_data);
00986 
00987 void icalattach_ref (icalattach *attach);
00988 void icalattach_unref (icalattach *attach);
00989 
00990 int icalattach_get_is_url (icalattach *attach);
00991 const char *icalattach_get_url (icalattach *attach);
00992 unsigned char *icalattach_get_data (icalattach *attach);
00993 
00994 struct icalattachtype* icalattachtype_new(void);
00995 void  icalattachtype_add_reference(struct icalattachtype* v);
00996 void icalattachtype_free(struct icalattachtype* v);
00997 
00998 void icalattachtype_set_url(struct icalattachtype* v, char* url);
00999 char* icalattachtype_get_url(struct icalattachtype* v);
01000 
01001 void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
01002                             int owns);
01003 char* icalattachtype_get_base64(struct icalattachtype* v);
01004 
01005 void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
01006                             int owns);
01007 void* icalattachtype_get_binary(struct icalattachtype* v);
01008 
01009 
01010 
01011 #endif /* !ICALATTACH_H */
01012 /* -*- Mode: C -*- */
01013 /*======================================================================
01014   FILE: icalvalue.h
01015   CREATOR: eric 20 March 1999
01016 
01017 
01018   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
01019   $Locker:  $
01020 
01021   
01022 
01023  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
01024 
01025  This program is free software; you can redistribute it and/or modify
01026  it under the terms of either: 
01027 
01028     The LGPL as published by the Free Software Foundation, version
01029     2.1, available at: http://www.fsf.org/copyleft/lesser.html
01030 
01031   Or:
01032 
01033     The Mozilla Public License Version 1.0. You may obtain a copy of
01034     the License at http://www.mozilla.org/MPL/
01035 
01036   The original code is icalvalue.h
01037 
01038   ======================================================================*/
01039 
01040 #ifndef ICALDERIVEDVALUE_H
01041 #define ICALDERIVEDVALUE_H
01042 
01043      
01044 typedef struct icalvalue_impl icalvalue;
01045 
01046 
01047 
01048 void icalvalue_set_x(icalvalue* value, const char* v);
01049 icalvalue* icalvalue_new_x(const char* v);
01050 const char* icalvalue_get_x(const icalvalue* value);
01051 
01052 icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
01053 void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
01054 struct icalrecurrencetype icalvalue_get_recur(const icalvalue* value);
01055 
01056 icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
01057 void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
01058 struct icaltriggertype icalvalue_get_trigger(const icalvalue* value);
01059 
01060 icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
01061 void icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v);
01062 struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(const icalvalue* value);
01063 
01064 icalvalue *icalvalue_new_attach (icalattach *attach);
01065 void icalvalue_set_attach (icalvalue *value, icalattach *attach);
01066 icalattach *icalvalue_get_attach (const icalvalue *value);
01067 
01068 void icalvalue_reset_kind(icalvalue* value);
01069 
01070 typedef enum icalvalue_kind {
01071    ICAL_ANY_VALUE=5000,
01072     ICAL_BOOLEAN_VALUE=5001,
01073     ICAL_UTCOFFSET_VALUE=5002,
01074     ICAL_XLICCLASS_VALUE=5003,
01075     ICAL_RECUR_VALUE=5004,
01076     ICAL_METHOD_VALUE=5005,
01077     ICAL_CALADDRESS_VALUE=5006,
01078     ICAL_PERIOD_VALUE=5007,
01079     ICAL_STATUS_VALUE=5008,
01080     ICAL_BINARY_VALUE=5009,
01081     ICAL_TEXT_VALUE=5010,
01082     ICAL_DURATION_VALUE=5011,
01083     ICAL_DATETIMEPERIOD_VALUE=5012,
01084     ICAL_INTEGER_VALUE=5013,
01085     ICAL_URI_VALUE=5014,
01086     ICAL_TRIGGER_VALUE=5015,
01087     ICAL_ATTACH_VALUE=5016,
01088     ICAL_CLASS_VALUE=5017,
01089     ICAL_FLOAT_VALUE=5018,
01090     ICAL_QUERY_VALUE=5019,
01091     ICAL_STRING_VALUE=5020,
01092     ICAL_TRANSP_VALUE=5021,
01093     ICAL_X_VALUE=5022,
01094     ICAL_DATETIME_VALUE=5023,
01095     ICAL_REQUESTSTATUS_VALUE=5024,
01096     ICAL_GEO_VALUE=5025,
01097     ICAL_DATE_VALUE=5026,
01098     ICAL_ACTION_VALUE=5027,
01099    ICAL_NO_VALUE=5028
01100 } icalvalue_kind ;
01101 
01102 #define ICALPROPERTY_FIRST_ENUM 10000
01103 
01104 typedef enum icalproperty_action {
01105     ICAL_ACTION_X = 10000,
01106     ICAL_ACTION_AUDIO = 10001,
01107     ICAL_ACTION_DISPLAY = 10002,
01108     ICAL_ACTION_EMAIL = 10003,
01109     ICAL_ACTION_PROCEDURE = 10004,
01110     ICAL_ACTION_NONE = 10005
01111 } icalproperty_action;
01112 
01113 typedef enum icalproperty_class {
01114     ICAL_CLASS_X = 10006,
01115     ICAL_CLASS_PUBLIC = 10007,
01116     ICAL_CLASS_PRIVATE = 10008,
01117     ICAL_CLASS_CONFIDENTIAL = 10009,
01118     ICAL_CLASS_NONE = 10010
01119 } icalproperty_class;
01120 
01121 typedef enum icalproperty_method {
01122     ICAL_METHOD_X = 10011,
01123     ICAL_METHOD_PUBLISH = 10012,
01124     ICAL_METHOD_REQUEST = 10013,
01125     ICAL_METHOD_REPLY = 10014,
01126     ICAL_METHOD_ADD = 10015,
01127     ICAL_METHOD_CANCEL = 10016,
01128     ICAL_METHOD_REFRESH = 10017,
01129     ICAL_METHOD_COUNTER = 10018,
01130     ICAL_METHOD_DECLINECOUNTER = 10019,
01131     ICAL_METHOD_CREATE = 10020,
01132     ICAL_METHOD_READ = 10021,
01133     ICAL_METHOD_RESPONSE = 10022,
01134     ICAL_METHOD_MOVE = 10023,
01135     ICAL_METHOD_MODIFY = 10024,
01136     ICAL_METHOD_GENERATEUID = 10025,
01137     ICAL_METHOD_DELETE = 10026,
01138     ICAL_METHOD_NONE = 10027
01139 } icalproperty_method;
01140 
01141 typedef enum icalproperty_status {
01142     ICAL_STATUS_X = 10028,
01143     ICAL_STATUS_TENTATIVE = 10029,
01144     ICAL_STATUS_CONFIRMED = 10030,
01145     ICAL_STATUS_COMPLETED = 10031,
01146     ICAL_STATUS_NEEDSACTION = 10032,
01147     ICAL_STATUS_CANCELLED = 10033,
01148     ICAL_STATUS_INPROCESS = 10034,
01149     ICAL_STATUS_DRAFT = 10035,
01150     ICAL_STATUS_FINAL = 10036,
01151     ICAL_STATUS_NONE = 10037
01152 } icalproperty_status;
01153 
01154 typedef enum icalproperty_transp {
01155     ICAL_TRANSP_X = 10038,
01156     ICAL_TRANSP_OPAQUE = 10039,
01157     ICAL_TRANSP_OPAQUENOCONFLICT = 10040,
01158     ICAL_TRANSP_TRANSPARENT = 10041,
01159     ICAL_TRANSP_TRANSPARENTNOCONFLICT = 10042,
01160     ICAL_TRANSP_NONE = 10043
01161 } icalproperty_transp;
01162 
01163 typedef enum icalproperty_xlicclass {
01164     ICAL_XLICCLASS_X = 10044,
01165     ICAL_XLICCLASS_PUBLISHNEW = 10045,
01166     ICAL_XLICCLASS_PUBLISHUPDATE = 10046,
01167     ICAL_XLICCLASS_PUBLISHFREEBUSY = 10047,
01168     ICAL_XLICCLASS_REQUESTNEW = 10048,
01169     ICAL_XLICCLASS_REQUESTUPDATE = 10049,
01170     ICAL_XLICCLASS_REQUESTRESCHEDULE = 10050,
01171     ICAL_XLICCLASS_REQUESTDELEGATE = 10051,
01172     ICAL_XLICCLASS_REQUESTNEWORGANIZER = 10052,
01173     ICAL_XLICCLASS_REQUESTFORWARD = 10053,
01174     ICAL_XLICCLASS_REQUESTSTATUS = 10054,
01175     ICAL_XLICCLASS_REQUESTFREEBUSY = 10055,
01176     ICAL_XLICCLASS_REPLYACCEPT = 10056,
01177     ICAL_XLICCLASS_REPLYDECLINE = 10057,
01178     ICAL_XLICCLASS_REPLYDELEGATE = 10058,
01179     ICAL_XLICCLASS_REPLYCRASHERACCEPT = 10059,
01180     ICAL_XLICCLASS_REPLYCRASHERDECLINE = 10060,
01181     ICAL_XLICCLASS_ADDINSTANCE = 10061,
01182     ICAL_XLICCLASS_CANCELEVENT = 10062,
01183     ICAL_XLICCLASS_CANCELINSTANCE = 10063,
01184     ICAL_XLICCLASS_CANCELALL = 10064,
01185     ICAL_XLICCLASS_REFRESH = 10065,
01186     ICAL_XLICCLASS_COUNTER = 10066,
01187     ICAL_XLICCLASS_DECLINECOUNTER = 10067,
01188     ICAL_XLICCLASS_MALFORMED = 10068,
01189     ICAL_XLICCLASS_OBSOLETE = 10069,
01190     ICAL_XLICCLASS_MISSEQUENCED = 10070,
01191     ICAL_XLICCLASS_UNKNOWN = 10071,
01192     ICAL_XLICCLASS_NONE = 10072
01193 } icalproperty_xlicclass;
01194 
01195 #define ICALPROPERTY_LAST_ENUM 10073
01196 
01197 
01198  /* BOOLEAN */ 
01199 icalvalue* icalvalue_new_boolean(int v); 
01200 int icalvalue_get_boolean(const icalvalue* value); 
01201 void icalvalue_set_boolean(icalvalue* value, int v);
01202 
01203 
01204  /* UTC-OFFSET */ 
01205 icalvalue* icalvalue_new_utcoffset(int v); 
01206 int icalvalue_get_utcoffset(const icalvalue* value); 
01207 void icalvalue_set_utcoffset(icalvalue* value, int v);
01208 
01209 
01210  /* X-LIC-CLASS */ 
01211 icalvalue* icalvalue_new_xlicclass(enum icalproperty_xlicclass v); 
01212 enum icalproperty_xlicclass icalvalue_get_xlicclass(const icalvalue* value); 
01213 void icalvalue_set_xlicclass(icalvalue* value, enum icalproperty_xlicclass v);
01214 
01215 
01216  /* METHOD */ 
01217 icalvalue* icalvalue_new_method(enum icalproperty_method v); 
01218 enum icalproperty_method icalvalue_get_method(const icalvalue* value); 
01219 void icalvalue_set_method(icalvalue* value, enum icalproperty_method v);
01220 
01221 
01222  /* CAL-ADDRESS */ 
01223 icalvalue* icalvalue_new_caladdress(const char* v); 
01224 const char* icalvalue_get_caladdress(const icalvalue* value); 
01225 void icalvalue_set_caladdress(icalvalue* value, const char* v);
01226 
01227 
01228  /* PERIOD */ 
01229 icalvalue* icalvalue_new_period(struct icalperiodtype v); 
01230 struct icalperiodtype icalvalue_get_period(const icalvalue* value); 
01231 void icalvalue_set_period(icalvalue* value, struct icalperiodtype v);
01232 
01233 
01234  /* STATUS */ 
01235 icalvalue* icalvalue_new_status(enum icalproperty_status v); 
01236 enum icalproperty_status icalvalue_get_status(const icalvalue* value); 
01237 void icalvalue_set_status(icalvalue* value, enum icalproperty_status v);
01238 
01239 
01240  /* BINARY */ 
01241 icalvalue* icalvalue_new_binary(const char* v); 
01242 const char* icalvalue_get_binary(const icalvalue* value); 
01243 void icalvalue_set_binary(icalvalue* value, const char* v);
01244 
01245 
01246  /* TEXT */ 
01247 icalvalue* icalvalue_new_text(const char* v); 
01248 const char* icalvalue_get_text(const icalvalue* value); 
01249 void icalvalue_set_text(icalvalue* value, const char* v);
01250 
01251 
01252  /* DURATION */ 
01253 icalvalue* icalvalue_new_duration(struct icaldurationtype v); 
01254 struct icaldurationtype icalvalue_get_duration(const icalvalue* value); 
01255 void icalvalue_set_duration(icalvalue* value, struct icaldurationtype v);
01256 
01257 
01258  /* INTEGER */ 
01259 icalvalue* icalvalue_new_integer(int v); 
01260 int icalvalue_get_integer(const icalvalue* value); 
01261 void icalvalue_set_integer(icalvalue* value, int v);
01262 
01263 
01264  /* URI */ 
01265 icalvalue* icalvalue_new_uri(const char* v); 
01266 const char* icalvalue_get_uri(const icalvalue* value); 
01267 void icalvalue_set_uri(icalvalue* value, const char* v);
01268 
01269 
01270  /* CLASS */ 
01271 icalvalue* icalvalue_new_class(enum icalproperty_class v); 
01272 enum icalproperty_class icalvalue_get_class(const icalvalue* value); 
01273 void icalvalue_set_class(icalvalue* value, enum icalproperty_class v);
01274 
01275 
01276  /* FLOAT */ 
01277 icalvalue* icalvalue_new_float(float v); 
01278 float icalvalue_get_float(const icalvalue* value); 
01279 void icalvalue_set_float(icalvalue* value, float v);
01280 
01281 
01282  /* QUERY */ 
01283 icalvalue* icalvalue_new_query(const char* v); 
01284 const char* icalvalue_get_query(const icalvalue* value); 
01285 void icalvalue_set_query(icalvalue* value, const char* v);
01286 
01287 
01288  /* STRING */ 
01289 icalvalue* icalvalue_new_string(const char* v); 
01290 const char* icalvalue_get_string(const icalvalue* value); 
01291 void icalvalue_set_string(icalvalue* value, const char* v);
01292 
01293 
01294  /* TRANSP */ 
01295 icalvalue* icalvalue_new_transp(enum icalproperty_transp v); 
01296 enum icalproperty_transp icalvalue_get_transp(const icalvalue* value); 
01297 void icalvalue_set_transp(icalvalue* value, enum icalproperty_transp v);
01298 
01299 
01300  /* DATE-TIME */ 
01301 icalvalue* icalvalue_new_datetime(struct icaltimetype v); 
01302 struct icaltimetype icalvalue_get_datetime(const icalvalue* value); 
01303 void icalvalue_set_datetime(icalvalue* value, struct icaltimetype v);
01304 
01305 
01306  /* REQUEST-STATUS */ 
01307 icalvalue* icalvalue_new_requeststatus(struct icalreqstattype v); 
01308 struct icalreqstattype icalvalue_get_requeststatus(const icalvalue* value); 
01309 void icalvalue_set_requeststatus(icalvalue* value, struct icalreqstattype v);
01310 
01311 
01312  /* GEO */ 
01313 icalvalue* icalvalue_new_geo(struct icalgeotype v); 
01314 struct icalgeotype icalvalue_get_geo(const icalvalue* value); 
01315 void icalvalue_set_geo(icalvalue* value, struct icalgeotype v);
01316 
01317 
01318  /* DATE */ 
01319 icalvalue* icalvalue_new_date(struct icaltimetype v); 
01320 struct icaltimetype icalvalue_get_date(const icalvalue* value); 
01321 void icalvalue_set_date(icalvalue* value, struct icaltimetype v);
01322 
01323 
01324  /* ACTION */ 
01325 icalvalue* icalvalue_new_action(enum icalproperty_action v); 
01326 enum icalproperty_action icalvalue_get_action(const icalvalue* value); 
01327 void icalvalue_set_action(icalvalue* value, enum icalproperty_action v);
01328 
01329 #endif /*ICALVALUE_H*/
01330 /* -*- Mode: C -*- */
01331 /*======================================================================
01332   FILE: icalparam.h
01333   CREATOR: eric 20 March 1999
01334 
01335 
01336   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
01337   $Locker:  $
01338 
01339   
01340 
01341  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
01342 
01343  This program is free software; you can redistribute it and/or modify
01344  it under the terms of either: 
01345 
01346     The LGPL as published by the Free Software Foundation, version
01347     2.1, available at: http://www.fsf.org/copyleft/lesser.html
01348 
01349   Or:
01350 
01351     The Mozilla Public License Version 1.0. You may obtain a copy of
01352     the License at http://www.mozilla.org/MPL/
01353 
01354   The original code is icalparam.h
01355 
01356   ======================================================================*/
01357 
01358 #ifndef ICALDERIVEDPARAMETER_H
01359 #define ICALDERIVEDPARAMETER_H
01360 
01361 
01362 typedef struct icalparameter_impl icalparameter;
01363 
01364 const char* icalparameter_enum_to_string(int e);
01365 int icalparameter_string_to_enum(const char* str); 
01366 
01367 typedef enum icalparameter_kind {
01368     ICAL_ANY_PARAMETER = 0,
01369     ICAL_ALTREP_PARAMETER, 
01370     ICAL_CN_PARAMETER, 
01371     ICAL_CUTYPE_PARAMETER, 
01372     ICAL_DELEGATEDFROM_PARAMETER, 
01373     ICAL_DELEGATEDTO_PARAMETER, 
01374     ICAL_DIR_PARAMETER, 
01375     ICAL_ENCODING_PARAMETER, 
01376     ICAL_FBTYPE_PARAMETER, 
01377     ICAL_FMTTYPE_PARAMETER, 
01378     ICAL_LANGUAGE_PARAMETER, 
01379     ICAL_MEMBER_PARAMETER, 
01380     ICAL_PARTSTAT_PARAMETER, 
01381     ICAL_RANGE_PARAMETER, 
01382     ICAL_RELATED_PARAMETER, 
01383     ICAL_RELTYPE_PARAMETER, 
01384     ICAL_ROLE_PARAMETER, 
01385     ICAL_RSVP_PARAMETER, 
01386     ICAL_SENTBY_PARAMETER, 
01387     ICAL_TZID_PARAMETER, 
01388     ICAL_VALUE_PARAMETER, 
01389     ICAL_X_PARAMETER, 
01390     ICAL_XLICCOMPARETYPE_PARAMETER, 
01391     ICAL_XLICERRORTYPE_PARAMETER, 
01392     ICAL_NO_PARAMETER
01393 } icalparameter_kind;
01394 
01395 #define ICALPARAMETER_FIRST_ENUM 20000
01396 
01397 typedef enum icalparameter_cutype {
01398     ICAL_CUTYPE_X = 20000,
01399     ICAL_CUTYPE_INDIVIDUAL = 20001,
01400     ICAL_CUTYPE_GROUP = 20002,
01401     ICAL_CUTYPE_RESOURCE = 20003,
01402     ICAL_CUTYPE_ROOM = 20004,
01403     ICAL_CUTYPE_UNKNOWN = 20005,
01404     ICAL_CUTYPE_NONE = 20006
01405 } icalparameter_cutype;
01406 
01407 typedef enum icalparameter_encoding {
01408     ICAL_ENCODING_X = 20007,
01409     ICAL_ENCODING_8BIT = 20008,
01410     ICAL_ENCODING_BASE64 = 20009,
01411     ICAL_ENCODING_NONE = 20010
01412 } icalparameter_encoding;
01413 
01414 typedef enum icalparameter_fbtype {
01415     ICAL_FBTYPE_X = 20011,
01416     ICAL_FBTYPE_FREE = 20012,
01417     ICAL_FBTYPE_BUSY = 20013,
01418     ICAL_FBTYPE_BUSYUNAVAILABLE = 20014,
01419     ICAL_FBTYPE_BUSYTENTATIVE = 20015,
01420     ICAL_FBTYPE_NONE = 20016
01421 } icalparameter_fbtype;
01422 
01423 typedef enum icalparameter_partstat {
01424     ICAL_PARTSTAT_X = 20017,
01425     ICAL_PARTSTAT_NEEDSACTION = 20018,
01426     ICAL_PARTSTAT_ACCEPTED = 20019,
01427     ICAL_PARTSTAT_DECLINED = 20020,
01428     ICAL_PARTSTAT_TENTATIVE = 20021,
01429     ICAL_PARTSTAT_DELEGATED = 20022,
01430     ICAL_PARTSTAT_COMPLETED = 20023,
01431     ICAL_PARTSTAT_INPROCESS = 20024,
01432     ICAL_PARTSTAT_NONE = 20025
01433 } icalparameter_partstat;
01434 
01435 typedef enum icalparameter_range {
01436     ICAL_RANGE_X = 20026,
01437     ICAL_RANGE_THISANDPRIOR = 20027,
01438     ICAL_RANGE_THISANDFUTURE = 20028,
01439     ICAL_RANGE_NONE = 20029
01440 } icalparameter_range;
01441 
01442 typedef enum icalparameter_related {
01443     ICAL_RELATED_X = 20030,
01444     ICAL_RELATED_START = 20031,
01445     ICAL_RELATED_END = 20032,
01446     ICAL_RELATED_NONE = 20033
01447 } icalparameter_related;
01448 
01449 typedef enum icalparameter_reltype {
01450     ICAL_RELTYPE_X = 20034,
01451     ICAL_RELTYPE_PARENT = 20035,
01452     ICAL_RELTYPE_CHILD = 20036,
01453     ICAL_RELTYPE_SIBLING = 20037,
01454     ICAL_RELTYPE_NONE = 20038
01455 } icalparameter_reltype;
01456 
01457 typedef enum icalparameter_role {
01458     ICAL_ROLE_X = 20039,
01459     ICAL_ROLE_CHAIR = 20040,
01460     ICAL_ROLE_REQPARTICIPANT = 20041,
01461     ICAL_ROLE_OPTPARTICIPANT = 20042,
01462     ICAL_ROLE_NONPARTICIPANT = 20043,
01463     ICAL_ROLE_NONE = 20044
01464 } icalparameter_role;
01465 
01466 typedef enum icalparameter_rsvp {
01467     ICAL_RSVP_X = 20045,
01468     ICAL_RSVP_TRUE = 20046,
01469     ICAL_RSVP_FALSE = 20047,
01470     ICAL_RSVP_NONE = 20048
01471 } icalparameter_rsvp;
01472 
01473 typedef enum icalparameter_value {
01474     ICAL_VALUE_X = 20049,
01475     ICAL_VALUE_BINARY = 20050,
01476     ICAL_VALUE_BOOLEAN = 20051,
01477     ICAL_VALUE_DATE = 20052,
01478     ICAL_VALUE_DURATION = 20053,
01479     ICAL_VALUE_FLOAT = 20054,
01480     ICAL_VALUE_INTEGER = 20055,
01481     ICAL_VALUE_PERIOD = 20056,
01482     ICAL_VALUE_RECUR = 20057,
01483     ICAL_VALUE_TEXT = 20058,
01484     ICAL_VALUE_URI = 20059,
01485     ICAL_VALUE_ERROR = 20060,
01486     ICAL_VALUE_DATETIME = 20061,
01487     ICAL_VALUE_UTCOFFSET = 20062,
01488     ICAL_VALUE_CALADDRESS = 20063,
01489     ICAL_VALUE_NONE = 20064
01490 } icalparameter_value;
01491 
01492 typedef enum icalparameter_xliccomparetype {
01493     ICAL_XLICCOMPARETYPE_X = 20065,
01494     ICAL_XLICCOMPARETYPE_EQUAL = 20066,
01495     ICAL_XLICCOMPARETYPE_NOTEQUAL = 20067,
01496     ICAL_XLICCOMPARETYPE_LESS = 20068,
01497     ICAL_XLICCOMPARETYPE_GREATER = 20069,
01498     ICAL_XLICCOMPARETYPE_LESSEQUAL = 20070,
01499     ICAL_XLICCOMPARETYPE_GREATEREQUAL = 20071,
01500     ICAL_XLICCOMPARETYPE_REGEX = 20072,
01501     ICAL_XLICCOMPARETYPE_ISNULL = 20073,
01502     ICAL_XLICCOMPARETYPE_ISNOTNULL = 20074,
01503     ICAL_XLICCOMPARETYPE_NONE = 20075
01504 } icalparameter_xliccomparetype;
01505 
01506 typedef enum icalparameter_xlicerrortype {
01507     ICAL_XLICERRORTYPE_X = 20076,
01508     ICAL_XLICERRORTYPE_COMPONENTPARSEERROR = 20077,
01509     ICAL_XLICERRORTYPE_PROPERTYPARSEERROR = 20078,
01510     ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR = 20079,
01511     ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR = 20080,
01512     ICAL_XLICERRORTYPE_VALUEPARSEERROR = 20081,
01513     ICAL_XLICERRORTYPE_INVALIDITIP = 20082,
01514     ICAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR = 20083,
01515     ICAL_XLICERRORTYPE_MIMEPARSEERROR = 20084,
01516     ICAL_XLICERRORTYPE_VCALPROPPARSEERROR = 20085,
01517     ICAL_XLICERRORTYPE_NONE = 20086
01518 } icalparameter_xlicerrortype;
01519 
01520 #define ICALPARAMETER_LAST_ENUM 20087
01521 
01522 /* DELEGATED-FROM */
01523 icalparameter* icalparameter_new_delegatedfrom(const char* v);
01524 const char* icalparameter_get_delegatedfrom(const icalparameter* value);
01525 void icalparameter_set_delegatedfrom(icalparameter* value, const char* v);
01526 
01527 /* RELATED */
01528 icalparameter* icalparameter_new_related(icalparameter_related v);
01529 icalparameter_related icalparameter_get_related(const icalparameter* value);
01530 void icalparameter_set_related(icalparameter* value, icalparameter_related v);
01531 
01532 /* SENT-BY */
01533 icalparameter* icalparameter_new_sentby(const char* v);
01534 const char* icalparameter_get_sentby(const icalparameter* value);
01535 void icalparameter_set_sentby(icalparameter* value, const char* v);
01536 
01537 /* LANGUAGE */
01538 icalparameter* icalparameter_new_language(const char* v);
01539 const char* icalparameter_get_language(const icalparameter* value);
01540 void icalparameter_set_language(icalparameter* value, const char* v);
01541 
01542 /* RELTYPE */
01543 icalparameter* icalparameter_new_reltype(icalparameter_reltype v);
01544 icalparameter_reltype icalparameter_get_reltype(const icalparameter* value);
01545 void icalparameter_set_reltype(icalparameter* value, icalparameter_reltype v);
01546 
01547 /* ENCODING */
01548 icalparameter* icalparameter_new_encoding(icalparameter_encoding v);
01549 icalparameter_encoding icalparameter_get_encoding(const icalparameter* value);
01550 void icalparameter_set_encoding(icalparameter* value, icalparameter_encoding v);
01551 
01552 /* ALTREP */
01553 icalparameter* icalparameter_new_altrep(const char* v);
01554 const char* icalparameter_get_altrep(const icalparameter* value);
01555 void icalparameter_set_altrep(icalparameter* value, const char* v);
01556 
01557 /* FMTTYPE */
01558 icalparameter* icalparameter_new_fmttype(const char* v);
01559 const char* icalparameter_get_fmttype(const icalparameter* value);
01560 void icalparameter_set_fmttype(icalparameter* value, const char* v);
01561 
01562 /* FBTYPE */
01563 icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v);
01564 icalparameter_fbtype icalparameter_get_fbtype(const icalparameter* value);
01565 void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype v);
01566 
01567 /* RSVP */
01568 icalparameter* icalparameter_new_rsvp(icalparameter_rsvp v);
01569 icalparameter_rsvp icalparameter_get_rsvp(const icalparameter* value);
01570 void icalparameter_set_rsvp(icalparameter* value, icalparameter_rsvp v);
01571 
01572 /* RANGE */
01573 icalparameter* icalparameter_new_range(icalparameter_range v);
01574 icalparameter_range icalparameter_get_range(const icalparameter* value);
01575 void icalparameter_set_range(icalparameter* value, icalparameter_range v);
01576 
01577 /* DELEGATED-TO */
01578 icalparameter* icalparameter_new_delegatedto(const char* v);
01579 const char* icalparameter_get_delegatedto(const icalparameter* value);
01580 void icalparameter_set_delegatedto(icalparameter* value, const char* v);
01581 
01582 /* CN */
01583 icalparameter* icalparameter_new_cn(const char* v);
01584 const char* icalparameter_get_cn(const icalparameter* value);
01585 void icalparameter_set_cn(icalparameter* value, const char* v);
01586 
01587 /* ROLE */
01588 icalparameter* icalparameter_new_role(icalparameter_role v);
01589 icalparameter_role icalparameter_get_role(const icalparameter* value);
01590 void icalparameter_set_role(icalparameter* value, icalparameter_role v);
01591 
01592 /* X-LIC-COMPARETYPE */
01593 icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v);
01594 icalparameter_xliccomparetype icalparameter_get_xliccomparetype(const icalparameter* value);
01595 void icalparameter_set_xliccomparetype(icalparameter* value, icalparameter_xliccomparetype v);
01596 
01597 /* PARTSTAT */
01598 icalparameter* icalparameter_new_partstat(icalparameter_partstat v);
01599 icalparameter_partstat icalparameter_get_partstat(const icalparameter* value);
01600 void icalparameter_set_partstat(icalparameter* value, icalparameter_partstat v);
01601 
01602 /* X-LIC-ERRORTYPE */
01603 icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v);
01604 icalparameter_xlicerrortype icalparameter_get_xlicerrortype(const icalparameter* value);
01605 void icalparameter_set_xlicerrortype(icalparameter* value, icalparameter_xlicerrortype v);
01606 
01607 /* MEMBER */
01608 icalparameter* icalparameter_new_member(const char* v);
01609 const char* icalparameter_get_member(const icalparameter* value);
01610 void icalparameter_set_member(icalparameter* value, const char* v);
01611 
01612 /* X */
01613 icalparameter* icalparameter_new_x(const char* v);
01614 const char* icalparameter_get_x(const icalparameter* value);
01615 void icalparameter_set_x(icalparameter* value, const char* v);
01616 
01617 /* CUTYPE */
01618 icalparameter* icalparameter_new_cutype(icalparameter_cutype v);
01619 icalparameter_cutype icalparameter_get_cutype(const icalparameter* value);
01620 void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v);
01621 
01622 /* TZID */
01623 icalparameter* icalparameter_new_tzid(const char* v);
01624 const char* icalparameter_get_tzid(const icalparameter* value);
01625 void icalparameter_set_tzid(icalparameter* value, const char* v);
01626 
01627 /* VALUE */
01628 icalparameter* icalparameter_new_value(icalparameter_value v);
01629 icalparameter_value icalparameter_get_value(const icalparameter* value);
01630 void icalparameter_set_value(icalparameter* value, icalparameter_value v);
01631 
01632 /* DIR */
01633 icalparameter* icalparameter_new_dir(const char* v);
01634 const char* icalparameter_get_dir(const icalparameter* value);
01635 void icalparameter_set_dir(icalparameter* value, const char* v);
01636 
01637 #endif /*ICALPARAMETER_H*/
01638 
01639 /* Everything below this line is machine generated. Do not edit. */
01640 /* -*- Mode: C -*- */
01641 /*======================================================================
01642   FILE: icalvalue.h
01643   CREATOR: eric 20 March 1999
01644 
01645 
01646   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
01647   $Locker:  $
01648 
01649  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
01650 
01651  This program is free software; you can redistribute it and/or modify
01652  it under the terms of either: 
01653 
01654     The LGPL as published by the Free Software Foundation, version
01655     2.1, available at: http://www.fsf.org/copyleft/lesser.html
01656 
01657   Or:
01658 
01659     The Mozilla Public License Version 1.0. You may obtain a copy of
01660     the License at http://www.mozilla.org/MPL/
01661 
01662   The original code is icalvalue.h
01663 
01664   ======================================================================*/
01665 
01666 #ifndef ICALVALUE_H
01667 #define ICALVALUE_H
01668 
01669 #include <time.h>
01670                           
01671 /* Defined in icalderivedvalue.h */
01672 /*typedef struct icalvalue_impl icalvalue;*/
01673 
01674 icalvalue* icalvalue_new(icalvalue_kind kind);
01675 
01676 icalvalue* icalvalue_new_clone(const icalvalue* value);
01677 
01678 icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str);
01679 
01680 void icalvalue_free(icalvalue* value);
01681 
01682 int icalvalue_is_valid(const icalvalue* value);
01683 
01684 const char* icalvalue_as_ical_string(const icalvalue* value);
01685 
01686 icalvalue_kind icalvalue_isa(const icalvalue* value);
01687 
01688 int icalvalue_isa_value(void*);
01689 
01690 icalparameter_xliccomparetype icalvalue_compare(const icalvalue* a, const icalvalue *b);
01691 
01692 
01693 /* Special, non autogenerated value accessors */
01694 
01695 icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
01696 void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
01697 struct icalrecurrencetype icalvalue_get_recur(const icalvalue* value);
01698 
01699 icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
01700 void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
01701 struct icaltriggertype icalvalue_get_trigger(const icalvalue* value);
01702 
01703 icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
01704 void icalvalue_set_datetimeperiod(icalvalue* value, 
01705                               struct icaldatetimeperiodtype v);
01706 struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(const icalvalue* value);
01707 
01708 /* Convert enumerations */
01709 
01710 icalvalue_kind icalvalue_string_to_kind(const char* str);
01711 const char* icalvalue_kind_to_string(const icalvalue_kind kind);
01712 
01714 int icalvalue_kind_is_valid(const icalvalue_kind kind);
01715 
01717 int icalvalue_encode_ical_string(const char *szText, char *szEncText, int MaxBufferLen);
01718 
01719 #endif /*ICALVALUE_H*/
01720 /* -*- Mode: C -*- */
01721 /*======================================================================
01722   FILE: icalparam.h
01723   CREATOR: eric 20 March 1999
01724 
01725 
01726   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
01727   $Locker:  $
01728 
01729   
01730 
01731  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
01732 
01733  This program is free software; you can redistribute it and/or modify
01734  it under the terms of either: 
01735 
01736     The LGPL as published by the Free Software Foundation, version
01737     2.1, available at: http://www.fsf.org/copyleft/lesser.html
01738 
01739   Or:
01740 
01741     The Mozilla Public License Version 1.0. You may obtain a copy of
01742     the License at http://www.mozilla.org/MPL/
01743 
01744   The original code is icalparam.h
01745 
01746   ======================================================================*/
01747 
01748 #ifndef ICALPARAM_H
01749 #define ICALPARAM_H
01750 
01751 
01752 /* Declared in icalderivedparameter.h */
01753 /*typedef struct icalparameter_impl icalparameter;*/
01754 
01755 icalparameter* icalparameter_new(icalparameter_kind kind);
01756 icalparameter* icalparameter_new_clone(icalparameter* p);
01757 
01758 /* Create from string of form "PARAMNAME=VALUE" */
01759 icalparameter* icalparameter_new_from_string(const char* value);
01760 
01761 /* Create from just the value, the part after the "=" */
01762 icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind, const char* value);
01763 
01764 void icalparameter_free(icalparameter* parameter);
01765 
01766 char* icalparameter_as_ical_string(icalparameter* parameter);
01767 
01768 int icalparameter_is_valid(icalparameter* parameter);
01769 
01770 icalparameter_kind icalparameter_isa(icalparameter* parameter);
01771 
01772 int icalparameter_isa_parameter(void* param);
01773 
01774 /* Acess the name of an X parameer */
01775 void icalparameter_set_xname (icalparameter* param, const char* v);
01776 const char* icalparameter_get_xname(icalparameter* param);
01777 void icalparameter_set_xvalue (icalparameter* param, const char* v);
01778 const char* icalparameter_get_xvalue(icalparameter* param);
01779 
01780 /* Convert enumerations */
01781 
01782 const char* icalparameter_kind_to_string(icalparameter_kind kind);
01783 icalparameter_kind icalparameter_string_to_kind(const char* string);
01784 
01785 
01786 
01787 #endif 
01788 /* -*- Mode: C -*-
01789   ======================================================================
01790   FILE: icalderivedproperties.{c,h}
01791   CREATOR: eric 09 May 1999
01792   
01793   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
01794     
01795  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
01796  ======================================================================*/
01797 
01798 
01799 #ifndef ICALDERIVEDPROPERTY_H
01800 #define ICALDERIVEDPROPERTY_H
01801 
01802 #include <time.h>
01803 
01804 typedef struct icalproperty_impl icalproperty;
01805 
01806 typedef enum icalproperty_kind {
01807     ICAL_ANY_PROPERTY = 0,
01808     ICAL_ACTION_PROPERTY, 
01809     ICAL_ALLOWCONFLICT_PROPERTY, 
01810     ICAL_ATTACH_PROPERTY, 
01811     ICAL_ATTENDEE_PROPERTY, 
01812     ICAL_CALID_PROPERTY, 
01813     ICAL_CALMASTER_PROPERTY, 
01814     ICAL_CALSCALE_PROPERTY, 
01815     ICAL_CARID_PROPERTY, 
01816     ICAL_CATEGORIES_PROPERTY, 
01817     ICAL_CLASS_PROPERTY, 
01818     ICAL_COMMENT_PROPERTY, 
01819     ICAL_COMPLETED_PROPERTY, 
01820     ICAL_CONTACT_PROPERTY, 
01821     ICAL_CREATED_PROPERTY, 
01822     ICAL_DECREED_PROPERTY, 
01823     ICAL_DEFAULTCHARSET_PROPERTY, 
01824     ICAL_DEFAULTLOCALE_PROPERTY, 
01825     ICAL_DEFAULTTZID_PROPERTY, 
01826     ICAL_DESCRIPTION_PROPERTY, 
01827     ICAL_DTEND_PROPERTY, 
01828     ICAL_DTSTAMP_PROPERTY, 
01829     ICAL_DTSTART_PROPERTY, 
01830     ICAL_DUE_PROPERTY, 
01831     ICAL_DURATION_PROPERTY, 
01832     ICAL_EXDATE_PROPERTY, 
01833     ICAL_EXPAND_PROPERTY, 
01834     ICAL_EXRULE_PROPERTY, 
01835     ICAL_FREEBUSY_PROPERTY, 
01836     ICAL_GEO_PROPERTY, 
01837     ICAL_LASTMODIFIED_PROPERTY, 
01838     ICAL_LOCATION_PROPERTY, 
01839     ICAL_MAXRESULTS_PROPERTY, 
01840     ICAL_MAXRESULTSSIZE_PROPERTY, 
01841     ICAL_METHOD_PROPERTY, 
01842     ICAL_ORGANIZER_PROPERTY, 
01843     ICAL_OWNER_PROPERTY, 
01844     ICAL_PERCENTCOMPLETE_PROPERTY, 
01845     ICAL_PRIORITY_PROPERTY, 
01846     ICAL_PRODID_PROPERTY, 
01847     ICAL_QUERY_PROPERTY, 
01848     ICAL_QUERYNAME_PROPERTY, 
01849     ICAL_RDATE_PROPERTY, 
01850     ICAL_RECURRENCEID_PROPERTY, 
01851     ICAL_RELATEDTO_PROPERTY, 
01852     ICAL_RELCALID_PROPERTY, 
01853     ICAL_REPEAT_PROPERTY, 
01854     ICAL_REQUESTSTATUS_PROPERTY, 
01855     ICAL_RESOURCES_PROPERTY, 
01856     ICAL_RRULE_PROPERTY, 
01857     ICAL_SCOPE_PROPERTY, 
01858     ICAL_SEQUENCE_PROPERTY, 
01859     ICAL_STATUS_PROPERTY, 
01860     ICAL_SUMMARY_PROPERTY, 
01861     ICAL_TARGET_PROPERTY, 
01862     ICAL_TRANSP_PROPERTY, 
01863     ICAL_TRIGGER_PROPERTY, 
01864     ICAL_TZID_PROPERTY, 
01865     ICAL_TZNAME_PROPERTY, 
01866     ICAL_TZOFFSETFROM_PROPERTY, 
01867     ICAL_TZOFFSETTO_PROPERTY, 
01868     ICAL_TZURL_PROPERTY, 
01869     ICAL_UID_PROPERTY, 
01870     ICAL_URL_PROPERTY, 
01871     ICAL_VERSION_PROPERTY, 
01872     ICAL_X_PROPERTY, 
01873     ICAL_XLICCLASS_PROPERTY, 
01874     ICAL_XLICCLUSTERCOUNT_PROPERTY, 
01875     ICAL_XLICERROR_PROPERTY, 
01876     ICAL_XLICMIMECHARSET_PROPERTY, 
01877     ICAL_XLICMIMECID_PROPERTY, 
01878     ICAL_XLICMIMECONTENTTYPE_PROPERTY, 
01879     ICAL_XLICMIMEENCODING_PROPERTY, 
01880     ICAL_XLICMIMEFILENAME_PROPERTY, 
01881     ICAL_XLICMIMEOPTINFO_PROPERTY, 
01882     ICAL_NO_PROPERTY
01883 } icalproperty_kind;
01884 
01885 
01886 /* ACTION */
01887 icalproperty* icalproperty_new_action(enum icalproperty_action v);
01888 void icalproperty_set_action(icalproperty* prop, enum icalproperty_action v);
01889 enum icalproperty_action icalproperty_get_action(const icalproperty* prop);icalproperty* icalproperty_vanew_action(enum icalproperty_action v, ...);
01890 
01891 /* ALLOW-CONFLICT */
01892 icalproperty* icalproperty_new_allowconflict(const char* v);
01893 void icalproperty_set_allowconflict(icalproperty* prop, const char* v);
01894 const char* icalproperty_get_allowconflict(const icalproperty* prop);icalproperty* icalproperty_vanew_allowconflict(const char* v, ...);
01895 
01896 /* ATTACH */
01897 icalproperty* icalproperty_new_attach(icalattach * v);
01898 void icalproperty_set_attach(icalproperty* prop, icalattach * v);
01899 icalattach * icalproperty_get_attach(const icalproperty* prop);icalproperty* icalproperty_vanew_attach(icalattach * v, ...);
01900 
01901 /* ATTENDEE */
01902 icalproperty* icalproperty_new_attendee(const char* v);
01903 void icalproperty_set_attendee(icalproperty* prop, const char* v);
01904 const char* icalproperty_get_attendee(const icalproperty* prop);icalproperty* icalproperty_vanew_attendee(const char* v, ...);
01905 
01906 /* CALID */
01907 icalproperty* icalproperty_new_calid(const char* v);
01908 void icalproperty_set_calid(icalproperty* prop, const char* v);
01909 const char* icalproperty_get_calid(const icalproperty* prop);icalproperty* icalproperty_vanew_calid(const char* v, ...);
01910 
01911 /* CALMASTER */
01912 icalproperty* icalproperty_new_calmaster(const char* v);
01913 void icalproperty_set_calmaster(icalproperty* prop, const char* v);
01914 const char* icalproperty_get_calmaster(const icalproperty* prop);icalproperty* icalproperty_vanew_calmaster(const char* v, ...);
01915 
01916 /* CALSCALE */
01917 icalproperty* icalproperty_new_calscale(const char* v);
01918 void icalproperty_set_calscale(icalproperty* prop, const char* v);
01919 const char* icalproperty_get_calscale(const icalproperty* prop);icalproperty* icalproperty_vanew_calscale(const char* v, ...);
01920 
01921 /* CARID */
01922 icalproperty* icalproperty_new_carid(const char* v);
01923 void icalproperty_set_carid(icalproperty* prop, const char* v);
01924 const char* icalproperty_get_carid(const icalproperty* prop);icalproperty* icalproperty_vanew_carid(const char* v, ...);
01925 
01926 /* CATEGORIES */
01927 icalproperty* icalproperty_new_categories(const char* v);
01928 void icalproperty_set_categories(icalproperty* prop, const char* v);
01929 const char* icalproperty_get_categories(const icalproperty* prop);icalproperty* icalproperty_vanew_categories(const char* v, ...);
01930 
01931 /* CLASS */
01932 icalproperty* icalproperty_new_class(enum icalproperty_class v);
01933 void icalproperty_set_class(icalproperty* prop, enum icalproperty_class v);
01934 enum icalproperty_class icalproperty_get_class(const icalproperty* prop);icalproperty* icalproperty_vanew_class(enum icalproperty_class v, ...);
01935 
01936 /* COMMENT */
01937 icalproperty* icalproperty_new_comment(const char* v);
01938 void icalproperty_set_comment(icalproperty* prop, const char* v);
01939 const char* icalproperty_get_comment(const icalproperty* prop);icalproperty* icalproperty_vanew_comment(const char* v, ...);
01940 
01941 /* COMPLETED */
01942 icalproperty* icalproperty_new_completed(struct icaltimetype v);
01943 void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v);
01944 struct icaltimetype icalproperty_get_completed(const icalproperty* prop);icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...);
01945 
01946 /* CONTACT */
01947 icalproperty* icalproperty_new_contact(const char* v);
01948 void icalproperty_set_contact(icalproperty* prop, const char* v);
01949 const char* icalproperty_get_contact(const icalproperty* prop);icalproperty* icalproperty_vanew_contact(const char* v, ...);
01950 
01951 /* CREATED */
01952 icalproperty* icalproperty_new_created(struct icaltimetype v);
01953 void icalproperty_set_created(icalproperty* prop, struct icaltimetype v);
01954 struct icaltimetype icalproperty_get_created(const icalproperty* prop);icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...);
01955 
01956 /* DECREED */
01957 icalproperty* icalproperty_new_decreed(const char* v);
01958 void icalproperty_set_decreed(icalproperty* prop, const char* v);
01959 const char* icalproperty_get_decreed(const icalproperty* prop);icalproperty* icalproperty_vanew_decreed(const char* v, ...);
01960 
01961 /* DEFAULT-CHARSET */
01962 icalproperty* icalproperty_new_defaultcharset(const char* v);
01963 void icalproperty_set_defaultcharset(icalproperty* prop, const char* v);
01964 const char* icalproperty_get_defaultcharset(const icalproperty* prop);icalproperty* icalproperty_vanew_defaultcharset(const char* v, ...);
01965 
01966 /* DEFAULT-LOCALE */
01967 icalproperty* icalproperty_new_defaultlocale(const char* v);
01968 void icalproperty_set_defaultlocale(icalproperty* prop, const char* v);
01969 const char* icalproperty_get_defaultlocale(const icalproperty* prop);icalproperty* icalproperty_vanew_defaultlocale(const char* v, ...);
01970 
01971 /* DEFAULT-TZID */
01972 icalproperty* icalproperty_new_defaulttzid(const char* v);
01973 void icalproperty_set_defaulttzid(icalproperty* prop, const char* v);
01974 const char* icalproperty_get_defaulttzid(const icalproperty* prop);icalproperty* icalproperty_vanew_defaulttzid(const char* v, ...);
01975 
01976 /* DESCRIPTION */
01977 icalproperty* icalproperty_new_description(const char* v);
01978 void icalproperty_set_description(icalproperty* prop, const char* v);
01979 const char* icalproperty_get_description(const icalproperty* prop);icalproperty* icalproperty_vanew_description(const char* v, ...);
01980 
01981 /* DTEND */
01982 icalproperty* icalproperty_new_dtend(struct icaltimetype v);
01983 void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v);
01984 struct icaltimetype icalproperty_get_dtend(const icalproperty* prop);icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...);
01985 
01986 /* DTSTAMP */
01987 icalproperty* icalproperty_new_dtstamp(struct icaltimetype v);
01988 void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v);
01989 struct icaltimetype icalproperty_get_dtstamp(const icalproperty* prop);icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...);
01990 
01991 /* DTSTART */
01992 icalproperty* icalproperty_new_dtstart(struct icaltimetype v);
01993 void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v);
01994 struct icaltimetype icalproperty_get_dtstart(const icalproperty* prop);icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...);
01995 
01996 /* DUE */
01997 icalproperty* icalproperty_new_due(struct icaltimetype v);
01998 void icalproperty_set_due(icalproperty* prop, struct icaltimetype v);
01999 struct icaltimetype icalproperty_get_due(const icalproperty* prop);icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...);
02000 
02001 /* DURATION */
02002 icalproperty* icalproperty_new_duration(struct icaldurationtype v);
02003 void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v);
02004 struct icaldurationtype icalproperty_get_duration(const icalproperty* prop);icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...);
02005 
02006 /* EXDATE */
02007 icalproperty* icalproperty_new_exdate(struct icaltimetype v);
02008 void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v);
02009 struct icaltimetype icalproperty_get_exdate(const icalproperty* prop);icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...);
02010 
02011 /* EXPAND */
02012 icalproperty* icalproperty_new_expand(int v);
02013 void icalproperty_set_expand(icalproperty* prop, int v);
02014 int icalproperty_get_expand(const icalproperty* prop);icalproperty* icalproperty_vanew_expand(int v, ...);
02015 
02016 /* EXRULE */
02017 icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v);
02018 void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v);
02019 struct icalrecurrencetype icalproperty_get_exrule(const icalproperty* prop);icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...);
02020 
02021 /* FREEBUSY */
02022 icalproperty* icalproperty_new_freebusy(struct icalperiodtype v);
02023 void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v);
02024 struct icalperiodtype icalproperty_get_freebusy(const icalproperty* prop);icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...);
02025 
02026 /* GEO */
02027 icalproperty* icalproperty_new_geo(struct icalgeotype v);
02028 void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v);
02029 struct icalgeotype icalproperty_get_geo(const icalproperty* prop);icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...);
02030 
02031 /* LAST-MODIFIED */
02032 icalproperty* icalproperty_new_lastmodified(struct icaltimetype v);
02033 void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v);
02034 struct icaltimetype icalproperty_get_lastmodified(const icalproperty* prop);icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...);
02035 
02036 /* LOCATION */
02037 icalproperty* icalproperty_new_location(const char* v);
02038 void icalproperty_set_location(icalproperty* prop, const char* v);
02039 const char* icalproperty_get_location(const icalproperty* prop);icalproperty* icalproperty_vanew_location(const char* v, ...);
02040 
02041 /* MAXRESULTS */
02042 icalproperty* icalproperty_new_maxresults(int v);
02043 void icalproperty_set_maxresults(icalproperty* prop, int v);
02044 int icalproperty_get_maxresults(const icalproperty* prop);icalproperty* icalproperty_vanew_maxresults(int v, ...);
02045 
02046 /* MAXRESULTSSIZE */
02047 icalproperty* icalproperty_new_maxresultssize(int v);
02048 void icalproperty_set_maxresultssize(icalproperty* prop, int v);
02049 int icalproperty_get_maxresultssize(const icalproperty* prop);icalproperty* icalproperty_vanew_maxresultssize(int v, ...);
02050 
02051 /* METHOD */
02052 icalproperty* icalproperty_new_method(enum icalproperty_method v);
02053 void icalproperty_set_method(icalproperty* prop, enum icalproperty_method v);
02054 enum icalproperty_method icalproperty_get_method(const icalproperty* prop);icalproperty* icalproperty_vanew_method(enum icalproperty_method v, ...);
02055 
02056 /* ORGANIZER */
02057 icalproperty* icalproperty_new_organizer(const char* v);
02058 void icalproperty_set_organizer(icalproperty* prop, const char* v);
02059 const char* icalproperty_get_organizer(const icalproperty* prop);icalproperty* icalproperty_vanew_organizer(const char* v, ...);
02060 
02061 /* OWNER */
02062 icalproperty* icalproperty_new_owner(const char* v);
02063 void icalproperty_set_owner(icalproperty* prop, const char* v);
02064 const char* icalproperty_get_owner(const icalproperty* prop);icalproperty* icalproperty_vanew_owner(const char* v, ...);
02065 
02066 /* PERCENT-COMPLETE */
02067 icalproperty* icalproperty_new_percentcomplete(int v);
02068 void icalproperty_set_percentcomplete(icalproperty* prop, int v);
02069 int icalproperty_get_percentcomplete(const icalproperty* prop);icalproperty* icalproperty_vanew_percentcomplete(int v, ...);
02070 
02071 /* PRIORITY */
02072 icalproperty* icalproperty_new_priority(int v);
02073 void icalproperty_set_priority(icalproperty* prop, int v);
02074 int icalproperty_get_priority(const icalproperty* prop);icalproperty* icalproperty_vanew_priority(int v, ...);
02075 
02076 /* PRODID */
02077 icalproperty* icalproperty_new_prodid(const char* v);
02078 void icalproperty_set_prodid(icalproperty* prop, const char* v);
02079 const char* icalproperty_get_prodid(const icalproperty* prop);icalproperty* icalproperty_vanew_prodid(const char* v, ...);
02080 
02081 /* QUERY */
02082 icalproperty* icalproperty_new_query(const char* v);
02083 void icalproperty_set_query(icalproperty* prop, const char* v);
02084 const char* icalproperty_get_query(const icalproperty* prop);icalproperty* icalproperty_vanew_query(const char* v, ...);
02085 
02086 /* QUERYNAME */
02087 icalproperty* icalproperty_new_queryname(const char* v);
02088 void icalproperty_set_queryname(icalproperty* prop, const char* v);
02089 const char* icalproperty_get_queryname(const icalproperty* prop);icalproperty* icalproperty_vanew_queryname(const char* v, ...);
02090 
02091 /* RDATE */
02092 icalproperty* icalproperty_new_rdate(struct icaldatetimeperiodtype v);
02093 void icalproperty_set_rdate(icalproperty* prop, struct icaldatetimeperiodtype v);
02094 struct icaldatetimeperiodtype icalproperty_get_rdate(const icalproperty* prop);icalproperty* icalproperty_vanew_rdate(struct icaldatetimeperiodtype v, ...);
02095 
02096 /* RECURRENCE-ID */
02097 icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v);
02098 void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v);
02099 struct icaltimetype icalproperty_get_recurrenceid(const icalproperty* prop);icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...);
02100 
02101 /* RELATED-TO */
02102 icalproperty* icalproperty_new_relatedto(const char* v);
02103 void icalproperty_set_relatedto(icalproperty* prop, const char* v);
02104 const char* icalproperty_get_relatedto(const icalproperty* prop);icalproperty* icalproperty_vanew_relatedto(const char* v, ...);
02105 
02106 /* RELCALID */
02107 icalproperty* icalproperty_new_relcalid(const char* v);
02108 void icalproperty_set_relcalid(icalproperty* prop, const char* v);
02109 const char* icalproperty_get_relcalid(const icalproperty* prop);icalproperty* icalproperty_vanew_relcalid(const char* v, ...);
02110 
02111 /* REPEAT */
02112 icalproperty* icalproperty_new_repeat(int v);
02113 void icalproperty_set_repeat(icalproperty* prop, int v);
02114 int icalproperty_get_repeat(const icalproperty* prop);icalproperty* icalproperty_vanew_repeat(int v, ...);
02115 
02116 /* REQUEST-STATUS */
02117 icalproperty* icalproperty_new_requeststatus(struct icalreqstattype v);
02118 void icalproperty_set_requeststatus(icalproperty* prop, struct icalreqstattype v);
02119 struct icalreqstattype icalproperty_get_requeststatus(const icalproperty* prop);icalproperty* icalproperty_vanew_requeststatus(struct icalreqstattype v, ...);
02120 
02121 /* RESOURCES */
02122 icalproperty* icalproperty_new_resources(const char* v);
02123 void icalproperty_set_resources(icalproperty* prop, const char* v);
02124 const char* icalproperty_get_resources(const icalproperty* prop);icalproperty* icalproperty_vanew_resources(const char* v, ...);
02125 
02126 /* RRULE */
02127 icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v);
02128 void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v);
02129 struct icalrecurrencetype icalproperty_get_rrule(const icalproperty* prop);icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...);
02130 
02131 /* SCOPE */
02132 icalproperty* icalproperty_new_scope(const char* v);
02133 void icalproperty_set_scope(icalproperty* prop, const char* v);
02134 const char* icalproperty_get_scope(const icalproperty* prop);icalproperty* icalproperty_vanew_scope(const char* v, ...);
02135 
02136 /* SEQUENCE */
02137 icalproperty* icalproperty_new_sequence(int v);
02138 void icalproperty_set_sequence(icalproperty* prop, int v);
02139 int icalproperty_get_sequence(const icalproperty* prop);icalproperty* icalproperty_vanew_sequence(int v, ...);
02140 
02141 /* STATUS */
02142 icalproperty* icalproperty_new_status(enum icalproperty_status v);
02143 void icalproperty_set_status(icalproperty* prop, enum icalproperty_status v);
02144 enum icalproperty_status icalproperty_get_status(const icalproperty* prop);icalproperty* icalproperty_vanew_status(enum icalproperty_status v, ...);
02145 
02146 /* SUMMARY */
02147 icalproperty* icalproperty_new_summary(const char* v);
02148 void icalproperty_set_summary(icalproperty* prop, const char* v);
02149 const char* icalproperty_get_summary(const icalproperty* prop);icalproperty* icalproperty_vanew_summary(const char* v, ...);
02150 
02151 /* TARGET */
02152 icalproperty* icalproperty_new_target(const char* v);
02153 void icalproperty_set_target(icalproperty* prop, const char* v);
02154 const char* icalproperty_get_target(const icalproperty* prop);icalproperty* icalproperty_vanew_target(const char* v, ...);
02155 
02156 /* TRANSP */
02157 icalproperty* icalproperty_new_transp(enum icalproperty_transp v);
02158 void icalproperty_set_transp(icalproperty* prop, enum icalproperty_transp v);
02159 enum icalproperty_transp icalproperty_get_transp(const icalproperty* prop);icalproperty* icalproperty_vanew_transp(enum icalproperty_transp v, ...);
02160 
02161 /* TRIGGER */
02162 icalproperty* icalproperty_new_trigger(struct icaltriggertype v);
02163 void icalproperty_set_trigger(icalproperty* prop, struct icaltriggertype v);
02164 struct icaltriggertype icalproperty_get_trigger(const icalproperty* prop);icalproperty* icalproperty_vanew_trigger(struct icaltriggertype v, ...);
02165 
02166 /* TZID */
02167 icalproperty* icalproperty_new_tzid(const char* v);
02168 void icalproperty_set_tzid(icalproperty* prop, const char* v);
02169 const char* icalproperty_get_tzid(const icalproperty* prop);icalproperty* icalproperty_vanew_tzid(const char* v, ...);
02170 
02171 /* TZNAME */
02172 icalproperty* icalproperty_new_tzname(const char* v);
02173 void icalproperty_set_tzname(icalproperty* prop, const char* v);
02174 const char* icalproperty_get_tzname(const icalproperty* prop);icalproperty* icalproperty_vanew_tzname(const char* v, ...);
02175 
02176 /* TZOFFSETFROM */
02177 icalproperty* icalproperty_new_tzoffsetfrom(int v);
02178 void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v);
02179 int icalproperty_get_tzoffsetfrom(const icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...);
02180 
02181 /* TZOFFSETTO */
02182 icalproperty* icalproperty_new_tzoffsetto(int v);
02183 void icalproperty_set_tzoffsetto(icalproperty* prop, int v);
02184 int icalproperty_get_tzoffsetto(const icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetto(int v, ...);
02185 
02186 /* TZURL */
02187 icalproperty* icalproperty_new_tzurl(const char* v);
02188 void icalproperty_set_tzurl(icalproperty* prop, const char* v);
02189 const char* icalproperty_get_tzurl(const icalproperty* prop);icalproperty* icalproperty_vanew_tzurl(const char* v, ...);
02190 
02191 /* UID */
02192 icalproperty* icalproperty_new_uid(const char* v);
02193 void icalproperty_set_uid(icalproperty* prop, const char* v);
02194 const char* icalproperty_get_uid(const icalproperty* prop);icalproperty* icalproperty_vanew_uid(const char* v, ...);
02195 
02196 /* URL */
02197 icalproperty* icalproperty_new_url(const char* v);
02198 void icalproperty_set_url(icalproperty* prop, const char* v);
02199 const char* icalproperty_get_url(const icalproperty* prop);icalproperty* icalproperty_vanew_url(const char* v, ...);
02200 
02201 /* VERSION */
02202 icalproperty* icalproperty_new_version(const char* v);
02203 void icalproperty_set_version(icalproperty* prop, const char* v);
02204 const char* icalproperty_get_version(const icalproperty* prop);icalproperty* icalproperty_vanew_version(const char* v, ...);
02205 
02206 /* X */
02207 icalproperty* icalproperty_new_x(const char* v);
02208 void icalproperty_set_x(icalproperty* prop, const char* v);
02209 const char* icalproperty_get_x(const icalproperty* prop);icalproperty* icalproperty_vanew_x(const char* v, ...);
02210 
02211 /* X-LIC-CLASS */
02212 icalproperty* icalproperty_new_xlicclass(enum icalproperty_xlicclass v);
02213 void icalproperty_set_xlicclass(icalproperty* prop, enum icalproperty_xlicclass v);
02214 enum icalproperty_xlicclass icalproperty_get_xlicclass(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicclass(enum icalproperty_xlicclass v, ...);
02215 
02216 /* X-LIC-CLUSTERCOUNT */
02217 icalproperty* icalproperty_new_xlicclustercount(const char* v);
02218 void icalproperty_set_xlicclustercount(icalproperty* prop, const char* v);
02219 const char* icalproperty_get_xlicclustercount(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicclustercount(const char* v, ...);
02220 
02221 /* X-LIC-ERROR */
02222 icalproperty* icalproperty_new_xlicerror(const char* v);
02223 void icalproperty_set_xlicerror(icalproperty* prop, const char* v);
02224 const char* icalproperty_get_xlicerror(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicerror(const char* v, ...);
02225 
02226 /* X-LIC-MIMECHARSET */
02227 icalproperty* icalproperty_new_xlicmimecharset(const char* v);
02228 void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v);
02229 const char* icalproperty_get_xlicmimecharset(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...);
02230 
02231 /* X-LIC-MIMECID */
02232 icalproperty* icalproperty_new_xlicmimecid(const char* v);
02233 void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v);
02234 const char* icalproperty_get_xlicmimecid(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...);
02235 
02236 /* X-LIC-MIMECONTENTTYPE */
02237 icalproperty* icalproperty_new_xlicmimecontenttype(const char* v);
02238 void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v);
02239 const char* icalproperty_get_xlicmimecontenttype(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...);
02240 
02241 /* X-LIC-MIMEENCODING */
02242 icalproperty* icalproperty_new_xlicmimeencoding(const char* v);
02243 void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v);
02244 const char* icalproperty_get_xlicmimeencoding(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...);
02245 
02246 /* X-LIC-MIMEFILENAME */
02247 icalproperty* icalproperty_new_xlicmimefilename(const char* v);
02248 void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v);
02249 const char* icalproperty_get_xlicmimefilename(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...);
02250 
02251 /* X-LIC-MIMEOPTINFO */
02252 icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v);
02253 void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v);
02254 const char* icalproperty_get_xlicmimeoptinfo(const icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...);
02255 
02256 
02257 #endif /*ICALPROPERTY_H*/
02258 /* -*- Mode: C -*- */
02259 /*======================================================================
02260   FILE: icalproperty.h
02261   CREATOR: eric 20 March 1999
02262 
02263 
02264   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
02265   $Locker:  $
02266 
02267   
02268 
02269  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
02270 
02271  This program is free software; you can redistribute it and/or modify
02272  it under the terms of either: 
02273 
02274     The LGPL as published by the Free Software Foundation, version
02275     2.1, available at: http://www.fsf.org/copyleft/lesser.html
02276 
02277   Or:
02278 
02279     The Mozilla Public License Version 1.0. You may obtain a copy of
02280     the License at http://www.mozilla.org/MPL/
02281 
02282   The original code is icalparam.h
02283 
02284   ======================================================================*/
02285 
02286 
02287 #ifndef ICALPROPERTY_H
02288 #define ICALPROPERTY_H
02289 
02290 #include <time.h>
02291 #include <stdarg.h>  /* for va_... */
02292 
02293 
02294 
02295 /* Actually in icalderivedproperty.h:
02296    typedef struct icalproperty_impl icalproperty; */
02297 
02298 
02299 icalproperty* icalproperty_new(icalproperty_kind kind);
02300 
02301 icalproperty* icalproperty_new_clone(icalproperty * prop);
02302 
02303 icalproperty* icalproperty_new_from_string(const char* str);
02304 
02305 const char* icalproperty_as_ical_string(icalproperty* prop);
02306 
02307 void  icalproperty_free(icalproperty* prop);
02308 
02309 icalproperty_kind icalproperty_isa(icalproperty* property);
02310 int icalproperty_isa_property(void* property);
02311 
02312 void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args);
02313 void icalproperty_add_parameter(icalproperty* prop,icalparameter* parameter);
02314 void icalproperty_set_parameter(icalproperty* prop,icalparameter* parameter);
02315 void icalproperty_set_parameter_from_string(icalproperty* prop,
02316                                             const char* name, const char* value);
02317 const char* icalproperty_get_parameter_as_string(icalproperty* prop,
02318                                                  const char* name);
02319 
02320 void icalproperty_remove_parameter(icalproperty* prop,
02321                                icalparameter_kind kind);
02322 
02323 void icalproperty_remove_parameter_by_kind(icalproperty* prop,
02324                                       icalparameter_kind kind);
02325 
02326 void icalproperty_remove_parameter_by_name(icalproperty* prop,
02327                                       const char *name);
02328 
02329 void icalproperty_remove_parameter_by_ref(icalproperty* prop,
02330                                      icalparameter *param);
02331 
02332 
02333 
02334 int icalproperty_count_parameters(const icalproperty* prop);
02335 
02336 /* Iterate through the parameters */
02337 icalparameter* icalproperty_get_first_parameter(icalproperty* prop,
02338                                           icalparameter_kind kind);
02339 icalparameter* icalproperty_get_next_parameter(icalproperty* prop,
02340                                           icalparameter_kind kind);
02341 /* Access the value of the property */
02342 void icalproperty_set_value(icalproperty* prop, icalvalue* value);
02343 void icalproperty_set_value_from_string(icalproperty* prop,const char* value, const char* kind);
02344 
02345 icalvalue* icalproperty_get_value(const icalproperty* prop);
02346 const char* icalproperty_get_value_as_string(const icalproperty* prop);
02347 
02348 /* Deal with X properties */
02349 
02350 void icalproperty_set_x_name(icalproperty* prop, const char* name);
02351 const char* icalproperty_get_x_name(icalproperty* prop);
02352 
02357 const char* icalproperty_get_property_name (const icalproperty* prop);
02358 
02359 icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
02360 
02361 /* Convert kinds to string and get default value type */
02362 
02363 icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);
02364 icalproperty_kind icalproperty_value_kind_to_kind(icalvalue_kind kind);
02365 const char* icalproperty_kind_to_string(icalproperty_kind kind);
02366 icalproperty_kind icalproperty_string_to_kind(const char* string);
02367 
02369 int icalproperty_kind_is_valid(const icalproperty_kind kind);
02370 
02371 icalproperty_method icalproperty_string_to_method(const char* str);
02372 const char* icalproperty_method_to_string(icalproperty_method method);
02373 
02374 
02375 const char* icalproperty_enum_to_string(int e);
02376 int icalproperty_string_to_enum(const char* str);
02377 int icalproperty_kind_and_string_to_enum(const int kind, const char* str);
02378 
02379 const char* icalproperty_status_to_string(icalproperty_status);
02380 icalproperty_status icalproperty_string_to_status(const char* string);
02381 
02382 int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e);
02383 
02384 
02385 
02386 
02387 #endif /*ICALPROPERTY_H*/
02388 /*======================================================================
02389  FILE: pvl.h
02390  CREATOR: eric November, 1995
02391 
02392 
02393  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
02394 ======================================================================*/
02395 
02396 
02397 #ifndef __PVL_H__
02398 #define __PVL_H__
02399 
02400 typedef struct pvl_list_t* pvl_list;
02401 typedef struct pvl_elem_t* pvl_elem;
02402 
02409 typedef struct pvl_elem_t
02410 {
02411        int MAGIC;                  
02412        void *d;                    
02413        struct pvl_elem_t *next;    
02414        struct pvl_elem_t *prior;   
02415 } pvl_elem_t;
02416 
02417 
02418 
02424 extern int  pvl_elem_count;
02425 extern int  pvl_list_count;
02426 
02427 /* Create new lists or elements */
02428 pvl_elem pvl_new_element(void* d, pvl_elem next,pvl_elem prior);
02429 pvl_list pvl_newlist(void);
02430 void pvl_free(pvl_list);
02431 
02432 /* Add, remove, or get the head of the list */
02433 void pvl_unshift(pvl_list l,void *d);
02434 void* pvl_shift(pvl_list l);
02435 pvl_elem pvl_head(pvl_list);
02436 
02437 /* Add, remove or get the tail of the list */
02438 void pvl_push(pvl_list l,void *d);
02439 void* pvl_pop(pvl_list l);
02440 pvl_elem pvl_tail(pvl_list);
02441 
02442 /* Insert elements in random places */
02443 typedef int (*pvl_comparef)(void* a, void* b); /* a, b are of the data type*/
02444 void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d);
02445 void pvl_insert_after(pvl_list l,pvl_elem e,void *d);
02446 void pvl_insert_before(pvl_list l,pvl_elem e,void *d);
02447 
02448 /* Remove an element, or clear the entire list */
02449 void* pvl_remove(pvl_list,pvl_elem); /* Remove element, return data */
02450 void pvl_clear(pvl_list); /* Remove all elements, de-allocate all data */
02451 
02452 int pvl_count(pvl_list);
02453 
02454 /* Navagate the list */
02455 pvl_elem pvl_next(pvl_elem e);
02456 pvl_elem pvl_prior(pvl_elem e);
02457 
02458 /* get the data in the list */
02459 #ifndef PVL_USE_MACROS
02460 void* pvl_data(pvl_elem);
02461 #else
02462 #define pvl_data(x) x==0 ? 0 : ((struct pvl_elem_t *)x)->d;
02463 #endif
02464 
02465 
02466 /* Find an element for which a function returns true */
02467 typedef int (*pvl_findf)(void* a, void* b); /*a is list elem, b is other data*/
02468 pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v);
02469 pvl_elem pvl_find_next(pvl_list l,pvl_findf f,void* v);
02470 
02475 typedef void (*pvl_applyf)(void* a, void* b); 
02476 void pvl_apply(pvl_list l,pvl_applyf f, void *v);
02477 
02478 
02479 #endif /* __PVL_H__ */
02480 
02481 
02482 
02483 
02484 
02485 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
02486 /*======================================================================
02487  FILE: icalarray.h
02488  CREATOR: Damon Chaplin 07 March 2001
02489 
02490 
02491  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
02492  $Locker:  $
02493 
02494  (C) COPYRIGHT 2001, Ximian, Inc.
02495 
02496  This program is free software; you can redistribute it and/or modify
02497  it under the terms of either: 
02498 
02499     The LGPL as published by the Free Software Foundation, version
02500     2.1, available at: http://www.fsf.org/copyleft/lesser.html
02501 
02502   Or:
02503 
02504     The Mozilla Public License Version 1.0. You may obtain a copy of
02505     the License at http://www.mozilla.org/MPL/
02506 
02507 
02508 ======================================================================*/
02509 
02510 
02511 #ifndef ICALARRAY_H
02512 #define ICALARRAY_H
02513 
02520 typedef struct _icalarray icalarray;
02521 struct _icalarray {
02522     int               element_size;
02523     int               increment_size;
02524     int               num_elements;
02525     int               space_allocated;
02526     void      *data;
02527 };
02528 
02529 
02530 
02531 icalarray *icalarray_new           (int           element_size,
02532                                     int           increment_size);
02533 void      icalarray_free           (icalarray    *array);
02534 
02535 void      icalarray_append         (icalarray    *array,
02536                                     void         *element);
02537 void      icalarray_remove_element_at     (icalarray    *array,
02538                                     int           position);
02539 
02540 void     *icalarray_element_at            (icalarray    *array,
02541                                     int           position);
02542 
02543 void      icalarray_sort           (icalarray    *array,
02544                                     int          (*compare) (const void *, const void *));
02545 
02546 
02547 #endif /* ICALARRAY_H */
02548 /* -*- Mode: C -*- */
02549 /*======================================================================
02550  FILE: icalcomponent.h
02551  CREATOR: eric 20 March 1999
02552 
02553 
02554  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
02555 
02556  This program is free software; you can redistribute it and/or modify
02557  it under the terms of either: 
02558 
02559     The LGPL as published by the Free Software Foundation, version
02560     2.1, available at: http://www.fsf.org/copyleft/lesser.html
02561 
02562   Or:
02563 
02564     The Mozilla Public License Version 1.0. You may obtain a copy of
02565     the License at http://www.mozilla.org/MPL/
02566 
02567   The original code is icalcomponent.h
02568 
02569 ======================================================================*/
02570 
02571 #ifndef ICALCOMPONENT_H
02572 #define ICALCOMPONENT_H
02573 
02574 
02575 typedef struct icalcomponent_impl icalcomponent;
02576 
02577 #ifndef ICALTIMEONE_DEFINED
02578 #define ICALTIMEONE_DEFINED
02579 
02582 typedef struct _icaltimezone              icaltimezone;
02583 #endif
02584 
02585 
02586 /* This is exposed so that callers will not have to allocate and
02587    deallocate iterators. Pretend that you can't see it. */
02588 typedef struct icalcompiter
02589 {
02590        icalcomponent_kind kind;
02591        pvl_elem iter;
02592 
02593 } icalcompiter;
02594 
02595 icalcomponent* icalcomponent_new(icalcomponent_kind kind);
02596 icalcomponent* icalcomponent_new_clone(icalcomponent* component);
02597 icalcomponent* icalcomponent_new_from_string(char* str);
02598 icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...);
02599 void icalcomponent_free(icalcomponent* component);
02600 
02601 char* icalcomponent_as_ical_string(icalcomponent* component);
02602 
02603 int icalcomponent_is_valid(icalcomponent* component);
02604 
02605 icalcomponent_kind icalcomponent_isa(const icalcomponent* component);
02606 
02607 int icalcomponent_isa_component (void* component);
02608 
02609 /* 
02610  * Working with properties
02611  */
02612 
02613 void icalcomponent_add_property(icalcomponent* component,
02614                             icalproperty* property);
02615 
02616 void icalcomponent_remove_property(icalcomponent* component,
02617                                icalproperty* property);
02618 
02619 int icalcomponent_count_properties(icalcomponent* component,
02620                                icalproperty_kind kind);
02621 
02622 /* Iterate through the properties */
02623 icalproperty* icalcomponent_get_current_property(icalcomponent* component);
02624 
02625 icalproperty* icalcomponent_get_first_property(icalcomponent* component,
02626                                          icalproperty_kind kind);
02627 icalproperty* icalcomponent_get_next_property(icalcomponent* component,
02628                                          icalproperty_kind kind);
02629 
02630 
02631 /* 
02632  * Working with components
02633  */ 
02634 
02635 
02636 /* Return the first VEVENT, VTODO or VJOURNAL sub-component of cop, or
02637    comp if it is one of those types */
02638 
02639 icalcomponent* icalcomponent_get_inner(icalcomponent* comp);
02640 
02641 
02642 void icalcomponent_add_component(icalcomponent* parent,
02643                             icalcomponent* child);
02644 
02645 void icalcomponent_remove_component(icalcomponent* parent,
02646                             icalcomponent* child);
02647 
02648 int icalcomponent_count_components(icalcomponent* component,
02649                                icalcomponent_kind kind);
02650 
02655 void icalcomponent_merge_component(icalcomponent* comp,
02656                                icalcomponent* comp_to_merge);
02657 
02658 
02659 /* Iteration Routines. There are two forms of iterators, internal and
02660 external. The internal ones came first, and are almost completely
02661 sufficient, but they fail badly when you want to construct a loop that
02662 removes components from the container.*/
02663 
02664 
02665 /* Iterate through components */
02666 icalcomponent* icalcomponent_get_current_component (icalcomponent* component);
02667 
02668 icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
02669                                          icalcomponent_kind kind);
02670 icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
02671                                          icalcomponent_kind kind);
02672 
02673 /* Using external iterators */
02674 icalcompiter icalcomponent_begin_component(icalcomponent* component,
02675                                       icalcomponent_kind kind);
02676 icalcompiter icalcomponent_end_component(icalcomponent* component,
02677                                     icalcomponent_kind kind);
02678 icalcomponent* icalcompiter_next(icalcompiter* i);
02679 icalcomponent* icalcompiter_prior(icalcompiter* i);
02680 icalcomponent* icalcompiter_deref(icalcompiter* i);
02681 
02682 
02683 /* Working with embedded error properties */
02684 
02685 
02686 /* Check the component against itip rules and insert error properties*/
02687 /* Working with embedded error properties */
02688 int icalcomponent_check_restrictions(icalcomponent* comp);
02689 
02691 int icalcomponent_count_errors(icalcomponent* component);
02692 
02694 void icalcomponent_strip_errors(icalcomponent* component);
02695 
02697 void icalcomponent_convert_errors(icalcomponent* component);
02698 
02699 /* Internal operations. They are private, and you should not be using them. */
02700 icalcomponent* icalcomponent_get_parent(icalcomponent* component);
02701 void icalcomponent_set_parent(icalcomponent* component, 
02702                            icalcomponent* parent);
02703 
02704 /* Kind conversion routines */
02705 
02706 int icalcomponent_kind_is_valid(const icalcomponent_kind kind);
02707 
02708 icalcomponent_kind icalcomponent_string_to_kind(const char* string);
02709 
02710 const char* icalcomponent_kind_to_string(icalcomponent_kind kind);
02711 
02712 
02713 /************* Derived class methods.  ****************************
02714 
02715 If the code was in an OO language, the remaining routines would be
02716 members of classes derived from icalcomponent. Don't call them on the
02717 wrong component subtypes. */
02718 
02721 icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c);
02722 
02725 struct icaltime_span icalcomponent_get_span(icalcomponent* comp);
02726 
02727 /******************** Convienience routines **********************/
02728 
02729 void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v);
02730 struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp);
02731 
02732 /* For the icalcomponent routines only, dtend and duration are tied
02733    together. If you call the set routine for one and the other exists,
02734    the routine will calculate the change to the other. That is, if
02735    there is a DTEND and you call set_duration, the routine will modify
02736    DTEND to be the sum of DTSTART and the duration. If you call a get
02737    routine for one and the other exists, the routine will calculate
02738    the return value. If you call a set routine and neither exists, the
02739    routine will create the apcompriate comperty */
02740 
02741 
02742 struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp);
02743 void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v);
02744 
02745 struct icaltimetype icalcomponent_get_due(icalcomponent* comp);
02746 void icalcomponent_set_due(icalcomponent* comp, struct icaltimetype v);
02747 
02748 void icalcomponent_set_duration(icalcomponent* comp, 
02749                             struct icaldurationtype v);
02750 struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp);
02751 
02752 void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method);
02753 icalproperty_method icalcomponent_get_method(icalcomponent* comp);
02754 
02755 struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp);
02756 void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v);
02757 
02758 void icalcomponent_set_summary(icalcomponent* comp, const char* v);
02759 const char* icalcomponent_get_summary(icalcomponent* comp);
02760 
02761 void icalcomponent_set_comment(icalcomponent* comp, const char* v);
02762 const char* icalcomponent_get_comment(icalcomponent* comp);
02763 
02764 void icalcomponent_set_uid(icalcomponent* comp, const char* v);
02765 const char* icalcomponent_get_uid(icalcomponent* comp);
02766 
02767 void icalcomponent_set_relcalid(icalcomponent* comp, const char* v);
02768 const char* icalcomponent_get_relcalid(icalcomponent* comp);
02769 
02770 void icalcomponent_set_recurrenceid(icalcomponent* comp, 
02771                                 struct icaltimetype v);
02772 struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
02773 
02774 void icalcomponent_set_description(icalcomponent* comp, const char* v);
02775 const char* icalcomponent_get_description(icalcomponent* comp);
02776 
02777 void icalcomponent_set_location(icalcomponent* comp, const char* v);
02778 const char* icalcomponent_get_location(icalcomponent* comp);
02779 
02780 void icalcomponent_set_organizer(icalcomponent* comp, 
02781                              struct icalorganizertype org);
02782 struct icalorganizertype icalcomponent_get_organizer(icalcomponent* comp);
02783 
02784 
02785 void icalcomponent_set_sequence(icalcomponent* comp, int v);
02786 int icalcomponent_get_sequence(icalcomponent* comp);
02787 
02788 void icalcomponent_set_status(icalcomponent* comp, int v);
02789 int icalcomponent_get_status(icalcomponent* comp);
02790 
02791 
02794 void icalcomponent_foreach_tzid(icalcomponent* comp,
02795                             void (*callback)(icalparameter *param, void *data),
02796                             void *callback_data);
02797 
02800 icaltimezone* icalcomponent_get_timezone(icalcomponent* comp,
02801                                     const char *tzid);
02802 
02803 int icalproperty_recurrence_is_excluded(icalcomponent *comp,
02804                                        struct icaltimetype *dtstart,
02805                                        struct icaltimetype *recurtime); 
02806 
02807 void icalcomponent_foreach_recurrence(icalcomponent* comp,
02808                                   struct icaltimetype start,
02809                                   struct icaltimetype end,
02810                      void (*callback)(icalcomponent *comp, 
02811                                          struct icaltime_span *span, 
02812                                          void *data),
02813                            void *callback_data);
02814 
02815 
02816 /*************** Type Specific routines ***************/
02817 
02818 icalcomponent* icalcomponent_new_vcalendar();
02819 icalcomponent* icalcomponent_new_vevent();
02820 icalcomponent* icalcomponent_new_vtodo();
02821 icalcomponent* icalcomponent_new_vjournal();
02822 icalcomponent* icalcomponent_new_valarm();
02823 icalcomponent* icalcomponent_new_vfreebusy();
02824 icalcomponent* icalcomponent_new_vtimezone();
02825 icalcomponent* icalcomponent_new_xstandard();
02826 icalcomponent* icalcomponent_new_xdaylight();
02827 icalcomponent* icalcomponent_new_vagenda();
02828 icalcomponent* icalcomponent_new_vquery();
02829 
02830 #endif /* !ICALCOMPONENT_H */
02831 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
02832 /*======================================================================
02833  FILE: icaltimezone.h
02834  CREATOR: Damon Chaplin 15 March 2001
02835 
02836 
02837  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
02838  $Locker:  $
02839 
02840  (C) COPYRIGHT 2001, Damon Chaplin
02841 
02842  This program is free software; you can redistribute it and/or modify
02843  it under the terms of either: 
02844 
02845     The LGPL as published by the Free Software Foundation, version
02846     2.1, available at: http://www.fsf.org/copyleft/lesser.html
02847 
02848   Or:
02849 
02850     The Mozilla Public License Version 1.0. You may obtain a copy of
02851     the License at http://www.mozilla.org/MPL/
02852 
02853 
02854 ======================================================================*/
02860 #ifndef ICALTIMEZONE_H
02861 #define ICALTIMEZONE_H
02862 
02863 #include <stdio.h> /* For FILE* */
02864 
02865 
02871 icaltimezone *icaltimezone_new                   (void);
02872 
02875 void icaltimezone_free                           (icaltimezone *zone,
02876                                            int free_struct);
02877 
02878 
02884 void icaltimezone_free_builtin_timezones(void);
02885 
02887 icalarray* icaltimezone_get_builtin_timezones    (void);
02888 
02890 icaltimezone* icaltimezone_get_builtin_timezone  (const char *location);
02891 
02893 icaltimezone* icaltimezone_get_builtin_timezone_from_tzid (const char *tzid);
02894 
02896 icaltimezone* icaltimezone_get_utc_timezone      (void);
02897 
02899 char*  icaltimezone_get_tzid                     (icaltimezone *zone);
02900 
02902 char*  icaltimezone_get_location          (icaltimezone *zone);
02903 
02908 char*  icaltimezone_get_tznames           (icaltimezone *zone);
02909 
02911 double icaltimezone_get_latitude          (icaltimezone *zone);
02912 
02914 double icaltimezone_get_longitude         (icaltimezone *zone);
02915 
02917 icalcomponent*       icaltimezone_get_component  (icaltimezone *zone);
02918 
02922 int    icaltimezone_set_component         (icaltimezone *zone,
02923                                            icalcomponent       *comp);
02924 
02929 void   icaltimezone_convert_time          (struct icaltimetype *tt,
02930                                            icaltimezone *from_zone,
02931                                            icaltimezone *to_zone);
02932 
02933 
02942 int    icaltimezone_get_utc_offset        (icaltimezone *zone,
02943                                            struct icaltimetype *tt,
02944                                            int          *is_daylight);
02945 
02950 int    icaltimezone_get_utc_offset_of_utc_time   (icaltimezone *zone,
02951                                            struct icaltimetype *tt,
02952                                            int          *is_daylight);
02953 
02954 
02955 
02956 /*
02957  * Handling arrays of timezones. Mainly for internal use.
02958  */
02959 icalarray*  icaltimezone_array_new        (void);
02960 
02961 void       icaltimezone_array_append_from_vtimezone (icalarray     *timezones,
02962                                                 icalcomponent *child);
02963 void       icaltimezone_array_free        (icalarray    *timezones);
02964 
02965 
02966 /*
02967  * @par Handling the default location the timezone files
02968  */
02969 
02971 void set_zone_directory(char *path);
02972 
02974 void free_zone_directory();
02975 
02976 /*
02977  * @par Debugging Output.
02978  */
02979 
02982 int    icaltimezone_dump_changes          (icaltimezone *zone,
02983                                            int           max_year,
02984                                            FILE         *fp);
02985 
02986 #endif /* ICALTIMEZONE_H */
02987 /* -*- Mode: C -*- */
02988 /*======================================================================
02989   FILE: icalparser.h
02990   CREATOR: eric 20 April 1999
02991   
02992   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
02993 
02994 
02995  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
02996 
02997  This program is free software; you can redistribute it and/or modify
02998  it under the terms of either: 
02999 
03000     The LGPL as published by the Free Software Foundation, version
03001     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03002 
03003   Or:
03004 
03005     The Mozilla Public License Version 1.0. You may obtain a copy of
03006     the License at http://www.mozilla.org/MPL/
03007 
03008   The original code is icalparser.h
03009 
03010 ======================================================================*/
03011 
03012 
03013 #ifndef ICALPARSER_H
03014 #define ICALPARSER_H
03015 
03016 
03017 #include <stdio.h> /* For FILE* */
03018 
03019 typedef struct icalparser_impl icalparser;
03020 
03021 
03031 typedef enum icalparser_state {
03032     ICALPARSER_ERROR,
03033     ICALPARSER_SUCCESS,
03034     ICALPARSER_BEGIN_COMP,
03035     ICALPARSER_END_COMP,
03036     ICALPARSER_IN_PROGRESS
03037 } icalparser_state;
03038 
03039 icalparser* icalparser_new(void);
03040 icalcomponent* icalparser_add_line(icalparser* parser, char* str );
03041 icalcomponent* icalparser_clean(icalparser* parser);
03042 icalparser_state icalparser_get_state(icalparser* parser);
03043 void icalparser_free(icalparser* parser);
03044 
03045 
03053 icalcomponent* icalparser_parse(icalparser *parser,
03054        char* (*line_gen_func)(char *s, size_t size, void *d));
03055 
03060 void icalparser_set_gen_data(icalparser* parser, void* data);
03061 
03062 
03063 icalcomponent* icalparser_parse_string(const char* str);
03064 
03065 
03066 /***********************************************************************
03067  * Parser support functions
03068  ***********************************************************************/
03069 
03071 icalvalue*  icalparser_parse_value(icalvalue_kind kind, 
03072                                const char* str, icalcomponent** errors);
03073 
03075 char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d));
03076 
03077 char* icalparser_string_line_generator(char *out, size_t buf_size, void *d);
03078 
03079 #endif /* !ICALPARSE_H */
03080 /* -*- Mode: C -*- */
03081 /*======================================================================
03082  FILE: icalmemory.h
03083  CREATOR: eric 30 June 1999
03084 
03085 
03086  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03087  $Locker:  $
03088 
03089  This program is free software; you can redistribute it and/or modify
03090  it under the terms of either: 
03091 
03092     The LGPL as published by the Free Software Foundation, version
03093     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03094 
03095   Or:
03096 
03097     The Mozilla Public License Version 1.0. You may obtain a copy of
03098     the License at http://www.mozilla.org/MPL/
03099 
03100  The Initial Developer of the Original Code is Eric Busboom
03101 
03102  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
03103 ======================================================================*/
03104 
03105 #ifndef ICALMEMORY_H
03106 #define ICALMEMORY_H
03107 
03108 #ifndef WIN32
03109 #include <sys/types.h> /* for size_t */
03110 #else
03111 #include <stddef.h>
03112 #endif
03113 
03114 /* Tmp buffers are managed by ical. References can be returned to the
03115    caller, although the caller will not own the memory. */
03116 
03117 void* icalmemory_tmp_buffer(size_t size);
03118 char* icalmemory_tmp_copy(const char* str);
03119 
03121 void  icalmemory_add_tmp_buffer(void*);
03122 
03123 
03125 void icalmemory_free_ring(void);
03126 
03127 /* Non-tmp buffers must be freed. These are mostly wrappers around
03128  * malloc, etc, but are used so the caller can change the memory
03129  * allocators in a future version of the library */
03130 
03131 void* icalmemory_new_buffer(size_t size);
03132 void* icalmemory_resize_buffer(void* buf, size_t size);
03133 void icalmemory_free_buffer(void* buf);
03134 
03142 /* THESE ROUTINES CAN NOT BE USED ON TMP BUFFERS. Only use them on
03143    normally allocated memory, or on buffers created from
03144    icalmemory_new_buffer, never with buffers created by
03145    icalmemory_tmp_buffer. If icalmemory_append_string has to resize a
03146    buffer on the ring, the ring will loose track of it an you will
03147    have memory problems. */
03148 
03149 void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, 
03150                            const char* string);
03151 
03153 void icalmemory_append_char(char** buf, char** pos, size_t* buf_size, 
03154                            char ch);
03155 
03158 char* icalmemory_strdup(const char *s);
03159 
03160 #endif /* !ICALMEMORY_H */
03161 
03162 
03163 
03164 /* -*- Mode: C -*- */
03165 /*======================================================================
03166   FILE: icalerror.h
03167   CREATOR: eric 09 May 1999
03168   
03169   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03170 
03171 
03172  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
03173 
03174  This program is free software; you can redistribute it and/or modify
03175  it under the terms of either: 
03176 
03177     The LGPL as published by the Free Software Foundation, version
03178     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03179 
03180   Or:
03181 
03182     The Mozilla Public License Version 1.0. You may obtain a copy of
03183     the License at http://www.mozilla.org/MPL/
03184 
03185   The original code is icalerror.h
03186 
03187 ======================================================================*/
03188 
03189 
03190 #ifndef ICALERROR_H
03191 #define ICALERROR_H
03192 
03193 #include <assert.h>
03194 #include <stdio.h> /* For icalerror_warn() */
03195 
03196 
03197 #ifdef HAVE_CONFIG_H
03198 #endif
03199 
03200 #define ICAL_SETERROR_ISFUNC
03201 
03202 
03206 void icalerror_stop_here(void);
03207 
03208 void icalerror_crash_here(void);
03209 
03210 typedef enum icalerrorenum {
03211     ICAL_NO_ERROR,     /* icalerrno may not be initialized - put it first so and pray that the compiler initialize things to zero */    
03212     ICAL_BADARG_ERROR,
03213     ICAL_NEWFAILED_ERROR,
03214     ICAL_ALLOCATION_ERROR,
03215     ICAL_MALFORMEDDATA_ERROR, 
03216     ICAL_PARSE_ERROR,
03217     ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */
03218     ICAL_FILE_ERROR,
03219     ICAL_USAGE_ERROR,
03220     ICAL_UNIMPLEMENTED_ERROR,
03221     ICAL_UNKNOWN_ERROR  /* Used for problems in input to icalerror_strerror()*/
03222 
03223 } icalerrorenum;
03224 
03225 icalerrorenum * icalerrno_return(void);
03226 #define icalerrno (*(icalerrno_return()))
03227 
03233 extern int icalerror_errors_are_fatal;
03234 
03235 /* Warning messages */
03236 
03237 #ifdef __GNUC__ca
03238 #define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);}
03239 #else /* __GNU_C__ */
03240 #define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);}
03241 #endif /* __GNU_C__ */
03242 
03243 
03244 void icalerror_clear_errno(void);
03245 void _icalerror_set_errno(icalerrorenum);
03246 
03247 /* Make an individual error fatal or non-fatal. */
03248 typedef enum icalerrorstate { 
03249     ICAL_ERROR_FATAL,     /* Not fata */
03250     ICAL_ERROR_NONFATAL,  /* Fatal */
03251     ICAL_ERROR_DEFAULT,   /* Use the value of icalerror_errors_are_fatal*/
03252     ICAL_ERROR_UNKNOWN    /* Asked state for an unknown error type */
03253 } icalerrorstate ;
03254 
03255 char* icalerror_strerror(icalerrorenum e);
03256 char* icalerror_perror();
03257 void icalerror_set_error_state( icalerrorenum error, icalerrorstate);
03258 icalerrorstate icalerror_get_error_state( icalerrorenum error);
03259 
03260 #ifndef ICAL_SETERROR_ISFUNC
03261 #define icalerror_set_errno(x) \
03262 icalerrno = x; \
03263 if(icalerror_get_error_state(x)==ICAL_ERROR_FATAL || \
03264    (icalerror_get_error_state(x)==ICAL_ERROR_DEFAULT && \
03265     icalerror_errors_are_fatal == 1 )){ \
03266    icalerror_warn(icalerror_strerror(x)); \
03267    assert(0); \
03268 } 
03269 #else
03270 void icalerror_set_errno(icalerrorenum x); 
03271 #endif
03272 
03273 #ifdef ICAL_ERRORS_ARE_FATAL
03274 #undef NDEBUG
03275 #endif
03276 
03277 #define icalerror_check_value_type(value,type);
03278 #define icalerror_check_property_type(value,type);
03279 #define icalerror_check_parameter_type(value,type);
03280 #define icalerror_check_component_type(value,type);
03281 
03282 /* Assert with a message */
03283 #ifdef ICAL_ERRORS_ARE_FATAL
03284 
03285 #ifdef __GNUC__
03286 #define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
03287 #else /*__GNUC__*/
03288 #define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
03289 #endif /*__GNUC__*/
03290 
03291 #else /* ICAL_ERRORS_ARE_FATAL */
03292 #define icalerror_assert(test,message) 
03293 #endif /* ICAL_ERRORS_ARE_FATAL */
03294 
03295 /* Check & abort if check fails */
03296 #define icalerror_check_arg(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); }
03297 
03298 /* Check & return void if check fails*/
03299 #define icalerror_check_arg_rv(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return; }
03300 
03301 /* Check & return 0 if check fails*/
03302 #define icalerror_check_arg_rz(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
03303 
03304 /* Check & return an error if check fails*/
03305 #define icalerror_check_arg_re(test,arg,error) if(!(test)) { icalerror_stop_here(); assert(0); return error;}
03306 
03307 /* Check & return something*/
03308 #define icalerror_check_arg_rx(test,arg,x) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return x;}
03309 
03310 
03311 
03312 /* String interfaces to set an error to NONFATAL and restore it to its
03313    original value */
03314 
03315 icalerrorstate icalerror_supress(const char* error);
03316 void icalerror_restore(const char* error, icalerrorstate es);
03317 
03318 
03319 #endif /* !ICALERROR_H */
03320 
03321 
03322 
03323 /* -*- Mode: C -*- */
03324 /*======================================================================
03325   FILE: icalrestriction.h
03326   CREATOR: eric 24 April 1999
03327   
03328   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03329 
03330 
03331  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
03332 
03333  This program is free software; you can redistribute it and/or modify
03334  it under the terms of either: 
03335 
03336     The LGPL as published by the Free Software Foundation, version
03337     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03338 
03339   Or:
03340 
03341     The Mozilla Public License Version 1.0. You may obtain a copy of
03342     the License at http://www.mozilla.org/MPL/
03343 
03344   The original code is icalrestriction.h
03345 
03346   Contributions from:
03347      Graham Davison (g.m.davison@computer.org)
03348 
03349 
03350 ======================================================================*/
03351 
03352 
03353 #ifndef ICALRESTRICTION_H
03354 #define ICALRESTRICTION_H
03355 
03356 /* These must stay in this order for icalrestriction_compare to work */
03357 typedef enum icalrestriction_kind {
03358     ICAL_RESTRICTION_NONE=0,              /* 0 */
03359     ICAL_RESTRICTION_ZERO,         /* 1 */
03360     ICAL_RESTRICTION_ONE,          /* 2 */
03361     ICAL_RESTRICTION_ZEROPLUS,            /* 3 */
03362     ICAL_RESTRICTION_ONEPLUS,             /* 4 */
03363     ICAL_RESTRICTION_ZEROORONE,           /* 5 */
03364     ICAL_RESTRICTION_ONEEXCLUSIVE, /* 6 */
03365     ICAL_RESTRICTION_ONEMUTUAL,           /* 7 */
03366     ICAL_RESTRICTION_UNKNOWN              /* 8 */
03367 } icalrestriction_kind;
03368 
03369 int 
03370 icalrestriction_compare(icalrestriction_kind restr, int count);
03371 
03372 
03373 int
03374 icalrestriction_is_parameter_allowed(icalproperty_kind property,
03375                                        icalparameter_kind parameter);
03376 
03377 int icalrestriction_check(icalcomponent* comp);
03378 
03379 
03380 #endif /* !ICALRESTRICTION_H */
03381 
03382 
03383 
03384 /* -*- Mode: C -*-
03385   ======================================================================
03386   FILE: sspm.h Mime Parser
03387   CREATOR: eric 25 June 2000
03388   
03389   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03390   $Locker:  $
03391     
03392  The contents of this file are subject to the Mozilla Public License
03393  Version 1.0 (the "License"); you may not use this file except in
03394  compliance with the License. You may obtain a copy of the License at
03395  http://www.mozilla.org/MPL/
03396  
03397  Software distributed under the License is distributed on an "AS IS"
03398  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
03399  the License for the specific language governing rights and
03400  limitations under the License.
03401  
03402 
03403  This program is free software; you can redistribute it and/or modify
03404  it under the terms of either: 
03405 
03406     The LGPL as published by the Free Software Foundation, version
03407     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03408 
03409   Or:
03410 
03411     The Mozilla Public License Version 1.0. You may obtain a copy of
03412     the License at http://www.mozilla.org/MPL/
03413 
03414   The Initial Developer of the Original Code is Eric Busboom
03415 
03416  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
03417  ======================================================================*/
03418 
03419 #ifndef SSPM_H
03420 #define SSPM_H
03421 
03422 enum sspm_major_type {
03423     SSPM_NO_MAJOR_TYPE,
03424     SSPM_TEXT_MAJOR_TYPE,
03425     SSPM_IMAGE_MAJOR_TYPE,
03426     SSPM_AUDIO_MAJOR_TYPE,
03427     SSPM_VIDEO_MAJOR_TYPE,
03428     SSPM_APPLICATION_MAJOR_TYPE,
03429     SSPM_MULTIPART_MAJOR_TYPE,
03430     SSPM_MESSAGE_MAJOR_TYPE,
03431     SSPM_UNKNOWN_MAJOR_TYPE
03432 };
03433 
03434 enum sspm_minor_type {
03435     SSPM_NO_MINOR_TYPE,
03436     SSPM_ANY_MINOR_TYPE,
03437     SSPM_PLAIN_MINOR_TYPE,
03438     SSPM_RFC822_MINOR_TYPE,
03439     SSPM_DIGEST_MINOR_TYPE,
03440     SSPM_CALENDAR_MINOR_TYPE,
03441     SSPM_MIXED_MINOR_TYPE,
03442     SSPM_RELATED_MINOR_TYPE,
03443     SSPM_ALTERNATIVE_MINOR_TYPE,
03444     SSPM_PARALLEL_MINOR_TYPE,
03445     SSPM_UNKNOWN_MINOR_TYPE
03446 };
03447 
03448 enum sspm_encoding {
03449     SSPM_NO_ENCODING,
03450     SSPM_QUOTED_PRINTABLE_ENCODING,
03451     SSPM_8BIT_ENCODING,
03452     SSPM_7BIT_ENCODING,
03453     SSPM_BINARY_ENCODING,
03454     SSPM_BASE64_ENCODING,
03455     SSPM_UNKNOWN_ENCODING
03456 };
03457 
03458 enum sspm_error{
03459     SSPM_NO_ERROR,
03460     SSPM_UNEXPECTED_BOUNDARY_ERROR,
03461     SSPM_WRONG_BOUNDARY_ERROR,
03462     SSPM_NO_BOUNDARY_ERROR,
03463     SSPM_NO_HEADER_ERROR,
03464     SSPM_MALFORMED_HEADER_ERROR
03465 };
03466 
03467 
03468 struct sspm_header
03469 {
03470        int def;
03471        char* boundary;
03472        enum sspm_major_type major;
03473        enum sspm_minor_type minor;
03474        char *minor_text;
03475        char ** content_type_params;
03476        char* charset;
03477        enum sspm_encoding encoding;
03478        char* filename;
03479        char* content_id;
03480        enum sspm_error error;
03481        char* error_text;
03482 };
03483 
03484 struct sspm_part {
03485        struct sspm_header header;
03486        int level;
03487        size_t data_size;
03488        void *data;
03489 };
03490 
03491 struct sspm_action_map {
03492        enum sspm_major_type major;
03493        enum sspm_minor_type minor;
03494        void* (*new_part)();
03495        void (*add_line)(void *part, struct sspm_header *header, 
03496                       char* line, size_t size);
03497        void* (*end_part)(void* part);
03498        void (*free_part)(void *part);
03499 };
03500 
03501 char* sspm_major_type_string(enum sspm_major_type type);
03502 char* sspm_minor_type_string(enum sspm_minor_type type);
03503 char* sspm_encoding_string(enum sspm_encoding type);
03504 
03505 int sspm_parse_mime(struct sspm_part *parts, 
03506                   size_t max_parts,
03507                   struct sspm_action_map *actions,
03508                   char* (*get_string)(char *s, size_t size, void* data),
03509                   void *get_string_data,
03510                   struct sspm_header *first_header
03511     );
03512 
03513 void sspm_free_parts(struct sspm_part *parts, size_t max_parts);
03514 
03515 char *decode_quoted_printable(char *dest, 
03516                                    char *src,
03517                                    size_t *size);
03518 char *decode_base64(char *dest, 
03519                           char *src,
03520                           size_t *size);
03521 
03522 
03523 int sspm_write_mime(struct sspm_part *parts,size_t num_parts,
03524                   char **output_string, char* header);
03525 
03526 #endif /*SSPM_H*/
03527 /* -*- Mode: C -*- */
03528 /*======================================================================
03529  FILE: icalmime.h
03530  CREATOR: eric 26 July 2000
03531 
03532 
03533  $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03534  $Locker:  $
03535 
03536  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
03537 
03538  This program is free software; you can redistribute it and/or modify
03539  it under the terms of either: 
03540 
03541     The LGPL as published by the Free Software Foundation, version
03542     2.1, available at: http://www.fsf.org/copyleft/lesser.html
03543 
03544   Or:
03545 
03546     The Mozilla Public License Version 1.0. You may obtain a copy of
03547     the License at http://www.mozilla.org/MPL/
03548 
03549 ======================================================================*/
03550 
03551 #ifndef ICALMIME_H
03552 #define ICALMIME_H
03553 
03554 
03555 icalcomponent* icalmime_parse(     char* (*line_gen_func)(char *s, size_t size, 
03556                                                  void *d),
03557                             void *data);
03558 
03559 /* The inverse of icalmime_parse, not implemented yet. Use sspm.h directly.  */
03560 char* icalmime_as_mime_string(char* component);
03561 
03562 
03563 
03564 #endif /* !ICALMIME_H */
03565 
03566 
03567 
03568 /* -*- Mode: C -*-
03569   ======================================================================
03570   FILE: icallangbind.h
03571   CREATOR: eric 25 jan 2001
03572   
03573   DESCRIPTION:
03574   
03575   $Id: ical.h,v 1.6 2002/10/10 00:41:34 acampi Exp $
03576   $Locker:  $
03577 
03578   (C) COPYRIGHT 1999 Eric Busboom 
03579   http://www.softwarestudio.org
03580   
03581   This package is free software and is provided "as is" without
03582   express or implied warranty.  It may be used, redistributed and/or
03583   modified under the same terms as perl itself. ( Either the Artistic
03584   License or the GPL. )
03585 
03586   ======================================================================*/
03587 
03588 #ifndef __ICALLANGBIND_H__
03589 #define __ICALLANGBIND_H__
03590 
03591 int* icallangbind_new_array(int size);
03592 void icallangbind_free_array(int* array);
03593 int icallangbind_access_array(int* array, int index);
03594 icalproperty* icallangbind_get_property(icalcomponent *c, int n, const char* prop);
03595 const char* icallangbind_get_property_val(icalproperty* p);
03596 const char* icallangbind_get_parameter(icalproperty *p, const char* parameter);
03597 icalcomponent* icallangbind_get_component(icalcomponent *c, const char* comp);
03598 
03599 icalproperty* icallangbind_get_first_property(icalcomponent *c,
03600                                               const char* prop);
03601 
03602 icalproperty* icallangbind_get_next_property(icalcomponent *c,
03603                                               const char* prop);
03604 
03605 icalcomponent* icallangbind_get_first_component(icalcomponent *c,
03606                                               const char* comp);
03607 
03608 icalcomponent* icallangbind_get_next_component(icalcomponent *c,
03609                                               const char* comp);
03610 
03611 icalparameter* icallangbind_get_first_parameter(icalproperty *prop);
03612 
03613 icalparameter* icallangbind_get_next_parameter(icalproperty *prop);
03614 
03615 const char* icallangbind_property_eval_string(icalproperty* prop, char* sep);
03616 
03617 
03618 int icallangbind_string_to_open_flag(const char* str);
03619 #endif /*__ICALLANGBIND_H__*/
03620 #ifdef __cplusplus
03621 };
03622 #endif