home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / helpbrowser / helpbrowser.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-16  |  32.6 KB  |  1,278 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * The GIMP Help Browser
  5.  * Copyright (C) 1999 Sven Neumann <sven@gimp.org>
  6.  *                    Michael Natterer <mitschel@cs.tu-berlin.de>
  7.  *
  8.  * Some code & ideas stolen from the GNOME help browser.
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  */
  24. #include "config.h"
  25.  
  26. #include <string.h> 
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <unistd.h>
  30.  
  31. #include <gtk/gtk.h>
  32. #include <gdk/gdkkeysyms.h>
  33. #include <gtk-xmhtml/gtk-xmhtml.h>
  34.  
  35. #include <libgimp/gimp.h>
  36. #include <libgimp/gimpui.h>
  37.  
  38. #include "queue.h"
  39.  
  40. #include "libgimp/stdplugins-intl.h"
  41.  
  42. #include "forward.xpm"
  43. #include "back.xpm"
  44.  
  45.  
  46. /*  defines  */
  47.  
  48. #ifdef __EMX__
  49. #define chdir _chdir2
  50. #endif
  51.  
  52. #define GIMP_HELP_EXT_NAME      "extension_gimp_help_browser"
  53. #define GIMP_HELP_TEMP_EXT_NAME "extension_gimp_help_browser_temp"
  54.  
  55. #define GIMP_HELP_PREFIX        "help"
  56.  
  57. enum {
  58.   CONTENTS,
  59.   INDEX,
  60.   HELP
  61. };
  62.  
  63. enum {
  64.   URL_UNKNOWN,
  65.   URL_NAMED, /* ??? */
  66.   URL_JUMP,
  67.   URL_FILE_LOCAL,
  68.  
  69.   /* aliases */
  70.   URL_LAST = URL_FILE_LOCAL
  71. };
  72.  
  73. /*  structures  */
  74.  
  75. typedef struct 
  76. {
  77.   gint       index;
  78.   gchar     *label;
  79.   Queue     *queue;
  80.   gchar     *current_ref;
  81.   GtkWidget *html;
  82.   gchar     *home;
  83. } HelpPage;
  84.  
  85. typedef struct
  86. {
  87.   gchar *title;
  88.   gchar *ref;
  89.   gint   count;
  90. } HistoryItem;
  91.  
  92. /*  constant strings  */
  93.  
  94. static gchar *doc_not_found_format_string =
  95. N_("<html><head><title>Document not found</title></head>"
  96.    "<body bgcolor=\"#ffffff\">"
  97.    "<center>"
  98.    "<p>"
  99.    "%s"
  100.    "<h3>Couldn't find document</h3>"
  101.    "<tt>%s</tt>"
  102.    "</center>"
  103.    "<p>"
  104.    "<small>This either means that the help for this topic has not been written "
  105.    "yet or that something is wrong with your installation. "
  106.    "Please check carefully before you report this as a bug.</small>" 
  107.    "</body>"
  108.    "</html>");
  109.  
  110. static gchar *dir_not_found_format_string =
  111. N_("<html><head><title>Directory not found</title></head>"
  112.    "<body bgcolor=\"#ffffff\">"
  113.    "<center>"
  114.    "<p>"
  115.    "%s"
  116.    "<h3>Couldn't change to directory</h3>"
  117.    "<tt>%s</tt>"
  118.    "<h3>while trying to access</h3>"
  119.    "<tt>%s</tt>"
  120.    "</center>"
  121.    "<p>"
  122.    "<small>This either means that the help for this topic has not been written "
  123.    "yet or that something is wrong with your installation. "
  124.    "Please check carefully before you report this as a bug.</small>" 
  125.    "</body>"
  126.    "</html>");
  127.  
  128. static gchar *eek_png_tag = "<h1>Eeek!</h1>";
  129.  
  130.  
  131. /*  the three help notebook pages  */
  132.  
  133. static HelpPage pages[] =
  134. {
  135.   {
  136.     CONTENTS,
  137.     N_("Contents"),
  138.     NULL,
  139.     NULL,
  140.     NULL,
  141.     "contents.html"
  142.   },
  143.  
  144.   {
  145.     INDEX,
  146.     N_("Index"),
  147.     NULL,
  148.     NULL,
  149.     NULL,
  150.     "index.html"
  151.   },
  152.  
  153.   {
  154.     HELP,
  155.     NULL,
  156.     NULL,
  157.     NULL,
  158.     NULL,
  159.     "introduction.html"
  160.   }
  161. };
  162.  
  163. static gchar     *gimp_help_root = NULL;
  164.  
  165. static HelpPage  *current_page = &pages[HELP];
  166. static GList     *history = NULL;
  167.  
  168. static GtkWidget *back_button;
  169. static GtkWidget *forward_button;
  170. static GtkWidget *notebook;
  171. static GtkWidget *combo;
  172.  
  173. static GtkTargetEntry help_dnd_target_table[] =
  174. {
  175.   { "_NETSCAPE_URL", 0, 0 },
  176. };
  177. static guint n_help_dnd_targets = (sizeof (help_dnd_target_table) /
  178.                    sizeof (help_dnd_target_table[0]));
  179.  
  180. /*  GIMP plugin stuff  */
  181.  
  182. static void query (void);
  183. static void run   (gchar      *name,
  184.            gint        nparams,
  185.            GimpParam  *param,
  186.            gint       *nreturn_vals,
  187.            GimpParam **return_vals);
  188.  
  189. GimpPlugInInfo PLUG_IN_INFO =
  190. {
  191.   NULL,  /* init_proc  */
  192.   NULL,  /* quit_proc  */
  193.   query, /* query_proc */
  194.   run,   /* run_proc   */
  195. };
  196.  
  197. static gboolean temp_proc_installed = FALSE;
  198.  
  199. /*  forward declaration  */
  200.  
  201. static gint load_page (HelpPage *source_page,
  202.                HelpPage *dest_page,
  203.                gchar    *ref,
  204.                gint      pos, 
  205.                gboolean  add_to_queue,
  206.                gboolean  add_to_history);
  207.  
  208. /*  functions  */
  209.  
  210. static void
  211. close_callback (GtkWidget *widget,
  212.         gpointer   user_data)
  213. {
  214.   gtk_main_quit ();
  215. }
  216.  
  217. static void
  218. update_toolbar (HelpPage *page)
  219. {
  220.   if (back_button)
  221.     gtk_widget_set_sensitive (back_button, queue_isprev (page->queue));
  222.   if (forward_button)
  223.     gtk_widget_set_sensitive (forward_button, queue_isnext (page->queue));
  224. }
  225.  
  226. static void
  227. jump_to_anchor (HelpPage *page, 
  228.         gchar    *anchor)
  229. {
  230.   gint pos;
  231.  
  232.   g_return_if_fail (page != NULL && anchor != NULL);
  233.  
  234.   if (*anchor != '#') 
  235.     {
  236.       gchar *a = g_strconcat ("#", anchor, NULL);
  237.       XmHTMLAnchorScrollToName (page->html, a);
  238.       g_free (a);
  239.     }
  240.   else
  241.     XmHTMLAnchorScrollToName (page->html, anchor);
  242.  
  243.   pos = gtk_xmhtml_get_topline (GTK_XMHTML (page->html));
  244.   queue_add (page->queue, page->current_ref, pos);
  245.  
  246.   update_toolbar (page);
  247. }
  248.  
  249. static void
  250. forward_callback (GtkWidget *widget,
  251.           gpointer   data)
  252. {
  253.   gchar *ref;
  254.   gint pos;
  255.  
  256.   if (!(ref = queue_next (current_page->queue, &pos)))
  257.     return;
  258.  
  259.   load_page (current_page, current_page, ref, pos, FALSE, FALSE);
  260.   queue_move_next (current_page->queue);
  261.  
  262.   update_toolbar (current_page);
  263. }
  264.  
  265. static void
  266. back_callback (GtkWidget *widget,
  267.            gpointer   data)
  268. {
  269.   gchar *ref;
  270.   gint pos;
  271.  
  272.   if (!(ref = queue_prev (current_page->queue, &pos)))
  273.     return;
  274.  
  275.   load_page (current_page, current_page, ref, pos, FALSE, FALSE);
  276.   queue_move_prev (current_page->queue);
  277.  
  278.   update_toolbar (current_page);
  279. }
  280.  
  281. static void 
  282. entry_changed_callback (GtkWidget *widget,
  283.             gpointer   data)
  284. {
  285.   GList       *list;
  286.   HistoryItem *item;
  287.   gchar       *entry_text;
  288.   gchar       *compare_text;
  289.   gboolean     found = FALSE;
  290.  
  291.   entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
  292.  
  293.   for (list = history; list && !found; list = list->next)
  294.     {
  295.       item = (HistoryItem *) list->data;
  296.  
  297.       if (item->count)
  298.     compare_text = g_strdup_printf ("%s <%i>",
  299.                     item->title,
  300.                     item->count + 1);
  301.       else
  302.     compare_text = item->title;
  303.  
  304.       if (strcmp (compare_text, entry_text) == 0)
  305.     {
  306.       load_page (&pages[HELP], &pages[HELP], item->ref, 0, TRUE, FALSE);
  307.       found = TRUE;
  308.     }
  309.  
  310.       if (item->count)
  311.     g_free (compare_text);
  312.     }
  313. }
  314.  
  315. static gint
  316. entry_button_press_callback (GtkWidget      *widget,
  317.                  GdkEventButton *bevent,
  318.                  gpointer        data)
  319. {
  320.   if (current_page != &pages[HELP])
  321.     gtk_notebook_set_page (GTK_NOTEBOOK (notebook), HELP);
  322.  
  323.   return FALSE;
  324. }
  325.  
  326. static void
  327. history_add (gchar *ref,
  328.          gchar *title)
  329. {
  330.   GList       *list;
  331.   GList       *found = NULL;
  332.   HistoryItem *item;
  333.   GList       *combo_list = NULL;
  334.   gint         title_found_count = 0;
  335.  
  336.   for (list = history; list && !found; list = list->next)
  337.     {
  338.       item = (HistoryItem *) list->data;
  339.  
  340.       if (strcmp (item->title, title) == 0)
  341.     {
  342.       if (strcmp (item->ref, ref) != 0)
  343.         {
  344.           title_found_count++;
  345.           continue;
  346.         }
  347.  
  348.       found = list;    }
  349.     }
  350.  
  351.   if (found)
  352.     {
  353.       item = (HistoryItem *) found->data;
  354.       history = g_list_remove_link (history, found);
  355.     }
  356.   else
  357.     {
  358.       item = g_new (HistoryItem, 1);
  359.       item->ref = g_strdup (ref);
  360.       item->title = g_strdup (title);
  361.       item->count = title_found_count;
  362.     }
  363.  
  364.   history = g_list_prepend (history, item);
  365.  
  366.   for (list = history; list; list = list->next)
  367.     {
  368.       gchar* combo_title;
  369.  
  370.       item = (HistoryItem *) list->data;
  371.  
  372.       if (item->count)
  373.     combo_title = g_strdup_printf ("%s <%i>",
  374.                        item->title,
  375.                        item->count + 1);
  376.       else
  377.     combo_title = g_strdup (item->title);
  378.  
  379.       combo_list = g_list_prepend (combo_list, combo_title);
  380.     }
  381.  
  382.   combo_list = g_list_reverse (combo_list);
  383.  
  384.   gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  385.   gtk_combo_set_popdown_strings (GTK_COMBO (combo), combo_list);
  386. /*    gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), item->title); */
  387.   gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  388.  
  389.   for (list = combo_list; list; list = list->next)
  390.     g_free (list->data);
  391.  
  392.   g_list_free (combo_list);
  393. }
  394.  
  395. static void
  396. html_source (HelpPage *page,
  397.          gchar    *ref,
  398.          gint      pos,
  399.          gchar    *source, 
  400.          gboolean  add_to_queue,
  401.          gboolean  add_to_history)
  402. {
  403.   gchar *title = NULL;
  404.   
  405.   g_return_if_fail (page != NULL && ref != NULL && source != NULL);
  406.   
  407.   /* Load it up */
  408.   gtk_xmhtml_source (GTK_XMHTML (page->html), source);
  409.   
  410.   gtk_xmhtml_set_topline (GTK_XMHTML(page->html), pos);
  411.   
  412.   if (add_to_queue) 
  413.     queue_add (page->queue, ref, pos);
  414.  
  415.   if (page->index == HELP)
  416.     {
  417.       title = XmHTMLGetTitle (page->html);
  418.       if (!title)
  419.     title = (_("<Untitled>"));
  420.       
  421.       if (add_to_history)
  422.     history_add (ref, title);
  423.  
  424.       gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry),
  425.                     combo);
  426.       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), title);
  427.       gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry),
  428.                       combo);
  429.     }
  430.  
  431.   update_toolbar (page);
  432. }
  433.  
  434. static gint
  435. load_page (HelpPage *source_page,
  436.        HelpPage *dest_page,
  437.        gchar    *ref,      
  438.        gint      pos,
  439.        gboolean  add_to_queue,
  440.        gboolean  add_to_history)
  441. {
  442.   GString  *file_contents;
  443.   FILE     *afile = NULL;
  444.   char      aline[1024];
  445.   gchar    *old_dir;
  446.   gchar    *new_dir, *new_base;
  447.   gchar    *new_ref;
  448.   gboolean  page_valid  = FALSE;
  449.   gboolean  filters_dir = FALSE;
  450.  
  451.   g_return_val_if_fail (ref != NULL && source_page != NULL && dest_page != NULL, FALSE);
  452.  
  453.   old_dir  = g_dirname (source_page->current_ref);
  454.   new_dir  = g_dirname (ref);
  455.   new_base = g_basename (ref);
  456.  
  457.   /* return value is intentionally ignored */
  458.   chdir (old_dir);
  459.  
  460.   file_contents = g_string_new (NULL);
  461.  
  462.   if (chdir (new_dir) == -1)
  463.     {
  464.       if (g_path_is_absolute (ref))
  465.     new_ref = g_strdup (ref);
  466.       else
  467.     new_ref = g_strconcat (old_dir, G_DIR_SEPARATOR_S, ref, NULL);
  468.  
  469.       g_string_sprintf (file_contents, gettext (dir_not_found_format_string),
  470.             eek_png_tag, new_dir, new_ref);
  471.       html_source (dest_page, new_ref, 0, file_contents->str, add_to_queue, FALSE);
  472.  
  473.       goto FINISH;
  474.     }
  475.  
  476.   if (strcmp (g_basename (new_dir), "filters") == 0)
  477.     filters_dir = TRUE;
  478.  
  479.   g_free (new_dir);
  480.   new_dir = g_get_current_dir ();
  481.  
  482.   new_ref = g_strconcat (new_dir, G_DIR_SEPARATOR_S, new_base, NULL);
  483.  
  484.   if (strcmp (dest_page->current_ref, new_ref) == 0)
  485.     {
  486.       gtk_xmhtml_set_topline (GTK_XMHTML (dest_page->html), pos);
  487.  
  488.       if (add_to_queue)
  489.     queue_add (dest_page->queue, new_ref, pos);
  490.  
  491.       goto FINISH;
  492.     }
  493.  
  494.   /*
  495.    *  handle basename like: filename.html#11111 -> filename.html
  496.    */ 
  497.   g_strdelimit (new_base,"#",'\0');
  498.  
  499.   afile = fopen (new_base, "rt");
  500.  
  501.   if (afile != NULL)
  502.     {
  503.       while (fgets (aline, sizeof (aline), afile))
  504.     file_contents = g_string_append (file_contents, aline);
  505.       fclose (afile);
  506.     }
  507.   else if (filters_dir)
  508.     {
  509.       gchar *undocumented_filter;
  510.  
  511.       undocumented_filter = g_strconcat (new_dir, G_DIR_SEPARATOR_S,
  512.                      "undocumented_filter.html", NULL);
  513.  
  514.  
  515.       afile = fopen (undocumented_filter, "rt");
  516.  
  517.       if (afile != NULL)
  518.     {
  519.       while (fgets (aline, sizeof (aline), afile))
  520.         file_contents = g_string_append (file_contents, aline);
  521.       fclose (afile);
  522.     }
  523.  
  524.       g_free (undocumented_filter);
  525.     }
  526.  
  527.   if (strlen (file_contents->str) <= 0)
  528.     {
  529.       chdir (old_dir);
  530.       g_string_sprintf (file_contents, gettext (doc_not_found_format_string),
  531.             eek_png_tag, ref);
  532.     }
  533.   else
  534.     page_valid = TRUE;
  535.  
  536.   html_source (dest_page, new_ref, 0, file_contents->str, 
  537.            add_to_queue, add_to_history && page_valid);
  538.  
  539.  FINISH:
  540.  
  541.   g_free (dest_page->current_ref);
  542.   dest_page->current_ref = new_ref;
  543.  
  544.   g_string_free (file_contents, TRUE);
  545.   g_free (old_dir);
  546.   g_free (new_dir);
  547.  
  548.   gtk_notebook_set_page (GTK_NOTEBOOK (notebook), dest_page->index);
  549.  
  550.   return (page_valid);
  551. }
  552.  
  553. static void
  554. xmhtml_activate (GtkWidget *html,
  555.          gpointer   data)
  556. {
  557.   XmHTMLAnchorCallbackStruct *cbs = (XmHTMLAnchorCallbackStruct *) data;
  558.   GimpParam *return_vals;
  559.   gint       nreturn_vals;
  560.  
  561.   switch (cbs->url_type)
  562.     {
  563.     case URL_JUMP:
  564.       jump_to_anchor (current_page, cbs->href);
  565.       break;
  566.  
  567.     case URL_FILE_LOCAL:
  568.       load_page (current_page, &pages[HELP], cbs->href, 0, TRUE, TRUE);
  569.       break;
  570.  
  571.     default:
  572.       /*  try to call netscape through the web_browser interface */
  573.       return_vals = gimp_run_procedure ("extension_web_browser",
  574.                     &nreturn_vals,
  575.                     GIMP_PDB_INT32,  GIMP_RUN_NONINTERACTIVE,
  576.                     GIMP_PDB_STRING, cbs->href,
  577.                     GIMP_PDB_INT32,  FALSE,
  578.                     GIMP_PDB_END);
  579.        gimp_destroy_params (return_vals, nreturn_vals);
  580.       break;
  581.     }
  582. }
  583.  
  584. static void 
  585. notebook_switch_callback (GtkNotebook     *notebook,
  586.               GtkNotebookPage *page,
  587.               gint             page_num,
  588.               gpointer         user_data)
  589. {
  590.   GtkXmHTML *html;
  591.   gint       i;
  592.   GList     *children;
  593.  
  594.   g_return_if_fail (page_num >= 0 && page_num < 3);
  595.  
  596.   html = GTK_XMHTML (current_page->html);
  597.  
  598.   /*  The html widget fails to do the following by itself  */
  599.  
  600.   GTK_WIDGET_UNSET_FLAGS (html->html.work_area, GTK_MAPPED);
  601.   GTK_WIDGET_UNSET_FLAGS (html->html.vsb, GTK_MAPPED);
  602.   GTK_WIDGET_UNSET_FLAGS (html->html.hsb, GTK_MAPPED);
  603.  
  604.   /*  Frames  */
  605.   for (i = 0; i < html->html.nframes; i++)
  606.     GTK_WIDGET_UNSET_FLAGS (html->html.frames[i]->frame, GTK_MAPPED);
  607.  
  608.   /*  Form widgets  */
  609.   for (children = html->children; children; children = children->next)
  610.     GTK_WIDGET_UNSET_FLAGS (children->data, GTK_MAPPED);
  611.  
  612.   /*  Set the new page  */
  613.   current_page = &pages[page_num];
  614. }
  615.  
  616. static void 
  617. notebook_switch_after_callback (GtkNotebook     *notebook,
  618.                 GtkNotebookPage *page,
  619.                 gint             page_num,
  620.                 gpointer         user_data)
  621. {
  622.   GtkAccelGroup *accel_group = gtk_accel_group_get_default ();
  623.  
  624.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  625.                   "page_up", accel_group,
  626.                   'b', 0, 0);
  627.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  628.                   "page_down", accel_group,
  629.                   ' ', 0, 0);
  630.  
  631.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  632.                   "page_up", accel_group,
  633.                   GDK_Page_Up, 0, 0);
  634.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  635.                   "page_down", accel_group,
  636.                   GDK_Page_Down, 0, 0);
  637.  
  638.   update_toolbar (current_page);
  639. }
  640.  
  641.  
  642. static gint
  643. notebook_label_button_press_callback (GtkWidget *widget,
  644.                       GdkEvent  *event,
  645.                       gpointer   data)
  646. {
  647.   guint i = GPOINTER_TO_UINT (data);
  648.  
  649.   if (current_page != &pages[i])
  650.     gtk_notebook_set_page (GTK_NOTEBOOK (notebook), i);
  651.   
  652.   return TRUE;
  653. }
  654.  
  655. static void
  656. combo_drag_begin (GtkWidget *widget,
  657.           gpointer   data)
  658. { 
  659. }
  660.  
  661. static void
  662. combo_drag_handle (GtkWidget        *widget, 
  663.            GdkDragContext   *context,
  664.            GtkSelectionData *selection_data,
  665.            guint             info,
  666.            guint             time,
  667.            gpointer          data)
  668. {
  669.   HelpPage *page = (HelpPage*)data;
  670.  
  671.   if (page->current_ref != NULL)
  672.     {
  673.       gtk_selection_data_set (selection_data,
  674.                   selection_data->target,
  675.                   8, 
  676.                   page->current_ref, 
  677.                   strlen (page->current_ref));
  678.     }
  679. }
  680.  
  681. static void
  682. page_up_callback (GtkWidget *widget,
  683.           GtkWidget *html)
  684. {
  685.   GtkAdjustment *adj;
  686.  
  687.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  688.   gtk_adjustment_set_value (adj, adj->value - (adj->page_size));
  689. }
  690.  
  691. static void
  692. page_down_callback (GtkWidget *widget,
  693.             GtkWidget *html)
  694. {
  695.   GtkAdjustment *adj;
  696.  
  697.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  698.   gtk_adjustment_set_value (adj, adj->value + (adj->page_size));
  699. }
  700.  
  701. static gint
  702. wheel_callback (GtkWidget      *widget,
  703.         GdkEventButton *bevent,
  704.         GtkWidget      *html)
  705. {
  706.   GtkAdjustment *adj;
  707.   gfloat new_value;
  708.  
  709.   if (! GTK_XMHTML (html)->html.needs_vsb)
  710.     return FALSE;
  711.  
  712.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  713.  
  714.   switch (bevent->button)
  715.     {
  716.     case 4:
  717.       new_value = adj->value - adj->page_increment / 2;
  718.       break;
  719.  
  720.     case 5:
  721.       new_value = adj->value + adj->page_increment / 2;
  722.       break;
  723.  
  724.     default:
  725.       return FALSE;
  726.     }
  727.  
  728.   new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
  729.   gtk_adjustment_set_value (adj, new_value);
  730.  
  731.   return TRUE;
  732. }
  733.  
  734. static gint
  735. set_initial_history (gpointer data)
  736. {
  737.   gint   add_to_history = GPOINTER_TO_INT (data);
  738.   gchar *title;
  739.  
  740.   title = XmHTMLGetTitle (pages[HELP].html);
  741.   if (add_to_history)
  742.     history_add (pages[HELP].current_ref, title);
  743.  
  744.   gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  745.   gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), title);
  746.   gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  747.  
  748.   return FALSE;
  749. }
  750.  
  751. gboolean
  752. open_browser_dialog (gchar *help_path,
  753.              gchar *locale,
  754.              gchar *help_file)
  755. {
  756.   GtkWidget *window;
  757.   GtkWidget *vbox, *hbox, *bbox, *html_box;
  758.   GtkWidget *button;
  759.   GtkWidget *title;
  760.   GtkWidget *drag_source;
  761.   GtkWidget *label;
  762.  
  763.   gchar   *initial_dir;
  764.   gchar   *initial_ref;
  765.   gchar   *root_dir;
  766.   gchar   *eek_png_path;
  767.   gint     success;
  768.   guint    i;
  769.  
  770.   gimp_ui_init ("helpbrowser", TRUE);
  771.  
  772.   root_dir = g_strdup (gimp_help_root);
  773.  
  774.   if (chdir (root_dir) == -1)
  775.     {
  776.       g_message (_("GIMP Help Browser Error.\n\n"
  777.            "Couldn't find my root html directory.\n"
  778.            "(%s)"), root_dir);
  779.       return FALSE;
  780.     }
  781.  
  782.   eek_png_path = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  783.                   "images", G_DIR_SEPARATOR_S,
  784.                   "eek.png", NULL);
  785.   if (access (eek_png_path, R_OK) == 0)
  786.     eek_png_tag = g_strdup_printf ("<img src=\"%s\">", eek_png_path);
  787.  
  788.   g_free (eek_png_path);
  789.  
  790.   if (chdir (help_path) == -1)
  791.     {
  792.       g_message (_("GIMP Help Browser Error.\n\n"
  793.            "Couldn't find my root html directory.\n"
  794.            "(%s)"), help_path);
  795.       return FALSE;
  796.     }
  797.  
  798.   initial_dir = g_get_current_dir ();
  799.  
  800.   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  801.   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
  802.               GTK_SIGNAL_FUNC (close_callback),
  803.               NULL);
  804.   gtk_signal_connect (GTK_OBJECT (window), "destroy",
  805.               GTK_SIGNAL_FUNC (close_callback),
  806.               NULL);
  807.   gtk_window_set_wmclass (GTK_WINDOW (window), "helpbrowser", "Gimp");
  808.   gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
  809.  
  810.   gimp_help_connect_help_accel (window, gimp_standard_help_func,
  811.                 "dialogs/help.html");
  812.  
  813.   vbox = gtk_vbox_new (FALSE, 0);
  814.   gtk_container_add (GTK_CONTAINER (window), vbox);
  815.  
  816.   hbox = gtk_hbox_new (FALSE, 0);
  817.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  818.  
  819.   bbox = gtk_hbutton_box_new ();
  820.   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 0);
  821.   gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
  822.  
  823.   back_button = gimp_pixmap_button_new (back_xpm, _("Back"));
  824.   gtk_button_set_relief (GTK_BUTTON (back_button), GTK_RELIEF_NONE);
  825.   gtk_container_add (GTK_CONTAINER (bbox), back_button);
  826.   gtk_widget_set_sensitive (GTK_WIDGET (back_button), FALSE);
  827.   gtk_signal_connect (GTK_OBJECT (back_button), "clicked",
  828.               GTK_SIGNAL_FUNC (back_callback),
  829.               NULL);
  830.   gtk_widget_show (back_button);
  831.  
  832.   forward_button = gimp_pixmap_button_new (forward_xpm, _("Forward"));
  833.   gtk_button_set_relief (GTK_BUTTON (forward_button), GTK_RELIEF_NONE);
  834.   gtk_container_add (GTK_CONTAINER (bbox), forward_button);
  835.   gtk_widget_set_sensitive (GTK_WIDGET (forward_button), FALSE);
  836.   gtk_signal_connect (GTK_OBJECT (forward_button), "clicked",
  837.               GTK_SIGNAL_FUNC (forward_callback),
  838.               NULL);
  839.   gtk_widget_show (forward_button);
  840.  
  841.   gtk_widget_show (bbox);
  842.  
  843.   bbox = gtk_hbutton_box_new ();
  844.   gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
  845.  
  846.   button = gtk_button_new_with_label (_("Close"));
  847.   gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
  848.   gtk_container_add (GTK_CONTAINER (bbox), button);
  849.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  850.                GTK_SIGNAL_FUNC (close_callback),
  851.               NULL);
  852.   gtk_widget_show (button);
  853.  
  854.   gtk_widget_show (bbox);
  855.   gtk_widget_show (hbox);
  856.  
  857.   notebook = gtk_notebook_new ();
  858.   gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  859.   gtk_notebook_set_tab_vborder (GTK_NOTEBOOK (notebook), 0);
  860.   gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
  861.  
  862.   for (i = 0; i < 3; i++)
  863.     {
  864.       static guint page_up_signal = 0;
  865.       static guint page_down_signal = 0;
  866.  
  867.       pages[i].index       = i;
  868.       pages[i].html        = gtk_xmhtml_new ();
  869.       pages[i].queue       = queue_new ();
  870.  
  871.       gtk_xmhtml_set_anchor_underline_type (GTK_XMHTML (pages[i].html),
  872.                         GTK_ANCHOR_SINGLE_LINE);
  873.       gtk_xmhtml_set_anchor_buttons (GTK_XMHTML (pages[i].html), FALSE);
  874.       gtk_widget_set_usize (GTK_WIDGET (pages[i].html), -1, 300);
  875.  
  876.       switch (i)
  877.     {
  878.     case CONTENTS:
  879.     case INDEX:
  880.       pages[i].current_ref = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  881.                           locale, G_DIR_SEPARATOR_S,
  882.                           ".", NULL);
  883.  
  884.       title = drag_source = gtk_event_box_new ();
  885.       label = gtk_label_new (gettext (pages[i].label));
  886.       gtk_container_add (GTK_CONTAINER (title), label);
  887.       gtk_widget_show (label);
  888.       break;
  889.     case HELP:
  890.       pages[i].current_ref = g_strconcat (initial_dir, G_DIR_SEPARATOR_S,
  891.                           locale, G_DIR_SEPARATOR_S,
  892.                           ".", NULL);
  893.  
  894.       title = combo = gtk_combo_new ();
  895.       drag_source = GTK_COMBO (combo)->entry;
  896.       gtk_widget_set_usize (GTK_WIDGET (combo), 300, -1);
  897.       gtk_entry_set_editable (GTK_ENTRY (GTK_COMBO (combo)->entry), FALSE); 
  898.       gtk_combo_set_use_arrows (GTK_COMBO (combo), TRUE);
  899.       gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), 
  900.                   "changed",
  901.                   GTK_SIGNAL_FUNC (entry_changed_callback), 
  902.                   combo);
  903.       gtk_signal_connect (GTK_OBJECT (GTK_WIDGET (GTK_COMBO (combo)->entry)), 
  904.                   "button-press-event",
  905.                   GTK_SIGNAL_FUNC (entry_button_press_callback), 
  906.                   NULL);
  907.       gtk_widget_show (combo);
  908.       break;
  909.     default:
  910.       title = drag_source = NULL;     /* to please the compiler */
  911.       break;
  912.     }      
  913.  
  914.       /*  connect to the button_press signal to make notebook switching work */ 
  915.       gtk_signal_connect (GTK_OBJECT (title), "button_press_event",
  916.               GTK_SIGNAL_FUNC (notebook_label_button_press_callback), 
  917.               GUINT_TO_POINTER (i));
  918.  
  919.       /*  dnd source  */
  920.       gtk_drag_source_set (GTK_WIDGET (drag_source),
  921.                GDK_BUTTON1_MASK,
  922.                help_dnd_target_table, n_help_dnd_targets, 
  923.                GDK_ACTION_MOVE | GDK_ACTION_COPY);
  924.       gtk_signal_connect (GTK_OBJECT (drag_source), "drag_begin",
  925.               GTK_SIGNAL_FUNC (combo_drag_begin),
  926.               &pages[i]);
  927.       gtk_signal_connect (GTK_OBJECT (drag_source), "drag_data_get",
  928.               GTK_SIGNAL_FUNC (combo_drag_handle),
  929.               &pages[i]);
  930.  
  931.       html_box = gtk_vbox_new (FALSE, 0);
  932.       gtk_container_add (GTK_CONTAINER (html_box), pages[i].html);
  933.  
  934.       gtk_notebook_append_page (GTK_NOTEBOOK (notebook), html_box, title);
  935.       gtk_widget_show (title);
  936.  
  937.       if (i == HELP && help_file)
  938.     {
  939.       initial_ref = g_strconcat (initial_dir, G_DIR_SEPARATOR_S,
  940.                      locale, G_DIR_SEPARATOR_S,
  941.                      help_file, NULL);
  942.     }
  943.       else
  944.     {
  945.       initial_ref = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  946.                      locale, G_DIR_SEPARATOR_S,
  947.                      pages[i].home, NULL);
  948.     }
  949.  
  950.       success = load_page (&pages[i], &pages[i], initial_ref, 0, TRUE, FALSE);
  951.       g_free (initial_ref);
  952.  
  953.       gtk_widget_show (pages[i].html);
  954.       gtk_widget_show (html_box);
  955.       gtk_signal_connect (GTK_OBJECT (pages[i].html), "activate",
  956.               (GtkSignalFunc) xmhtml_activate,
  957.               &pages[i]);
  958.  
  959.       if (! page_up_signal)
  960.     {
  961.       page_up_signal = gtk_object_class_user_signal_new 
  962.         (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb)->klass,
  963.          "page_up",
  964.          GTK_RUN_FIRST,
  965.          gtk_marshal_NONE__NONE,
  966.          GTK_TYPE_NONE, 0);
  967.       page_down_signal = gtk_object_class_user_signal_new
  968.         (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb)->klass,
  969.          "page_down",
  970.          GTK_RUN_FIRST,
  971.          gtk_marshal_NONE__NONE,
  972.          GTK_TYPE_NONE, 0);
  973.     }
  974.  
  975.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb),
  976.               "page_up",
  977.               GTK_SIGNAL_FUNC (page_up_callback),
  978.               pages[i].html);
  979.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb), 
  980.               "page_down",
  981.               GTK_SIGNAL_FUNC (page_down_callback),
  982.               pages[i].html);
  983.  
  984.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.work_area),
  985.               "button_press_event",
  986.               GTK_SIGNAL_FUNC (wheel_callback),
  987.               pages[i].html);
  988.     }
  989.  
  990.   g_free (root_dir);
  991.  
  992.   gtk_signal_connect (GTK_OBJECT (notebook), "switch-page",
  993.               GTK_SIGNAL_FUNC (notebook_switch_callback),
  994.               NULL);
  995.   gtk_signal_connect_after (GTK_OBJECT (notebook), "switch-page",
  996.                 GTK_SIGNAL_FUNC (notebook_switch_after_callback),
  997.                 NULL);
  998.  
  999.   gtk_notebook_set_page (GTK_NOTEBOOK (notebook), HELP);
  1000.   gtk_widget_show (notebook);
  1001.  
  1002.   gtk_widget_show (vbox);
  1003.   gtk_widget_show (window);
  1004.  
  1005.   gtk_idle_add ((GtkFunction) set_initial_history, GINT_TO_POINTER (success));
  1006.  
  1007.   g_free (initial_dir);
  1008.  
  1009.   return TRUE;
  1010. }
  1011.  
  1012. static gint
  1013. idle_load_page (gpointer data)
  1014. {
  1015.   gchar *path = data;
  1016.  
  1017.   load_page (&pages[HELP], &pages[HELP], path, 0, TRUE, TRUE);
  1018.   g_free (path);
  1019.  
  1020.   return FALSE;
  1021. }
  1022.  
  1023. static void
  1024. run_temp_proc (gchar      *name,
  1025.            gint        nparams,
  1026.            GimpParam  *param,
  1027.            gint       *nreturn_vals,
  1028.            GimpParam **return_vals)
  1029. {
  1030.   static GimpParam  values[1];
  1031.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  1032.   gchar *help_path;
  1033.   gchar *locale;
  1034.   gchar *help_file;
  1035.   gchar *path;
  1036.  
  1037.   /*  set default values  */
  1038.   help_path = g_strdup (gimp_help_root);
  1039.   locale    = g_strdup ("C");
  1040.   help_file = g_strdup ("introduction.html");
  1041.  
  1042.   /*  Make sure all the arguments are there!  */
  1043.   if (nparams == 3)
  1044.     {
  1045.       if (param[0].data.d_string && strlen (param[0].data.d_string))
  1046.     {
  1047.       g_free (help_path);
  1048.       help_path = g_strdup (param[0].data.d_string);
  1049.       g_strdelimit (help_path, "/", G_DIR_SEPARATOR);
  1050.     }
  1051.       if (param[1].data.d_string && strlen (param[1].data.d_string))
  1052.     {
  1053.       g_free (locale);
  1054.       locale    = g_strdup (param[1].data.d_string);
  1055.     }
  1056.       if (param[2].data.d_string && strlen (param[2].data.d_string))
  1057.     {
  1058.       g_free (help_file);
  1059.       help_file = g_strdup (param[2].data.d_string);
  1060.       g_strdelimit (help_file, "/", G_DIR_SEPARATOR);
  1061.     }
  1062.     }
  1063.  
  1064.   path = g_strconcat (help_path, G_DIR_SEPARATOR_S, 
  1065.               locale, G_DIR_SEPARATOR_S,
  1066.               help_file, NULL);
  1067.  
  1068.   g_free (help_path);
  1069.   g_free (locale);
  1070.   g_free (help_file);
  1071.  
  1072.   gtk_idle_add (idle_load_page, path);
  1073.  
  1074.   *nreturn_vals = 1;
  1075.   *return_vals = values;
  1076.  
  1077.   values[0].type = GIMP_PDB_STATUS;
  1078.   values[0].data.d_status = status;
  1079. }
  1080.  
  1081. /*  from libgimp/gimp.c  */
  1082. void
  1083. gimp_run_temp (void);
  1084.  
  1085. static gboolean
  1086. input_callback (GIOChannel   *channel,
  1087.                 GIOCondition  condition,
  1088.                 gpointer      data)
  1089. {
  1090.   /* We have some data in the wire - read it */
  1091.   /* The below will only ever run a single proc */
  1092.   gimp_run_temp ();
  1093.  
  1094.   return TRUE;
  1095. }
  1096.  
  1097. static void
  1098. install_temp_proc (void)
  1099. {
  1100.   static GimpParamDef args[] =
  1101.   {
  1102.     { GIMP_PDB_STRING, "help_path", "" },
  1103.     { GIMP_PDB_STRING, "locale",    "Langusge to use" },
  1104.     { GIMP_PDB_STRING, "help_file", "Path of a local document to open. "
  1105.                                     "Can be relative to GIMP_HELP_PATH." }
  1106.   };
  1107.   static gint nargs = sizeof (args) / sizeof (args[0]);
  1108.  
  1109.   gimp_install_temp_proc (GIMP_HELP_TEMP_EXT_NAME,
  1110.               "DON'T USE THIS ONE",
  1111.               "(Temporary procedure)",
  1112.               "Sven Neumann <sven@gimp.org>, "
  1113.               "Michael Natterer <mitschel@cs.tu-berlin.de>",
  1114.               "Sven Neumann & Michael Natterer",
  1115.               "1999",
  1116.               NULL,
  1117.               "",
  1118.               GIMP_TEMPORARY,
  1119.               nargs, 0,
  1120.               args, NULL,
  1121.               run_temp_proc);
  1122.  
  1123.   /* Tie into the gdk input function */
  1124.   g_io_add_watch (_readchannel, G_IO_IN | G_IO_PRI, input_callback, NULL);
  1125.  
  1126.   temp_proc_installed = TRUE;
  1127. }
  1128.  
  1129. static gboolean
  1130. open_url (gchar *help_path,
  1131.       gchar *locale,
  1132.       gchar *help_file)
  1133. {
  1134.   if (! open_browser_dialog (help_path, locale, help_file))
  1135.     return FALSE;
  1136.  
  1137.   install_temp_proc ();
  1138.   gtk_main ();
  1139.  
  1140.   return TRUE;
  1141. }
  1142.  
  1143. MAIN ()
  1144.  
  1145. static void
  1146. query (void)
  1147. {
  1148.   static GimpParamDef args[] =
  1149.   {
  1150.     { GIMP_PDB_INT32,  "run_mode",  "Interactive" },
  1151.     { GIMP_PDB_STRING, "help_path", "" },
  1152.     { GIMP_PDB_STRING, "locale",    "Language to use" },
  1153.     { GIMP_PDB_STRING, "help_file", "Path of a local document to open. "
  1154.                                     "Can be relative to GIMP_HELP_PATH." }
  1155.   };
  1156.   static gint nargs = sizeof (args) / sizeof (args[0]);
  1157.  
  1158.   gimp_install_procedure (GIMP_HELP_EXT_NAME,
  1159.                           "Browse the GIMP help pages",
  1160.                           "A small and simple HTML browser optimzed for "
  1161.               "browsing the GIMP help pages.",
  1162.                           "Sven Neumann <sven@gimp.org>, "
  1163.               "Michael Natterer <mitch@gimp.org>",
  1164.               "Sven Neumann & Michael Natterer",
  1165.                           "1999",
  1166.                           NULL,
  1167.                           "",
  1168.                           GIMP_EXTENSION,
  1169.                           nargs, 0,
  1170.                           args, NULL);
  1171. }
  1172.  
  1173. static void
  1174. run (gchar      *name,
  1175.      gint        nparams,
  1176.      GimpParam  *param,
  1177.      gint       *nreturn_vals,
  1178.      GimpParam **return_vals)
  1179. {
  1180.   static GimpParam  values[1];
  1181.   GimpRunModeType   run_mode;
  1182.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  1183.   gchar *env_root_dir = NULL;
  1184.   gchar *help_path    = NULL;
  1185.   gchar *locale       = NULL;
  1186.   gchar *help_file    = NULL;
  1187.  
  1188.   run_mode = param[0].data.d_int32;
  1189.  
  1190.   values[0].type = GIMP_PDB_STATUS;
  1191.   values[0].data.d_status = status;
  1192.  
  1193.   *nreturn_vals = 1;
  1194.   *return_vals = values;
  1195.  
  1196.   INIT_I18N_UI ();
  1197.  
  1198.   if (strcmp (name, GIMP_HELP_EXT_NAME) == 0)
  1199.     {
  1200.       switch (run_mode)
  1201.         {
  1202.         case GIMP_RUN_INTERACTIVE:
  1203.         case GIMP_RUN_NONINTERACTIVE:
  1204.     case GIMP_RUN_WITH_LAST_VALS:
  1205.       /*  set default values  */
  1206.       env_root_dir = g_getenv ("GIMP_HELP_ROOT");
  1207.  
  1208.       if (env_root_dir)
  1209.         {
  1210.           if (chdir (env_root_dir) == -1)
  1211.         {
  1212.           g_message (_("GIMP Help Browser Error.\n\n"
  1213.                    "Couldn't find GIMP_HELP_ROOT html directory.\n"
  1214.                    "(%s)"), env_root_dir);
  1215.  
  1216.           status = GIMP_PDB_EXECUTION_ERROR;
  1217.           break;
  1218.         }
  1219.  
  1220.           gimp_help_root = g_strdup (env_root_dir);
  1221.         }
  1222.       else
  1223.         {
  1224.           gimp_help_root = g_strconcat (gimp_data_directory(),
  1225.                         G_DIR_SEPARATOR_S, 
  1226.                         GIMP_HELP_PREFIX, NULL);
  1227.         }
  1228.  
  1229.       help_path = g_strdup (gimp_help_root);
  1230.       locale    = g_strdup ("C");
  1231.       help_file = g_strdup ("introduction.html");
  1232.       
  1233.       /*  Make sure all the arguments are there!  */
  1234.       if (nparams == 4)
  1235.         {
  1236.           if (param[1].data.d_string && strlen (param[1].data.d_string))
  1237.         {
  1238.           g_free (help_path);
  1239.           help_path = g_strdup (param[1].data.d_string);
  1240.           g_strdelimit (help_path, "/", G_DIR_SEPARATOR);
  1241.         }
  1242.           if (param[2].data.d_string && strlen (param[2].data.d_string))
  1243.         {
  1244.           g_free (locale);
  1245.           locale = g_strdup (param[2].data.d_string);
  1246.         }
  1247.           if (param[3].data.d_string && strlen (param[3].data.d_string))
  1248.         {
  1249.           g_free (help_file);
  1250.           help_file = g_strdup (param[3].data.d_string);
  1251.           g_strdelimit (help_file, "/", G_DIR_SEPARATOR);
  1252.         }
  1253.         }
  1254.           break;
  1255.  
  1256.         default:
  1257.       status = GIMP_PDB_CALLING_ERROR;
  1258.           break;
  1259.         }
  1260.  
  1261.       if (status == GIMP_PDB_SUCCESS)
  1262.         {
  1263.              if (!open_url (help_path, locale, help_file))
  1264.             values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
  1265.       else
  1266.         values[0].data.d_status = GIMP_PDB_SUCCESS;
  1267.  
  1268.       g_free (help_path);
  1269.       g_free (locale);
  1270.       g_free (help_file);
  1271.         }
  1272.       else
  1273.         values[0].data.d_status = status;
  1274.     }
  1275.   else
  1276.     values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
  1277. }
  1278.