Event: QOF event handlers.
[Query Object Framework]


Files

file  gnc-event.h
 engine event handling interface (to be renamed qofevent.h in libqof2)

Typedefs

typedef void(* GNCEngineEventHandler )(GUID *entity, QofIdType type, GNCEngineEventType event_type, gpointer user_data)

Enumerations

enum  GNCEngineEventType {
  GNC_EVENT_NONE = 0, GNC_EVENT_CREATE = 1 << 0, GNC_EVENT_MODIFY = 1 << 1, GNC_EVENT_DESTROY = 1 << 2,
  GNC_EVENT_ADD = 1 << 3, GNC_EVENT_REMOVE = 1 << 4, GNC_EVENT_ALL = 0xff
}

Functions

gint gnc_engine_register_event_handler (GNCEngineEventHandler handler, gpointer user_data)
void gnc_engine_unregister_event_handler (gint handler_id)
void gnc_engine_gen_event (QofEntity *entity, GNCEngineEventType event_type)
void gnc_engine_suspend_events (void)
void gnc_engine_resume_events (void)


Typedef Documentation

typedef void(* GNCEngineEventHandler)(GUID *entity, QofIdType type, GNCEngineEventType event_type, gpointer user_data)
 

GNCEngineEventHandler

Handler invoked when an engine event occurs.

Parameters:
entity,: GUID of entity generating event
type,: QofIdType of the entity generating the event
event_type,: one of the single-bit GNCEngineEventTypes, not a combination
user_data,: user_data supplied when handler was registered.

Definition at line 62 of file gnc-event.h.


Function Documentation

void gnc_engine_gen_event QofEntity entity,
GNCEngineEventType  event_type
 

gnc_engine_generate_event

Invoke all registered event handlers using the given arguments.

GNC_EVENT_CREATE events should be generated after the object has been created and registered in the engine entity table. GNC_EVENT_MODIFY events should be generated whenever any data member or submember (i.e., splits) is changed. GNC_EVENT_DESTROY events should be called before the object has been destroyed or removed from the entity table.

Parameters:
entity,: the GUID of the entity generating the event
event_type,: the type of event -- this should be one of the single-bit GNCEngineEventType values, not a combination.

Definition at line 199 of file gnc-event.c.

00200 {
00201   if (!entity)
00202     return;
00203 
00204   if (suspend_counter)
00205     return;
00206 
00207   gnc_engine_generate_event_internal (entity, event_type);
00208 }

gint gnc_engine_register_event_handler GNCEngineEventHandler  handler,
gpointer  user_data
 

gnc_engine_register_event_handler

Register a handler for engine events.

Parameters:
handler,: handler to register
user_data,: data provided when handler is invoked
Returns:
id identifying handler

Definition at line 50 of file gnc-event.c.

00052 {
00053   HandlerInfo *hi;
00054   gint handler_id;
00055   GList *node;
00056 
00057   ENTER ("(handler=%p, data=%p)", handler, user_data);
00058   /* sanity check */
00059   if (!handler)
00060   {
00061     PERR ("no handler specified");
00062     return 0;
00063   }
00064 
00065   /* look for a free handler id */
00066   handler_id = next_handler_id;
00067   node = handlers;
00068 
00069   while (node)
00070   {
00071     hi = node->data;
00072 
00073     if (hi->handler_id == handler_id)
00074     {
00075       handler_id++;
00076       node = handlers;
00077       continue;
00078     }
00079 
00080     node = node->next;
00081   }
00082 
00083   /* Found one, add the handler */
00084   hi = g_new0 (HandlerInfo, 1);
00085 
00086   hi->handler = handler;
00087   hi->user_data = user_data;
00088   hi->handler_id = handler_id;
00089 
00090   handlers = g_list_prepend (handlers, hi);
00091 
00092   /* Update id for next registration */
00093   next_handler_id = handler_id + 1;
00094 
00095   LEAVE ("(handler=%p, data=%p) handler_id=%d", handler, user_data, handler_id);
00096   return handler_id;
00097 }

void gnc_engine_resume_events void   ) 
 

gnc_engine_resume_events

Resume engine event generation.

Definition at line 140 of file gnc-event.c.

00141 {
00142   if (suspend_counter == 0)
00143   {
00144     PERR ("suspend counter underflow");
00145     return;
00146   }
00147 
00148   suspend_counter--;
00149 }

void gnc_engine_suspend_events void   ) 
 

gnc_engine_suspend_events

Suspend all engine events. This function may be called multiple times. To resume event generation, an equal number of calls to gnc_engine_resume_events must be made.

Definition at line 129 of file gnc-event.c.

00130 {
00131   suspend_counter++;
00132 
00133   if (suspend_counter == 0)
00134   {
00135     PERR ("suspend counter overflow");
00136   }
00137 }

void gnc_engine_unregister_event_handler gint  handler_id  ) 
 

gnc_engine_unregister_event_handler

Unregister an engine event handler.

Parameters:
handler_id,: the id of the handler to unregister

Definition at line 100 of file gnc-event.c.

00101 {
00102   GList *node;
00103 
00104   ENTER ("(handler_id=%d)", handler_id);
00105   for (node = handlers; node; node = node->next)
00106   {
00107     HandlerInfo *hi = node->data;
00108 
00109     if (hi->handler_id != handler_id)
00110       continue;
00111 
00112     /* Found it, take out of list */ 
00113     handlers = g_list_remove_link (handlers, node);
00114 
00115     LEAVE ("(handler_id=%d) handler=%p data=%p", handler_id, hi->handler, hi->user_data);
00116     /* safety */
00117     hi->handler = NULL;
00118 
00119     g_list_free_1 (node);
00120     g_free (hi);
00121 
00122     return;
00123   }
00124 
00125   PERR ("no such handler: %d", handler_id);
00126 }


Generated on Fri Oct 21 15:49:58 2005 for QOF by  doxygen 1.4.5