<MACRO>
<NAME>GCAL_TYPE_QUICK_ADD_POPOVER</NAME>
#define GCAL_TYPE_QUICK_ADD_POPOVER (gcal_quick_add_popover_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_quick_add_popover_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_quick_add_popover_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalQuickAddPopover *self, GcalManager         *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_quick_add_popover_get_date_start</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalQuickAddPopover *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_quick_add_popover_set_date_start</NAME>
<RETURNS>void                  </RETURNS>
GcalQuickAddPopover *self, GDateTime           *dt
</FUNCTION>
<FUNCTION>
<NAME>gcal_quick_add_popover_get_date_end</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalQuickAddPopover *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_quick_add_popover_set_date_end</NAME>
<RETURNS>void                  </RETURNS>
GcalQuickAddPopover *self, GDateTime           *dt
</FUNCTION>
<STRUCT>
<NAME>GcalQuickAddPopover</NAME>
</STRUCT>
<MACRO>
<NAME>CSS_TEMPLATE</NAME>
#define CSS_TEMPLATE \
".color-%1$d {"\
"  background-color: %2$s"\
"}"\
".color-%1$d.slanted {"\
"  background-color: transparent;"\
"  background-image: linear-gradient(100deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(280deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(100deg, /* left edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px),"\
"                    linear-gradient(280deg, /* right edge shadow*/"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"  border-bottom: 1px solid transparent; /* for the shadow displacement */"\
"  background-size: 50%% 100%%, 50%% 100%%, 50%% 100%%, 50%% 100%%;"\
"  background-position: left bottom, right bottom, left bottom, right bottom;"\
"  background-repeat: no-repeat;"\
"  background-origin: padding-box, padding-box, border-box, border-box;"\
"  background-clip: padding-box, padding-box, border-box, border-box;"\
"  padding-left: 24px;"\
"  padding-right: 24px;"\
"  padding-top: 3px;"\
"  padding-bottom: 4px;"\
"  border-radius: 0;"\
"}"\
".color-%1$d.slanted:backdrop {"\
"  background-image: linear-gradient(100deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(280deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"\
".color-%1$d.slanted:dir(rtl) {"\
"  background-image: linear-gradient(80deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(260deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(80deg, /* left edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px),"\
"                    linear-gradient(260deg, /* right edge shadow*/"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"}"\
".color-%1$d.slanted:dir(rtl):backdrop {"\
"  background-image: linear-gradient(80deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(260deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"\
".color-%1$d.slanted-start {"\
"  background-color: transparent;"\
"  background-image: linear-gradient(100deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(100deg, /* left edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"  border-bottom: 1px solid transparent; /* for the shadow displacement */"\
"  background-position: left bottom, left bottom;"\
"  background-size: 100%% 100%%, 100%% 100%%;"\
"  background-origin: padding-box, border-box;"\
"  background-clip: padding-box, border-box;"\
"  border-radius: 0 2px 2px 0;"\
"  padding-right: 4px;"\
"  padding-left: 24px;"\
"  padding-top: 3px;"\
"  padding-bottom: 4px;"\
"}"\
".color-%1$d.slanted-start:backdrop {"\
"  background-image: linear-gradient(100deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"\
".color-%1$d.slanted-start:dir(rtl) {"\
"  background-image: linear-gradient(260deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(260deg, /* right edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"  border-bottom: 1px solid transparent; /* for the shadow displacement */"\
"  background-position: right bottom, right bottom;"\
"  border-radius: 2px 0 0 2px;"\
"  padding-right: 24px;"\
"  padding-left: 4px;"\
"}"\
".color-%1$d.slanted-start:dir(rtl):backdrop {"\
"  background-image: linear-gradient(260deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"\
".color-%1$d.slanted-end {"\
"  background-color: transparent;"\
"  background-image: linear-gradient(280deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(280deg, /* right edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"  border-bottom: 1px solid transparent; /* for the shadow displacement */"\
"  background-position: right bottom, right bottom;"\
"  background-size: 100%% 100%%, 100%% 100%%;"\
"  background-origin: padding-box, border-box;"\
"  background-clip: padding-box, border-box;"\
"  border-radius: 2px 0 0 2px;"\
"  padding-right: 24px;"\
"  padding-left: 4px;"\
"  padding-top: 3px;"\
"  padding-bottom: 4px;"\
"}"\
".color-%1$d.slanted-end:backdrop {"\
"  background-image: linear-gradient(280deg, /* right edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"\
".color-%1$d.slanted-end:dir(rtl) {"\
"  background-image: linear-gradient(80deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px),"\
"                    linear-gradient(80deg, /* left edge shadow */"\
"                                    transparent          5px,"\
"                                    @event_shadow_color  6px,"\
"                                    @event_shadow_color  9px,"\
"                                    transparent         10px,"\
"                                    transparent         16px,"\
"                                    @event_shadow_color	17px);"\
"  background-position: left bottom, left bottom;"\
"  border-radius: 0 2px 2px 0;"\
"  padding-right: 4px;"\
"  padding-left: 24px;"\
"}"\
".color-%1$d.slanted-end:dir(rtl):backdrop {"\
"  background-image: linear-gradient(80deg, /* left edge */"\
"                                    alpha(%2$s, 0)  5px,"\
"                                    %2$s            6px,"\
"                                    %2$s	    9px,"\
"                                    alpha(%2$s, 0) 10px,"\
"                                    alpha(%2$s, 0) 16px,"\
"                                    %2$s	   17px);"\
"}"
</MACRO>
<ENUM>
<NAME>GcalEventError</NAME>
typedef enum
{
  GCAL_EVENT_ERROR_INVALID_START_DATE
} GcalEventError;
</ENUM>
<MACRO>
<NAME>GCAL_EVENT_ERROR</NAME>
#define GCAL_EVENT_ERROR gcal_event_error_quark ()
</MACRO>
<MACRO>
<NAME>GCAL_TYPE_EVENT</NAME>
#define GCAL_TYPE_EVENT (gcal_event_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_event_error_quark</NAME>
<RETURNS>GQuark                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_new</NAME>
<RETURNS>GcalEvent *           </RETURNS>
ESource            *source, ECalComponent      *component, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_all_day</NAME>
<RETURNS>gboolean              </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_all_day</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, gboolean            all_day
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_color</NAME>
<RETURNS>GdkRGBA *             </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_color</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, GdkRGBA            *color
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_component</NAME>
<RETURNS>ECalComponent *       </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_date_end</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_date_end</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, GDateTime          *dt
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_date_start</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_date_start</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, GDateTime          *dt
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_description</NAME>
<RETURNS>const gchar *         </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_description</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, const gchar        *description
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_has_recurrence</NAME>
<RETURNS>gboolean              </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_has_alarms</NAME>
<RETURNS>gboolean              </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_alarms</NAME>
<RETURNS>GList *               </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_add_alarm</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, guint               type, gboolean            has_sound
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_remove_alarm</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, guint               type
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_location</NAME>
<RETURNS>const gchar *         </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_location</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, const gchar        *location
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_source</NAME>
<RETURNS>ESource *             </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_source</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_summary</NAME>
<RETURNS>const gchar *         </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_summary</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, const gchar        *summary
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_timezone</NAME>
<RETURNS>GTimeZone *           </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_set_timezone</NAME>
<RETURNS>void                  </RETURNS>
GcalEvent          *self, GTimeZone          *timezone
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_get_uid</NAME>
<RETURNS>const gchar *         </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_is_multiday</NAME>
<RETURNS>gboolean              </RETURNS>
GcalEvent          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_compare</NAME>
<RETURNS>gint                  </RETURNS>
GcalEvent          *event1, GcalEvent          *event2
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_compare_with_current</NAME>
<RETURNS>gint                  </RETURNS>
GcalEvent          *event1, GcalEvent          *event2, time_t             *current_time
</FUNCTION>
<STRUCT>
<NAME>GcalEvent</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_DATE_SELECTOR</NAME>
#define GCAL_TYPE_DATE_SELECTOR             (gcal_date_selector_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_date_selector_new</NAME>
<RETURNS>GtkWidget *       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_selector_get_date</NAME>
<RETURNS>GDateTime *       </RETURNS>
GcalDateSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_selector_set_date</NAME>
<RETURNS>void              </RETURNS>
GcalDateSelector *selector, GDateTime        *date
</FUNCTION>
<STRUCT>
<NAME>GcalDateSelector</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_TIME_SELECTOR</NAME>
#define GCAL_TYPE_TIME_SELECTOR             (gcal_time_selector_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_time_selector_new</NAME>
<RETURNS>GtkWidget *       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_time_selector_set_time_format</NAME>
<RETURNS>void              </RETURNS>
GcalTimeSelector *selector, gboolean          format_24h
</FUNCTION>
<FUNCTION>
<NAME>gcal_time_selector_get_time</NAME>
<RETURNS>GDateTime *       </RETURNS>
GcalTimeSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>gcal_time_selector_set_time</NAME>
<RETURNS>void              </RETURNS>
GcalTimeSelector *selector, GDateTime        *time
</FUNCTION>
<STRUCT>
<NAME>GcalTimeSelector</NAME>
</STRUCT>
<ENUM>
<NAME>GcalDateChooserDayOptions</NAME>
typedef enum
{
  GCAL_DATE_CHOOSER_DAY_NONE    = 1 << 0,
  GCAL_DATE_CHOOSER_DAY_WEEKEND = 1 << 1,
  GCAL_DATE_CHOOSER_DAY_HOLIDAY = 1 << 2,
  GCAL_DATE_CHOOSER_DAY_MARKED  = 1 << 3
} GcalDateChooserDayOptions;
</ENUM>
<MACRO>
<NAME>GCAL_TYPE_DATE_CHOOSER</NAME>
#define GCAL_TYPE_DATE_CHOOSER (gcal_date_chooser_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GcalDateChooserDayOptionsCallback</NAME>
<RETURNS>GcalDateChooserDayOptions </RETURNS>
GcalDateChooser *self,
                                                                        GDateTime       *date,
                                                                        gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_get_date</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_date</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, GDateTime          *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_day_options_callback</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, GcalDateChooserDayOptionsCallback callback, gpointer            data, GDestroyNotify      destroy
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_invalidate_day_options</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_get_no_month_change</NAME>
<RETURNS>gboolean              </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_no_month_change</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, gboolean            setting
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_get_show_heading</NAME>
<RETURNS>gboolean              </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_show_heading</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, gboolean            setting
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_get_show_day_names</NAME>
<RETURNS>gboolean              </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_show_day_names</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, gboolean            setting
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_get_show_week_numbers</NAME>
<RETURNS>gboolean              </RETURNS>
GcalDateChooser    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_set_show_week_numbers</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooser    *self, gboolean            setting
</FUNCTION>
<STRUCT>
<NAME>GcalDateChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_SUBSCRIBER_VIEW</NAME>
#define GCAL_TYPE_SUBSCRIBER_VIEW                       (gcal_subscriber_view_get_type ())
</MACRO>
<MACRO>
<NAME>GCAL_SUBSCRIBER_VIEW</NAME>
#define GCAL_SUBSCRIBER_VIEW(obj)                       (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_SUBSCRIBER_VIEW, GcalSubscriberView))
</MACRO>
<MACRO>
<NAME>GCAL_SUBSCRIBER_VIEW_CLASS</NAME>
#define GCAL_SUBSCRIBER_VIEW_CLASS(klass)               (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_SUBSCRIBER_VIEW, GcalSubscriberViewClass))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SUBSCRIBER_VIEW</NAME>
#define GCAL_IS_SUBSCRIBER_VIEW(obj)                    (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_SUBSCRIBER_VIEW))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SUBSCRIBER_VIEW_CLASS</NAME>
#define GCAL_IS_SUBSCRIBER_VIEW_CLASS(klass)            (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_SUBSCRIBER_VIEW))
</MACRO>
<MACRO>
<NAME>GCAL_SUBSCRIBER_VIEW_GET_CLASS</NAME>
#define GCAL_SUBSCRIBER_VIEW_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_SUBSCRIBER_VIEW, GcalSubscriberViewClass))
</MACRO>
<STRUCT>
<NAME>GcalSubscriberView</NAME>
struct _GcalSubscriberView
{
  GtkContainer parent;

  GcalSubscriberViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GcalSubscriberViewClass</NAME>
struct _GcalSubscriberViewClass
{
  GtkContainerClass parent_class;

  /*< signals >*/
  void       (*event_activated)   (GcalSubscriberView *subscriber_view, GcalEventWidget *event_widget);

  /*< public >*/
  guint     (*get_child_cell)     (GcalSubscriberView *subscriber_view, GcalEventWidget *child);
  void      (*clear_state)        (GcalSubscriberView *subscriber_view);

  /* gcal-view replacements */
  GtkWidget*     (*get_child_by_uuid)        (GcalSubscriberView *subscriber_view, const gchar *uuid);
};
</STRUCT>
<FUNCTION>
<NAME>gcal_subscriber_view_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_subscriber_view_get_child_by_uuid</NAME>
<RETURNS>GtkWidget *     </RETURNS>
GcalSubscriberView *subscriber_view, const gchar        *uuid
</FUNCTION>
<STRUCT>
<NAME>GcalSubscriberViewPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_APPLICATION</NAME>
#define GCAL_TYPE_APPLICATION                                    (gcal_application_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_application_new</NAME>
<RETURNS>GcalApplication *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_application_get_manager</NAME>
<RETURNS>GcalManager *         </RETURNS>
GcalApplication    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_application_get_settings</NAME>
<RETURNS>GSettings *           </RETURNS>
GcalApplication    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_application_set_uuid</NAME>
<RETURNS>void                  </RETURNS>
GcalApplication    *self, const gchar        *app_uuid
</FUNCTION>
<FUNCTION>
<NAME>gcal_application_set_initial_date</NAME>
<RETURNS>void                  </RETURNS>
GcalApplication    *self, GDateTime          *initial_date
</FUNCTION>
<STRUCT>
<NAME>GcalApplication</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_SHELL_SEARCH_PROVIDER</NAME>
#define GCAL_TYPE_SHELL_SEARCH_PROVIDER (gcal_shell_search_provider_get_type())
</MACRO>
<STRUCT>
<NAME>GcalShellSearchProviderClass</NAME>
struct _GcalShellSearchProviderClass
{
  GObjectClass parent;
};
</STRUCT>
<FUNCTION>
<NAME>gcal_shell_search_provider_new</NAME>
<RETURNS>GcalShellSearchProvider  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider_dbus_export</NAME>
<RETURNS>gboolean                  </RETURNS>
GcalShellSearchProvider *search_provider, GDBusConnection         *connection, const gchar             *object_path, GError                 **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider_dbus_unexport</NAME>
<RETURNS>void                      </RETURNS>
GcalShellSearchProvider *search_provider, GDBusConnection         *connection, const gchar             *object_path
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider_connect</NAME>
<RETURNS>void                      </RETURNS>
GcalShellSearchProvider *search_provider, GcalManager             *manager
</FUNCTION>
<STRUCT>
<NAME>GcalShellSearchProvider</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_WINDOW</NAME>
#define GCAL_TYPE_WINDOW                    (gcal_window_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_window_new_with_view_and_date</NAME>
<RETURNS>GtkWidget *           </RETURNS>
GcalApplication     *app, GcalWindowViewType   view_type, icaltimetype        *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_window_new_event</NAME>
<RETURNS>void                  </RETURNS>
GcalWindow          *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_window_set_search_mode</NAME>
<RETURNS>void                  </RETURNS>
GcalWindow          *self, gboolean             enabled
</FUNCTION>
<FUNCTION>
<NAME>gcal_window_set_search_query</NAME>
<RETURNS>void                  </RETURNS>
GcalWindow          *self, const gchar          *query
</FUNCTION>
<FUNCTION>
<NAME>gcal_window_open_event_by_uuid</NAME>
<RETURNS>void                  </RETURNS>
GcalWindow          *self, const gchar         *uuid
</FUNCTION>
<STRUCT>
<NAME>GcalWindow</NAME>
</STRUCT>
<FUNCTION>
<NAME>calendar_get_resource</NAME>
<RETURNS>GResource  *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GCAL_TYPE_VIEW</NAME>
#define GCAL_TYPE_VIEW (gcal_view_get_type ())
</MACRO>
<STRUCT>
<NAME>GcalViewInterface</NAME>
struct _GcalViewInterface
{
  GTypeInterface parent;

  /* signals */
  void           (*create_event)                       (GcalView     *view,
                                                        icaltimetype *start_span,
                                                        icaltimetype *end_span,
                                                        gdouble       x,
                                                        gdouble       y);
  void           (*create_event_detailed)              (GcalView     *view,
                                                        icaltimetype *start_span,
                                                        icaltimetype *end_span);

  icaltimetype*  (*get_date)                           (GcalView     *view);

  void           (*set_date)                           (GcalView     *view,
                                                        icaltimetype *date);

  /* Marks related API */
  void           (*clear_marks)                        (GcalView    *view);

  GList*         (*get_children_by_uuid)               (GcalView    *view,
                                                        const gchar *uuid);
};
</STRUCT>
<FUNCTION>
<NAME>gcal_view_set_date</NAME>
<RETURNS>void           </RETURNS>
GcalView     *view, icaltimetype *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_view_get_date</NAME>
<RETURNS>icaltimetype * </RETURNS>
GcalView     *view
</FUNCTION>
<FUNCTION>
<NAME>gcal_view_clear_marks</NAME>
<RETURNS>void           </RETURNS>
GcalView     *view
</FUNCTION>
<FUNCTION>
<NAME>gcal_view_get_children_by_uuid</NAME>
<RETURNS>GList *        </RETURNS>
GcalView     *view, const gchar  *uuid
</FUNCTION>
<STRUCT>
<NAME>GcalView</NAME>
</STRUCT>
<MACRO>
<NAME>E_TYPE_CAL_DATA_MODEL</NAME>
#define E_TYPE_CAL_DATA_MODEL \
	(e_cal_data_model_get_type ())
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL</NAME>
#define E_CAL_DATA_MODEL(obj) \
	(G_TYPE_CHECK_INSTANCE_CAST \
	((obj), E_TYPE_CAL_DATA_MODEL, ECalDataModel))
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL_CLASS</NAME>
#define E_CAL_DATA_MODEL_CLASS(cls) \
	(G_TYPE_CHECK_CLASS_CAST \
	((cls), E_TYPE_CAL_DATA_MODEL, ECalDataModelClass))
</MACRO>
<MACRO>
<NAME>E_IS_CAL_DATA_MODEL</NAME>
#define E_IS_CAL_DATA_MODEL(obj) \
	(G_TYPE_CHECK_INSTANCE_TYPE \
	((obj), E_TYPE_CAL_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>E_IS_CAL_DATA_MODEL_CLASS</NAME>
#define E_IS_CAL_DATA_MODEL_CLASS(cls) \
	(G_TYPE_CHECK_CLASS_TYPE \
	((cls), E_TYPE_CAL_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL_GET_CLASS</NAME>
#define E_CAL_DATA_MODEL_GET_CLASS(obj) \
	(G_TYPE_INSTANCE_GET_CLASS \
	((obj), E_TYPE_CAL_DATA_MODEL, ECalDataModelClass))
</MACRO>
<ENUM>
<NAME>ECalDataModelViewState</NAME>
typedef enum {
	E_CAL_DATA_MODEL_VIEW_STATE_START,
	E_CAL_DATA_MODEL_VIEW_STATE_PROGRESS,
	E_CAL_DATA_MODEL_VIEW_STATE_COMPLETE,
	E_CAL_DATA_MODEL_VIEW_STATE_STOP
} ECalDataModelViewState;
</ENUM>
<STRUCT>
<NAME>ECalDataModel</NAME>
struct _ECalDataModel {
	GObject parent;
	ECalDataModelPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>ECalDataModelClass</NAME>
struct _ECalDataModelClass {
	GObjectClass parent_class;

	/* Signals */
	void (* view_state_changed)	(ECalDataModel *data_model,
					 ECalClientView *view,
					 ECalDataModelViewState state,
					 guint percent,
					 const gchar *message,
					 const GError *error);
};
</STRUCT>
<USER_FUNCTION>
<NAME>EThreadJobFunc</NAME>
<RETURNS>void </RETURNS>
gpointer user_data,
						 GCancellable *cancellable,
						 GError **error
</USER_FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_type</NAME>
<RETURNS>GType 		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_new</NAME>
<RETURNS>ECalDataModel  *	</RETURNS>
ECalDataModelSubmitThreadJobFunc func
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_new_clone</NAME>
<RETURNS>ECalDataModel  * </RETURNS>
ECalDataModel *src_data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_submit_thread_job</NAME>
<RETURNS>GCancellable  *</RETURNS>
ECalDataModel *data_model, EThreadJobFunc func, gpointer user_data, GDestroyNotify free_user_data
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_disposing</NAME>
<RETURNS>gboolean 	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_set_disposing</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, gboolean disposing
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_expand_recurrences</NAME>
<RETURNS>gboolean 	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_set_expand_recurrences</NAME>
<RETURNS>void 	</RETURNS>
ECalDataModel *data_model, gboolean expand_recurrences
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_timezone</NAME>
<RETURNS>icaltimezone  *	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_set_timezone</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, icaltimezone *zone
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_set_filter</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, const gchar *sexp
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_dup_filter</NAME>
<RETURNS>gchar  *		</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_add_client</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, ECalClient *client
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_remove_client</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, const gchar *uid
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_ref_client</NAME>
<RETURNS>ECalClient  *	</RETURNS>
ECalDataModel *data_model, const gchar *uid
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_clients</NAME>
<RETURNS>GList  *		</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_components</NAME>
<RETURNS>GSList  *	</RETURNS>
ECalDataModel *data_model, time_t in_range_start, time_t in_range_end
</FUNCTION>
<USER_FUNCTION>
<NAME>ECalDataModelForeachFunc</NAME>
<RETURNS>gboolean </RETURNS>
ECalDataModel *data_model,
						 ECalClient *client,
						 const ECalComponentId *id,
						 ECalComponent *comp,
						 time_t instance_start,
						 time_t instance_end,
						 gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_foreach_component</NAME>
<RETURNS>gboolean 	</RETURNS>
ECalDataModel *data_model, time_t in_range_start, time_t in_range_end, ECalDataModelForeachFunc func, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscribe</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, ECalDataModelSubscriber *subscriber, time_t range_start, time_t range_end
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_unsubscribe</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModel *data_model, ECalDataModelSubscriber *subscriber
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_get_subscriber_range</NAME>
<RETURNS>gboolean 	</RETURNS>
ECalDataModel *data_model, ECalDataModelSubscriber *subscriber, time_t *range_start, time_t *range_end
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_freeze_views_update</NAME>
<RETURNS>void 	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_thaw_views_update</NAME>
<RETURNS>void 	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_is_views_update_frozen</NAME>
<RETURNS>gboolean 	</RETURNS>
ECalDataModel *data_model
</FUNCTION>
<STRUCT>
<NAME>ECalDataModelPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_WINDOW_VIEW_TYPE</NAME>
#define GCAL_WINDOW_VIEW_TYPE	(gcal_window_view_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_window_view_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_log_init</NAME>
<RETURNS>void                  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>ICAL_TIME_TYPE</NAME>
#define ICAL_TIME_TYPE (icaltime_get_type ())
</MACRO>
<MACRO>
<NAME>ALIGNED</NAME>
#define ALIGNED(x)      (round (x) + 0.5)
</MACRO>
<MACRO>
<NAME>MINUTES_PER_DAY</NAME>
#define MINUTES_PER_DAY 1440
</MACRO>
<MACRO>
<NAME>MAX_MINUTES</NAME>
#define MAX_MINUTES     (7 * MINUTES_PER_DAY)
</MACRO>
<MACRO>
<NAME>gcal_clear_datetime</NAME>
#define gcal_clear_datetime(dt) g_clear_pointer (dt, g_date_time_unref)
</MACRO>
<ENUM>
<NAME>GcalWindowViewType</NAME>
typedef enum
{
  GCAL_WINDOW_VIEW_DAY,
  GCAL_WINDOW_VIEW_WEEK,
  GCAL_WINDOW_VIEW_MONTH,
  GCAL_WINDOW_VIEW_YEAR,
  GCAL_WINDOW_VIEW_LIST,
  GCAL_WINDOW_VIEW_SEARCH,
} GcalWindowViewType;
</ENUM>
<FUNCTION>
<NAME>icaltime_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>datetime_compare_date</NAME>
<RETURNS>gint             </RETURNS>
GDateTime             *dt1, GDateTime             *dt2
</FUNCTION>
<FUNCTION>
<NAME>datetime_to_icaltime</NAME>
<RETURNS>icaltimetype *   </RETURNS>
GDateTime             *dt
</FUNCTION>
<FUNCTION>
<NAME>datetime_is_date</NAME>
<RETURNS>gboolean         </RETURNS>
GDateTime             *dt
</FUNCTION>
<FUNCTION>
<NAME>icaltime_to_datetime</NAME>
<RETURNS>GDateTime *      </RETURNS>
const icaltimetype    *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_dup_icaltime</NAME>
<RETURNS>icaltimetype *   </RETURNS>
const icaltimetype    *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_get_weekday</NAME>
<RETURNS>gchar *          </RETURNS>
gint                   i
</FUNCTION>
<FUNCTION>
<NAME>gcal_get_month_name</NAME>
<RETURNS>gchar *          </RETURNS>
gint                   i
</FUNCTION>
<FUNCTION>
<NAME>gcal_get_surface_from_color</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GdkRGBA               *color, gint                   size
</FUNCTION>
<FUNCTION>
<NAME>get_circle_surface_from_color</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GdkRGBA               *color, gint                   size
</FUNCTION>
<FUNCTION>
<NAME>get_color_name_from_source</NAME>
<RETURNS>void             </RETURNS>
ESource               *source, GdkRGBA               *out_color
</FUNCTION>
<FUNCTION>
<NAME>get_desc_from_component</NAME>
<RETURNS>gchar *          </RETURNS>
ECalComponent         *component, const gchar           *joint_char
</FUNCTION>
<FUNCTION>
<NAME>get_uuid_from_component</NAME>
<RETURNS>gchar *          </RETURNS>
ESource               *source, ECalComponent         *component
</FUNCTION>
<FUNCTION>
<NAME>get_first_weekday</NAME>
<RETURNS>gint             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>build_component_from_details</NAME>
<RETURNS>ECalComponent *  </RETURNS>
const gchar           *summary, GDateTime             *initial_date, GDateTime             *final_date
</FUNCTION>
<FUNCTION>
<NAME>icaltime_compare_date</NAME>
<RETURNS>gint             </RETURNS>
const icaltimetype    *date1, const icaltimetype    *date2
</FUNCTION>
<FUNCTION>
<NAME>icaltime_compare_with_current</NAME>
<RETURNS>gint             </RETURNS>
const icaltimetype    *date1, const icaltimetype    *date2, time_t                *current_time_t
</FUNCTION>
<FUNCTION>
<NAME>get_start_of_week</NAME>
<RETURNS>GDateTime *      </RETURNS>
icaltimetype          *date
</FUNCTION>
<FUNCTION>
<NAME>get_end_of_week</NAME>
<RETURNS>GDateTime *      </RETURNS>
icaltimetype          *date
</FUNCTION>
<FUNCTION>
<NAME>is_clock_format_24h</NAME>
<RETURNS>gboolean         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>e_strftime_fix_am_pm</NAME>
<RETURNS>gsize            </RETURNS>
gchar                 *str, gsize                  max, const gchar           *fmt, const struct tm       *tm
</FUNCTION>
<FUNCTION>
<NAME>e_utf8_strftime_fix_am_pm</NAME>
<RETURNS>gsize            </RETURNS>
gchar                 *str, gsize                  max, const gchar           *fmt, const struct tm       *tm
</FUNCTION>
<FUNCTION>
<NAME>fix_popover_menu_icons</NAME>
<RETURNS>void             </RETURNS>
GtkPopover            *popover
</FUNCTION>
<FUNCTION>
<NAME>uri_get_fields</NAME>
<RETURNS>gboolean         </RETURNS>
const gchar           *uri, gchar                **schema, gchar                **host, gchar                **path, gboolean              *is_file
</FUNCTION>
<FUNCTION>
<NAME>get_source_parent_name_color</NAME>
<RETURNS>void             </RETURNS>
GcalManager           *manager, ESource               *source, gchar                **name, gchar                **color
</FUNCTION>
<FUNCTION>
<NAME>format_utc_offset</NAME>
<RETURNS>gchar *          </RETURNS>
gint64                 offset
</FUNCTION>
<FUNCTION>
<NAME>get_alarm_trigger_minutes</NAME>
<RETURNS>gint             </RETURNS>
GcalEvent             *event, ECalComponentAlarm    *alarm
</FUNCTION>
<FUNCTION>
<NAME>should_change_date_for_scroll</NAME>
<RETURNS>gboolean         </RETURNS>
gdouble               *scroll_value, GdkEventScroll        *scroll_event
</FUNCTION>
<FUNCTION>
<NAME>is_source_enabled</NAME>
<RETURNS>gboolean         </RETURNS>
ESource               *source
</FUNCTION>
<FUNCTION>
<NAME>ask_recurrence_modification_type</NAME>
<RETURNS>gboolean         </RETURNS>
GtkWidget             *parent, ECalObjModType        *modtype, ESource               *source
</FUNCTION>
<MACRO>
<NAME>E_TYPE_CAL_DATA_MODEL_SUBSCRIBER</NAME>
#define E_TYPE_CAL_DATA_MODEL_SUBSCRIBER \
	(e_cal_data_model_subscriber_get_type ())
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL_SUBSCRIBER</NAME>
#define E_CAL_DATA_MODEL_SUBSCRIBER(obj) \
	(G_TYPE_CHECK_INSTANCE_CAST \
	((obj), E_TYPE_CAL_DATA_MODEL_SUBSCRIBER, ECalDataModelSubscriber))
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL_SUBSCRIBER_INTERFACE</NAME>
#define E_CAL_DATA_MODEL_SUBSCRIBER_INTERFACE(cls) \
	(G_TYPE_CHECK_CLASS_CAST \
	((cls), E_TYPE_CAL_DATA_MODEL_SUBSCRIBER, ECalDataModelSubscriberInterface))
</MACRO>
<MACRO>
<NAME>E_IS_CAL_DATA_MODEL_SUBSCRIBER</NAME>
#define E_IS_CAL_DATA_MODEL_SUBSCRIBER(obj) \
	(G_TYPE_CHECK_INSTANCE_TYPE \
	((obj), E_TYPE_CAL_DATA_MODEL_SUBSCRIBER))
</MACRO>
<MACRO>
<NAME>E_IS_CAL_DATA_MODEL_SUBSCRIBER_INTERFACE</NAME>
#define E_IS_CAL_DATA_MODEL_SUBSCRIBER_INTERFACE(cls) \
	(G_TYPE_CHECK_CLASS_TYPE \
	((cls), E_TYPE_CAL_DATA_MODEL_SUBSCRIBER))
</MACRO>
<MACRO>
<NAME>E_CAL_DATA_MODEL_SUBSCRIBER_GET_INTERFACE</NAME>
#define E_CAL_DATA_MODEL_SUBSCRIBER_GET_INTERFACE(obj) \
	(G_TYPE_INSTANCE_GET_INTERFACE \
	((obj), E_TYPE_CAL_DATA_MODEL_SUBSCRIBER, ECalDataModelSubscriberInterface))
</MACRO>
<STRUCT>
<NAME>ECalDataModelSubscriberInterface</NAME>
struct _ECalDataModelSubscriberInterface {
	GTypeInterface parent_interface;

	void	(*component_added)	(ECalDataModelSubscriber *subscriber,
					 ECalClient *client,
					 ECalComponent *comp);
	void	(*component_modified)	(ECalDataModelSubscriber *subscriber,
					 ECalClient *client,
					 ECalComponent *comp);
	void	(*component_removed)	(ECalDataModelSubscriber *subscriber,
					 ECalClient *client,
					 const gchar *uid,
					 const gchar *rid);
	void	(*freeze)		(ECalDataModelSubscriber *subscriber);
	void	(*thaw)			(ECalDataModelSubscriber *subscriber);
};
</STRUCT>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_get_type</NAME>
<RETURNS>GType 		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_component_added</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModelSubscriber *subscriber, ECalClient *client, ECalComponent *comp
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_component_modified</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModelSubscriber *subscriber, ECalClient *client, ECalComponent *comp
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_component_removed</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModelSubscriber *subscriber, ECalClient *client, const gchar *uid, const gchar *rid
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_freeze</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModelSubscriber *subscriber
</FUNCTION>
<FUNCTION>
<NAME>e_cal_data_model_subscriber_thaw</NAME>
<RETURNS>void 		</RETURNS>
ECalDataModelSubscriber *subscriber
</FUNCTION>
<STRUCT>
<NAME>ECalDataModelSubscriber</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_MANAGER</NAME>
#define GCAL_TYPE_MANAGER                                        (gcal_manager_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_manager_new_with_settings</NAME>
<RETURNS>GcalManager *         </RETURNS>
GSettings          *settings
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_source</NAME>
<RETURNS>ESource *             </RETURNS>
GcalManager        *manager, const gchar        *uid
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_sources</NAME>
<RETURNS>GList *               </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_sources_connected</NAME>
<RETURNS>GList *               </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_default_source</NAME>
<RETURNS>ESource *             </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_default_source</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_system_timezone</NAME>
<RETURNS>icaltimezone *        </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_subscriber</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ECalDataModelSubscriber *subscriber, time_t              range_start, time_t              range_end
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_search_subscriber</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ECalDataModelSubscriber *subscriber, time_t              range_start, time_t              range_end
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_query</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *self, const gchar        *query
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_query_client_data</NAME>
<RETURNS>gchar *               </RETURNS>
GcalManager        *manager, ESource            *source, const gchar        *field
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_refresh</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_is_client_writable</NAME>
<RETURNS>gboolean              </RETURNS>
GcalManager        *manager, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_create_event</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, GcalEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_update_event</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, GcalEvent          *event, ECalObjModType      mod
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_remove_event</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, GcalEvent          *event, ECalObjModType      mod
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_move_event_to_source</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, GcalEvent          *event, ESource            *dest
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_add_source</NAME>
<RETURNS>gchar *               </RETURNS>
GcalManager        *manager, const gchar        *name, const gchar        *backend, const gchar        *color
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_enable_source</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_disable_source</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_save_source</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, ESource            *source
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_events</NAME>
<RETURNS>GList *               </RETURNS>
GcalManager        *manager, icaltimetype       *range_start, icaltimetype       *range_end
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_loading</NAME>
<RETURNS>gboolean              </RETURNS>
GcalManager        *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_clock</NAME>
<RETURNS>GcalClock *           </RETURNS>
GcalManager        *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_goa_client</NAME>
<RETURNS>GoaClient *           </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_event_from_shell_search</NAME>
<RETURNS>GcalEvent *           </RETURNS>
GcalManager        *manager, const gchar        *uuid
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_setup_shell_search</NAME>
<RETURNS>void                  </RETURNS>
GcalManager             *self, ECalDataModelSubscriber *subscriber
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_shell_search_query</NAME>
<RETURNS>void                  </RETURNS>
GcalManager        *manager, const gchar        *query
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_set_shell_search_subscriber</NAME>
<RETURNS>void                  </RETURNS>
GcalManager             *manager, ECalDataModelSubscriber *subscriber, time_t                   range_start, time_t                   range_end
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_shell_search_done</NAME>
<RETURNS>gboolean              </RETURNS>
GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_manager_get_shell_search_events</NAME>
<RETURNS>GList *               </RETURNS>
GcalManager        *manager
</FUNCTION>
<STRUCT>
<NAME>GcalManager</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_SHELL_SEARCH_PROVIDER2</NAME>
#define GCAL_TYPE_SHELL_SEARCH_PROVIDER2 (gcal_shell_search_provider2_get_type ())
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2, GcalShellSearchProvider2))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SHELL_SEARCH_PROVIDER2</NAME>
#define GCAL_IS_SHELL_SEARCH_PROVIDER2(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2))
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_GET_IFACE</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2, GcalShellSearchProvider2Iface))
</MACRO>
<STRUCT>
<NAME>GcalShellSearchProvider2Iface</NAME>
struct _GcalShellSearchProvider2Iface
{
  GTypeInterface parent_iface;

  gboolean (*handle_activate_result) (
    GcalShellSearchProvider2 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_Result,
    const gchar *const *arg_Terms,
    guint arg_Timestamp);

  gboolean (*handle_get_initial_result_set) (
    GcalShellSearchProvider2 *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_Terms);

  gboolean (*handle_get_result_metas) (
    GcalShellSearchProvider2 *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_Results);

  gboolean (*handle_get_subsearch_result_set) (
    GcalShellSearchProvider2 *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_PreviousResults,
    const gchar *const *arg_Terms);

  gboolean (*handle_launch_search) (
    GcalShellSearchProvider2 *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_Terms,
    guint arg_Timestamp);

};
</STRUCT>
<FUNCTION>
<NAME>gcal_shell_search_provider2_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_interface_info</NAME>
<RETURNS>GDBusInterfaceInfo  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_override_properties</NAME>
<RETURNS>guint  </RETURNS>
GObjectClass *klass, guint property_id_begin
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_complete_get_initial_result_set</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *object, GDBusMethodInvocation *invocation, const gchar *const *Results
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_complete_get_subsearch_result_set</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *object, GDBusMethodInvocation *invocation, const gchar *const *Results
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_complete_get_result_metas</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *object, GDBusMethodInvocation *invocation, GVariant *Metas
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_complete_activate_result</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *object, GDBusMethodInvocation *invocation
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_complete_launch_search</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *object, GDBusMethodInvocation *invocation
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_initial_result_set</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Terms, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_initial_result_set_finish</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, gchar ***out_Results, GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_initial_result_set_sync</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Terms, gchar ***out_Results, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_subsearch_result_set</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_PreviousResults, const gchar *const *arg_Terms, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_subsearch_result_set_finish</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, gchar ***out_Results, GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_subsearch_result_set_sync</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_PreviousResults, const gchar *const *arg_Terms, gchar ***out_Results, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_result_metas</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Results, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_result_metas_finish</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, GVariant **out_Metas, GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_get_result_metas_sync</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Results, GVariant **out_Metas, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_activate_result</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *arg_Result, const gchar *const *arg_Terms, guint arg_Timestamp, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_activate_result_finish</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_activate_result_sync</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *arg_Result, const gchar *const *arg_Terms, guint arg_Timestamp, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_launch_search</NAME>
<RETURNS>void  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Terms, guint arg_Timestamp, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_launch_search_finish</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_call_launch_search_sync</NAME>
<RETURNS>gboolean  </RETURNS>
 GcalShellSearchProvider2 *proxy, const gchar *const *arg_Terms, guint arg_Timestamp, GCancellable *cancellable, GError **error
</FUNCTION>
<MACRO>
<NAME>GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY</NAME>
#define GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY (gcal_shell_search_provider2_proxy_get_type ())
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_PROXY</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY, GcalShellSearchProvider2Proxy))
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_PROXY_CLASS</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY, GcalShellSearchProvider2ProxyClass))
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_PROXY_GET_CLASS</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY, GcalShellSearchProvider2ProxyClass))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SHELL_SEARCH_PROVIDER2_PROXY</NAME>
#define GCAL_IS_SHELL_SEARCH_PROVIDER2_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SHELL_SEARCH_PROVIDER2_PROXY_CLASS</NAME>
#define GCAL_IS_SHELL_SEARCH_PROVIDER2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_PROXY))
</MACRO>
<STRUCT>
<NAME>GcalShellSearchProvider2Proxy</NAME>
struct _GcalShellSearchProvider2Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  GcalShellSearchProvider2ProxyPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GcalShellSearchProvider2ProxyClass</NAME>
struct _GcalShellSearchProvider2ProxyClass
{
  GDBusProxyClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new</NAME>
<RETURNS>void  </RETURNS>
 GDBusConnection     *connection, GDBusProxyFlags      flags, const gchar         *name, const gchar         *object_path, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new_finish</NAME>
<RETURNS>GcalShellSearchProvider2  *</RETURNS>
 GAsyncResult        *res, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new_sync</NAME>
<RETURNS>GcalShellSearchProvider2  *</RETURNS>
 GDBusConnection     *connection, GDBusProxyFlags      flags, const gchar         *name, const gchar         *object_path, GCancellable        *cancellable, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new_for_bus</NAME>
<RETURNS>void  </RETURNS>
 GBusType             bus_type, GDBusProxyFlags      flags, const gchar         *name, const gchar         *object_path, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new_for_bus_finish</NAME>
<RETURNS>GcalShellSearchProvider2  *</RETURNS>
 GAsyncResult        *res, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_proxy_new_for_bus_sync</NAME>
<RETURNS>GcalShellSearchProvider2  *</RETURNS>
 GBusType             bus_type, GDBusProxyFlags      flags, const gchar         *name, const gchar         *object_path, GCancellable        *cancellable, GError             **error
</FUNCTION>
<MACRO>
<NAME>GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON</NAME>
#define GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON (gcal_shell_search_provider2_skeleton_get_type ())
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_SKELETON</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON, GcalShellSearchProvider2Skeleton))
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_SKELETON_CLASS</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON, GcalShellSearchProvider2SkeletonClass))
</MACRO>
<MACRO>
<NAME>GCAL_SHELL_SEARCH_PROVIDER2_SKELETON_GET_CLASS</NAME>
#define GCAL_SHELL_SEARCH_PROVIDER2_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON, GcalShellSearchProvider2SkeletonClass))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SHELL_SEARCH_PROVIDER2_SKELETON</NAME>
#define GCAL_IS_SHELL_SEARCH_PROVIDER2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON))
</MACRO>
<MACRO>
<NAME>GCAL_IS_SHELL_SEARCH_PROVIDER2_SKELETON_CLASS</NAME>
#define GCAL_IS_SHELL_SEARCH_PROVIDER2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GCAL_TYPE_SHELL_SEARCH_PROVIDER2_SKELETON))
</MACRO>
<STRUCT>
<NAME>GcalShellSearchProvider2Skeleton</NAME>
struct _GcalShellSearchProvider2Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  GcalShellSearchProvider2SkeletonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GcalShellSearchProvider2SkeletonClass</NAME>
struct _GcalShellSearchProvider2SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gcal_shell_search_provider2_skeleton_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_shell_search_provider2_skeleton_new</NAME>
<RETURNS>GcalShellSearchProvider2  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GcalShellSearchProvider2</NAME>
</STRUCT>
<STRUCT>
<NAME>GcalShellSearchProvider2ProxyPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GcalShellSearchProvider2SkeletonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_CLOCK</NAME>
#define GCAL_TYPE_CLOCK (gcal_clock_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_clock_new</NAME>
<RETURNS>GcalClock *           </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GcalClock</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_ENABLE_TRACE</NAME>
# define GCAL_ENABLE_TRACE 0
</MACRO>
<MACRO>
<NAME>GCAL_LOG_LEVEL_TRACE</NAME>
# define GCAL_LOG_LEVEL_TRACE ((GLogLevelFlags)(1 << G_LOG_LEVEL_USER_SHIFT))
</MACRO>
<MACRO>
<NAME>GCAL_TRACE_MSG</NAME>
# define GCAL_TRACE_MSG(fmt, ...)                                        \
   g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, "  MSG: %s():%d: " fmt,     \
         G_STRFUNC, __LINE__, ##__VA_ARGS__)
</MACRO>
<MACRO>
<NAME>GCAL_PROBE</NAME>
# define GCAL_PROBE                                                      \
   g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, "PROBE: %s():%d",           \
         G_STRFUNC, __LINE__)
