Main Page | Class List | Directories | File List | Class Members | File Members

ghook.c File Reference

#include "glib.h"

Go to the source code of this file.

Defines

#define G_HOOKS_PREALLOC   (16)

Functions

void g_hook_list_init (GHookList *hook_list, guint hook_size)
void g_hook_list_clear (GHookList *hook_list)
GHook * g_hook_alloc (GHookList *hook_list)
void g_hook_free (GHookList *hook_list, GHook *hook)
void g_hook_destroy_link (GHookList *hook_list, GHook *hook)
gboolean g_hook_destroy (GHookList *hook_list, guint hook_id)
void g_hook_unref (GHookList *hook_list, GHook *hook)
void g_hook_ref (GHookList *hook_list, GHook *hook)
void g_hook_prepend (GHookList *hook_list, GHook *hook)
void g_hook_insert_before (GHookList *hook_list, GHook *sibling, GHook *hook)
void g_hook_list_invoke (GHookList *hook_list, gboolean may_recurse)
void g_hook_list_invoke_check (GHookList *hook_list, gboolean may_recurse)
void g_hook_list_marshal_check (GHookList *hook_list, gboolean may_recurse, GHookCheckMarshaller marshaller, gpointer data)
void g_hook_list_marshal (GHookList *hook_list, gboolean may_recurse, GHookMarshaller marshaller, gpointer data)
GHook * g_hook_first_valid (GHookList *hook_list, gboolean may_be_in_call)
GHook * g_hook_next_valid (GHookList *hook_list, GHook *hook, gboolean may_be_in_call)
GHook * g_hook_get (GHookList *hook_list, guint hook_id)
GHook * g_hook_find (GHookList *hook_list, gboolean need_valids, GHookFindFunc func, gpointer data)
GHook * g_hook_find_data (GHookList *hook_list, gboolean need_valids, gpointer data)
GHook * g_hook_find_func (GHookList *hook_list, gboolean need_valids, gpointer func)
GHook * g_hook_find_func_data (GHookList *hook_list, gboolean need_valids, gpointer func, gpointer data)
void g_hook_insert_sorted (GHookList *hook_list, GHook *hook, GHookCompareFunc func)
gint g_hook_compare_ids (GHook *new_hook, GHook *sibling)

Define Documentation

#define G_HOOKS_PREALLOC   (16)
 

Definition at line 38 of file ghook.c.

Referenced by g_hook_list_init().

Function Documentation

GHook* g_hook_alloc (  GHookList *  hook_list  ) 
 

Definition at line 94 of file ghook.c.

References _GHook::data, _GHook::destroy, _GHook::flags, _GHook::func, g_chunk_new0, G_HOOK_FLAG_ACTIVE, g_return_val_if_fail, _GHook::hook_id, _GHookList::hook_memchunk, _GHookList::is_setup, _GHook::next, NULL, _GHook::prev, and _GHook::ref_count.

Referenced by g_source_add().

00095 {
00096   GHook *hook;
00097   
00098   g_return_val_if_fail (hook_list != NULL, NULL);
00099   g_return_val_if_fail (hook_list->is_setup, NULL);
00100   
00101   hook = g_chunk_new0 (GHook, hook_list->hook_memchunk);
00102   hook->data = NULL;
00103   hook->next = NULL;
00104   hook->prev = NULL;
00105   hook->flags = G_HOOK_FLAG_ACTIVE;
00106   hook->ref_count = 0;
00107   hook->hook_id = 0;
00108   hook->func = NULL;
00109   hook->destroy = NULL;
00110   
00111   return hook;
00112 }

gint g_hook_compare_ids (  GHook *  new_hook,
GHook *  sibling
) 
 

Definition at line 629 of file ghook.c.

References _GHook::hook_id.

00631 {
00632   return ((glong) new_hook->hook_id) - ((glong) sibling->hook_id);
00633 }

gboolean g_hook_destroy (  GHookList *  hook_list,
guint  hook_id
) 
 

