## event-db

event-db

## Synopsis

    #define             SECONDS_IN_DAY
    #define             MON
    #define             TUE
    #define             WED
    #define             THU
    #define             FRI
    #define             SAT
    #define             SUN
    #define             TYPE_EVENT
    #define             EVENT                               (obj)
    #define             EVENT_CLASS                         (klass)
    #define             IS_EVENT                            (obj)
    #define             IS_EVENT_CLASS                      (klass)
    #define             EVENT_GET_CLASS                     (obj)
                        EventClass;
                        Event;
    GType               event_get_type                      (void);
                        EventCalendar;
    #define             TYPE_EVENT_CALENDAR
    #define             EVENT_CALENDAR                      (obj)
    #define             EVENT_CALENDAR_CLASS                (klass)
    #define             IS_EVENT_CALENDAR                   (obj)
    #define             IS_EVENT_CALENDAR_CLASS             (klass)
    #define             EVENT_CALENDAR_GET_CLASS            (obj)
    GType               event_calendar_get_type             (void);
                        EventDB;
    #define             TYPE_EVENT_DB
    #define             EVENT_DB                            (obj)
    #define             EVENT_DB_CLASS                      (klass)
    #define             IS_EVENT_DB                         (obj)
    #define             IS_EVENT_DB_CLASS                   (klass)
    #define             EVENT_DB_GET_CLASS                  (obj)
    GType               event_db_get_type                   (void);
    void                (*EventDBAlarmFiredFunc)            (EventDB *,
                                                             Event *);
    void                (*EventDBError)                     (EventDB *,
                                                             const char *);
    void                event_db_error_punt                 (EventDB *edb,
                                                             GError *error);
    EventDB*            event_db_new                        (const char *filename,
                                                             GError **error);
    Event*              event_db_next_alarm                 (EventDB *edb,
                                                             time_t now,
                                                             GError **error);
    GSList*             event_db_list_for_period            (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);
    GSList*             event_db_list_alarms_for_period     (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);
    GSList*             event_db_untimed_list_for_period    (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);
    GSList*             event_db_list_unacknowledged_alarms (EventDB *edb,
                                                             GError **error);
    Event*              event_db_find_by_uid                (EventDB *edb,
                                                             guint uid,
                                                             GError **error);
    Event*              event_db_find_by_eventid            (EventDB *edb,
                                                             const char *eventid,
                                                             GError **error);
    EventCalendar*      event_db_find_calendar_by_uid       (EventDB *edb,
                                                             guint uid,
                                                             GError **error);
    EventCalendar*      event_db_find_calendar_by_name      (EventDB *edb,
                                                             const gchar *name,
                                                             GError **error);
    GSList*             event_db_list_event_calendars       (EventDB *edb,
                                                             GError **error);
    EventCalendar*      event_db_get_default_calendar       (EventDB *edb,
                                                             const char *title,
                                                             GError **error);
    void                event_db_set_default_calendar       (EventDB *edb,
                                                             EventCalendar *ec,
                                                             GError **error);
    void                (*EventCalendarNew)                 (EventDB *edb,
                                                             EventCalendar *ec);
    void                (*EventCalendarDeleted)             (EventDB *edb,
                                                             EventCalendar *ec);
    void                (*EventCalendarReparented)          (EventDB *edb,
                                                             EventCalendar *ec);
    void                (*EventCalendarChanged)             (EventDB *edb,
                                                             EventCalendar *ec);
    void                (*EventCalendarModified)            (EventDB *edb,
                                                             EventCalendar *ec);
    EventDB*            event_calendar_get_event_db         (EventCalendar *ev);
    EventCalendar*      event_calendar_new                  (EventDB *edb,
                                                             GError **error);
    EventCalendar*      event_calendar_new_full             (EventDB *edb,
                                                             EventCalendar *parent,
                                                             gboolean visible,
                                                             const char *title,
                                                             const char *description,
                                                             const char *url,
                                                             struct _GdkColor *color,
                                                             int mode,
                                                             int sync_interval,
                                                             GError **error);
    void                event_calendar_delete               (EventCalendar *event_calendar,
                                                             gboolean delete_events,
                                                             EventCalendar *new_parent,
                                                             GError **error);
    guint               event_calendar_get_uid              (EventCalendar *ec);
    gboolean            event_calendar_get_visible          (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_visible          (EventCalendar *ec,
                                                             gboolean visible,
                                                             GError **error);
    gboolean            event_calendar_valid_parent         (EventCalendar *ec,
                                                             EventCalendar *new_parent,
                                                             GError **error);
    EventCalendar*      event_calendar_get_parent           (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_parent           (EventCalendar *ec,
                                                             EventCalendar *p,
                                                             GError **error);
    char*               event_calendar_get_title            (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_title            (EventCalendar *ec,
                                                             const char *title,
                                                             GError **error);
    char*               event_calendar_get_description      (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_description      (EventCalendar *ec,
                                                             const char *description,
                                                             GError **error);
    char*               event_calendar_get_url              (EventCalendar *ev,
                                                             GError **error);
    void                event_calendar_set_url              (EventCalendar *ec,
                                                             const char *url,
                                                             GError **error);
    char*               event_calendar_get_username         (EventCalendar *ev,
                                                             GError **error);
    void                event_calendar_set_username         (EventCalendar *ec,
                                                             const char *username,
                                                             GError **error);
    char*               event_calendar_get_password         (EventCalendar *ev,
                                                             GError **error);
    void                event_calendar_set_password         (EventCalendar *ec,
                                                             const char *password,
                                                             GError **error);
    int                 event_calendar_get_mode             (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_mode             (EventCalendar *ec,
                                                             int mode,
                                                             GError **error);
    gboolean            event_calendar_get_color            (EventCalendar *ec,
                                                             struct _GdkColor *color,
                                                             GError **error);
    void                event_calendar_set_color            (EventCalendar *ec,
                                                             const struct _GdkColor *color,
                                                             GError **error);
    int                 event_calendar_get_sync_interval    (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_sync_interval    (EventCalendar *ec,
                                                             int sync_interval,
                                                             GError **error);
    time_t              event_calendar_get_last_pull        (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_last_pull        (EventCalendar *ec,
                                                             time_t last_pull,
                                                             GError **error);
    time_t              event_calendar_get_last_push        (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_set_last_push        (EventCalendar *ec,
                                                             time_t last_push,
                                                             GError **error);
    time_t              event_calendar_get_last_modification
                                                            (EventCalendar *ec,
                                                             GError **error);
    GSList*             event_calendar_list_events          (EventCalendar *ec,
                                                             GError **error);
    GSList*             event_calendar_list_events_modified_between
                                                            (EventCalendar *ec,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);
    GSList*             event_calendar_list_deleted         (EventCalendar *ec,
                                                             GError **error);
    void                event_calendar_flush_deleted        (EventCalendar *ec,
                                                             GError **error);
    GSList*             event_calendar_list_calendars       (EventCalendar *ec,
                                                             GError **error);
    void                (*EventNew)                         (EventDB *edb,
                                                             Event *ev);
    void                (*EventRemoved)                     (EventDB *edb,
                                                             Event *ev);
    void                (*EventModified)                    (EventDB *edb,
                                                             Event *ev);
    gint                event_compare_func                  (gconstpointer a,
                                                             gconstpointer b);
    gint                event_alarm_compare_func            (gconstpointer a,
                                                             gconstpointer b);
    Event*              event_new                           (EventDB *edb,
                                                             EventCalendar *ec,
                                                             const char *eventid,
                                                             GError **error);
    gboolean            event_flush                         (Event *ev,
                                                             GError **error);
    gboolean            event_remove                        (Event *ev,
                                                             GError **error);
    void                event_list_unref                    (GSList *l);
    EventDB*            event_get_event_db                  (Event *ev);
    EventCalendar*      event_get_calendar                  (Event *ev,
                                                             GError **error);
    void                event_set_calendar                  (Event *ev,
                                                             EventCalendar *ec,
                                                             GError **error);
    gboolean            event_get_color                     (Event *ev,
                                                             struct _GdkColor *color,
                                                             GError **error);
    gboolean            event_get_visible                   (Event *ev,
                                                             GError **error);
    time_t              event_get_start                     (Event *ev);
    unsigned long       event_get_duration                  (Event *ev);
    void                event_set_duration                  (Event *ev,
                                                             long duration ,
                                                             GError **error);
    unsigned long       event_get_alarm                     (Event *ev);
    void                event_set_alarm                     (Event *ev,
                                                             long alarm ,
                                                             GError **error);
    void                event_acknowledge                   (Event *ev,
                                                             GError **error);
    guint32             event_get_sequence                  (Event *ev,
                                                             GError **error);
    void                event_set_sequence                  (Event *ev,
                                                             guint32 sequence,
                                                             GError **error);
    time_t              event_get_last_modification         (Event *event);
    #define             event_is_recurrence                 (ev)
    enum event_recurrence_type event_get_recurrence_type    (Event *ev);
    void                event_set_recurrence_type           (Event *ev,
                                                             enum event_recurrence_type type,
                                                             GError **error);
    time_t              event_get_recurrence_start          (Event *ev);
    void                event_set_recurrence_start          (Event *ev,
                                                             time_t start,
                                                             GError **error);
    time_t              event_get_recurrence_end            (Event *ev);
    void                event_set_recurrence_end            (Event *ev,
                                                             time_t end,
                                                             GError **error);
    guint32             event_get_recurrence_count          (Event *ev);
    void                event_set_recurrence_count          (Event *ev,
                                                             guint32 count,
                                                             GError **error);
    guint32             event_get_recurrence_increment      (Event *ev);
    void                event_set_recurrence_increment      (Event *ev,
                                                             guint32 increment,
                                                             GError **error);
    GSList*             event_get_recurrence_byday          (Event *ev,
                                                             GError **error);
    void                event_set_recurrence_byday          (Event *event,
                                                             GSList *list,
                                                             GError **error);
    void                event_add_recurrence_exception      (Event *ev,
                                                             time_t start,
                                                             GError **error);
    gboolean            event_get_untimed                   (Event *ev);
    void                event_set_untimed                   (Event *ev,
                                                             gboolean value,
                                                             GError **error);
    unsigned long       event_get_uid                       (Event *ev);
    char*               event_get_eventid                   (Event *ev,
                                                             GError **error);
    char*               event_get_summary                   (Event *ev,
                                                             GError **error);
    void                event_set_summary                   (Event *ev,
                                                             const char *summary,
                                                             GError **error);
    char*               event_get_description               (Event *ev,
                                                             GError **error);
    void                event_set_description               (Event *ev,
                                                             const char *description,
                                                             GError **error);
    char*               event_get_location                  (Event *ev,
                                                             GError **error);
    void                event_set_location                  (Event *ev,
                                                             const char *location,
                                                             GError **error);
    GSList*             event_get_categories                (Event *ev,
                                                             GError **error);
    void                event_add_category                  (Event *ev,
                                                             int category,
                                                             GError **error);
    void                event_set_categories                (Event *ev,
                                                             GSList *categories,
                                                             GError **error);

## Object Hierarchy

      GObject
       +----Event
             +----EventSource

      GObject
       +----EventCalendar

      GObject
       +----EventDB

## Signals

      "alarm-fired"                                    : Run Last
      "calendar-changed"                               : Run Last
      "calendar-deleted"                               : Run Last
      "calendar-modified"                              : Run Last
      "calendar-new"                                   : Run Last
      "calendar-reparented"                            : Run Last
      "error"                                          : Run Last
      "event-modified"                                 : Run Last
      "event-new"                                      : Run Last
      "event-removed"                                  : Run Last
      "alarm-fired"                                    : Run Last
      "calendar-changed"                               : Run Last
      "calendar-deleted"                               : Run Last
      "calendar-modified"                              : Run Last
      "calendar-new"                                   : Run Last
      "calendar-reparented"                            : Run Last
      "error"                                          : Run Last
      "event-modified"                                 : Run Last
      "event-new"                                      : Run Last
      "event-removed"                                  : Run Last

## Description

## Details

### SECONDS_IN_DAY

    #define             SECONDS_IN_DAY

### MON

    #define             MON

### TUE

    #define             TUE

### WED

    #define             WED

### THU

    #define             THU

### FRI

    #define             FRI

### SAT

    #define             SAT

### SUN

    #define             SUN

### TYPE_EVENT

    #define             TYPE_EVENT

### EVENT()

    #define             EVENT(obj)

`obj` : |

### EVENT_CLASS()

    #define             EVENT_CLASS(klass)

`klass` : |

### IS_EVENT()

    #define             IS_EVENT(obj)

`obj` : |

### IS_EVENT_CLASS()

    #define             IS_EVENT_CLASS(klass)

`klass` : |

### EVENT_GET_CLASS()

    #define             EVENT_GET_CLASS(obj)

`obj` : |

### EventClass

    typedef struct {
      GObjectClass gobject_class;
    } EventClass;

### Event

    typedef struct _Event Event;

### event_get_type ()

    GType               event_get_type                      (void);

Returns : |

### EventCalendar

    typedef struct _EventCalendar EventCalendar;

### TYPE_EVENT_CALENDAR

    #define             TYPE_EVENT_CALENDAR

### EVENT_CALENDAR()

    #define             EVENT_CALENDAR(obj)

`obj` : |

### EVENT_CALENDAR_CLASS()

    #define             EVENT_CALENDAR_CLASS(klass)

`klass` : |

### IS_EVENT_CALENDAR()

    #define             IS_EVENT_CALENDAR(obj)

`obj` : |

### IS_EVENT_CALENDAR_CLASS()

    #define             IS_EVENT_CALENDAR_CLASS(klass)

`klass` : |

### EVENT_CALENDAR_GET_CLASS()

    #define             EVENT_CALENDAR_GET_CLASS(obj)

`obj` : |

### event_calendar_get_type ()

    GType               event_calendar_get_type             (void);

Returns : |

### EventDB

    typedef struct _EventDB EventDB;

### TYPE_EVENT_DB

    #define             TYPE_EVENT_DB

### EVENT_DB()

    #define             EVENT_DB(obj)

`obj` : |

### EVENT_DB_CLASS()

    #define             EVENT_DB_CLASS(klass)

`klass` : |

### IS_EVENT_DB()

    #define             IS_EVENT_DB(obj)

`obj` : |

### IS_EVENT_DB_CLASS()

    #define             IS_EVENT_DB_CLASS(klass)

`klass` : |

### EVENT_DB_GET_CLASS()

    #define             EVENT_DB_GET_CLASS(obj)

`obj` : |

### event_db_get_type ()

    GType               event_db_get_type                   (void);

Returns : |

### EventDBAlarmFiredFunc ()

    void                (*EventDBAlarmFiredFunc)            (EventDB *,
                                                             Event *);

`Param1` : |
`Param2` : |

### EventDBError ()

    void                (*EventDBError)                     (EventDB *,
                                                             const char *);

`Param1` : |
`Param2` : |

### event_db_error_punt ()

    void                event_db_error_punt                 (EventDB *edb,
                                                             GError *error);

`edb` : |
`error` : |

### event_db_new ()

    EventDB*            event_db_new                        (const char *filename,
                                                             GError **error);

`filename` : |
`error` : |
Returns : |

### event_db_next_alarm ()

    Event*              event_db_next_alarm                 (EventDB *edb,
                                                             time_t now,
                                                             GError **error);

`edb` : |
`now` : |
`error` : |
Returns : |

### event_db_list_for_period ()

    GSList*             event_db_list_for_period            (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);

`evd` : |
`start` : |
`end` : |
`error` : |
Returns : |

### event_db_list_alarms_for_period ()

    GSList*             event_db_list_alarms_for_period     (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);

`evd` : |
`start` : |
`end` : |
`error` : |
Returns : |

### event_db_untimed_list_for_period ()

    GSList*             event_db_untimed_list_for_period    (EventDB *evd,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);

`evd` : |
`start` : |
`end` : |
`error` : |
Returns : |

### event_db_list_unacknowledged_alarms ()

    GSList*             event_db_list_unacknowledged_alarms (EventDB *edb,
                                                             GError **error);

`edb` : |
`error` : |
Returns : |

### event_db_find_by_uid ()

    Event*              event_db_find_by_uid                (EventDB *edb,
                                                             guint uid,
                                                             GError **error);

`edb` : |
`uid` : |
`error` : |
Returns : |

### event_db_find_by_eventid ()

    Event*              event_db_find_by_eventid            (EventDB *edb,
                                                             const char *eventid,
                                                             GError **error);

`edb` : |
`eventid` : |
`error` : |
Returns : |

### event_db_find_calendar_by_uid ()

    EventCalendar*      event_db_find_calendar_by_uid       (EventDB *edb,
                                                             guint uid,
                                                             GError **error);

`edb` : |
`uid` : |
`error` : |
Returns : |

### event_db_find_calendar_by_name ()

    EventCalendar*      event_db_find_calendar_by_name      (EventDB *edb,
                                                             const gchar *name,
                                                             GError **error);

Get a desired calendar by name.

`edb` : |
`name` : |
`error` : |
Returns : |

### event_db_list_event_calendars ()

    GSList*             event_db_list_event_calendars       (EventDB *edb,
                                                             GError **error);

`edb` : |
`error` : |
Returns : |

### event_db_get_default_calendar ()

    EventCalendar*      event_db_get_default_calendar       (EventDB *edb,
                                                             const char *title,
                                                             GError **error);

`edb` : |
`title` : |
`error` : |
Returns : |

### event_db_set_default_calendar ()

    void                event_db_set_default_calendar       (EventDB *edb,
                                                             EventCalendar *ec,
                                                             GError **error);

`edb` : |
`ec` : |
`error` : |

### EventCalendarNew ()

    void                (*EventCalendarNew)                 (EventDB *edb,
                                                             EventCalendar *ec);

`edb` : |
`ec` : |

### EventCalendarDeleted ()

    void                (*EventCalendarDeleted)             (EventDB *edb,
                                                             EventCalendar *ec);

`edb` : |
`ec` : |

### EventCalendarReparented ()

    void                (*EventCalendarReparented)          (EventDB *edb,
                                                             EventCalendar *ec);

`edb` : |
`ec` : |

### EventCalendarChanged ()

    void                (*EventCalendarChanged)             (EventDB *edb,
                                                             EventCalendar *ec);

`edb` : |
`ec` : |

### EventCalendarModified ()

    void                (*EventCalendarModified)            (EventDB *edb,
                                                             EventCalendar *ec);

`edb` : |
`ec` : |

### event_calendar_get_event_db ()

    EventDB*            event_calendar_get_event_db         (EventCalendar *ev);

`ev` : |
Returns : |

### event_calendar_new ()

    EventCalendar*      event_calendar_new                  (EventDB *edb,
                                                             GError **error);

`edb` : |
`error` : |
Returns : |

### event_calendar_new_full ()

    EventCalendar*      event_calendar_new_full             (EventDB *edb,
                                                             EventCalendar *parent,
                                                             gboolean visible,
                                                             const char *title,
                                                             const char *description,
                                                             const char *url,
                                                             struct _GdkColor *color,
                                                             int mode,
                                                             int sync_interval,
                                                             GError **error);

`edb` : |
`parent` : |
`visible` : |
`title` : |
`description` : |
`url` : |
`color` : |
`mode` : |
`sync_interval` : |
`error` : |
Returns : |

### event_calendar_delete ()

    void                event_calendar_delete               (EventCalendar *event_calendar,
                                                             gboolean delete_events,
                                                             EventCalendar *new_parent,
                                                             GError **error);

`event_calendar` : |
`delete_events` : |
`new_parent` : |
`error` : |

### event_calendar_get_uid ()

    guint               event_calendar_get_uid              (EventCalendar *ec);

`ec` : |
Returns : |

### event_calendar_get_visible ()

    gboolean            event_calendar_get_visible          (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_visible ()

    void                event_calendar_set_visible          (EventCalendar *ec,
                                                             gboolean visible,
                                                             GError **error);

`ec` : |
`visible` : |
`error` : |

### event_calendar_valid_parent ()

    gboolean            event_calendar_valid_parent         (EventCalendar *ec,
                                                             EventCalendar *new_parent,
                                                             GError **error);

`ec` : |
`new_parent` : |
`error` : |
Returns : |

### event_calendar_get_parent ()

    EventCalendar*      event_calendar_get_parent           (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_parent ()

    void                event_calendar_set_parent           (EventCalendar *ec,
                                                             EventCalendar *p,
                                                             GError **error);

`ec` : |
`p` : |
`error` : |

### event_calendar_get_title ()

    char*               event_calendar_get_title            (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_title ()

    void                event_calendar_set_title            (EventCalendar *ec,
                                                             const char *title,
                                                             GError **error);

`ec` : |
`title` : |
`error` : |

### event_calendar_get_description ()

    char*               event_calendar_get_description      (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_description ()

    void                event_calendar_set_description      (EventCalendar *ec,
                                                             const char *description,
                                                             GError **error);

`ec` : |
`description` : |
`error` : |

### event_calendar_get_url ()

    char*               event_calendar_get_url              (EventCalendar *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_calendar_set_url ()

    void                event_calendar_set_url              (EventCalendar *ec,
                                                             const char *url,
                                                             GError **error);

`ec` : |
`url` : |
`error` : |

### event_calendar_get_username ()

    char*               event_calendar_get_username         (EventCalendar *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_calendar_set_username ()

    void                event_calendar_set_username         (EventCalendar *ec,
                                                             const char *username,
                                                             GError **error);

`ec` : |
`username` : |
`error` : |

### event_calendar_get_password ()

    char*               event_calendar_get_password         (EventCalendar *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_calendar_set_password ()

    void                event_calendar_set_password         (EventCalendar *ec,
                                                             const char *password,
                                                             GError **error);

`ec` : |
`password` : |
`error` : |

### event_calendar_get_mode ()

    int                 event_calendar_get_mode             (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_mode ()

    void                event_calendar_set_mode             (EventCalendar *ec,
                                                             int mode,
                                                             GError **error);

`ec` : |
`mode` : |
`error` : |

### event_calendar_get_color ()

    gboolean            event_calendar_get_color            (EventCalendar *ec,
                                                             struct _GdkColor *color,
                                                             GError **error);

`ec` : |
`color` : |
`error` : |
Returns : |

### event_calendar_set_color ()

    void                event_calendar_set_color            (EventCalendar *ec,
                                                             const struct _GdkColor *color,
                                                             GError **error);

`ec` : |
`color` : |
`error` : |

### event_calendar_get_sync_interval ()

    int                 event_calendar_get_sync_interval    (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_sync_interval ()

    void                event_calendar_set_sync_interval    (EventCalendar *ec,
                                                             int sync_interval,
                                                             GError **error);

`ec` : |
`sync_interval` : |
`error` : |

### event_calendar_get_last_pull ()

    time_t              event_calendar_get_last_pull        (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_last_pull ()

    void                event_calendar_set_last_pull        (EventCalendar *ec,
                                                             time_t last_pull,
                                                             GError **error);

`ec` : |
`last_pull` : |
`error` : |

### event_calendar_get_last_push ()

    time_t              event_calendar_get_last_push        (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_set_last_push ()

    void                event_calendar_set_last_push        (EventCalendar *ec,
                                                             time_t last_push,
                                                             GError **error);

`ec` : |
`last_push` : |
`error` : |

### event_calendar_get_last_modification ()

    time_t              event_calendar_get_last_modification
                                                            (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_list_events ()

    GSList*             event_calendar_list_events          (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### event_calendar_list_events_modified_between ()

    GSList*             event_calendar_list_events_modified_between
                                                            (EventCalendar *ec,
                                                             time_t start,
                                                             time_t end,
                                                             GError **error);

`ec` : |
`start` : |
`end` : |
`error` : |
Returns : |

### event_calendar_list_deleted ()

    GSList*             event_calendar_list_deleted         (EventCalendar *ec,
                                                             GError **error);

Retrieve a list of deleted events since the last `event_calendar_flush_deleted()` call. The events contain a very basic set of information only and should be used to indicate wether a particular event was deleted or not only. The returned list of events needs to be freed by the caller.

`ec` : |
`error` : |
Returns : |

### event_calendar_flush_deleted ()

    void                event_calendar_flush_deleted        (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |

### event_calendar_list_calendars ()

    GSList*             event_calendar_list_calendars       (EventCalendar *ec,
                                                             GError **error);

`ec` : |
`error` : |
Returns : |

### EventNew ()

    void                (*EventNew)                         (EventDB *edb,
                                                             Event *ev);

`edb` : |
`ev` : |

### EventRemoved ()

    void                (*EventRemoved)                     (EventDB *edb,
                                                             Event *ev);

`edb` : |
`ev` : |

### EventModified ()

    void                (*EventModified)                    (EventDB *edb,
                                                             Event *ev);

`edb` : |
`ev` : |

### event_compare_func ()

    gint                event_compare_func                  (gconstpointer a,
                                                             gconstpointer b);

`a` : |
`b` : |
Returns : |

### event_alarm_compare_func ()

    gint                event_alarm_compare_func            (gconstpointer a,
                                                             gconstpointer b);

`a` : |
`b` : |
Returns : |

### event_new ()

    Event*              event_new                           (EventDB *edb,
                                                             EventCalendar *ec,
                                                             const char *eventid,
                                                             GError **error);

`edb` : |
`ec` : |
`eventid` : |
`error` : |
Returns : |

### event_flush ()

    gboolean            event_flush                         (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_remove ()

    gboolean            event_remove                        (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_list_unref ()

    void                event_list_unref                    (GSList *l);

g_object_unref each Event * on the list and destroy the list.

`l` : |

### event_get_event_db ()

    EventDB*            event_get_event_db                  (Event *ev);

`ev` : |
Returns : |

### event_get_calendar ()

    EventCalendar*      event_get_calendar                  (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_calendar ()

    void                event_set_calendar                  (Event *ev,
                                                             EventCalendar *ec,
                                                             GError **error);

`ev` : |
`ec` : |
`error` : |

### event_get_color ()

    gboolean            event_get_color                     (Event *ev,
                                                             struct _GdkColor *color,
                                                             GError **error);

`ev` : |
`color` : |
`error` : |
Returns : |

### event_get_visible ()

    gboolean            event_get_visible                   (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_get_start ()

    time_t              event_get_start                     (Event *ev);

`ev` : |
Returns : |

### event_get_duration ()

    unsigned long       event_get_duration                  (Event *ev);

`ev` : |
Returns : |

### event_set_duration ()

    void                event_set_duration                  (Event *ev,
                                                             long duration ,
                                                             GError **error);

`ev` : |
`Param2` : |
`error` : |

### event_get_alarm ()

    unsigned long       event_get_alarm                     (Event *ev);

`ev` : |
Returns : |

### event_set_alarm ()

    void                event_set_alarm                     (Event *ev,
                                                             long alarm ,
                                                             GError **error);

`ev` : |
`Param2` : |
`error` : |

### event_acknowledge ()

    void                event_acknowledge                   (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |

### event_get_sequence ()

    guint32             event_get_sequence                  (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_sequence ()

    void                event_set_sequence                  (Event *ev,
                                                             guint32 sequence,
                                                             GError **error);

`ev` : |
`sequence` : |
`error` : |

### event_get_last_modification ()

    time_t              event_get_last_modification         (Event *event);

`event` : |
Returns : |

### event_is_recurrence()

    #define             event_is_recurrence(ev)

`ev` : |

### event_get_recurrence_type ()

    enum event_recurrence_type event_get_recurrence_type    (Event *ev);

`ev` : |
Returns : |

### event_set_recurrence_type ()

    void                event_set_recurrence_type           (Event *ev,
                                                             enum event_recurrence_type type,
                                                             GError **error);

`ev` : |
`type` : |
`error` : |

### event_get_recurrence_start ()

    time_t              event_get_recurrence_start          (Event *ev);

`ev` : |
Returns : |

### event_set_recurrence_start ()

    void                event_set_recurrence_start          (Event *ev,
                                                             time_t start,
                                                             GError **error);

`ev` : |
`start` : |
`error` : |

### event_get_recurrence_end ()

    time_t              event_get_recurrence_end            (Event *ev);

`ev` : |
Returns : |

### event_set_recurrence_end ()

    void                event_set_recurrence_end            (Event *ev,
                                                             time_t end,
                                                             GError **error);

`ev` : |
`end` : |
`error` : |

### event_get_recurrence_count ()

    guint32             event_get_recurrence_count          (Event *ev);

`ev` : |
Returns : |

### event_set_recurrence_count ()

    void                event_set_recurrence_count          (Event *ev,
                                                             guint32 count,
                                                             GError **error);

`ev` : |
`count` : |
`error` : |

### event_get_recurrence_increment ()

    guint32             event_get_recurrence_increment      (Event *ev);

`ev` : |
Returns : |

### event_set_recurrence_increment ()

    void                event_set_recurrence_increment      (Event *ev,
                                                             guint32 increment,
                                                             GError **error);

`ev` : |
`increment` : |
`error` : |

### event_get_recurrence_byday ()

    GSList*             event_get_recurrence_byday          (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_recurrence_byday ()

    void                event_set_recurrence_byday          (Event *event,
                                                             GSList *list,
                                                             GError **error);

`event` : |
`list` : |
`error` : |

### event_add_recurrence_exception ()

    void                event_add_recurrence_exception      (Event *ev,
                                                             time_t start,
                                                             GError **error);

`ev` : |
`start` : |
`error` : |

### event_get_untimed ()

    gboolean            event_get_untimed                   (Event *ev);

`ev` : |
Returns : |

### event_set_untimed ()

    void                event_set_untimed                   (Event *ev,
                                                             gboolean value,
                                                             GError **error);

`ev` : |
`value` : |
`error` : |

### event_get_uid ()

    unsigned long       event_get_uid                       (Event *ev);

`ev` : |
Returns : |

### event_get_eventid ()

    char*               event_get_eventid                   (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_get_summary ()

    char*               event_get_summary                   (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_summary ()

    void                event_set_summary                   (Event *ev,
                                                             const char *summary,
                                                             GError **error);

`ev` : |
`summary` : |
`error` : |

### event_get_description ()

    char*               event_get_description               (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_description ()

    void                event_set_description               (Event *ev,
                                                             const char *description,
                                                             GError **error);

`ev` : |
`description` : |
`error` : |

### event_get_location ()

    char*               event_get_location                  (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_set_location ()

    void                event_set_location                  (Event *ev,
                                                             const char *location,
                                                             GError **error);

`ev` : |
`location` : |
`error` : |

### event_get_categories ()

    GSList*             event_get_categories                (Event *ev,
                                                             GError **error);

`ev` : |
`error` : |
Returns : |

### event_add_category ()

    void                event_add_category                  (Event *ev,
                                                             int category,
                                                             GError **error);

`ev` : |
`category` : |
`error` : |

### event_set_categories ()

    void                event_set_categories                (Event *ev,
                                                             GSList *categories,
                                                             GError **error);

`ev` : |
`categories` : |
`error` : |

## Signal Details

### The "alarm-fired" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-changed" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-deleted" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-modified" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-new" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-reparented" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "error" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-modified" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-new" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-removed" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "alarm-fired" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-changed" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-deleted" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-modified" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-new" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "calendar-reparented" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "error" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-modified" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-new" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @:

### The "event-removed" signal

    void                user_function                      (EventDB *eventdb,
                                                            gpointer arg1,
                                                            gpointer user_data)      : Run Last

@: @: