/** * e_cal_backend_sexp_match_comp: * @sexp: An #ESExp object. * @comp: Component to match against the expression. * @backend: Backend. * * Matches the given ECalComponent against the expression. * * Returns: TRUE if the component matched the expression, FALSE if not. */ gboolean e_cal_backend_sexp_match_comp (ECalBackendSExp *sexp, ECalComponent *comp, ECalBackend *backend) { ESExpResult *r; gboolean retval; g_return_val_if_fail (E_IS_CAL_BACKEND_SEXP (sexp), FALSE); g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); g_return_val_if_fail (E_IS_CAL_BACKEND (backend), FALSE); sexp->priv->search_context->comp = g_object_ref (comp); sexp->priv->search_context->backend = g_object_ref (backend); /* if it's not a valid vcard why is it in our db? :) */ if (!sexp->priv->search_context->comp) { g_object_unref (sexp->priv->search_context->backend); return FALSE; } r = e_sexp_eval (sexp->priv->search_sexp); retval = (r && r->type == ESEXP_RES_BOOL && r->value.boolean); g_object_unref (sexp->priv->search_context->comp); g_object_unref (sexp->priv->search_context->backend); e_sexp_result_free (sexp->priv->search_sexp, r); return retval; }
/** * e_cal_util_is_first_instance: * @comp: an #ECalComponent instance * @rid: a recurrence ID * @tz_cb: (closure tz_cb_data) (scope call): The #ECalRecurResolveTimezoneFn to call * @tz_cb_data: (closure): User data to be passed to the @tz_cb callback * * Returns whether the given @rid is the first instance of * the recurrence defined in the @comp. * * Return: Whether the @rid identifies the first instance of @comp. * * Since: 3.16 **/ gboolean e_cal_util_is_first_instance (ECalComponent *comp, struct icaltimetype rid, ECalRecurResolveTimezoneFn tz_cb, gpointer tz_cb_data) { CheckFirstInstanceData ifs; icalcomponent *icalcomp; time_t start, end; g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); g_return_val_if_fail (!icaltime_is_null_time (rid), FALSE); ifs.rid = rid; ifs.matches = FALSE; icalcomp = e_cal_component_get_icalcomponent (comp); start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp)) - 24 * 60 * 60; end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp)) + 24 * 60 * 60; e_cal_recur_generate_instances (comp, start, end, check_first_instance_cb, &ifs, tz_cb, tz_cb_data, icaltimezone_get_utc_timezone ()); return ifs.matches; }
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 () */
void e_cal_component_set_outofsync (ECalComponent *comp, gboolean outofsync) { GSList *categ_list, *iter; gboolean updated = FALSE; g_return_if_fail (comp != NULL); g_return_if_fail (E_IS_CAL_COMPONENT (comp)); e_cal_component_get_categories_list (comp, &categ_list); if (outofsync) { for (iter = categ_list; iter != NULL; iter = iter->next) { gchar *cat = (gchar *) iter->data; if (!g_strcmp0 (cat, "outofsync")) goto exit; } categ_list = g_slist_prepend (categ_list, g_strdup ("outofsync")); updated = TRUE; } else { GSList *next; for (iter = categ_list; iter != NULL; iter = next) { next = iter->next; gchar *cat = (gchar *) iter->data; if (!g_strcmp0 (cat, "outofsync")) { categ_list = g_slist_delete_link (categ_list, iter); g_free (cat); updated = TRUE; } } } if (updated) e_cal_component_set_categories_list (comp, categ_list); exit: e_cal_component_free_categories_list (categ_list); }
static ECompEditor * get_component_editor (EShell *shell, ECalClient *client, ECalComponent *comp, gboolean is_new, GError **error) { ECompEditorFlags flags = 0; ECompEditor *comp_editor = NULL; ESourceRegistry *registry; g_return_val_if_fail (E_IS_SHELL (shell), NULL); g_return_val_if_fail (E_IS_CAL_CLIENT (client), NULL); g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL); registry = e_shell_get_registry (shell); if (is_new) { flags |= E_COMP_EDITOR_FLAG_IS_NEW; } else { comp_editor = e_comp_editor_find_existing_for ( e_client_get_source (E_CLIENT (client)), e_cal_component_get_icalcomponent (comp)); } if (!comp_editor) { if (itip_organizer_is_user (registry, comp, client)) flags |= E_COMP_EDITOR_FLAG_ORGANIZER_IS_USER; if (e_cal_component_has_attendees (comp)) flags |= E_COMP_EDITOR_FLAG_WITH_ATTENDEES; comp_editor = e_comp_editor_open_for_component (NULL, shell, e_client_get_source (E_CLIENT (client)), e_cal_component_get_icalcomponent (comp), flags); if (comp_editor) { /* request save for new events */ e_comp_editor_set_changed (comp_editor, is_new); } } return comp_editor; }
gboolean datetime_is_date_only (ECalComponent *comp, gboolean datetime_check) { ECalComponentDateTime dt; gboolean is_date_only; g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); dt.value = NULL; if (datetime_check == DATETIME_CHECK_DTSTART) e_cal_component_get_dtstart (comp, &dt); else e_cal_component_get_dtend (comp, &dt); is_date_only = dt.value && dt.value->is_date; e_cal_component_free_datetime (&dt); return is_date_only; }
/* Stores information about actually shown component and * returns whether component in the preview changed */ static gboolean update_comp_info (ECalComponentPreview *preview, ECalClient *client, ECalComponent *comp, icaltimezone *zone, gboolean use_24_hour_format) { ECalComponentPreviewPrivate *priv; gboolean changed; g_return_val_if_fail (preview != NULL, TRUE); g_return_val_if_fail (E_IS_CAL_COMPONENT_PREVIEW (preview), TRUE); priv = preview->priv; if (!E_IS_CAL_COMPONENT (comp) || !E_IS_CAL_CLIENT (client)) { changed = !priv->cal_uid; clear_comp_info (preview); } else { ESource *source; const gchar *uid; gchar *cal_uid; gchar *comp_uid; struct icaltimetype comp_last_modified, *itm = NULL; gint *sequence = NULL; gint comp_sequence; source = e_client_get_source (E_CLIENT (client)); cal_uid = g_strdup (e_source_get_uid (source)); e_cal_component_get_uid (comp, &uid); comp_uid = g_strdup (uid); e_cal_component_get_last_modified (comp, &itm); if (itm) { comp_last_modified = *itm; e_cal_component_free_icaltimetype (itm); } else comp_last_modified = icaltime_null_time (); e_cal_component_get_sequence (comp, &sequence); if (sequence) { comp_sequence = *sequence; e_cal_component_free_sequence (sequence); } else comp_sequence = 0; changed = !priv->cal_uid || !priv->comp_uid || !cal_uid || !comp_uid || !g_str_equal (priv->cal_uid, cal_uid) || !g_str_equal (priv->comp_uid, comp_uid) || priv->comp_sequence != comp_sequence || icaltime_compare (priv->comp_last_modified, comp_last_modified) != 0; clear_comp_info (preview); priv->cal_uid = cal_uid; priv->comp_uid = comp_uid; priv->comp_sequence = comp_sequence; priv->comp_last_modified = comp_last_modified; priv->comp = g_object_ref (comp); priv->client = g_object_ref (client); priv->timezone = icaltimezone_copy (zone); priv->use_24_hour_format = use_24_hour_format; } return changed; }
static CompEditor * get_component_editor (EShell *shell, ECalClient *client, ECalComponent *comp, gboolean is_new, GError **error) { ECalComponentId *id; CompEditorFlags flags = 0; CompEditor *editor = NULL; ESourceRegistry *registry; g_return_val_if_fail (E_IS_SHELL (shell), NULL); g_return_val_if_fail (E_IS_CAL_CLIENT (client), NULL); g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL); registry = e_shell_get_registry (shell); id = e_cal_component_get_id (comp); g_return_val_if_fail (id != NULL, NULL); g_return_val_if_fail (id->uid != NULL, NULL); if (is_new) { flags |= COMP_EDITOR_NEW_ITEM; } else { editor = comp_editor_find_instance (id->uid); } if (!editor) { if (itip_organizer_is_user (registry, comp, client)) flags |= COMP_EDITOR_USER_ORG; switch (e_cal_component_get_vtype (comp)) { case E_CAL_COMPONENT_EVENT: if (e_cal_component_has_attendees (comp)) flags |= COMP_EDITOR_MEETING; editor = event_editor_new (client, shell, flags); if (flags & COMP_EDITOR_MEETING) event_editor_show_meeting (EVENT_EDITOR (editor)); break; case E_CAL_COMPONENT_TODO: if (e_cal_component_has_attendees (comp)) flags |= COMP_EDITOR_IS_ASSIGNED; editor = task_editor_new (client, shell, flags); if (flags & COMP_EDITOR_IS_ASSIGNED) task_editor_show_assignment (TASK_EDITOR (editor)); break; case E_CAL_COMPONENT_JOURNAL: if (e_cal_component_has_organizer (comp)) flags |= COMP_EDITOR_IS_SHARED; editor = memo_editor_new (client, shell, flags); break; default: g_warn_if_reached (); break; } if (editor) { comp_editor_edit_comp (editor, comp); /* request save for new events */ comp_editor_set_changed (editor, is_new); } } e_cal_component_free_id (id); return editor; }
/** * e_intervaltree_insert: * @tree: interval tree * @start: start of the interval * @end: end of the interval * @comp: Component * * Since: 2.32 **/ gboolean e_intervaltree_insert (EIntervalTree *tree, time_t start, time_t end, ECalComponent *comp) { EIntervalTreePrivate *priv; EIntervalNode *y; EIntervalNode *x; EIntervalNode *newNode; const gchar *uid; gchar *rid; g_return_val_if_fail (tree != NULL, FALSE); g_return_val_if_fail (comp != NULL, FALSE); g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); priv = tree->priv; g_static_rec_mutex_lock (&priv->mutex); e_cal_component_get_uid (comp, &uid); rid = e_cal_component_get_recurid_as_string (comp); e_intervaltree_remove (tree, uid, rid); x = g_new (EIntervalNode, 1); x->min = x->start = start; x->max = x->end = end; x->comp = g_object_ref (comp); binary_tree_insert (tree, x); newNode = x; x->red = TRUE; fixup_min_max_fields (tree, x->parent); while (x->parent->red) { /* use sentinel instead of checking for root */ if (x->parent == x->parent->parent->left) { y = x->parent->parent->right; if (y->red) { x->parent->red = FALSE; y->red = FALSE; x->parent->parent->red = TRUE; x = x->parent->parent; } else { if (x == x->parent->right) { x = x ->parent; left_rotate (tree, x); } x->parent->red = FALSE; x->parent->parent->red = TRUE; right_rotate (tree, x->parent->parent); } } else { /* case for x->parent == x->parent->parent->right */ y = x->parent->parent->left; if (y->red) { x->parent->red = FALSE; y->red = FALSE; x->parent->parent->red = TRUE; x = x->parent->parent; } else { if (x == x->parent->left) { x = x->parent; right_rotate (tree, x); } x->parent->red = FALSE; x->parent->parent->red = TRUE; left_rotate (tree, x->parent->parent); } } } priv->root->left->red = FALSE; g_hash_table_insert (priv->id_node_hash, component_key (uid, rid), newNode); g_free (rid); g_static_rec_mutex_unlock (&priv->mutex); return TRUE; }