</MACRO>
<MACRO>
<NAME>GCAL_TODO</NAME>
# define GCAL_TODO(_msg)                                                 \
   g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, " TODO: %s():%d: %s",       \
         G_STRFUNC, __LINE__, _msg)
</MACRO>
<MACRO>
<NAME>GCAL_ENTRY</NAME>
# define GCAL_ENTRY                                                      \
   g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, "ENTRY: %s():%d",           \
         G_STRFUNC, __LINE__)
</MACRO>
<MACRO>
<NAME>GCAL_EXIT</NAME>
# define GCAL_EXIT                                                       \
   G_STMT_START {                                                        \
      g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, " EXIT: %s():%d",        \
            G_STRFUNC, __LINE__);                                        \
      return;                                                            \
   } G_STMT_END
</MACRO>
<MACRO>
<NAME>GCAL_GOTO</NAME>
# define GCAL_GOTO(_l)                                                   \
   G_STMT_START {                                                        \
      g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, " GOTO: %s():%d ("#_l")",\
            G_STRFUNC, __LINE__);                                        \
      goto _l;                                                           \
   } G_STMT_END
</MACRO>
<MACRO>
<NAME>GCAL_RETURN</NAME>
# define GCAL_RETURN(_r)                                                 \
   G_STMT_START {                                                        \
      g_log(G_LOG_DOMAIN, GCAL_LOG_LEVEL_TRACE, " EXIT: %s():%d ",       \
            G_STRFUNC, __LINE__);                                        \
      return _r;                                                         \
   } G_STMT_END
