libanjuta/anjuta-async-notify.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta
   4  * Copyright (C) James Liggett 2008 <jrliggett@cox.net>
   5  *
   6  * anjuta is free software: you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * anjuta is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  * See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "anjuta-async-notify.h"
  21
  22 /**
  23  * SECTION: anjuta-async-notify
  24  * @short_description: Mechanism used by interfaces that run asynchronously to
  25  *                                         notify clients of finished tasks and to report errors.
  26  *
  27  * #AnjutaAsyncNotify is a way to allow Anjuta interfaces that run
  28  * asynchronously, such as #IAnjutaVCS, to notify clients that a method has
  29  * completed. #AnjutaAsyncNotify also reports errors to the user.
  30  *
  31  * All clients need to do is create an instance of #AnjutaAsyncNotify, connect
  32  * to the finished signal, and pass it in to the interface method to be called.
  33  */
  34
  35 enum
  36 {
  37         FINISHED,
  38
  39         LAST_SIGNAL
  40 };
  41
  42
  43 static guint async_notify_signals[LAST_SIGNAL] = { 0 };
  44
  45 struct _AnjutaAsyncNotifyPriv
  46 {
  47         GError *error;
  48 };
  49
  50 G_DEFINE_TYPE (AnjutaAsyncNotify, anjuta_async_notify, G_TYPE_OBJECT);
  51
  52 static void
  53 anjuta_async_notify_init (AnjutaAsyncNotify *self)
  54 {
  55         self->priv = g_new0 (AnjutaAsyncNotifyPriv, 1);
  56 }
  57
  58 static void
  59 anjuta_async_notify_finalize (GObject *object)
  60 {
  61         AnjutaAsyncNotify *self;
  62
  63         self = ANJUTA_ASYNC_NOTIFY (object);
  64
  65         g_error_free (self->priv->error);
  66         g_free (self->priv);
  67
  68         G_OBJECT_CLASS (anjuta_async_notify_parent_class)->finalize (object);
  69 }
  70
  71 static void
  72 anjuta_async_notify_finished (AnjutaAsyncNotify *self)
  73 {
  74
  75 }
  76
  77 static void
  78 anjuta_async_notify_class_init (AnjutaAsyncNotifyClass *klass)
  79 {
  80         GObjectClass* object_class = G_OBJECT_CLASS (klass);
  81
  82         object_class->finalize = anjuta_async_notify_finalize;
  83
  84         klass->finished = anjuta_async_notify_finished;
  85
  86         /**
  87          * AnjutaAsyncNotify::finished:
  88          * @notify: AnjutaAsyncNotify object.
  89          *
  90          * Notifies clients that the requested task has finished.
  91          */
  92         async_notify_signals[FINISHED] =
  93                 g_signal_new ("finished",
  94                               G_OBJECT_CLASS_TYPE (klass),
  95                               0,
  96                               G_STRUCT_OFFSET (AnjutaAsyncNotifyClass, finished),
  97                               NULL, NULL,
  98                               g_cclosure_marshal_VOID__VOID,
  99                               G_TYPE_NONE, 0,
 100                               NULL);
 101 }
 102
 103 /**
 104  * anjuta_async_notify_new:
 105  *
 106  * Creates a new #AnjutaAsyncNotify object.
 107  *
 108  * Return value: a new #AnjutaAsyncNotify instance
 109  */
 110 AnjutaAsyncNotify *
 111 anjuta_async_notify_new (void)
 112 {
 113         return g_object_new (ANJUTA_TYPE_ASYNC_NOTIFY, NULL);
 114 }
 115
 116 /**
 117  * anjuta_async_notify_get_error:
 118  * @self: An #AnjutaAsyncNotify object
 119  * @error: Return location for the error set by the called interface to which
 120  *                 this object was passed. If no error is set, @error is set to NULL.
 121  *
 122  * Gets the error set on @self.
 123  */
 124 void
 125 anjuta_async_notify_get_error (AnjutaAsyncNotify *self, GError **error)
 126 {
 127         if (self->priv->error)
 128                 *error = g_error_copy (self->priv->error);
 129 }
 130
 131 /**
 132  * anjuta_async_notify_set_error:
 133  * @self: An #AnjutaAsyncNotify object
 134  * @error: Error to set
 135  *
 136  * Sets the error for an interface call. This method should only be used by
 137  * interface implementations themselves, not by clients.
 138  */
 139 void
 140 anjuta_async_notify_set_error (AnjutaAsyncNotify *self, GError *error)
 141 {
 142         if (self->priv->error)
 143                 g_error_free (self->priv->error);
 144
 145         self->priv->error = g_error_copy (error);
 146 }
 147
 148 /**
 149  * anjuta_async_notify_notify_finished:
 150  * @self: An #AnjutaAsyncNotify object
 151  *
 152  * Emits the finished signal. This method should only be used by
 153  * interface methods themselves, not by clients.
 154  */
 155 void
 156 anjuta_async_notify_notify_finished (AnjutaAsyncNotify *self)
 157 {
 158         g_signal_emit_by_name (self, "finished", NULL);
 159 }