Exemple #1
0
static void
dump_group (ESourceGroup *group)
{
	GSList *sources, *p;

	g_print ("Group %s\n", e_source_group_peek_uid (group));
	g_print ("\tname: %s\n", e_source_group_peek_name (group));
	g_print ("\tbase_uri: %s\n", e_source_group_peek_base_uri (group));

	sources = e_source_group_peek_sources (group);
	for (p = sources; p != NULL; p = p->next) {
		ESource *source = E_SOURCE (p->data);

		dump_source (source);

		if (e_source_peek_group (source) != group)
			g_warning ("\t\t** ERROR ** parent pointer is %p, should be %p",
				   (gpointer) e_source_peek_group (source),
				   (gpointer) group);
	}
}
static void
synch_done (struct account_synch_msg *m)
{

    g_print ("SxAS: Emitting finished signal (%d) [%p]\n",
             m->success, g_thread_self ());

    /* Workaround for broken e_source_list and/or gconf */
    if (m->success) {
        ESourceList *slist;
        ESourceGroup *group;
        const char *group_uid;
        gboolean changed;
        ScalixAccountSynchPrivate *priv;

        changed = FALSE;
        slist = NULL;
        e_cal_get_sources (&slist, E_CAL_SOURCE_TYPE_EVENT, NULL);

        group_uid = e_source_group_peek_uid (m->esg_cals);
        group = e_source_list_peek_group_by_uid (slist, group_uid);

        g_print ("Cal: %s %p\n", group_uid, group);

        if (group == NULL) {
            e_source_list_add_group (slist, m->esg_cals, -1);
        } else {
            char *xml;

            xml = e_source_group_to_xml (m->esg_cals);
            g_print ("Xml: %s\n", xml);
            e_source_group_update_from_xml (group, xml, &changed);
            g_free (xml);
        }

        e_source_list_sync (slist, NULL);
        g_object_unref (slist);

        slist = NULL;
        changed = FALSE;
        e_book_get_addressbooks (&slist, NULL);

        group_uid = e_source_group_peek_uid (m->esg_cnts);
        group = e_source_list_peek_group_by_uid (slist, group_uid);
        g_print ("Cnt: %s %p\n", group_uid, group);

        if (group == NULL) {
            e_source_list_add_group (slist, m->esg_cnts, -1);
        } else {
            char *xml;

            xml = e_source_group_to_xml (m->esg_cnts);
            g_print ("Xml: %s\n", xml);
            e_source_group_update_from_xml (group, xml, &changed);
            g_free (xml);
        }

        e_source_list_sync (slist, NULL);
        g_object_unref (slist);

        priv = SCALIX_ACCOUNT_SYNCH_GET_PRIVATE (m->sxas);

        g_print ("SV: %s\n", m->sversion);

        scalix_account_prefs_set_sversion (priv->account, m->sversion, NULL);

    }

    g_signal_emit (m->sxas, sxas_signals[SAS_SIGNAL_FINISHED], 0, m->success);

    g_print ("SxAS: Emitting done\n");

}
Exemple #3
0
static void
calendar_sources_load_esource_list (CalendarSourceData *source_data)
{
  GSList  *clients = NULL;
  GSList  *groups, *l;
  gboolean emit_signal = FALSE;

  g_return_if_fail (source_data->esource_list != NULL);

  debug_dump_selected_sources (source_data->selected_sources);

  dprintf ("Source groups:\n");
  groups = e_source_list_peek_groups (source_data->esource_list);
  for (l = groups; l; l = l->next)
    {
      GSList *esources, *s;

      dprintf ("  %s\n", e_source_group_peek_uid (l->data));
      dprintf ("    sources:\n");

      esources = e_source_group_peek_sources (l->data);
      for (s = esources; s; s = s->next)
	{
	  ESource *esource = E_SOURCE (s->data);
	  ECal    *client;

	  dprintf ("      type = '%s' uid = '%s', name = '%s', relative uri = '%s': \n",
                   source_data->source_type == E_CAL_SOURCE_TYPE_EVENT ? "appointment" : "task",
		   e_source_peek_uid (esource),
		   e_source_peek_name (esource),
		   e_source_peek_relative_uri (esource));

	  if (is_source_selected (esource, source_data->selected_sources) &&
	      (client = get_ecal_from_source (esource, source_data->source_type, source_data->clients)))
	    {
	      clients = g_slist_prepend (clients, client);
	    }
	}
    }
  dprintf ("\n");

  if (source_data->loaded && 
      !compare_ecal_lists (source_data->clients, clients))
    emit_signal = TRUE;

  for (l = source_data->clients; l; l = l->next)
    {
      g_signal_handlers_disconnect_by_func (G_OBJECT (l->data),
                                            G_CALLBACK (backend_died_cb),
                                            source_data);

      g_object_unref (l->data);
    }
  g_slist_free (source_data->clients);
  source_data->clients = g_slist_reverse (clients);

  /* connect to backend_died after we disconnected the previous signal
   * handlers. If we do it before, we'll lose some handlers (for clients that
   * were already there before) */
  for (l = source_data->clients; l; l = l->next)
    {
      g_signal_connect (G_OBJECT (l->data), "backend_died",
                        G_CALLBACK (backend_died_cb), source_data);
    }

  if (emit_signal) 
    {
      dprintf ("Emitting %s-sources-changed signal\n",
	       source_data->source_type == E_CAL_SOURCE_TYPE_EVENT ? "appointment" : "task");
      g_signal_emit (source_data->sources, source_data->changed_signal, 0);
    }

  debug_dump_ecal_list (source_data->clients);
}