Definition at line 157 of file ghook.c.

References FALSE, g_hook_destroy_link(), g_hook_get(), g_return_val_if_fail, NULL, and TRUE.

00159 {
00160   GHook *hook;
00161   
00162   g_return_val_if_fail (hook_list != NULL, FALSE);
00163   g_return_val_if_fail (hook_id > 0, FALSE);
00164   
00165   hook = g_hook_get (hook_list, hook_id);
00166   if (hook)
00167     {
00168       g_hook_destroy_link (hook_list, hook);
00169       return TRUE;
00170     }
00171   
00172   return FALSE;
00173 }

void g_hook_destroy_link (  GHookList *  hook_list,
GHook *  hook
) 
 

Definition at line 130 of file ghook.c.

References _GHook::data, _GHook::destroy, _GHook::flags, _GHook::func, G_HOOK_DEFERRED_DESTROY, G_HOOK_FLAG_ACTIVE, g_hook_unref(), g_return_if_fail, _GHookList::hook_destroy, _GHook::hook_id, and NULL.

Referenced by g_hook_destroy(), g_hook_list_clear(), g_hook_list_invoke_check(), g_hook_list_marshal_check(), g_main_dispatch(), g_source_remove(), g_source_remove_by_funcs_user_data(), g_source_remove_by_source_data(), and g_source_remove_by_user_data().

00132 {
00133   g_return_if_fail (hook_list != NULL);
00134   g_return_if_fail (hook != NULL);
00135   
00136   if (hook->hook_id)
00137     {
00138       hook->hook_id = 0;
00139       hook->flags &= ~G_HOOK_FLAG_ACTIVE;
00140       if (hook_list->hook_destroy)
00141         {
00142           if (hook_list->hook_destroy != G_HOOK_DEFERRED_DESTROY)
00143             hook_list->hook_destroy (hook_list, hook);
00144         }
00145       else if (hook->destroy)
00146         {
00147           hook->destroy (hook->data);
00148           hook->data = NULL;
00149           hook->func = NULL;
00150           hook->destroy = NULL;
00151         }
00152       g_hook_unref (hook_list, hook); /* counterpart to g_hook_insert_before */
00153     }
00154 }

GHook* g_hook_find (  GHookList *  hook_list,
gboolean  need_valids,
GHookFindFunc  func,
gpointer  data
) 
 

Definition at line 471 of file ghook.c.

References G_HOOK_ACTIVE, g_hook_ref(), g_hook_unref(), g_return_val_if_fail, _GHook::hook_id, _GHookList::hooks, _GHook::next, and NULL.

Referenced by g_source_remove_by_funcs_user_data(), and g_source_remove_by_source_data().

00475 {
00476   GHook *hook;
00477   
00478   g_return_val_if_fail (hook_list != NULL, NULL);
00479   g_return_val_if_fail (func != NULL, NULL);
00480   
00481   hook = hook_list->hooks;
00482   while (hook)
00483     {
00484       GHook *tmp;
00485 
00486       /* test only non-destroyed hooks */
00487       if (!hook->hook_id)
00488         {
00489           hook = hook->next;
00490           continue;
00491         }
00492       
00493       g_hook_ref (hook_list, hook);
00494       
00495       if (func (hook, data) && hook->hook_id && (!need_valids || G_HOOK_ACTIVE (hook)))
00496         {
00497           g_hook_unref (hook_list, hook);
00498           
00499           return hook;
00500         }
00501 
00502       tmp = hook->next;
00503       g_hook_unref (hook_list, hook);
00504       hook = tmp;
00505     }
00506   
00507   return NULL;
00508 }

GHook* g_hook_find_data (  GHookList *  hook_list,
gboolean  need_valids,
gpointer  data
) 
 

Definition at line 511 of file ghook.c.

References _GHook::data, G_HOOK_ACTIVE, g_return_val_if_fail, _GHook::hook_id, _GHookList::hooks, _GHook::next, and NULL.

Referenced by g_source_remove_by_user_data().

