00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #define GOB_VERSION_MAJOR 2
00029 #define GOB_VERSION_MINOR 0
00030 #define GOB_VERSION_PATCHLEVEL 16
00031
00032 #define selfp (self->_priv)
00033
00034 #include <string.h>
00035
00036 #ifdef G_LIKELY
00037 #define ___GOB_LIKELY(expr) G_LIKELY(expr)
00038 #define ___GOB_UNLIKELY(expr) G_UNLIKELY(expr)
00039 #else
00040 #define ___GOB_LIKELY(expr) (expr)
00041 #define ___GOB_UNLIKELY(expr) (expr)
00042 #endif
00043
00044
00045 #include "frame-common.h"
00046 #include "frame-signals.h"
00047 #include "gedit-spinner.h"
00048
00049
00050 #define SELF(x) FRAME_SIGNALS(x)
00051 #define SELF_CONST(x) FRAME_SIGNALS_CONST(x)
00052 #define IS_SELF(x) FRAME_IS_SIGNALS(x)
00053 #define TYPE_SELF FRAME_TYPE_SIGNALS
00054 #define SELF_CLASS(x) FRAME_SIGNALS_CLASS(x)
00055
00056 #define SELF_GET_CLASS(x) FRAME_SIGNALS_GET_CLASS(x)
00057
00058
00059 typedef Framesignals Self;
00060 typedef FramesignalsClass SelfClass;
00061
00062
00063 static void frame_signals_init (Framesignals * o) G_GNUC_UNUSED;
00064 static void frame_signals_class_init (FramesignalsClass * c) G_GNUC_UNUSED;
00065 static void ___real_frame_signals_spinner_stop (Framesignals * self, gpointer data);
00066 static void ___real_frame_signals_spinner_start (Framesignals * self, gpointer data);
00067
00068
00069
00070
00071 #define self_connect__spinner_stop(object,func,data) frame_signals_connect__spinner_stop((object),(func),(data))
00072 #define self_connect_after__spinner_stop(object,func,data) frame_signals_connect_after__spinner_stop((object),(func),(data))
00073 #define self_connect_data__spinner_stop(object,func,data,destroy_data,flags) frame_signals_connect_data__spinner_stop((object),(func),(data),(destroy_data),(flags))
00074 #define self_connect__spinner_start(object,func,data) frame_signals_connect__spinner_start((object),(func),(data))
00075 #define self_connect_after__spinner_start(object,func,data) frame_signals_connect_after__spinner_start((object),(func),(data))
00076 #define self_connect_data__spinner_start(object,func,data,destroy_data,flags) frame_signals_connect_data__spinner_start((object),(func),(data),(destroy_data),(flags))
00077
00078 typedef void (*___Sig1) (Framesignals *, gpointer , gpointer);
00079
00080 static void
00081 ___marshal_Sig1 (GClosure *closure,
00082 GValue *return_value G_GNUC_UNUSED,
00083 guint n_param_values,
00084 const GValue *param_values,
00085 gpointer invocation_hint G_GNUC_UNUSED,
00086 gpointer marshal_data)
00087 {
00088 register ___Sig1 callback;
00089 register GCClosure *cc = (GCClosure*) closure;
00090 register gpointer data1, data2;
00091
00092 g_return_if_fail (n_param_values == 2);
00093
00094 if (G_CCLOSURE_SWAP_DATA (closure)) {
00095 data1 = closure->data;
00096 data2 = g_value_peek_pointer (param_values + 0);
00097 } else {
00098 data1 = g_value_peek_pointer (param_values + 0);
00099 data2 = closure->data;
00100 }
00101
00102 callback = (___Sig1) (marshal_data != NULL ? marshal_data : cc->callback);
00103
00104 callback ((Framesignals *)data1,
00105 (gpointer ) g_value_get_pointer (param_values + 1),
00106 data2);
00107 }
00108
00109
00110 enum {
00111 SPINNER_STOP_SIGNAL,
00112 SPINNER_START_SIGNAL,
00113 LAST_SIGNAL
00114 };
00115
00116 static guint object_signals[LAST_SIGNAL] = {0};
00117
00118
00119 static GObjectClass *parent_class = NULL;
00120
00121
00122 #define self_spinner_stop frame_signals_spinner_stop
00123 #define self_spinner_start frame_signals_spinner_start
00124 #define self_new frame_signals_new
00125 GType
00126 frame_signals_get_type (void)
00127 {
00128 static GType type = 0;
00129
00130 if ___GOB_UNLIKELY(type == 0) {
00131 static const GTypeInfo info = {
00132 sizeof (FramesignalsClass),
00133 (GBaseInitFunc) NULL,
00134 (GBaseFinalizeFunc) NULL,
00135 (GClassInitFunc) frame_signals_class_init,
00136 (GClassFinalizeFunc) NULL,
00137 NULL ,
00138 sizeof (Framesignals),
00139 0 ,
00140 (GInstanceInitFunc) frame_signals_init,
00141 NULL
00142 };
00143
00144 type = g_type_register_static (G_TYPE_OBJECT, "Framesignals", &info, (GTypeFlags)0);
00145 }
00146
00147 return type;
00148 }
00149
00150
00151 #define GET_NEW ((Framesignals *)g_object_new(frame_signals_get_type(), NULL))
00152
00153
00154 #include <stdarg.h>
00155 static Framesignals * GET_NEW_VARG (const char *first, ...) G_GNUC_UNUSED;
00156 static Framesignals *
00157 GET_NEW_VARG (const char *first, ...)
00158 {
00159 Framesignals *ret;
00160 va_list ap;
00161 va_start (ap, first);
00162 ret = (Framesignals *)g_object_new_valist (frame_signals_get_type (), first, ap);
00163 va_end (ap);
00164 return ret;
00165 }
00166
00167 static void
00168 frame_signals_init (Framesignals * o G_GNUC_UNUSED)
00169 {
00170 #define __GOB_FUNCTION__ "Frame:signals::init"
00171 }
00172 #undef __GOB_FUNCTION__
00173 static void
00174 frame_signals_class_init (FramesignalsClass * c G_GNUC_UNUSED)
00175 {
00176 #define __GOB_FUNCTION__ "Frame:signals::class_init"
00177 GObjectClass *g_object_class G_GNUC_UNUSED = (GObjectClass*) c;
00178
00179 parent_class = g_type_class_ref (G_TYPE_OBJECT);
00180
00181 object_signals[SPINNER_STOP_SIGNAL] =
00182 g_signal_new ("spinner_stop",
00183 G_TYPE_FROM_CLASS (g_object_class),
00184 (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
00185 G_STRUCT_OFFSET (FramesignalsClass, spinner_stop),
00186 NULL, NULL,
00187 ___marshal_Sig1,
00188 G_TYPE_NONE, 1,
00189 G_TYPE_POINTER);
00190 if ___GOB_UNLIKELY(sizeof(gpointer ) != sizeof(gpointer ) || parent_class == NULL ) {
00191 g_error("/home/steve/SYNEMA/data/frame-signals.gob line 32: Type mismatch of \"spinner_stop\" signal signature");
00192 }
00193 object_signals[SPINNER_START_SIGNAL] =
00194 g_signal_new ("spinner_start",
00195 G_TYPE_FROM_CLASS (g_object_class),
00196 (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
00197 G_STRUCT_OFFSET (FramesignalsClass, spinner_start),
00198 NULL, NULL,
00199 ___marshal_Sig1,
00200 G_TYPE_NONE, 1,
00201 G_TYPE_POINTER);
00202 if ___GOB_UNLIKELY(sizeof(gpointer ) != sizeof(gpointer ) || parent_class == NULL ) {
00203 g_error("/home/steve/SYNEMA/data/frame-signals.gob line 45: Type mismatch of \"spinner_start\" signal signature");
00204 }
00205
00206 c->spinner_stop = ___real_frame_signals_spinner_stop;
00207 c->spinner_start = ___real_frame_signals_spinner_start;
00208 }
00209 #undef __GOB_FUNCTION__
00210
00211
00212
00213 void
00214 frame_signals_spinner_stop (Framesignals * self, gpointer data)
00215 {
00216 GValue ___param_values[2];
00217 GValue ___return_val;
00218
00219 memset (&___return_val, 0, sizeof (___return_val));
00220 memset (&___param_values, 0, sizeof (___param_values));
00221
00222 g_return_if_fail (self != NULL);
00223 g_return_if_fail (FRAME_IS_SIGNALS (self));
00224
00225 ___param_values[0].g_type = 0;
00226 g_value_init (&___param_values[0], G_TYPE_FROM_INSTANCE (self));
00227 g_value_set_instance (&___param_values[0], (gpointer) self);
00228
00229 ___param_values[1].g_type = 0;
00230 g_value_init (&___param_values[1], G_TYPE_POINTER);
00231 g_value_set_pointer (&___param_values[1], (gpointer ) data);
00232
00233 g_signal_emitv (___param_values,
00234 object_signals[SPINNER_STOP_SIGNAL],
00235 0 ,
00236 &___return_val);
00237
00238 g_value_unset (&___param_values[0]);
00239 g_value_unset (&___param_values[1]);
00240 }
00241 static void
00242 ___real_frame_signals_spinner_stop (Framesignals * self G_GNUC_UNUSED, gpointer data)
00243 {
00244 #define __GOB_FUNCTION__ "Frame:signals::spinner_stop"
00245 {
00246
00247 frame_t *f = (frame_t *) data;
00248
00249 if (f) {
00250 if (f->computing_spinner) {
00251 gedit_spinner_stop (GEDIT_SPINNER (f->computing_spinner));
00252 }
00253 }
00254 }}
00255 #undef __GOB_FUNCTION__
00256
00257 void
00258 frame_signals_spinner_start (Framesignals * self, gpointer data)
00259 {
00260 GValue ___param_values[2];
00261 GValue ___return_val;
00262
00263 memset (&___return_val, 0, sizeof (___return_val));
00264 memset (&___param_values, 0, sizeof (___param_values));
00265
00266 g_return_if_fail (self != NULL);
00267 g_return_if_fail (FRAME_IS_SIGNALS (self));
00268
00269 ___param_values[0].g_type = 0;
00270 g_value_init (&___param_values[0], G_TYPE_FROM_INSTANCE (self));
00271 g_value_set_instance (&___param_values[0], (gpointer) self);
00272
00273 ___param_values[1].g_type = 0;
00274 g_value_init (&___param_values[1], G_TYPE_POINTER);
00275 g_value_set_pointer (&___param_values[1], (gpointer ) data);
00276
00277 g_signal_emitv (___param_values,
00278 object_signals[SPINNER_START_SIGNAL],
00279 0 ,
00280 &___return_val);
00281
00282 g_value_unset (&___param_values[0]);
00283 g_value_unset (&___param_values[1]);
00284 }
00285 static void
00286 ___real_frame_signals_spinner_start (Framesignals * self G_GNUC_UNUSED, gpointer data)
00287 {
00288 #define __GOB_FUNCTION__ "Frame:signals::spinner_start"
00289 {
00290
00291 frame_t *f = (frame_t *) data;
00292
00293 if (f) {
00294 if ((f->show_spinner) && (f->computing_spinner)) {
00295 gedit_spinner_start (GEDIT_SPINNER (f->computing_spinner));
00296 }
00297 }
00298 }}
00299 #undef __GOB_FUNCTION__
00300
00301 GObject *
00302 frame_signals_new (void)
00303 {
00304 #define __GOB_FUNCTION__ "Frame:signals::new"
00305 {
00306
00307 return (GObject *)GET_NEW;
00308 }}
00309 #undef __GOB_FUNCTION__