static gpointer alter_cal_client (gpointer user_data) { ECalClient *cal_client = user_data; GError *error = NULL; icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; g_return_val_if_fail (cal_client != NULL, NULL); now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Initial event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) g_error ("create object sync: %s", error->message); icalcomponent_set_uid (icalcomp, uid); icalcomponent_set_summary (icalcomp, "Modified event summary"); if (!e_cal_client_modify_object_sync (cal_client, icalcomp, CALOBJ_MOD_ALL, NULL, &error)) g_error ("modify object sync: %s", error->message); if (!e_cal_client_remove_object_sync (cal_client, uid, NULL, CALOBJ_MOD_ALL, NULL, &error)) g_error ("remove object sync: %s", error->message); g_free (uid); icalcomponent_free (icalcomp); return FALSE; }
void dates_new_cb (GtkWidget *source, DatesData *d) { icalcomponent *comp; struct icalperiodtype period; if (!dates_view_get_selected_period (d->view, &period)) { struct icaltimetype date, now; /* Create a default time event */ date = *(dates_view_get_date (d->view)); now = icaltime_current_time_with_zone (date.zone); date.is_date = FALSE; now.is_date = FALSE; period.duration = icaldurationtype_null_duration (); period.duration.minutes = 0; /* New events default to starting at 9am */ period.duration.hours = 9; period.start = icaltime_add ( date, period.duration); /* NOTE: 11 is the magic number where we're viewing a * month or more. See dates_zoom_change. */ period.duration.hours = (d->zoom >= 11) ? 8 : 2; period.end = icaltime_add (period.start, period.duration); } comp = icalcomponent_new_vevent (); icalcomponent_set_dtstart (comp, period.start); icalcomponent_set_dtend (comp, period.end); icalcomponent_set_summary (comp, _("New event")); dates_new (d, comp, TRUE); }
/** * calendar_config_get_hide_completed_tasks_sexp: * * @get_completed: Whether to form subexpression that * gets completed or not completed tasks. * Returns the subexpression to use to filter out completed tasks according * to the config settings. The returned sexp should be freed. **/ char* calendar_config_get_hide_completed_tasks_sexp (gboolean get_completed) { char *sexp = NULL; if (calendar_config_get_hide_completed_tasks ()) { CalUnits units; gint value; units = calendar_config_get_hide_completed_tasks_units (); value = calendar_config_get_hide_completed_tasks_value (); if (value == 0) { /* If the value is 0, we want to hide completed tasks immediately, so we filter out all complete/incomplete tasks.*/ if (!get_completed) sexp = g_strdup ("(not is-completed?)"); else sexp = g_strdup ("(is-completed?)"); } else { char *isodate; icaltimezone *zone; struct icaltimetype tt; time_t t; /* Get the current time, and subtract the appropriate number of days/hours/minutes. */ zone = calendar_config_get_icaltimezone (); tt = icaltime_current_time_with_zone (zone); switch (units) { case CAL_DAYS: icaltime_adjust (&tt, -value, 0, 0, 0); break; case CAL_HOURS: icaltime_adjust (&tt, 0, -value, 0, 0); break; case CAL_MINUTES: icaltime_adjust (&tt, 0, 0, -value, 0); break; default: g_return_val_if_reached (NULL); } t = icaltime_as_timet_with_zone (tt, zone); /* Convert the time to an ISO date string, and build the query sub-expression. */ isodate = isodate_from_time_t (t); if (!get_completed) sexp = g_strdup_printf ("(not (completed-before? (make-time \"%s\")))", isodate); else sexp = g_strdup_printf ("(completed-before? (make-time \"%s\"))", isodate); g_free (isodate); } } return sexp; }
gint main (gint argc, gchar **argv) { ECalClient *cal_client; GError *error = NULL; icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; main_initialize (); cal_client = new_temp_client (E_CAL_CLIENT_SOURCE_TYPE_EVENTS, NULL); g_return_val_if_fail (cal_client != NULL, FALSE); if (!e_client_open_sync (E_CLIENT (cal_client), FALSE, NULL, &error)) { report_error ("client open sync", &error); g_object_unref (cal_client); return 1; } now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Test event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) { report_error ("create object sync", &error); icalcomponent_free (icalcomp); g_object_unref (cal_client); return 1; } icalcomponent_free (icalcomp); g_free (uid); /* synchronously without main-loop */ if (!test_sync (cal_client)) { g_object_unref (cal_client); return 1; } start_in_thread_with_main_loop (test_sync_in_thread, cal_client); if (!e_client_remove_sync (E_CLIENT (cal_client), NULL, &error)) { report_error ("client remove sync", &error); g_object_unref (cal_client); return 1; } g_object_unref (cal_client); if (get_main_loop_stop_result () == 0) g_print ("Test finished successfully.\n"); return get_main_loop_stop_result (); }
void kolab_util_backend_modtime_set_on_ecalcomp (ECalComponent *ecalcomp) { struct icaltimetype itt; g_assert (E_IS_CAL_COMPONENT (ecalcomp)); itt = icaltime_current_time_with_zone (NULL); /* need UTC here, hence NULL timezone */ e_cal_component_set_last_modified (ecalcomp, &itt); } /* kolab_util_backend_modtime_set_on_ecalcomp () */
static icalcomponent * create_object (void) { icalcomponent *icalcomp; struct icaltimetype now; now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "To-be-sent event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet_with_zone (icaltime_as_timet (now) + 60 * 60 * 60, 0, NULL)); return icalcomp; }
static gboolean execute_search (GcalShellSearchProvider *search_provider) { GcalShellSearchProviderPrivate *priv; guint i; gchar *search_query; icaltimezone *zone; time_t range_start, range_end; priv = search_provider->priv; if (!gcal_manager_load_completed (priv->manager)) return TRUE; zone = gcal_manager_get_system_timezone (priv->manager); priv->pending_search->date = icaltime_current_time_with_zone (zone); icaltime_adjust (&(priv->pending_search->date), -7, 0, 0, 0); /* -1 weeks from today */ range_start = icaltime_as_timet_with_zone (priv->pending_search->date, zone); icaltime_adjust (&(priv->pending_search->date), 21 * 2, 0, 0, 0); /* +3 weeks from today */ range_end = icaltime_as_timet_with_zone (priv->pending_search->date, zone); gcal_manager_set_shell_search_subscriber (priv->manager, E_CAL_DATA_MODEL_SUBSCRIBER (search_provider), range_start, range_end); search_query = g_strdup_printf ("(or (contains? \"summary\" \"%s\") (contains? \"description\" \"%s\"))", priv->pending_search->terms[0], priv->pending_search->terms[0]); for (i = 1; i < g_strv_length (priv->pending_search->terms); i++) { gchar *complete_query; gchar *second_query = g_strdup_printf ("(or (contains? \"summary\" \"%s\") (contains? \"description\" \"%s\"))", priv->pending_search->terms[0], priv->pending_search->terms[0]); complete_query = g_strdup_printf ("(and %s %s)", search_query, second_query); g_free (second_query); g_free (search_query); search_query = complete_query; } gcal_manager_set_shell_search_query (priv->manager, search_query); g_free (search_query); priv->scheduled_search_id = 0; g_application_hold (g_application_get_default ()); return FALSE; }
/** * e_cal_util_new_component: * @kind: Kind of the component to create. * * Creates a new #icalcomponent of the specified kind. * * Returns: the newly created component. */ icalcomponent * e_cal_util_new_component (icalcomponent_kind kind) { icalcomponent *comp; struct icaltimetype dtstamp; gchar *uid; comp = icalcomponent_new (kind); uid = e_cal_component_gen_uid (); icalcomponent_set_uid (comp, uid); g_free (uid); dtstamp = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomponent_set_dtstamp (comp, dtstamp); return comp; }
/* is_past_event: * * returns TRUE if @comp is in the past, FALSE otherwise. * Comparision is based only on date part, time part is ignored. */ static gboolean is_past_event (ECalComponent *comp) { ECalComponentDateTime end_date; gboolean res; if (!comp) return TRUE; e_cal_component_get_dtend (comp, &end_date); res = icaltime_compare_date_only ( *end_date.value, icaltime_current_time_with_zone ( icaltime_get_timezone (*end_date.value))) == -1; e_cal_component_free_datetime (&end_date); return res; }
static void setup_cal (ECalClient *cal_client) { GError *error = NULL; icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Test event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) g_error ("create object sync: %s", error->message); icalcomponent_free (icalcomp); g_free (uid); }
static void get_revision_compare_cycle (ECalClient *client) { icalcomponent *icalcomp; struct icaltimetype now; gchar *revision_before = NULL, *revision_after = NULL, *uid = NULL; GError *error = NULL; /* Build up new component */ now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Test event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_client_get_backend_property_sync (E_CLIENT (client), CLIENT_BACKEND_PROPERTY_REVISION, &revision_before, NULL, &error)) g_error ("Error getting book revision: %s", error->message); if (!e_cal_client_create_object_sync (client, icalcomp, &uid, NULL, &error)) g_error ("Error creating object: %s", error->message); if (!e_client_get_backend_property_sync (E_CLIENT (client), CLIENT_BACKEND_PROPERTY_REVISION, &revision_after, NULL, &error)) g_error ("Error getting book revision: %s", error->message); g_assert (revision_before); g_assert (revision_after); g_assert (strcmp (revision_before, revision_after) != 0); g_message ("Passed cycle, revision before '%s' revision after '%s'", revision_before, revision_after); g_free (revision_before); g_free (revision_after); g_free (uid); icalcomponent_free (icalcomp); }
static gchar * create_object (ECalClient *cal_client) { icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; GError *error = NULL; g_return_val_if_fail (cal_client != NULL, NULL); now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "To-be-removed event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet_with_zone (icaltime_as_timet (now) + 60 * 60 * 60, 0, NULL)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) g_error ("create object sync: %s", error->message); icalcomponent_free (icalcomp); return uid; }
int main() { icalarray *builtin_timezones; icaltimetype tt; int dd, hh, zz, tried = 0; long zz2 = -1; set_zone_directory("../../zoneinfo"); icaltimezone_set_tzid_prefix("/softwarestudio.org/"); tt = icaltime_current_time_with_zone(icaltimezone_get_builtin_timezone("America/New_York")); tt.year = 2038; (void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST")); tried++; tt.year = 2050; (void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST")); tried++; tt.year = 1958; (void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST")); tried++; builtin_timezones = icaltimezone_get_builtin_timezones(); printf("got %lu zones\n", (unsigned long)builtin_timezones->num_elements); if (builtin_timezones->num_elements == 0) { printf("YIKES. Try running from the build/bin directory\n"); return(1); } for (zz = -1; zz < (int)builtin_timezones->num_elements; zz++) { icaltimezone *zone; if (zz < 0) { zone = icaltimezone_get_utc_timezone(); } else { zone = icalarray_element_at(builtin_timezones, (size_t)zz); } tt = icaltime_current_time_with_zone(zone); for (dd = 0; dd < 370; dd += 17) { for (hh = 0; hh < 60 * 60 * 24; hh += 567) { int zz2cnt; icaltime_adjust(&tt, 0, 0, 0, 1); for (zz2cnt = 0; zz2cnt < 15; zz2cnt++) { icaltimezone *zone2; if (zz2 < 0) { zone2 = icaltimezone_get_utc_timezone(); } else { zone2 = icalarray_element_at(builtin_timezones, (size_t)zz2); } (void)icaltime_as_timet_with_zone(tt, zone2); tried++; zz2++; if (zz2 >= (long)builtin_timezones->num_elements) zz2 = -1; } } } printf("\r%lu %% done", (zz >= 0 ? zz : 0) * 100 / (unsigned long)builtin_timezones->num_elements); fflush(stdout); } printf("\ntried %d times\n", tried); return 0; }
static void task_shell_view_execute_search (EShellView *shell_view) { ETaskShellContent *task_shell_content; EShellWindow *shell_window; EShellContent *shell_content; EShellSearchbar *searchbar; EActionComboBox *combo_box; GtkRadioAction *action; ECalComponentPreview *task_preview; EPreviewPane *preview_pane; ETaskTable *task_table; EWebView *web_view; ECalModel *model; ECalDataModel *data_model; icaltimezone *timezone; struct icaltimetype current_time; time_t start_range; time_t end_range; time_t now_time; gchar *start, *end; gchar *query; gchar *temp; gint value; shell_window = e_shell_view_get_shell_window (shell_view); shell_content = e_shell_view_get_shell_content (shell_view); task_shell_content = E_TASK_SHELL_CONTENT (shell_content); searchbar = e_task_shell_content_get_searchbar (task_shell_content); task_shell_content = E_TASK_SHELL_CONTENT (shell_content); task_table = e_task_shell_content_get_task_table (task_shell_content); model = e_task_table_get_model (task_table); data_model = e_cal_model_get_data_model (model); timezone = e_cal_model_get_timezone (model); current_time = icaltime_current_time_with_zone (timezone); now_time = time_day_begin (icaltime_as_timet (current_time)); action = GTK_RADIO_ACTION (ACTION (TASK_SEARCH_ANY_FIELD_CONTAINS)); value = gtk_radio_action_get_current_value (action); if (value == TASK_SEARCH_ADVANCED) { query = e_shell_view_get_search_query (shell_view); if (!query) query = g_strdup (""); } else { const gchar *format; const gchar *text; GString *string; text = e_shell_searchbar_get_search_text (searchbar); if (text == NULL || *text == '\0') { text = ""; value = TASK_SEARCH_SUMMARY_CONTAINS; } switch (value) { default: text = ""; /* fall through */ case TASK_SEARCH_SUMMARY_CONTAINS: format = "(contains? \"summary\" %s)"; break; case TASK_SEARCH_DESCRIPTION_CONTAINS: format = "(contains? \"description\" %s)"; break; case TASK_SEARCH_ANY_FIELD_CONTAINS: format = "(contains? \"any\" %s)"; break; } /* Build the query. */ string = g_string_new (""); e_sexp_encode_string (string, text); query = g_strdup_printf (format, string->str); g_string_free (string, TRUE); } /* Apply selected filter. */ combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); value = e_action_combo_box_get_current_value (combo_box); switch (value) { case TASK_FILTER_ANY_CATEGORY: break; case TASK_FILTER_UNMATCHED: temp = g_strdup_printf ( "(and (has-categories? #f) %s)", query); g_free (query); query = temp; break; case TASK_FILTER_NEXT_7_DAYS_TASKS: start_range = now_time; end_range = time_day_end (time_add_day (start_range, 7)); start = isodate_from_time_t (start_range); end = isodate_from_time_t (end_range); temp = g_strdup_printf ( "(and %s (due-in-time-range? " "(make-time \"%s\") (make-time \"%s\")))", query, start, end); g_free (query); query = temp; break; case TASK_FILTER_ACTIVE_TASKS: start_range = now_time; end_range = time_day_end (time_add_day (start_range, 365)); start = isodate_from_time_t (start_range); end = isodate_from_time_t (end_range); temp = g_strdup_printf ( "(and %s (due-in-time-range? " "(make-time \"%s\") (make-time \"%s\")) " "(not (is-completed?)))", query, start, end); g_free (query); query = temp; break; case TASK_FILTER_OVERDUE_TASKS: start_range = 0; end_range = time_day_end (now_time); start = isodate_from_time_t (start_range); end = isodate_from_time_t (end_range); temp = g_strdup_printf ( "(and %s (due-in-time-range? " "(make-time \"%s\") (make-time \"%s\")) " "(not (is-completed?)))", query, start, end); g_free (query); query = temp; break; case TASK_FILTER_COMPLETED_TASKS: temp = g_strdup_printf ( "(and (is-completed?) %s)", query); g_free (query); query = temp; break; case TASK_FILTER_TASKS_WITH_ATTACHMENTS: temp = g_strdup_printf ( "(and (has-attachments?) %s)", query); g_free (query); query = temp; break; default: { GList *categories; const gchar *category_name; categories = e_util_dup_searchable_categories (); category_name = g_list_nth_data (categories, value); temp = g_strdup_printf ( "(and (has-categories? \"%s\") %s)", category_name, query); g_free (query); query = temp; g_list_free_full (categories, g_free); break; } } /* Honor the user's preference to hide completed tasks. */ temp = calendar_config_get_hide_completed_tasks_sexp (FALSE); if (temp != NULL) { gchar *temp2; temp2 = g_strdup_printf ("(and %s %s)", temp, query); g_free (query); g_free (temp); query = temp2; } /* Submit the query. */ e_cal_data_model_set_filter (data_model, query); g_free (query); preview_pane = e_task_shell_content_get_preview_pane (task_shell_content); web_view = e_preview_pane_get_web_view (preview_pane); task_preview = E_CAL_COMPONENT_PREVIEW (web_view); e_cal_component_preview_clear (task_preview); }