00514 {
00515   GHook *hook;
00516   
00517   g_return_val_if_fail (hook_list != NULL, NULL);
00518   
00519   hook = hook_list->hooks;
00520   while (hook)
00521     {
00522       /* test only non-destroyed hooks */
00523       if (hook->data == data &&
00524           hook->hook_id &&
00525           (!need_valids || G_HOOK_ACTIVE (hook)))
00526         return hook;
00527 
00528       hook = hook->next;
00529     }
00530   
00531   return NULL;
00532 }

GHook* g_hook_find_func (  GHookList *  hook_list,
gboolean  need_valids,
gpointer  func
) 
 

Definition at line 535 of file ghook.c.

References _GHook::func, G_HOOK_ACTIVE, g_return_val_if_fail, _GHook::hook_id, _GHookList::hooks, _GHook::next, and NULL.

00538 {
00539   GHook *hook;
00540   
00541   g_return_val_if_fail (hook_list != NULL, NULL);
00542   g_return_val_if_fail (func != NULL, NULL);
00543   
00544   hook = hook_list->hooks;
00545   while (hook)
00546     {
00547       /* test only non-destroyed hooks */
00548       if (hook->func == func &&
00549           hook->hook_id &&
00550           (!need_valids || G_HOOK_ACTIVE (hook)))
00551         return hook;
00552 
00553       hook = hook->next;
00554     }
00555   
00556   return NULL;
00557 }

GHook* g_hook_find_func_data (  GHookList *  hook_list,
gboolean  need_valids,
gpointer  func,
gpointer  data
) 
 

Definition at line 560 of file ghook.c.

References _GHook::data, _GHook::func, G_HOOK_ACTIVE, g_return_val_if_fail, _GHook::hook_id, _GHookList::hooks, _GHook::next, and NULL.

00564 {
00565   GHook *hook;
00566   
00567   g_return_val_if_fail (hook_list != NULL, NULL);
00568   g_return_val_if_fail (func != NULL, NULL);
00569   
00570   hook = hook_list->hooks;
00571   while (hook)
00572     {
00573       /* test only non-destroyed hooks */
00574       if (hook->data == data &&
00575           hook->func == func &&
00576           hook->hook_id &&
00577           (!need_valids || G_HOOK_ACTIVE (hook)))
00578         return hook;
00579 
00580       hook = hook->next;
00581     }
00582   
00583   return NULL;
00584 }

GHook* g_hook_first_valid (  GHookList *  hook_list,
gboolean  may_be_in_call
) 
 

Definition at line 398 of file ghook.c.

References G_HOOK_IN_CALL, G_HOOK_IS_VALID, g_hook_next_valid(), g_hook_ref(), g_return_val_if_fail, _GHookList::hooks, _GHookList::is_setup, and NULL.

Referenced by g_hook_list_invoke(), g_hook_list_invoke_check(), g_hook_list_marshal(), g_hook_list_marshal_check(), and g_main_iterate().

00400 {
00401   g_return_val_if_fail (hook_list != NULL, NULL);
00402   
00403   if (hook_list->is_setup)
00404     {
00405       GHook *hook;
00406       
00407       hook = hook_list->hooks;
00408       if (hook)
00409         {
00410           g_hook_ref (hook_list, hook);
00411           if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))
00412             return hook;
00413           else
00414             return g_hook_next_valid (hook_list, hook, may_be_in_call);
00415         }
00416     }
00417   
00418   return NULL;
00419 }

void g_hook_free (  GHookList *  hook_list,
GHook *  hook
) 
 

Definition at line 115 of file ghook.c.

References g_chunk_free, G_HOOK_IS_UNLINKED, g_return_if_fail, _GHookList::hook_free, _GHookList::hook_memchunk, _GHookList::is_setup, and NULL.

Referenced by g_hook_unref().