</MACRO>
<MACRO>
<NAME>GCAL_BUG</NAME>
#define GCAL_BUG(Component, Description, ...) \
  _GCAL_BUG(Component, Description, __FILE__, __LINE__, G_STRFUNC, ##__VA_ARGS__)
</MACRO>
<MACRO>
<NAME>GCAL_RESPONSE_DELETE_EVENT</NAME>
#define GCAL_RESPONSE_DELETE_EVENT 2
</MACRO>
<MACRO>
<NAME>GCAL_RESPONSE_SAVE_EVENT</NAME>
#define GCAL_RESPONSE_SAVE_EVENT   4
</MACRO>
<MACRO>
<NAME>GCAL_RESPONSE_CREATE_EVENT</NAME>
#define GCAL_RESPONSE_CREATE_EVENT 6
</MACRO>
<MACRO>
<NAME>GCAL_TYPE_EDIT_DIALOG</NAME>
#define GCAL_TYPE_EDIT_DIALOG                (gcal_edit_dialog_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_edit_dialog_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_set_event_is_new</NAME>
<RETURNS>void                  </RETURNS>
GcalEditDialog *dialog, gboolean       event_is_new
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_get_event</NAME>
<RETURNS>GcalEvent *           </RETURNS>
GcalEditDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_set_event</NAME>
<RETURNS>void                  </RETURNS>
GcalEditDialog *dialog, GcalEvent      *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalEditDialog *dialog, GcalManager    *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_set_time_format</NAME>
<RETURNS>void                  </RETURNS>
GcalEditDialog *dialog, gboolean        use_24h_format
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_get_date_end</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalEditDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gcal_edit_dialog_get_date_start</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalEditDialog *dialog
</FUNCTION>
<STRUCT>
<NAME>GcalEditDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_MULTI_CHOICE</NAME>
#define GCAL_TYPE_MULTI_CHOICE (gcal_multi_choice_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_multi_choice_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_multi_choice_get_value</NAME>
<RETURNS>gint                  </RETURNS>
GcalMultiChoice    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_multi_choice_set_value</NAME>
<RETURNS>void                  </RETURNS>
GcalMultiChoice    *self, gint                value
</FUNCTION>
<FUNCTION>
<NAME>gcal_multi_choice_set_choices</NAME>
<RETURNS>void                  </RETURNS>
GcalMultiChoice     *self, const gchar        **selfs
</FUNCTION>
<USER_FUNCTION>
<NAME>GcalMultiChoiceFormatCallback</NAME>
<RETURNS>gchar *</RETURNS>
GcalMultiChoice     *self,
                                                                  gint                 value,
                                                                  gpointer             user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gcal_multi_choice_set_format_callback</NAME>
<RETURNS>void                  </RETURNS>
GcalMultiChoice     *self, GcalMultiChoiceFormatCallback  callback, gpointer             user_data, GDestroyNotify       notify
</FUNCTION>
<STRUCT>
<NAME>GcalMultiChoice</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_DATE_CHOOSER_DAY</NAME>
#define GCAL_TYPE_DATE_CHOOSER_DAY (gcal_date_chooser_day_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_date_chooser_day_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_day_get_date</NAME>
<RETURNS>GDateTime *           </RETURNS>
GcalDateChooserDay *day
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_day_set_date</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooserDay *day, GDateTime          *date
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_day_set_other_month</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooserDay *day, gboolean            other_month
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_day_set_selected</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooserDay *day, gboolean            selected
</FUNCTION>
<FUNCTION>
<NAME>gcal_date_chooser_day_set_options</NAME>
<RETURNS>void                  </RETURNS>
GcalDateChooserDay *day, GcalDateChooserDayOptions options
</FUNCTION>
<STRUCT>
<NAME>GcalDateChooserDay</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_EVENT_WIDGET</NAME>
#define GCAL_TYPE_EVENT_WIDGET                    (gcal_event_widget_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_event_widget_new</NAME>
<RETURNS>GtkWidget *    </RETURNS>
GcalEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_get_event</NAME>
<RETURNS>GcalEvent *    </RETURNS>
GcalEventWidget    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_get_date_start</NAME>
<RETURNS>GDateTime *    </RETURNS>
GcalEventWidget    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_set_date_start</NAME>
<RETURNS>void           </RETURNS>
GcalEventWidget    *self, GDateTime          *date_start
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_get_date_end</NAME>
<RETURNS>GDateTime *    </RETURNS>
GcalEventWidget    *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_set_date_end</NAME>
<RETURNS>void           </RETURNS>
GcalEventWidget    *self, GDateTime          *date_end
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_set_read_only</NAME>
<RETURNS>void           </RETURNS>
GcalEventWidget    *event, gboolean            read_only
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_get_read_only</NAME>
<RETURNS>gboolean       </RETURNS>
GcalEventWidget    *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_set_has_reminders</NAME>
<RETURNS>void          </RETURNS>
GcalEventWidget    *event, gboolean            has_reminders
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_get_has_reminders</NAME>
<RETURNS>gboolean      </RETURNS>
GcalEventWidget    *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_clone</NAME>
<RETURNS>GtkWidget *    </RETURNS>
GcalEventWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_equal</NAME>
<RETURNS>gboolean      </RETURNS>
GcalEventWidget    *widget1, GcalEventWidget    *widget2
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_compare_by_length</NAME>
<RETURNS>gint          </RETURNS>
GcalEventWidget    *widget1, GcalEventWidget    *widget2
</FUNCTION>
<FUNCTION>
<NAME>gcal_event_widget_compare_by_start_date</NAME>
<RETURNS>gint          </RETURNS>
GcalEventWidget    *widget1, GcalEventWidget    *widget2
</FUNCTION>
<STRUCT>
<NAME>GcalEventWidget</NAME>
</STRUCT>
<STRUCT>
<NAME>GcalSubscriberViewPrivate</NAME>
struct _GcalSubscriberViewPrivate
{
  /**
   * Hash to keep children widgets (all of them, parent widgets and its parts if there's any),
   * uuid as key and a list of all the instances of the event as value. Here, the first widget on the list is
   * the master, and the rest are the parts. Note: that the master is a part itself, the first one
   */
  GHashTable     *children;

  /**
   * Hash containig single-cell events, day of the month, on month-view, month of the year on year-view as key and
   * a list of the events that belongs to this cell
   */
  GHashTable     *single_cell_children;

  /**
   * An organizaed list containig multiday events
   * This one contains only parents events, to find out its parts @children will be used
   */
  GList          *multi_cell_children;

  /**
   * Hash containing cells that who has overflow per list of hidden widgets.
   */
  GHashTable     *overflow_cells;
  /**
   * Set containing the master widgets hidden for delete;
   */
  GHashTable     *hidden_as_overflow;

  /* state flags */
  gboolean        children_changed;
};
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_SEARCH_VIEW</NAME>
#define GCAL_TYPE_SEARCH_VIEW                       (gcal_search_view_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_search_view_set_time_format</NAME>
<RETURNS>void            </RETURNS>
GcalSearchView *view, gboolean        format_24h
</FUNCTION>
<FUNCTION>
<NAME>gcal_search_view_search</NAME>
<RETURNS>void            </RETURNS>
GcalSearchView *view, const gchar    *field, const gchar    *query
</FUNCTION>
<FUNCTION>
<NAME>gcal_search_view_new</NAME>
<RETURNS>GtkWidget *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_search_view_connect</NAME>
<RETURNS>void            </RETURNS>
GcalSearchView *search_view, GcalManager    *manager
</FUNCTION>
<STRUCT>
<NAME>GcalSearchView</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_RESPONSE_REMOVE_SOURCE</NAME>
#define GCAL_RESPONSE_REMOVE_SOURCE   2
</MACRO>
<MACRO>
<NAME>GCAL_TYPE_SOURCE_DIALOG</NAME>
#define GCAL_TYPE_SOURCE_DIALOG (gcal_source_dialog_get_type())
</MACRO>
<ENUM>
<NAME>GcalSourceDialogMode</NAME>
typedef enum
{
  GCAL_SOURCE_DIALOG_MODE_CREATE,
  GCAL_SOURCE_DIALOG_MODE_CREATE_WEB,
  GCAL_SOURCE_DIALOG_MODE_EDIT,
  GCAL_SOURCE_DIALOG_MODE_NORMAL
} GcalSourceDialogMode;
</ENUM>
<FUNCTION>
<NAME>gcal_source_dialog_new</NAME>
<RETURNS>GtkWidget *          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_source_dialog_set_manager</NAME>
<RETURNS>void                 </RETURNS>
GcalSourceDialog   *dialog, GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_source_dialog_set_mode</NAME>
<RETURNS>void                 </RETURNS>
GcalSourceDialog     *dialog, GcalSourceDialogMode  mode
</FUNCTION>
<FUNCTION>
<NAME>gcal_source_dialog_set_source</NAME>
<RETURNS>void                 </RETURNS>
GcalSourceDialog     *dialog, ESource              *source
</FUNCTION>
<STRUCT>
<NAME>GcalSourceDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_YEAR_VIEW</NAME>
#define GCAL_TYPE_YEAR_VIEW            (gcal_year_view_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_year_view_set_manager</NAME>
<RETURNS>void               </RETURNS>
GcalYearView *year_view, GcalManager  *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_year_view_set_first_weekday</NAME>
<RETURNS>void               </RETURNS>
GcalYearView *year_view, gint          nr_day
</FUNCTION>
<FUNCTION>
<NAME>gcal_year_view_set_use_24h_format</NAME>
<RETURNS>void               </RETURNS>
GcalYearView *year_view, gboolean      use_24h_format
</FUNCTION>
<FUNCTION>
<NAME>gcal_year_view_set_current_date</NAME>
<RETURNS>void               </RETURNS>
GcalYearView *year_view, icaltimetype *current_date
</FUNCTION>
<STRUCT>
<NAME>GcalYearView</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_WEEK_VIEW</NAME>
#define GCAL_TYPE_WEEK_VIEW (gcal_week_view_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_week_view_new</NAME>
<RETURNS>GtkWidget *           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_view_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekView       *self, GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_view_set_first_weekday</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekView       *self, gint                day_nr
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_view_set_use_24h_format</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekView       *self, gboolean            use_24h
</FUNCTION>
<STRUCT>
<NAME>GcalWeekView</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_WEEK_GRID</NAME>
#define GCAL_TYPE_WEEK_GRID (gcal_week_grid_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_week_grid_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *week_grid, GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_set_first_weekday</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *week_grid, gint                nr_day
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_set_use_24h_format</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *week_grid, gboolean            use_24h_format
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_add_event</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *self, GcalEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_remove_event</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *self, const gchar        *uid
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_get_children_by_uuid</NAME>
<RETURNS>GList *               </RETURNS>
GcalWeekGrid       *self, const gchar        *uid
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_clear_marks</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_grid_set_date</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekGrid       *self, icaltimetype       *date
</FUNCTION>
<STRUCT>
<NAME>GcalWeekGrid</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_MONTH_VIEW</NAME>
#define GCAL_TYPE_MONTH_VIEW  (gcal_month_view_get_type ())
</MACRO>
<FUNCTION>
<NAME>gcal_month_view_set_first_weekday</NAME>
<RETURNS>void                  </RETURNS>
GcalMonthView      *self, gint                day_nr
</FUNCTION>
<FUNCTION>
<NAME>gcal_month_view_set_use_24h_format</NAME>
<RETURNS>void                  </RETURNS>
GcalMonthView      *self, gboolean            use_24h
</FUNCTION>
<FUNCTION>
<NAME>gcal_month_view_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalMonthView      *self , GcalManager        *manager
</FUNCTION>
<STRUCT>
<NAME>GcalMonthView</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_WEEK_HEADER</NAME>
#define GCAL_TYPE_WEEK_HEADER (gcal_week_header_get_type())
</MACRO>
<FUNCTION>
<NAME>gcal_week_header_set_manager</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, GcalManager        *manager
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_set_first_weekday</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, gint                nr_day
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_set_use_24h_format</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, gboolean            use_24h_format
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_add_event</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, GcalEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_remove_event</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, const gchar        *uuid
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_get_children_by_uuid</NAME>
<RETURNS>GList *               </RETURNS>
GcalWeekHeader     *self, const gchar        *uuid
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_get_sidebar_size_group</NAME>
<RETURNS>GtkSizeGroup *        </RETURNS>
GcalWeekHeader     *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_clear_marks</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_week_header_set_date</NAME>
<RETURNS>void                  </RETURNS>
GcalWeekHeader     *self, icaltimetype       *date
</FUNCTION>
<STRUCT>
<NAME>GcalWeekHeader</NAME>
</STRUCT>
<MACRO>
<NAME>GCAL_TYPE_RANGE_TREE</NAME>
#define GCAL_TYPE_RANGE_TREE (gcal_range_tree_get_type())
</MACRO>
<USER_FUNCTION>
<NAME>GcalRangeTraverseFunc</NAME>
<RETURNS>gboolean </RETURNS>
guint16             start,
                                                                  guint16             end,
                                                                  gpointer            data,
                                                                  gpointer            user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_new</NAME>
<RETURNS>GcalRangeTree *       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_copy</NAME>
<RETURNS>GcalRangeTree *       </RETURNS>
GcalRangeTree      *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_ref</NAME>
<RETURNS>GcalRangeTree *       </RETURNS>
GcalRangeTree      *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_unref</NAME>
<RETURNS>void                  </RETURNS>
GcalRangeTree      *self
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_add_range</NAME>
<RETURNS>void                  </RETURNS>
GcalRangeTree      *self, guint16             start, guint16             end, gpointer            data
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_remove_range</NAME>
<RETURNS>void                  </RETURNS>
GcalRangeTree      *self, guint16             start, guint16             end, gpointer            data
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_traverse</NAME>
<RETURNS>void                  </RETURNS>
GcalRangeTree      *self, GTraverseType       type, GcalRangeTraverseFunc func, gpointer           user_data
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_get_data_at_range</NAME>
<RETURNS>GPtrArray *           </RETURNS>
GcalRangeTree      *self, guint16             start, guint16             end
</FUNCTION>
<FUNCTION>
<NAME>gcal_range_tree_count_entries_at_range</NAME>
<RETURNS>guint64               </RETURNS>
GcalRangeTree      *self, guint16             start, guint16             end
</FUNCTION>
<STRUCT>
<NAME>GcalRangeTree</NAME>
</STRUCT>
