home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / module_db.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  28.4 KB  |  1,152 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * module_db.c (C) 1999 Austin Donnelly <austin@gimp.org>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19.  */
  20.  
  21. #include "config.h"
  22.  
  23. #include <glib.h>
  24.  
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <sys/types.h>
  28. #include <sys/stat.h>
  29. #ifdef HAVE_UNISTD_H
  30. #include <unistd.h>
  31. #endif
  32. #include <time.h>
  33.  
  34. #include <gtk/gtk.h>
  35.  
  36. #include "apptypes.h"
  37.  
  38. #include "appenv.h"
  39. #include "module_db.h"
  40. #include "gimpsignal.h"
  41. #include "gimprc.h"
  42. #include "datafiles.h"
  43. #include "gimpset.h"
  44. #include "gimpui.h"
  45.  
  46. #include "libgimp/gimpenv.h"
  47. #include "libgimp/gimpmodule.h"
  48.  
  49. #include "libgimp/gimpintl.h"
  50.  
  51.  
  52. /* export this to gimprc.c */
  53. gchar *module_db_load_inhibit = NULL;
  54.  
  55. typedef enum
  56. {
  57.   ST_MODULE_ERROR,         /* missing module_load function or other error    */
  58.   ST_LOADED_OK,            /* happy and running (normal state of affairs)    */
  59.   ST_LOAD_FAILED,          /* module_load returned GIMP_MODULE_UNLOAD        */
  60.   ST_UNLOAD_REQUESTED,     /* sent unload request, waiting for callback      */
  61.   ST_UNLOADED_OK           /* callback arrived, module not in memory anymore */
  62. } module_state;
  63.  
  64. static const gchar * const statename[] =
  65. {
  66.   N_("Module error"),
  67.   N_("Loaded OK"),
  68.   N_("Load failed"),
  69.   N_("Unload requested"),
  70.   N_("Unloaded OK")
  71. };
  72.  
  73. #ifdef __EMX__
  74. extern void gimp_color_selector_register   ();
  75. extern void gimp_color_selector_unregister ();
  76. extern void gimp_color_display_register    ();
  77. extern void gimp_color_display_unregister  ();
  78. extern void dialog_register                ();
  79. extern void dialog_unregister              ();
  80.  
  81. static struct main_funcs_struc
  82. {
  83.   gchar *name;
  84.   void (*func) ();
  85. } 
  86.  
  87. gimp_main_funcs[] =
  88. {
  89.   { "gimp_color_selector_register",   gimp_color_selector_register },
  90.   { "gimp_color_selector_unregister", gimp_color_selector_unregister },
  91.   { "gimp_color_display_register",    gimp_color_display_register },
  92.   { "gimp_color_display_unregister",  gimp_color_display_unregister },
  93.   { "dialog_register",                dialog_register },
  94.   { "dialog_unregister",              dialog_unregister },
  95.   { NULL, NULL }
  96. };
  97. #endif
  98.  
  99.  
  100. /* one of these objects is kept per-module */
  101. typedef struct
  102. {
  103.   GtkObject       object;
  104.  
  105.   gchar          *fullpath;     /* path to the module                        */
  106.   module_state    state;        /* what's happened to the module             */
  107.   gboolean        ondisk;       /* TRUE if file still exists                 */
  108.   gboolean        load_inhibit; /* user requests not to load at boot time    */
  109.   gint            refs;         /* how many time we're running in the module */
  110.  
  111.   /* stuff from now on may be NULL depending on the state the module is in   */
  112.   GimpModuleInfo *info;         /* returned values from module_init          */
  113.   GModule        *module;       /* handle on the module                      */
  114.   gchar          *last_module_error;
  115.  
  116.   GimpModuleInitFunc   init;
  117.   GimpModuleUnloadFunc unload;
  118. } ModuleInfo;
  119.  
  120.  
  121. static guint module_info_get_type (void);
  122.  
  123. #define MODULE_INFO_TYPE    module_info_get_type()
  124. #define MODULE_INFO(obj)    GTK_CHECK_CAST (obj, MODULE_INFO_TYPE, ModuleInfo)
  125. #define IS_MODULE_INFO(obj) GTK_CHECK_TYPE (obj, MODULE_INFO_TYPE)
  126.  
  127.  
  128. #define NUM_INFO_LINES 7
  129.  
  130. typedef struct
  131. {
  132.   GtkWidget  *table;
  133.   GtkWidget  *label[NUM_INFO_LINES];
  134.   GtkWidget  *button_label;
  135.   ModuleInfo *last_update;
  136.   GtkWidget  *button;
  137.   GtkWidget  *list;
  138.   GtkWidget  *load_inhibit_check;
  139. } BrowserState;
  140.  
  141. /* global set of module_info pointers */
  142. static GimpSet          *modules;
  143. static GimpSetHandlerId  modules_handler;
  144.  
  145. /* If the inhibit state of any modules changes, we might need to
  146.  * re-write the modulerc. */
  147. static gboolean need_to_rewrite_modulerc = FALSE;
  148.  
  149.  
  150. /* debug control: */
  151.  
  152. /*#define DUMP_DB*/
  153. /*#define DEBUG*/
  154.  
  155. #ifdef DEBUG
  156. #undef DUMP_DB
  157. #define DUMP_DB
  158. #define TRC(x) printf x
  159. #else
  160. #define TRC(x)
  161. #endif
  162.  
  163.  
  164. /* prototypes */
  165. static void         module_initialize      (gchar        *filename);
  166. static void         mod_load               (ModuleInfo   *mod,
  167.                         gboolean      verbose);
  168. static void         mod_unload             (ModuleInfo   *mod,
  169.                         gboolean      verbose);
  170. static gboolean     mod_idle_unref         (ModuleInfo   *mod);
  171. static ModuleInfo * module_find_by_path    (const gchar  *fullpath);
  172.  
  173. #ifdef DUMP_DB
  174. static void   print_module_info            (gpointer      data,
  175.                         gpointer      user_data);
  176. #endif
  177.  
  178. static void   browser_popdown_callback     (GtkWidget    *widget,
  179.                         gpointer      data);
  180. static void   browser_destroy_callback     (GtkWidget    *widget,
  181.                         gpointer      data);
  182. static void   browser_info_update          (ModuleInfo   *mod,
  183.                         BrowserState *st);
  184. static void   browser_info_add             (GimpSet      *set,
  185.                         ModuleInfo   *mod,
  186.                         BrowserState *st);
  187. static void   browser_info_remove          (GimpSet      *set,
  188.                         ModuleInfo   *mod,
  189.                         BrowserState *st);
  190. static void   browser_info_init            (BrowserState *st,
  191.                         GtkWidget    *table);
  192. static void   browser_select_callback      (GtkWidget    *widget,
  193.                         GtkWidget    *child);
  194. static void   browser_load_unload_callback (GtkWidget    *widget,
  195.                         gpointer      data);
  196. static void   browser_refresh_callback     (GtkWidget    *widget,
  197.                         gpointer      data);
  198. static void   make_list_item               (gpointer      data,
  199.                         gpointer      user_data);
  200.  
  201. static void   gimp_module_ref              (ModuleInfo   *mod);
  202. static void   gimp_module_unref            (ModuleInfo   *mod);
  203.  
  204.  
  205.  
  206. /**************************************************************/
  207. /* Exported functions */
  208.  
  209. void
  210. module_db_init (void)
  211. {
  212.   gchar *filename;
  213.  
  214.   /* load the modulerc file */
  215.   filename = gimp_personal_rc_file ("modulerc");
  216.   parse_gimprc_file (filename);
  217.   g_free (filename);
  218.  
  219.   /* Load and initialize gimp modules */
  220.  
  221.   modules = gimp_set_new (MODULE_INFO_TYPE, FALSE);
  222.  
  223.   if (g_module_supported ())
  224.     datafiles_read_directories (module_path,
  225.                 module_initialize, 0 /* no flags */);
  226. #ifdef DUMP_DB
  227.   gimp_set_foreach (modules, print_module_info, NULL);
  228. #endif
  229. }
  230.  
  231. static void
  232. free_a_single_module (gpointer data, 
  233.               gpointer user_data)
  234. {
  235.   ModuleInfo *mod = data;
  236.  
  237.   if (mod->module && mod->unload && mod->state == ST_LOADED_OK)
  238.     {
  239.       mod_unload (mod, FALSE);
  240.     }
  241. }
  242.  
  243. static void
  244. add_to_inhibit_string (gpointer data, 
  245.                gpointer user_data)
  246. {
  247.   ModuleInfo *mod = data;
  248.   GString    *str = user_data;
  249.  
  250.   if (mod->load_inhibit)
  251.     {
  252.       str = g_string_append_c (str, G_SEARCHPATH_SEPARATOR);
  253.       str = g_string_append (str, mod->fullpath);
  254.     }
  255. }
  256.  
  257.  
  258. static gboolean
  259. module_db_write_modulerc (void)
  260. {
  261.   GString  *str;
  262.   gchar    *p;
  263.   gchar    *filename;
  264.   FILE     *fp;
  265.   gboolean  saved = FALSE;
  266.  
  267.   str = g_string_new (NULL);
  268.   gimp_set_foreach (modules, add_to_inhibit_string, str);
  269.   if (str->len > 0)
  270.     p = str->str + 1;
  271.   else
  272.     p = "";
  273.  
  274.   filename = gimp_personal_rc_file ("modulerc");
  275.   fp = fopen (filename, "wt");
  276.   g_free (filename);
  277.   if (fp)
  278.     {
  279.       fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
  280.       fclose (fp);
  281.       saved = TRUE;
  282.     }
  283.  
  284.   g_string_free (str, TRUE);
  285.   return (saved);
  286. }
  287.  
  288.  
  289. void
  290. module_db_free (void)
  291. {
  292.   if (need_to_rewrite_modulerc)
  293.     {
  294.       if (module_db_write_modulerc ())
  295.     {
  296.       need_to_rewrite_modulerc = FALSE;
  297.     }
  298.     }
  299.   gimp_set_foreach (modules, free_a_single_module, NULL);
  300. }
  301.  
  302.  
  303. GtkWidget *
  304. module_db_browser_new (void)
  305. {
  306.   GtkWidget *shell;
  307.   GtkWidget *hbox;
  308.   GtkWidget *vbox;
  309.   GtkWidget *listbox;
  310.   GtkWidget *button;
  311.   BrowserState *st;
  312.  
  313.   shell = gimp_dialog_new (_("Module DB"), "module_db_dialog",
  314.                gimp_standard_help_func,
  315.                "dialogs/module_browser.html",
  316.                GTK_WIN_POS_NONE,
  317.                FALSE, TRUE, FALSE,
  318.  
  319.                _("OK"), browser_popdown_callback,
  320.                NULL, NULL, NULL, TRUE, TRUE,
  321.  
  322.                NULL);
  323.  
  324.   vbox = gtk_vbox_new (FALSE, 5);
  325.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
  326.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (shell)->vbox), vbox);
  327.   gtk_widget_show (vbox);
  328.  
  329.   listbox = gtk_scrolled_window_new (NULL, NULL);
  330.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox),
  331.                   GTK_POLICY_AUTOMATIC,
  332.                   GTK_POLICY_AUTOMATIC);
  333.   gtk_box_pack_start (GTK_BOX (vbox), listbox, TRUE, TRUE, 0);
  334.   gtk_widget_set_usize (listbox, 125, 100);
  335.   gtk_widget_show (listbox);
  336.  
  337.   st = g_new0 (BrowserState, 1);
  338.  
  339.   st->list = gtk_list_new ();
  340.   gtk_list_set_selection_mode (GTK_LIST (st->list), GTK_SELECTION_BROWSE);
  341.   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (listbox),
  342.                      st->list);
  343.  
  344.   gimp_set_foreach (modules, make_list_item, st);
  345.  
  346.   gtk_widget_show (st->list);
  347.  
  348.   st->table = gtk_table_new (5, NUM_INFO_LINES + 1, FALSE);
  349.   gtk_table_set_col_spacings (GTK_TABLE (st->table), 4);  
  350.   gtk_box_pack_start (GTK_BOX (vbox), st->table, FALSE, FALSE, 0);
  351.   gtk_widget_show (st->table);
  352.  
  353.   hbox = gtk_hbutton_box_new ();
  354.   gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD);
  355.  
  356.   gtk_widget_show (hbox);
  357.   gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 5);
  358.  
  359.   button = gtk_button_new_with_label (_("Refresh"));
  360.   gtk_widget_show (button);
  361.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  362.               browser_refresh_callback, st);
  363.   gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  364.  
  365.   st->button = gtk_button_new_with_label ("");
  366.   st->button_label = GTK_BIN (st->button)->child;
  367.   gtk_box_pack_start (GTK_BOX (hbox), st->button, TRUE, TRUE, 0);
  368.   gtk_widget_show (st->button);
  369.   gtk_signal_connect (GTK_OBJECT (st->button), "clicked",
  370.               browser_load_unload_callback, st);
  371.  
  372.   browser_info_init (st, st->table);
  373.   browser_info_update (st->last_update, st);
  374.  
  375.   gtk_object_set_user_data (GTK_OBJECT (st->list), st);
  376.  
  377.   gtk_signal_connect (GTK_OBJECT (st->list), "select_child",
  378.               browser_select_callback, NULL);
  379.  
  380.   /* hook the gimpset signals so we can refresh the display
  381.    * appropriately. */
  382.   modules_handler =
  383.     gimp_set_add_handler (modules, "modified", browser_info_update, st);
  384.  
  385.   gtk_signal_connect (GTK_OBJECT (modules), "add", 
  386.               browser_info_add, st);
  387.   gtk_signal_connect (GTK_OBJECT (modules), "remove", 
  388.               browser_info_remove, st);
  389.  
  390.   gtk_signal_connect (GTK_OBJECT (shell), "destroy",
  391.               browser_destroy_callback, st);
  392.  
  393.   return shell;
  394. }
  395.  
  396.  
  397. /**************************************************************/
  398. /* ModuleInfo object glue */
  399.  
  400.  
  401. typedef struct
  402. {
  403.   GtkObjectClass parent_class;
  404. } ModuleInfoClass;
  405.  
  406. enum
  407. {
  408.   MODIFIED,
  409.   LAST_SIGNAL
  410. };
  411. static guint module_info_signals[LAST_SIGNAL];
  412.  
  413.  
  414. static void
  415. module_info_destroy (GtkObject *object)
  416. {
  417.   ModuleInfo *mod = MODULE_INFO (object);
  418.  
  419.   /* if this trips, then we're onto some serious lossage in a moment */
  420.   g_return_if_fail (mod->refs == 0);
  421.  
  422.   if (mod->last_module_error)
  423.     g_free (mod->last_module_error);
  424.   g_free (mod->fullpath);
  425. }
  426.  
  427. static void
  428. module_info_class_init (ModuleInfoClass *klass)
  429. {
  430.   GtkObjectClass *object_class;
  431.   GtkType type;
  432.  
  433.   object_class = GTK_OBJECT_CLASS (klass);
  434.  
  435.   type = object_class->type;
  436.  
  437.   object_class->destroy = module_info_destroy;
  438.  
  439.   module_info_signals[MODIFIED] =
  440.     gimp_signal_new ("modified", 0, type, 0, gimp_sigtype_void);
  441.  
  442.   gtk_object_class_add_signals (object_class, module_info_signals, LAST_SIGNAL);
  443. }
  444.  
  445. static void
  446. module_info_init (ModuleInfo *mod)
  447. {
  448.   /* don't need to do anything */
  449. }
  450.  
  451. static guint
  452. module_info_get_type (void)
  453. {
  454.   static guint module_info_type = 0;
  455.  
  456.   if (!module_info_type)
  457.     {
  458.       static const GtkTypeInfo module_info_info =
  459.       {
  460.     "ModuleInfo",
  461.     sizeof (ModuleInfo),
  462.     sizeof (ModuleInfoClass),
  463.     (GtkClassInitFunc) module_info_class_init,
  464.     (GtkObjectInitFunc) module_info_init,
  465.     /* reserved_1 */ NULL,
  466.         /* reserved_2 */ NULL,
  467.         (GtkClassInitFunc) NULL,
  468.       };
  469.  
  470.       module_info_type =
  471.     gtk_type_unique (gtk_object_get_type (), &module_info_info);
  472.     }
  473.  
  474.   return module_info_type;
  475. }
  476.  
  477. /* exported API: */
  478.  
  479. static void
  480. module_info_modified (ModuleInfo *mod)
  481. {
  482.   gtk_signal_emit (GTK_OBJECT (mod), module_info_signals[MODIFIED]);
  483. }
  484.  
  485. static ModuleInfo *
  486. module_info_new (void)
  487. {
  488.   return MODULE_INFO (gtk_type_new (module_info_get_type ()));
  489. }
  490.  
  491. static void
  492. module_info_free (ModuleInfo *mod)
  493. {
  494.   gtk_object_unref (GTK_OBJECT (mod));
  495. }
  496.  
  497.  
  498. /**************************************************************/
  499. /* helper functions */
  500.  
  501.  
  502. /* name must be of the form lib*.so (Unix) or *.dll (Win32) */
  503. static gboolean
  504. valid_module_name (const gchar *filename)
  505. {
  506.   const gchar *basename;
  507.   gint len;
  508.  
  509.   basename = g_basename (filename);
  510.  
  511.   len = strlen (basename);
  512.  
  513. #if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN) && !defined(__EMX__)
  514.   if (len < 3 + 1 + 3)
  515.     return FALSE;
  516.  
  517.   if (strncmp (basename, "lib", 3))
  518.     return FALSE;
  519.  
  520.   if (strcmp (basename + len - 3, ".so"))
  521.     return FALSE;
  522. #else
  523.   if (len < 1 + 4)
  524.       return FALSE;
  525.  
  526.   if (g_strcasecmp (basename + len - 4, ".dll"))
  527.     return FALSE;
  528. #endif
  529.  
  530.   return TRUE;
  531. }
  532.  
  533.  
  534. static gboolean
  535. module_inhibited (const gchar *fullpath, 
  536.           const gchar *inhibit_list)
  537. {
  538.   gchar *p;
  539.   gint   pathlen;
  540.   const gchar *start;
  541.   const gchar *end;
  542.  
  543.   /* common case optimisation: the list is empty */
  544.   if (!inhibit_list || *inhibit_list == '\000')
  545.     return FALSE;
  546.  
  547.   p = strstr (inhibit_list, fullpath);
  548.   if (!p)
  549.     return FALSE;
  550.  
  551.   /* we have a substring, but check for colons either side */
  552.   start = p;
  553.   while (start != inhibit_list && *start != G_SEARCHPATH_SEPARATOR)
  554.       start--;
  555.   if (*start == G_SEARCHPATH_SEPARATOR)
  556.       start++;
  557.  
  558.   end = strchr (p, G_SEARCHPATH_SEPARATOR);
  559.   if (!end)
  560.     end = inhibit_list + strlen (inhibit_list);
  561.  
  562.   pathlen = strlen (fullpath);
  563.   if ((end - start) == pathlen)
  564.     return TRUE;
  565.   else
  566.     return FALSE;
  567. }
  568.  
  569.  
  570. static void
  571. module_initialize (gchar *filename)
  572. {
  573.   ModuleInfo *mod;
  574.  
  575.   if (!valid_module_name (filename))
  576.     return;
  577.  
  578.   /* don't load if we already know about it */
  579.   if (module_find_by_path (filename))
  580.     return;
  581.  
  582.   mod = module_info_new ();
  583.  
  584.   mod->fullpath = g_strdup (filename);
  585.   mod->ondisk = TRUE;
  586.   mod->state = ST_MODULE_ERROR;
  587.  
  588.   mod->info = NULL;
  589.   mod->module = NULL;
  590.   mod->last_module_error = NULL;
  591.   mod->init = NULL;
  592.   mod->unload = NULL;
  593.  
  594.   /* Count of times main gimp is within the module.  Normally, this
  595.    * will be 1, and we assume that the module won't call its
  596.    * unload callback until it is satisfied that it's not in use any
  597.    * more.  refs can be 2 temporarily while we're running the module's
  598.    * unload function, to stop the module attempting to unload
  599.    * itself. */
  600.   mod->refs = 0;
  601.  
  602.   mod->load_inhibit = module_inhibited (mod->fullpath, module_db_load_inhibit);
  603.   if (!mod->load_inhibit)
  604.     {
  605.       if (be_verbose)
  606.     g_print (_("load module: \"%s\"\n"), filename);
  607.  
  608.       mod_load (mod, TRUE);
  609.     }
  610.   else
  611.     {
  612.       if (be_verbose)
  613.     g_print (_("skipping module: \"%s\"\n"), filename);
  614.  
  615.       mod->state = ST_UNLOADED_OK;
  616.     }
  617.  
  618.   gimp_set_add (modules, mod);
  619. }
  620.  
  621. static void
  622. mod_load (ModuleInfo *mod, 
  623.       gboolean    verbose)
  624. {
  625.   gpointer symbol;
  626.  
  627.   g_return_if_fail (mod->module == NULL);
  628.  
  629.   mod->module = g_module_open (mod->fullpath, G_MODULE_BIND_LAZY);
  630.   if (!mod->module)
  631.     {
  632.       mod->state = ST_MODULE_ERROR;
  633.  
  634.       if (mod->last_module_error)
  635.     g_free (mod->last_module_error);
  636.       mod->last_module_error = g_strdup (g_module_error ());
  637.  
  638.       if (verbose)
  639.     g_warning (_("module load error: %s: %s"),
  640.            mod->fullpath, mod->last_module_error);
  641.       return;
  642.     }
  643.  
  644. #ifdef __EMX__
  645.   if (g_module_symbol (mod->module, "gimp_main_funcs", &symbol))
  646.     {
  647.       *(struct main_funcs_struc **)symbol = gimp_main_funcs;
  648.     }
  649. #endif
  650.   /* find the module_init symbol */
  651.   if (!g_module_symbol (mod->module, "module_init", &symbol))
  652.     {
  653.       mod->state = ST_MODULE_ERROR;
  654.  
  655.       if (mod->last_module_error)
  656.     g_free (mod->last_module_error);
  657.       mod->last_module_error = g_strdup ("missing module_init() symbol");
  658.  
  659.       if (verbose)
  660.     g_warning ("%s: module_init() symbol not found", mod->fullpath);
  661.  
  662.       g_module_close (mod->module);
  663.       mod->module = NULL;
  664.       mod->info = NULL;
  665.       return;
  666.     }
  667.  
  668.   /* run module's initialisation */
  669.   mod->init = symbol;
  670.   mod->info = NULL;
  671.   gimp_module_ref (mod); /* loaded modules are assumed to have a ref of 1 */
  672.   if (mod->init (&mod->info) == GIMP_MODULE_UNLOAD)
  673.     {
  674.       mod->state = ST_LOAD_FAILED;
  675.       gimp_module_unref (mod);
  676.       mod->info = NULL;
  677.       return;
  678.     }
  679.  
  680.   /* module is now happy */
  681.   mod->state = ST_LOADED_OK;
  682.   TRC (("loaded module %s, state at %p\n", mod->fullpath, mod));
  683.  
  684.   /* do we have an unload function? */
  685.   if (g_module_symbol (mod->module, "module_unload", &symbol))
  686.     mod->unload = symbol;
  687.   else
  688.     mod->unload = NULL;
  689. }
  690.  
  691.  
  692. static void
  693. mod_unload_completed_callback (void *data)
  694. {
  695.   ModuleInfo *mod = data;
  696.  
  697.   g_return_if_fail (mod->state == ST_UNLOAD_REQUESTED);
  698.  
  699.   /* lose the ref we gave this module when we loaded it,
  700.    * since the module's now happy to be unloaded. */
  701.   gimp_module_unref (mod);
  702.   mod->info = NULL;
  703.  
  704.   mod->state = ST_UNLOADED_OK;
  705.  
  706.   TRC (("module unload completed callback for %p\n", mod));
  707.  
  708.   module_info_modified (mod);
  709. }
  710.  
  711. static void
  712. mod_unload (ModuleInfo *mod, 
  713.         gboolean    verbose)
  714. {
  715.   g_return_if_fail (mod->module != NULL);
  716.   g_return_if_fail (mod->unload != NULL);
  717.  
  718.   if (mod->state == ST_UNLOAD_REQUESTED)
  719.     return;
  720.  
  721.   mod->state = ST_UNLOAD_REQUESTED;
  722.  
  723.   TRC (("module unload requested for %p\n", mod));
  724.  
  725.   /* Send the unload request.  Need to ref the module so we don't
  726.    * accidentally unload it while this call is in progress (eg if the
  727.    * callback is called before the unload function returns). */
  728.   gimp_module_ref (mod);
  729.   mod->unload (mod->info->shutdown_data, mod_unload_completed_callback, mod);
  730.  
  731.   gtk_idle_add ((GtkFunction) mod_idle_unref, (gpointer) mod);
  732. }
  733.  
  734. static gboolean
  735. mod_idle_unref (ModuleInfo *mod)
  736. {
  737.   gimp_module_unref (mod);
  738.  
  739.   return FALSE;
  740. }
  741.  
  742. #ifdef DUMP_DB
  743. static void
  744. print_module_info (gpointer data, 
  745.            gpointer user_data)
  746. {
  747.   ModuleInfo *i = data;
  748.  
  749.   g_print ("\n%s: %s\n",
  750.        i->fullpath, statename[i->state]);
  751.   g_print ("  module:%p  lasterr:%s  init:%p  unload:%p\n",
  752.        i->module, i->last_module_error? i->last_module_error : "NONE",
  753.        i->init, i->unload);
  754.   if (i->info)
  755.     {
  756.       g_print ("  shutdown_data: %p\n"
  757.            "  purpose:   %s\n"
  758.            "  author:    %s\n"
  759.            "  version:   %s\n"
  760.            "  copyright: %s\n"
  761.            "  date:      %s\n",
  762.            i->info->shutdown_data,
  763.            i->info->purpose, i->info->author, i->info->version,
  764.            i->info->copyright, i->info->date);
  765.     }
  766. }
  767. #endif
  768.  
  769.  
  770.  
  771. /**************************************************************/
  772. /* UI functions */
  773.  
  774. static void
  775. browser_popdown_callback (GtkWidget *widget,
  776.               gpointer   data)
  777. {
  778.   gtk_widget_destroy (GTK_WIDGET (data));
  779. }
  780.  
  781. static void
  782. browser_destroy_callback (GtkWidget *widget,
  783.               gpointer   data)
  784. {
  785.   gtk_signal_disconnect_by_data (GTK_OBJECT (modules), data);
  786.   gimp_set_remove_handler (modules, modules_handler);
  787.   g_free (data);
  788. }
  789.  
  790. static void
  791. browser_load_inhibit_callback (GtkWidget *widget,
  792.                    gpointer   data)
  793. {
  794.   BrowserState *st = data;
  795.   gboolean new_value;
  796.  
  797.   g_return_if_fail (st->last_update != NULL);
  798.  
  799.   new_value = ! GTK_TOGGLE_BUTTON (widget)->active;
  800.  
  801.   if (new_value == st->last_update->load_inhibit)
  802.     return;
  803.  
  804.   st->last_update->load_inhibit = new_value;
  805.   module_info_modified (st->last_update);
  806.  
  807.   need_to_rewrite_modulerc = TRUE;
  808. }
  809.  
  810. static void
  811. browser_info_update (ModuleInfo   *mod, 
  812.              BrowserState *st)
  813. {
  814.   gint i;
  815.   const gchar *text[NUM_INFO_LINES - 1];
  816.   gchar *status;
  817.  
  818.   /* only update the info if we're actually showing it */
  819.   if (mod != st->last_update)
  820.     return;
  821.  
  822.   if (!mod)
  823.     {
  824.       for (i=0; i < NUM_INFO_LINES; i++)
  825.     gtk_label_set_text (GTK_LABEL (st->label[i]), "");
  826.       gtk_label_set_text (GTK_LABEL(st->button_label), _("<No modules>"));
  827.       gtk_widget_set_sensitive (GTK_WIDGET (st->button), FALSE);
  828.       gtk_widget_set_sensitive (GTK_WIDGET (st->load_inhibit_check), FALSE);
  829.       return;
  830.     }
  831.  
  832.   if (mod->info)
  833.     {
  834.       text[0] = mod->info->purpose;
  835.       text[1] = mod->info->author;
  836.       text[2] = mod->info->version;
  837.       text[3] = mod->info->copyright;
  838.       text[4] = mod->info->date;
  839.       text[5] = mod->ondisk? _("on disk") : _("only in memory");
  840.     }
  841.   else
  842.     {
  843.       text[0] = "--";
  844.       text[1] = "--";
  845.       text[2] = "--";
  846.       text[3] = "--";
  847.       text[4] = "--";
  848.       text[5] = mod->ondisk? _("on disk") : _("nowhere (click 'refresh')");
  849.     }
  850.  
  851.   if (mod->state == ST_MODULE_ERROR && mod->last_module_error)
  852.     status = g_strdup_printf ("%s (%s)", gettext (statename[mod->state]),
  853.                   mod->last_module_error);
  854.   else
  855.     {
  856.       status = g_strdup (gettext (statename[mod->state]));
  857.     }
  858.  
  859.   for (i=0; i < NUM_INFO_LINES - 1; i++)
  860.     {
  861.       gtk_label_set_text (GTK_LABEL (st->label[i]), gettext (text[i]));
  862.     }
  863.  
  864.   gtk_label_set_text (GTK_LABEL (st->label[NUM_INFO_LINES-1]), status);
  865.  
  866.   g_free (status);
  867.  
  868.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (st->load_inhibit_check),
  869.                 !mod->load_inhibit);
  870.   gtk_widget_set_sensitive (GTK_WIDGET (st->load_inhibit_check), TRUE);
  871.  
  872.   /* work out what the button should do (if anything) */
  873.   switch (mod->state)
  874.     {
  875.     case ST_MODULE_ERROR:
  876.     case ST_LOAD_FAILED:
  877.     case ST_UNLOADED_OK:
  878.       gtk_label_set_text (GTK_LABEL(st->button_label), _("Load"));
  879.       gtk_widget_set_sensitive (GTK_WIDGET (st->button), mod->ondisk);
  880.       break;
  881.  
  882.     case ST_UNLOAD_REQUESTED:
  883.       gtk_widget_set_sensitive (GTK_WIDGET (st->button), FALSE);
  884.       break;
  885.  
  886.     case ST_LOADED_OK:
  887.       gtk_label_set_text (GTK_LABEL(st->button_label), _("Unload"));
  888.       gtk_widget_set_sensitive (GTK_WIDGET (st->button),
  889.                 mod->unload? TRUE : FALSE);
  890.       break;    
  891.     }
  892. }
  893.  
  894. static void
  895. browser_info_init (BrowserState *st, 
  896.            GtkWidget    *table)
  897. {
  898.   GtkWidget *label;
  899.   gint i;
  900.  
  901.   gchar *text[] =
  902.   {
  903.     N_("Purpose:"),
  904.     N_("Author:"),
  905.     N_("Version:"),
  906.     N_("Copyright:"),
  907.     N_("Date:"),
  908.     N_("Location:"),
  909.     N_("State:")
  910.   };
  911.  
  912.   for (i=0; i < sizeof(text) / sizeof(char *); i++)
  913.     {
  914.       label = gtk_label_new (gettext (text[i]));
  915.       gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  916.       gtk_table_attach (GTK_TABLE (table), label, 0, 1, i, i+1,
  917.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
  918.       gtk_widget_show (label);
  919.  
  920.       st->label[i] = gtk_label_new ("");
  921.       gtk_misc_set_alignment (GTK_MISC (st->label[i]), 0.0, 0.5);
  922.       gtk_table_attach (GTK_TABLE (st->table), st->label[i], 1, 2, i, i+1,
  923.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
  924.       gtk_widget_show (st->label[i]);
  925.     }
  926.  
  927.   st->load_inhibit_check =
  928.     gtk_check_button_new_with_label (_("Autoload during startup"));
  929.   gtk_widget_show (st->load_inhibit_check);
  930.   gtk_table_attach (GTK_TABLE (table), st->load_inhibit_check,
  931.             0, 2, i, i+1,
  932.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
  933.   gtk_signal_connect (GTK_OBJECT (st->load_inhibit_check), "toggled",
  934.               browser_load_inhibit_callback, st);
  935. }
  936.  
  937. static void
  938. browser_select_callback (GtkWidget *widget, 
  939.              GtkWidget *child)
  940. {
  941.   ModuleInfo *i;
  942.   BrowserState *st;
  943.  
  944.   i = gtk_object_get_user_data (GTK_OBJECT (child));
  945.   st = gtk_object_get_user_data (GTK_OBJECT (widget));
  946.  
  947.   if (st->last_update == i)
  948.     return;
  949.  
  950.   st->last_update = i;
  951.  
  952.   browser_info_update (st->last_update, st);
  953. }
  954.  
  955.  
  956. static void
  957. browser_load_unload_callback (GtkWidget *widget, 
  958.                   gpointer   data)
  959. {
  960.   BrowserState *st = data;
  961.  
  962.   if (st->last_update->state == ST_LOADED_OK)
  963.     mod_unload (st->last_update, FALSE);
  964.   else
  965.     mod_load (st->last_update, FALSE);
  966.  
  967.   module_info_modified (st->last_update);
  968. }
  969.  
  970.  
  971. static void
  972. make_list_item (gpointer data, 
  973.         gpointer user_data)
  974. {
  975.   ModuleInfo   *info = data;
  976.   BrowserState *st = user_data;
  977.   GtkWidget    *list_item;
  978.  
  979.   if (!st->last_update)
  980.     st->last_update = info;
  981.  
  982.   list_item = gtk_list_item_new_with_label (info->fullpath);
  983.  
  984.   gtk_widget_show (list_item);
  985.   gtk_object_set_user_data (GTK_OBJECT (list_item), info);
  986.  
  987.   gtk_container_add (GTK_CONTAINER (st->list), list_item);
  988. }
  989.  
  990.  
  991. static void
  992. browser_info_add (GimpSet      *set, 
  993.           ModuleInfo   *mod, 
  994.           BrowserState *st)
  995. {
  996.   make_list_item (mod, st);
  997. }
  998.  
  999.  
  1000. static void
  1001. browser_info_remove (GimpSet      *set, 
  1002.              ModuleInfo   *mod, 
  1003.              BrowserState *st)
  1004. {
  1005.   GList *dlist, *free_list;
  1006.   GtkWidget *list_item;
  1007.   ModuleInfo *i;
  1008.  
  1009.   dlist = gtk_container_children (GTK_CONTAINER (st->list));
  1010.   free_list = dlist;
  1011.  
  1012.   while (dlist)
  1013.   {
  1014.     list_item = dlist->data;
  1015.  
  1016.     i = gtk_object_get_user_data (GTK_OBJECT (list_item));
  1017.     g_return_if_fail (i != NULL);
  1018.  
  1019.     if (i == mod)
  1020.     {
  1021.       gtk_container_remove (GTK_CONTAINER (st->list), list_item);
  1022.       g_list_free(free_list);
  1023.       return;
  1024.     }
  1025.  
  1026.     dlist = dlist->next;
  1027.   }
  1028.  
  1029.   g_warning ("tried to remove module that wasn't in brower's list");
  1030.   g_list_free(free_list);
  1031. }
  1032.  
  1033.  
  1034.  
  1035. static void
  1036. module_db_module_ondisk (gpointer data, 
  1037.              gpointer user_data)
  1038. {
  1039.   ModuleInfo *mod = data;
  1040.   struct stat statbuf;
  1041.   gint ret;
  1042.   gint old_ondisk = mod->ondisk;
  1043.   GSList **kill_list = user_data;
  1044.  
  1045.   ret = stat (mod->fullpath, &statbuf);
  1046.   if (ret != 0)
  1047.     mod->ondisk = FALSE;
  1048.   else
  1049.     mod->ondisk = TRUE;
  1050.  
  1051.   /* if it's not on the disk, and it isn't in memory, mark it to be
  1052.    * removed later. */
  1053.   if (!mod->ondisk && !mod->module)
  1054.     {
  1055.       *kill_list = g_slist_append (*kill_list, mod);
  1056.       mod = NULL;
  1057.     }
  1058.  
  1059.   if (mod && mod->ondisk != old_ondisk)
  1060.     module_info_modified (mod);
  1061. }
  1062.  
  1063.  
  1064. static void
  1065. module_db_module_remove (gpointer data, 
  1066.              gpointer user_data)
  1067. {
  1068.   ModuleInfo *mod = data;
  1069.  
  1070.   gimp_set_remove (modules, mod);
  1071.  
  1072.   module_info_free (mod);
  1073. }
  1074.  
  1075.  
  1076.  
  1077. typedef struct
  1078. {
  1079.   const gchar *search_key;
  1080.   ModuleInfo  *found;
  1081. } find_by_path_closure;
  1082.  
  1083. static void
  1084. module_db_path_cmp (gpointer data, 
  1085.             gpointer user_data)
  1086. {
  1087.   ModuleInfo *mod = data;
  1088.   find_by_path_closure *cl = user_data;
  1089.  
  1090.   if (!strcmp (mod->fullpath, cl->search_key))
  1091.     cl->found = mod;
  1092. }
  1093.  
  1094. static ModuleInfo *
  1095. module_find_by_path (const char *fullpath)
  1096. {
  1097.   find_by_path_closure cl;
  1098.  
  1099.   cl.found = NULL;
  1100.   cl.search_key = fullpath;
  1101.  
  1102.   gimp_set_foreach (modules, module_db_path_cmp, &cl);
  1103.  
  1104.   return cl.found;
  1105. }
  1106.  
  1107.  
  1108.  
  1109. static void
  1110. browser_refresh_callback (GtkWidget *widget, 
  1111.               gpointer   data)
  1112. {
  1113.   GSList *kill_list = NULL;
  1114.  
  1115.   /* remove modules we don't have on disk anymore */
  1116.   gimp_set_foreach (modules, module_db_module_ondisk, &kill_list);
  1117.   g_slist_foreach (kill_list, module_db_module_remove, NULL);
  1118.   g_slist_free (kill_list);
  1119.   kill_list = NULL;
  1120.  
  1121.   /* walk filesystem and add new things we find */
  1122.   datafiles_read_directories (module_path,
  1123.                   module_initialize, 0 /* no flags */);
  1124. }
  1125.  
  1126.  
  1127. static void
  1128. gimp_module_ref (ModuleInfo *mod)
  1129. {
  1130.   g_return_if_fail (mod->refs >= 0);
  1131.   g_return_if_fail (mod->module != NULL);
  1132.   mod->refs++;
  1133. }
  1134.  
  1135. static void
  1136. gimp_module_unref (ModuleInfo *mod)
  1137. {
  1138.   g_return_if_fail (mod->refs > 0);
  1139.   g_return_if_fail (mod->module != NULL);
  1140.  
  1141.   mod->refs--;
  1142.  
  1143.   if (mod->refs == 0)
  1144.     {
  1145.       TRC (("module %p refs hit 0, g_module_closing it\n", mod));
  1146.       g_module_close (mod->module);
  1147.       mod->module = NULL;
  1148.     }
  1149. }
  1150.  
  1151. /* End of module_db.c */
  1152.