00117 {
00118   g_return_if_fail (hook_list != NULL);
00119   g_return_if_fail (hook_list->is_setup);
00120   g_return_if_fail (hook != NULL);
00121   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
00122 
00123   if (hook_list->hook_free)
00124     hook_list->hook_free (hook_list, hook);
00125   
00126   g_chunk_free (hook, hook_list->hook_memchunk);
00127 }

GHook* g_hook_get (  GHookList *  hook_list,
guint  hook_id
) 
 

Definition at line 451 of file ghook.c.

References g_return_val_if_fail, _GHook::hook_id, _GHookList::hooks, _GHook::next, and NULL.

Referenced by g_hook_destroy(), and g_source_remove().

00453 {
00454   GHook *hook;
00455   
00456   g_return_val_if_fail (hook_list != NULL, NULL);
00457   g_return_val_if_fail (hook_id > 0, NULL);
00458   
00459   hook = hook_list->hooks;
00460   while (hook)
00461     {
00462       if (hook->hook_id == hook_id)
00463         return hook;
00464       hook = hook->next;
00465     }
00466   
00467   return NULL;
00468 }

void g_hook_insert_before (  GHookList *  hook_list,
GHook *  sibling,
GHook *  hook
) 
 

Definition at line 239 of file ghook.c.

References G_HOOK_IS_UNLINKED, g_return_if_fail, _GHookList::hooks, _GHookList::is_setup, _GHook::next, NULL, _GHook::prev, and _GHookList::seq_id.

Referenced by g_hook_insert_sorted(), and g_hook_prepend().

00242 {
00243   g_return_if_fail (hook_list != NULL);
00244   g_return_if_fail (hook_list->is_setup);
00245   g_return_if_fail (hook != NULL);
00246   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
00247   g_return_if_fail (hook->func != NULL);
00248   
00249   hook->hook_id = hook_list->seq_id++;
00250   hook->ref_count = 1; /* counterpart to g_hook_destroy_link */
00251   
00252   if (sibling)
00253     {
00254       if (sibling->prev)
00255         {
00256           hook->prev = sibling->prev;
00257           hook->prev->next = hook;
00258           hook->next = sibling;
00259           sibling->prev = hook;
00260         }
00261       else
00262         {
00263           hook_list->hooks = hook;
00264           hook->next = sibling;
00265           sibling->prev = hook;
00266         }
00267     }
00268   else
00269     {
00270       if (hook_list->hooks)
00271         {
00272           sibling = hook_list->hooks;
00273           while (sibling->next)
00274             sibling = sibling->next;
00275           hook->prev = sibling;
00276           sibling->next = hook;
00277         }
00278       else
00279         hook_list->hooks = hook;
00280     }
00281 }

void g_hook_insert_sorted (  GHookList *  hook_list,
GHook *  hook,
GHookCompareFunc  func
) 
 

Definition at line 587 of file ghook.c.

References g_hook_insert_before(), G_HOOK_IS_UNLINKED, g_hook_ref(), g_hook_unref(), g_return_if_fail, _GHook::hook_id, _GHookList::hooks, _GHookList::is_setup, _GHook::next, and NULL.

Referenced by g_source_add().

00590 {
00591   GHook *sibling;
00592   
00593   g_return_if_fail (hook_list != NULL);
00594   g_return_if_fail (hook_list->is_setup);
00595   g_return_if_fail (hook != NULL);
00596   g_return_if_fail (G_HOOK_IS_UNLINKED (hook));
00597   g_return_if_fail (hook->func != NULL);
00598   g_return_if_fail (func != NULL);
00599 
00600   /* first non-destroyed hook */
00601   sibling = hook_list->hooks;
00602   while (sibling && !sibling->hook_id)
00603     sibling = sibling->next;
00604   
00605   while (sibling)
00606     {
00607       GHook *tmp;
00608       
00609       g_hook_ref (hook_list, sibling);
00610       if (func (hook, sibling) <= 0 && sibling->hook_id)
00611         {
00612           g_hook_unref (hook_list, sibling);
00613           break;
00614         }
00615 
00616       /* next non-destroyed hook */
00617       tmp = sibling->next;
00618       while (tmp && !tmp->hook_id)
00619         tmp = tmp->next;
00620 
00621       g_hook_unref (hook_list, sibling);
00622       sibling = tmp;
00623     }
00624   
00625   g_hook_insert_before (hook_list, sibling, hook);
00626 }

void g_hook_list_clear (  GHookList *  hook_list  ) 
 

Definition at line 62 of file ghook.c.

References FALSE, g_hook_destroy_link(), g_hook_ref(), g_hook_unref(), g_mem_chunk_destroy(), g_return_if_fail, _GHookList::hook_memchunk, _GHookList::hooks, _GHookList::is_setup, _GHook::next, and NULL.

00063 {
00064   g_return_if_fail (hook_list != NULL);
00065   
00066   if (hook_list->is_setup)
00067     {
00068       GHook *hook;
00069       
00070       hook_list->is_setup = FALSE;
00071       
00072       hook = hook_list->hooks;
00073       if (!hook)
00074         {
00075           g_mem_chunk_destroy (hook_list->hook_memchunk);
00076           hook_list->hook_memchunk = NULL;
00077         }
00078       else
00079         do
00080           {
00081             GHook *tmp;
00082             
00083             g_hook_ref (hook_list, hook);
00084             g_hook_destroy_link (hook_list, hook);
00085             tmp = hook->next;
00086             g_hook_unref (hook_list, hook);
00087             hook = tmp;
00088           }
00089         while (hook);
00090     }
00091 }

void g_hook_list_init (  GHookList *  hook_list,
guint  hook_size
) 
 

Definition at line 43 of file ghook.c.

References G_ALLOC_AND_FREE, G_HOOKS_PREALLOC, g_mem_chunk_new(), g_return_if_fail, _GHookList::hook_destroy, _GHookList::hook_free, _GHookList::hook_memchunk, _GHookList::hook_size, _GHookList::hooks, _GHookList::is_setup, NULL, _GHookList::seq_id, and TRUE.

Referenced by g_source_add().

00045 {
00046   g_return_if_fail (hook_list != NULL);
00047   g_return_if_fail (hook_size >= sizeof (GHook));
00048   
00049   hook_list->seq_id = 1;
00050   hook_list->hook_size = hook_size;
00051   hook_list->is_setup = TRUE;
00052   hook_list->hooks = NULL;
00053   hook_list->hook_memchunk = g_mem_chunk_new ("GHook Memchunk",
00054                                               hook_size,
00055                                               hook_size * G_HOOKS_PREALLOC,
00056                                               G_ALLOC_AND_FREE);
00057   hook_list->hook_free = NULL;
00058   hook_list->hook_destroy = NULL;
00059 }

void g_hook_list_invoke (  GHookList *  hook_list,
gboolean  may_recurse
) 
 

Definition at line 284 of file ghook.c.

References _GHook::data, _GHook::flags, _GHook::func, g_hook_first_valid(), G_HOOK_FLAG_IN_CALL, G_HOOK_IN_CALL, g_hook_next_valid(), g_return_if_fail, _GHookList::is_setup, and NULL.

00286 {
00287   GHook *hook;
00288   
00289   g_return_if_fail (hook_list != NULL);
00290   g_return_if_fail (hook_list->is_setup);
00291 
00292   hook = g_hook_first_valid (hook_list, may_recurse);
00293   while (hook)
00294     {
00295       GHookFunc func;
00296       gboolean was_in_call;
00297       
00298       func = (GHookFunc) hook->func;
00299       
00300       was_in_call = G_HOOK_IN_CALL (hook);
00301       hook->flags |= G_HOOK_FLAG_IN_CALL;
00302       func (hook->data);
00303       if (!was_in_call)
00304         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
00305       
00306       hook = g_hook_next_valid (hook_list, hook, may_recurse);
00307     }
00308 }

void g_hook_list_invoke_check (  GHookList *  hook_list,
gboolean  may_recurse
) 
 

Definition at line 311 of file ghook.c.

References _GHook::data, _GHook::flags, _GHook::func, g_hook_destroy_link(), g_hook_first_valid(), G_HOOK_FLAG_IN_CALL, G_HOOK_IN_CALL, g_hook_next_valid(), g_return_if_fail, _GHookList::is_setup, and NULL.

00313 {
00314   GHook *hook;
00315   
00316   g_return_if_fail (hook_list != NULL);
00317   g_return_if_fail (hook_list->is_setup);
00318   
00319   hook = g_hook_first_valid (hook_list, may_recurse);
00320   while (hook)
00321     {
00322       GHookCheckFunc func;
00323       gboolean was_in_call;
00324       gboolean need_destroy;
00325       
00326       func = (GHookCheckFunc) hook->func;
00327       
00328       was_in_call = G_HOOK_IN_CALL (hook);
00329       hook->flags |= G_HOOK_FLAG_IN_CALL;
00330       need_destroy = !func (hook->data);
00331       if (!was_in_call)
00332         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
00333       if (need_destroy)
00334         g_hook_destroy_link (hook_list, hook);
00335       
00336       hook = g_hook_next_valid (hook_list, hook, may_recurse);
00337     }
00338 }

void g_hook_list_marshal (  GHookList *  hook_list,
gboolean  may_recurse,
GHookMarshaller  marshaller,
gpointer  data
) 
 

Definition at line 371 of file ghook.c.

References _GHook::flags, g_hook_first_valid(), G_HOOK_FLAG_IN_CALL, G_HOOK_IN_CALL, g_hook_next_valid(), g_return_if_fail, _GHookList::is_setup, and NULL.

00375 {
00376   GHook *hook;
00377   
00378   g_return_if_fail (hook_list != NULL);
00379   g_return_if_fail (hook_list->is_setup);
00380   g_return_if_fail (marshaller != NULL);
00381   
00382   hook = g_hook_first_valid (hook_list, may_recurse);
00383   while (hook)
00384     {
00385       gboolean was_in_call;
00386       
00387       was_in_call = G_HOOK_IN_CALL (hook);
00388       hook->flags |= G_HOOK_FLAG_IN_CALL;
00389       marshaller (hook, data);
00390       if (!was_in_call)
00391         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
00392       
00393       hook = g_hook_next_valid (hook_list, hook, may_recurse);
00394     }
00395 }

void g_hook_list_marshal_check (  GHookList *  hook_list,
gboolean  may_recurse,
GHookCheckMarshaller  marshaller,
gpointer  data
) 
 

Definition at line 341 of file ghook.c.

References _GHook::flags, g_hook_destroy_link(), g_hook_first_valid(), G_HOOK_FLAG_IN_CALL, G_HOOK_IN_CALL, g_hook_next_valid(), g_return_if_fail, _GHookList::is_setup, and NULL.

00345 {
00346   GHook *hook;
00347   
00348   g_return_if_fail (hook_list != NULL);
00349   g_return_if_fail (hook_list->is_setup);
00350   g_return_if_fail (marshaller != NULL);
00351   
00352   hook = g_hook_first_valid (hook_list, may_recurse);
00353   while (hook)
00354     {
00355       gboolean was_in_call;
00356       gboolean need_destroy;
00357       
00358       was_in_call = G_HOOK_IN_CALL (hook);
00359       hook->flags |= G_HOOK_FLAG_IN_CALL;
00360       need_destroy = !marshaller (hook, data);
00361       if (!was_in_call)
00362         hook->flags &= ~G_HOOK_FLAG_IN_CALL;
00363       if (need_destroy)
00364         g_hook_destroy_link (hook_list, hook);
00365       
00366       hook = g_hook_next_valid (hook_list, hook, may_recurse);
00367     }
00368 }

GHook* g_hook_next_valid (  GHookList *  hook_list,
GHook *  hook,
gboolean  may_be_in_call
) 
 

Definition at line 422 of file ghook.c.

References G_HOOK_IN_CALL, G_HOOK_IS_VALID, g_hook_ref(), g_hook_unref(), g_return_val_if_fail, _GHook::next, and NULL.

Referenced by g_hook_first_valid(), g_hook_list_invoke(), g_hook_list_invoke_check(), g_hook_list_marshal(), g_hook_list_marshal_check(), and g_main_iterate().

00425 {
00426   GHook *ohook = hook;
00427 
00428   g_return_val_if_fail (hook_list != NULL, NULL);
00429 
00430   if (!hook)
00431     return NULL;
00432   
00433   hook = hook->next;
00434   while (hook)
00435     {
00436       if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))
00437         {
00438           g_hook_ref (hook_list, hook);
00439           g_hook_unref (hook_list, ohook);
00440           
00441           return hook;
00442         }
00443       hook = hook->next;
00444     }
00445   g_hook_unref (hook_list, ohook);
00446 
00447   return NULL;
00448 }

void g_hook_prepend (  GHookList *  hook_list,
GHook *  hook
) 
 

Definition at line 230 of file ghook.c.

References g_hook_insert_before(), g_return_if_fail, _GHookList::hooks, and NULL.

00232 {
00233   g_return_if_fail (hook_list != NULL);
00234   
00235   g_hook_insert_before (hook_list, hook_list->hooks, hook);
00236 }

void g_hook_ref (  GHookList *  hook_list,
GHook *  hook
) 
 

Definition at line 219 of file ghook.c.

References g_return_if_fail, NULL, and _GHook::ref_count.

Referenced by g_hook_find(), g_hook_first_valid(), g_hook_insert_sorted(), g_hook_list_clear(), g_hook_next_valid(), and g_main_iterate().

00221 {
00222   g_return_if_fail (hook_list != NULL);
00223   g_return_if_fail (hook != NULL);
00224   g_return_if_fail (hook->ref_count > 0);
00225   
00226   hook->ref_count++;
00227 }

void g_hook_unref (  GHookList *  hook_list,
GHook *  hook
) 
 

Definition at line 176 of file ghook.c.

References FALSE, g_hook_free(), G_HOOK_IN_CALL, g_mem_chunk_destroy(), g_return_if_fail, _GHook::hook_id, _GHookList::hook_memchunk, _GHookList::hooks, _GHookList::is_setup, _GHook::next, NULL, _GHook::prev, _GHook::ref_count, and TRUE.

Referenced by g_hook_destroy_link(), g_hook_find(), g_hook_insert_sorted(), g_hook_list_clear(), g_hook_next_valid(), g_main_dispatch(), and g_main_iterate().

00178 {
00179   g_return_if_fail (hook_list != NULL);
00180   g_return_if_fail (hook_list->hook_memchunk != NULL);
00181   g_return_if_fail (hook != NULL);
00182   g_return_if_fail (hook->ref_count > 0);
00183   
00184   hook->ref_count--;
00185   if (!hook->ref_count)
00186     {
00187       g_return_if_fail (hook->hook_id == 0);
00188       g_return_if_fail (!G_HOOK_IN_CALL (hook));
00189       
00190       if (hook->prev)
00191         hook->prev->next = hook->next;
00192       else
00193         hook_list->hooks = hook->next;
00194       if (hook->next)
00195         {
00196           hook->next->prev = hook->prev;
00197           hook->next = NULL;
00198         }
00199       hook->prev = NULL;
00200 
00201       if (!hook_list->is_setup)
00202         {
00203           hook_list->is_setup = TRUE;
00204           g_hook_free (hook_list, hook);
00205           hook_list->is_setup = FALSE;
00206       
00207           if (!hook_list->hooks)
00208             {
00209               g_mem_chunk_destroy (hook_list->hook_memchunk);
00210               hook_list->hook_memchunk = NULL;
00211             }
00212         }
00213       else
00214         g_hook_free (hook_list, hook);
00215     }
00216 }

© sourcejam.com 2005-2008