home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / docindex.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-20  |  19.0 KB  |  839 lines
  1. /* docindex.c - Creates the window used by the document index in go and gimp.
  2.  *
  3.  * Copyright (C) 1998 Chris Lahey.
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2, or (at your option)
  8.  * any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  */
  15. #include "config.h"
  16.  
  17. #include <ctype.h>
  18. #include <string.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21.  
  22. #include <gtk/gtk.h>
  23.  
  24. #include "dialog_handler.h"
  25. #include "docindex.h"
  26. #include "fileops.h"
  27. #include "gdisplay.h"
  28. #include "gimpimageP.h"
  29. #include "gimpui.h"
  30. #include "gimpdnd.h"
  31. #include "ops_buttons.h"
  32. #include "session.h"
  33.  
  34. #include "libgimp/gimpenv.h"
  35.  
  36. #include "libgimp/gimpintl.h"
  37.  
  38. #include "pixmaps/folder.xpm"
  39. #include "pixmaps/raise.xpm"
  40. #include "pixmaps/lower.xpm"
  41. #include "pixmaps/delete.xpm"
  42.  
  43.  
  44. typedef struct
  45. {
  46.   GtkWidget *window;
  47.   GtkWidget *list;
  48. } IdeaManager;
  49.  
  50. typedef struct
  51. {
  52.   gboolean  boole;
  53.   gchar    *string;
  54.   gpointer  data;
  55. } BoolCharPair;
  56.  
  57.  
  58. /*  forward declarations  */
  59.  
  60. static void      create_idea_list                  (void);
  61. static void      idea_add_in_position              (gchar       *label,
  62.                             gint         position);
  63. static void      open_idea_window                  (void);
  64. static void      open_or_raise                     (gchar       *file_name,
  65.                             gboolean    try_raise);
  66.  
  67. static void      idea_open_callback                (GtkWidget   *widget,
  68.                             gpointer     data);
  69. static void      idea_open_or_raise_callback       (GtkWidget   *widget,
  70.                             gpointer     data);
  71. static void      idea_up_callback                  (GtkWidget   *widget,
  72.                             gpointer     data);
  73. static void      idea_to_top_callback              (GtkWidget   *widget,
  74.                             gpointer     data);
  75. static void      idea_down_callback                (GtkWidget   *widget,
  76.                             gpointer     data);
  77. static void      idea_to_bottom_callback           (GtkWidget   *widget,
  78.                             gpointer     data);
  79. static void      idea_remove_callback              (GtkWidget   *widget,
  80.                             gpointer     data);
  81. static void      idea_hide_callback                (GtkWidget   *widget,
  82.                             gpointer     data);
  83.  
  84. static void      load_idea_manager                 (IdeaManager *ideas);
  85. static void      save_idea_manager                 (IdeaManager *ideas);
  86.  
  87. static void      clear_white                       (FILE        *fp);
  88. static gint      getinteger                        (FILE        *fp);
  89.  
  90.  
  91. /*  local variables  */
  92.  
  93. static IdeaManager *ideas     = NULL;
  94. static GList       *idea_list = NULL;
  95.  
  96.  
  97. /*  the ops buttons  */
  98. static GtkSignalFunc open_ext_callbacks[] = 
  99. {
  100.   idea_open_or_raise_callback, file_open_callback, NULL, NULL
  101. };
  102.  
  103. static GtkSignalFunc raise_ext_callbacks[] = 
  104. {
  105.   idea_to_top_callback, NULL, NULL, NULL
  106. };
  107.  
  108. static GtkSignalFunc lower_ext_callbacks[] = 
  109. {
  110.   idea_to_bottom_callback, NULL, NULL, NULL
  111. };
  112.  
  113. static OpsButton ops_buttons[] =
  114. {
  115.   { folder_xpm, idea_open_callback, open_ext_callbacks,
  116.     N_("Open the selected entry\n"
  117.        "<Shift> Raise window if already open\n"
  118.        "<Ctrl> Load Image dialog"), NULL,
  119.     NULL, 0 },
  120.   { raise_xpm, idea_up_callback, raise_ext_callbacks,
  121.     N_("Move the selected entry up in the index\n"
  122.        "<Shift> To top"), NULL,
  123.     NULL, 0 },
  124.   { lower_xpm, idea_down_callback, lower_ext_callbacks,
  125.     N_("Move the selected entry down in the index\n"
  126.        "<Shift> To bottom"), NULL,
  127.     NULL, 0 },
  128.   { delete_xpm, idea_remove_callback, NULL,
  129.     N_("Remove the selected entry from the index"), NULL,
  130.     NULL, 0 },
  131.   { NULL, NULL, NULL, NULL, NULL, NULL, 0 }
  132. };
  133.  
  134.  
  135. /*  dnd stuff  */
  136.  
  137. static GtkTargetEntry drag_types[] =
  138. {
  139.   GIMP_TARGET_URI_LIST,
  140.   GIMP_TARGET_TEXT_PLAIN,
  141.   GIMP_TARGET_NETSCAPE_URL
  142. };
  143. static gint n_drag_types = sizeof (drag_types) / sizeof (drag_types[0]);
  144.  
  145.  
  146. /*  public functions  */
  147.  
  148. void
  149. document_index_create (void)
  150. {
  151.   if (ideas)
  152.     gdk_window_raise (ideas->window->window);
  153.   else
  154.     open_idea_window ();
  155. }
  156.  
  157. void
  158. document_index_free (void)
  159. {
  160.   idea_hide_callback (NULL, NULL);
  161. }
  162.  
  163. void
  164. document_index_add (gchar *title)
  165. {
  166.   idea_add_in_position (title, 0);
  167. }
  168.  
  169. FILE *
  170. document_index_parse_init (void)
  171. {
  172.   FILE  *fp;
  173.   gchar *desktopfile;
  174.   gint   dummy;
  175.  
  176.   desktopfile = gimp_personal_rc_file ("ideas");
  177.  
  178.   fp = fopen (desktopfile, "r");
  179.  
  180.   if (fp != NULL)
  181.     {
  182.       /*  eventually strip away the old file format's first line  */
  183.       if (fscanf (fp, "%i %i %i %i", &dummy, &dummy, &dummy, &dummy) != 4)
  184.     {
  185.       fclose (fp);
  186.       fp = fopen (desktopfile, "r");
  187.     }
  188.     }
  189.  
  190.   g_free (desktopfile);
  191.  
  192.   return fp;
  193. }
  194.  
  195. gchar *
  196. document_index_parse_line (FILE * fp)
  197. {
  198.   gint   length;
  199.   gchar *filename;
  200.  
  201.   length = getinteger (fp);
  202.  
  203.   if (!feof (fp) && !ferror (fp))
  204.     {
  205.       filename = g_malloc0 (length + 1);
  206.       filename[fread (filename, 1, length, fp)] = 0;
  207.       clear_white (fp);
  208.       return filename;
  209.     }
  210.  
  211.   return NULL;
  212. }
  213.  
  214.  
  215. /*  local functions  */
  216.  
  217. static void
  218. load_from_list (gpointer data,
  219.         gpointer data_null)
  220. {
  221.   idea_add_in_position ((gchar *) data, -1);
  222. }
  223.  
  224. static void
  225. load_idea_manager (IdeaManager *ideas)
  226. {
  227.   FILE *fp = NULL;
  228.  
  229.   if (! idea_list)
  230.     fp = document_index_parse_init ();
  231.  
  232.   if (idea_list || fp)
  233.     {
  234.       gtk_widget_show (ideas->window);
  235.  
  236.       if (fp)
  237.     {
  238.       gchar *title;
  239.  
  240.       clear_white (fp);
  241.  
  242.       while ((title = document_index_parse_line (fp)))
  243.         {
  244.           idea_add_in_position (title, -1);
  245.           g_free (title);
  246.         }
  247.       fclose (fp);
  248.     }
  249.       else
  250.     {
  251.       g_list_foreach (idea_list, load_from_list, NULL);
  252.       g_list_foreach (idea_list, (GFunc) g_free, NULL);
  253.       g_list_free (idea_list);
  254.       idea_list = 0;
  255.     }
  256.     }
  257.   else
  258.     {
  259.       gtk_widget_show (ideas->window);
  260.     }
  261. }
  262.  
  263. static void
  264. save_to_ideas (gpointer data,
  265.            gpointer user_data)
  266. {
  267.   gchar *title;
  268.  
  269.   title = GTK_LABEL (GTK_BIN (data)->child)->label;
  270.  
  271.   fprintf ((FILE *) user_data, "%d %s\n", strlen (title), title);
  272. }
  273.  
  274. static void
  275. save_list_to_ideas (gpointer data,
  276.             gpointer user_data)
  277. {
  278.   gchar *title;
  279.  
  280.   title = (gchar *) data;
  281.  
  282.   fprintf ((FILE *) user_data, "%d %s\n", strlen (title), title);
  283. }
  284.  
  285. static void
  286. save_idea_manager (IdeaManager *ideas)
  287. {
  288.   FILE  *fp;
  289.   gchar *desktopfile;
  290.     
  291.   /* open persistant desktop file. */
  292.   desktopfile = gimp_personal_rc_file ("ideas");
  293.   fp = fopen (desktopfile, "w");
  294.   g_free (desktopfile);
  295.  
  296.   if (fp)
  297.     {
  298.       if (ideas)
  299.     {
  300.       g_list_foreach (GTK_LIST (ideas->list)->children, save_to_ideas, fp);
  301.     }
  302.       else if (idea_list)
  303.     {
  304.       g_list_foreach (idea_list, save_list_to_ideas, fp);
  305.     }
  306.  
  307.       fclose (fp);
  308.     }
  309. }
  310.  
  311. static void
  312. save_to_list (gpointer data,
  313.           gpointer null_data)
  314. {
  315.   gchar *title;
  316.  
  317.   title = g_strdup (GTK_LABEL (GTK_BIN (data)->child)->label);
  318.  
  319.   idea_list = g_list_append (idea_list, title);
  320. }
  321.  
  322. static void
  323. create_idea_list (void)
  324. {
  325.   if (idea_list)
  326.     {
  327.       g_list_foreach (idea_list, (GFunc) g_free, NULL);
  328.       g_list_free (idea_list);
  329.       idea_list = 0;
  330.     }
  331.  
  332.   g_list_foreach (GTK_LIST (ideas->list)->children, save_to_list, NULL);
  333. }
  334.  
  335. static gint
  336. list_item_callback (GtkWidget      *widget,
  337.             GdkEventButton *event,
  338.             gpointer        data)
  339. {
  340.   if (GTK_IS_LIST_ITEM (widget) &&
  341.       event->type == GDK_2BUTTON_PRESS)
  342.     {
  343.       open_or_raise (GTK_LABEL (GTK_BIN (widget)->child)->label, FALSE);
  344.     }
  345.  
  346.   return FALSE;
  347. } 
  348.  
  349. static void
  350. check_needed (gpointer data,
  351.           gpointer user_data)
  352. {
  353.   BoolCharPair *pair;
  354.  
  355.   pair = (BoolCharPair *) user_data;
  356.  
  357.   if (strcmp (pair->string, GTK_LABEL (GTK_BIN (data)->child)->label) == 0)
  358.     {
  359.       pair->boole = TRUE;
  360.       pair->data  = data;
  361.     }
  362. }
  363.  
  364. static void
  365. check_needed_list (gpointer data,
  366.            gpointer user_data)
  367. {
  368.   BoolCharPair *pair;
  369.  
  370.   pair = (BoolCharPair *) user_data;
  371.  
  372.   if (strcmp (pair->string, (gchar *) data) == 0)
  373.     {
  374.       pair->boole = TRUE;
  375.       pair->data  = data;
  376.     }
  377. }
  378.  
  379. static void
  380. idea_add_in_position_with_select (gchar    *title,
  381.                   gint      position,
  382.                   gboolean  select)
  383. {
  384.   BoolCharPair  pair;
  385.  
  386.   pair.boole  = FALSE;
  387.   pair.string = title;
  388.   pair.data   = NULL;
  389.  
  390.   if (ideas)
  391.     {
  392.       g_list_foreach (GTK_LIST (ideas->list)->children, check_needed, &pair);
  393.  
  394.       if (! pair.boole)
  395.     {
  396.       GtkWidget *listitem;
  397.       GList     *list = NULL;
  398.  
  399.       listitem = gtk_list_item_new_with_label (title);
  400.       list = g_list_append (list, listitem);
  401.  
  402.       if (position < 0)
  403.         gtk_list_append_items (GTK_LIST (ideas->list), list);
  404.       else
  405.         gtk_list_insert_items (GTK_LIST (ideas->list), list, position);
  406.  
  407.       gtk_signal_connect (GTK_OBJECT (listitem), "button_press_event",
  408.                   GTK_SIGNAL_FUNC (list_item_callback),
  409.                   NULL);
  410.  
  411.       gtk_widget_show (listitem);
  412.  
  413.       if (select)
  414.         gtk_list_item_select (GTK_LIST_ITEM  (listitem));
  415.     }
  416.       else /* move entry to top */
  417.     {
  418.       gchar *title;
  419.  
  420.       title = g_strdup (GTK_LABEL (GTK_BIN (pair.data)->child)->label);
  421.       gtk_container_remove (GTK_CONTAINER (ideas->list),
  422.                 GTK_WIDGET (pair.data));
  423.       idea_add_in_position_with_select (title, 0, TRUE);
  424.       g_free (title); 
  425.     }
  426.     }
  427.   else
  428.     {
  429.       if (! idea_list)
  430.     {
  431.       FILE  *fp;
  432.  
  433.       fp = document_index_parse_init ();
  434.  
  435.       if (fp)
  436.         {  
  437.           gchar *filename;
  438.  
  439.           while ((filename = document_index_parse_line (fp)))
  440.         {
  441.           idea_list = g_list_append (idea_list, g_strdup (filename));
  442.           g_free (filename);
  443.         }
  444.  
  445.           fclose (fp);
  446.         }
  447.     }
  448.  
  449.       g_list_foreach (idea_list, check_needed_list, &pair);
  450.  
  451.       if (! pair.boole)
  452.     {
  453.       if (position < 0)
  454.         idea_list = g_list_prepend (idea_list, g_strdup (title));
  455.       else
  456.         idea_list = g_list_insert (idea_list, g_strdup (title), position);
  457.     }
  458.       else /* move entry to top */
  459.     {
  460.       idea_list = g_list_remove (idea_list, pair.data);
  461.       g_free (pair.data);
  462.       idea_list = g_list_prepend (idea_list, g_strdup (title));
  463.     }
  464.     }
  465. }
  466.  
  467. static void
  468. idea_add_in_position (gchar *title,
  469.               gint   position)
  470. {
  471.   idea_add_in_position_with_select (title, position, TRUE);
  472. }
  473.  
  474. static void
  475. raise_if_match (gpointer data,
  476.         gpointer user_data)
  477. {
  478.   GDisplay     *gdisp;
  479.   BoolCharPair *pair;
  480.  
  481.   gdisp = (GDisplay *) data;
  482.   pair  = (BoolCharPair *) user_data;
  483.  
  484.   if (gdisp->gimage->has_filename &&
  485.       strcmp (pair->string, gdisp->gimage->filename) == 0)
  486.     {
  487.       pair->boole = TRUE;
  488.       gdk_window_raise (gdisp->shell->window);
  489.     }
  490. }
  491.  
  492. static void
  493. open_or_raise (gchar    *file_name,
  494.            gboolean  try_raise)
  495. {
  496.   BoolCharPair pair;
  497.  
  498.   pair.boole  = FALSE;
  499.   pair.string = file_name;
  500.   pair.data   = NULL;
  501.  
  502.   if (try_raise)
  503.     {
  504.       gdisplays_foreach (raise_if_match, &pair);
  505.  
  506.       if (! pair.boole)
  507.     {
  508.       file_open (file_name, file_name);
  509.     }
  510.     }
  511.   else
  512.     {
  513.       file_open (file_name, file_name);
  514.     }
  515. }
  516.  
  517.  
  518. /*  file parsing functions  */
  519.  
  520. static gint
  521. getinteger (FILE *fp)
  522. {
  523.   gchar    nextchar;
  524.   gint     response = 0;
  525.   gboolean negative = FALSE;
  526.  
  527.   while (isspace (nextchar = fgetc (fp)))
  528.     /* empty statement */ ;
  529.  
  530.   if (nextchar == '-')
  531.     {
  532.       negative = TRUE;
  533.       while (isspace (nextchar = fgetc (fp)))
  534.     /* empty statement */ ;
  535.     }
  536.  
  537.   for (; '0' <= nextchar && '9' >= nextchar; nextchar = fgetc (fp))
  538.     {
  539.       response *= 10;
  540.       response += nextchar - '0';
  541.     }
  542.   for (; isspace (nextchar); nextchar = fgetc (fp))
  543.     /* empty statement */ ;
  544.  
  545.   if (!feof(fp))
  546.     ungetc (nextchar, fp);
  547.   if (negative)
  548.     response = -response;
  549.  
  550.   return response;
  551. }
  552.  
  553. static void
  554. clear_white (FILE *fp)
  555. {
  556.   gint nextchar;
  557.  
  558.   while (isspace (nextchar = fgetc (fp)))
  559.     /* empty statement */ ;
  560.  
  561.   if (!feof(fp))
  562.     ungetc (nextchar, fp);
  563. }
  564.  
  565.  
  566. /*  toolbar / dialog callbacks  */
  567.  
  568. static gint
  569. idea_move (GtkWidget *widget,
  570.        gint       distance,
  571.        gboolean   select)
  572. {
  573.   gint   orig_position;
  574.   gint   position;
  575.   gchar *title;
  576.  
  577.   orig_position = g_list_index (GTK_LIST (ideas->list)->children, widget);
  578.   position = orig_position + distance;
  579.  
  580.   if (position < 0)
  581.     position = 0;
  582.  
  583.   if (position >= g_list_length (GTK_LIST (ideas->list)->children))
  584.     position = g_list_length (GTK_LIST (ideas->list)->children) - 1;
  585.  
  586.   if (position != orig_position)
  587.     {
  588.       title = g_strdup (GTK_LABEL (GTK_BIN (widget)->child)->label);
  589.       gtk_container_remove (GTK_CONTAINER (ideas->list), widget);
  590.       idea_add_in_position_with_select (title, position, select);
  591.       g_free (title); 
  592.    }
  593.  
  594.   return position - orig_position;
  595. }
  596.  
  597. static void
  598. idea_open_callback (GtkWidget   *widget,
  599.             gpointer     data)
  600. {
  601.   GtkWidget *selected;
  602.  
  603.   if (GTK_LIST (ideas->list)->selection)
  604.     {
  605.       selected = GTK_LIST (ideas->list)->selection->data;
  606.       open_or_raise (GTK_LABEL (GTK_BIN (selected)->child)->label, FALSE);
  607.     }
  608.   else
  609.     {
  610.       file_open_callback (widget, data);
  611.     }
  612. }
  613.  
  614. static void
  615. idea_open_or_raise_callback (GtkWidget   *widget,
  616.                  gpointer     data)
  617. {
  618.   GtkWidget *selected;
  619.  
  620.   if (GTK_LIST (ideas->list)->selection)
  621.     {
  622.       selected = GTK_LIST (ideas->list)->selection->data;
  623.       open_or_raise (GTK_LABEL (GTK_BIN (selected)->child)->label, TRUE);
  624.     }
  625.   else
  626.     {
  627.       file_open_callback (widget, data);
  628.     }
  629. }
  630.  
  631. static void
  632. idea_up_callback (GtkWidget *widget,
  633.           gpointer   data)
  634. {
  635.   GtkWidget *selected;
  636.  
  637.   if (GTK_LIST (ideas->list)->selection)
  638.     {
  639.       selected = GTK_LIST (ideas->list)->selection->data;
  640.       idea_move (selected, -1, TRUE);
  641.     }
  642. }
  643.  
  644. static void
  645. idea_to_top_callback (GtkWidget   *widget,
  646.               gpointer     data)
  647. {
  648.   GtkWidget *selected;
  649.  
  650.   if (GTK_LIST (ideas->list)->selection)
  651.     {
  652.       selected = GTK_LIST (ideas->list)->selection->data;
  653.       idea_move (selected, - g_list_length (GTK_LIST (ideas->list)->children),
  654.          TRUE);
  655.     }
  656. }
  657.  
  658. static void
  659. idea_down_callback (GtkWidget *widget,
  660.             gpointer   data)
  661. {
  662.   GtkWidget *selected;
  663.  
  664.   if (GTK_LIST (ideas->list)->selection)
  665.     {
  666.       selected = GTK_LIST (ideas->list)->selection->data;
  667.       idea_move (selected, 1, TRUE);
  668.     }
  669. }
  670.  
  671. static void
  672. idea_to_bottom_callback (GtkWidget   *widget,
  673.              gpointer     data)
  674. {
  675.   GtkWidget *selected;
  676.  
  677.   if (GTK_LIST (ideas->list)->selection)
  678.     {
  679.       selected = GTK_LIST (ideas->list)->selection->data;
  680.       idea_move (selected, g_list_length (GTK_LIST (ideas->list)->children),
  681.          TRUE);
  682.     }
  683. }
  684.  
  685. static void
  686. idea_remove (GtkWidget *widget)
  687. {
  688.   gint position;
  689.  
  690.   position = g_list_index (GTK_LIST (ideas->list)->children, widget);
  691.  
  692.   gtk_container_remove (GTK_CONTAINER (ideas->list), widget);
  693.  
  694.   if (g_list_length (GTK_LIST (ideas->list)->children) - 1 < position)
  695.     position = g_list_length (GTK_LIST (ideas->list)->children) - 1;
  696.  
  697.   gtk_list_select_item (GTK_LIST (ideas->list), position);  
  698. }
  699.  
  700. static void
  701. idea_remove_callback (GtkWidget *widget,
  702.               gpointer   data)
  703. {
  704.   GtkWidget *selected;
  705.  
  706.   if (GTK_LIST (ideas->list)->selection)
  707.     {
  708.       selected = GTK_LIST (ideas->list)->selection->data;
  709.       idea_remove (selected);
  710.     }
  711. }
  712.  
  713. static void
  714. idea_hide_callback (GtkWidget *widget,
  715.             gpointer   data)
  716. {
  717.   if (ideas || idea_list)
  718.     save_idea_manager (ideas);
  719.  
  720.   /* False if exiting */
  721.   if (ideas)
  722.     {
  723.       create_idea_list ();
  724.       dialog_unregister (ideas->window);
  725.       session_get_window_info (ideas->window, &document_index_session_info);
  726.       gtk_widget_destroy (ideas->window);
  727.       g_free (ideas);
  728.       ideas = 0;
  729.     }
  730. }
  731.  
  732. static void
  733. ops_buttons_update (GtkWidget *widget,
  734.             gpointer   data)
  735. {
  736.   GtkWidget *selected = NULL;
  737.   gint       length   = 0;
  738.   gint       index    = -1;
  739.  
  740.   length = g_list_length (GTK_LIST (ideas->list)->children);
  741.  
  742.   if (GTK_LIST (ideas->list)->selection)
  743.     {
  744.       selected = GTK_LIST (ideas->list)->selection->data;
  745.       index  = g_list_index  (GTK_LIST (ideas->list)->children, selected);
  746.     }
  747.  
  748. #define SET_OPS_SENSITIVE(button,condition) \
  749.         gtk_widget_set_sensitive (ops_buttons[(button)].widget, \
  750.                                   (condition) != 0)
  751.  
  752.   SET_OPS_SENSITIVE (1, selected && index > 0);
  753.   SET_OPS_SENSITIVE (2, selected && index < (length - 1));
  754.   SET_OPS_SENSITIVE (3, selected);
  755.  
  756. #undef SET_OPS_SENSITIVE
  757. }
  758.  
  759. static void
  760. open_idea_window (void)
  761. {
  762.   GtkWidget *main_vbox;
  763.   GtkWidget *scrolled_win;
  764.   GtkWidget *abox;
  765.   GtkWidget *button_box;
  766.   gint       i;
  767.  
  768.   ideas = g_new0 (IdeaManager, 1);
  769.  
  770.   ideas->window = gimp_dialog_new (_("Document Index"), "docindex",
  771.                    gimp_standard_help_func,
  772.                    "dialogs/document_index.html",
  773.                    GTK_WIN_POS_MOUSE,
  774.                    FALSE, TRUE, FALSE,
  775.  
  776.                    _("Close"), idea_hide_callback,
  777.                    NULL, NULL, NULL, TRUE, TRUE,
  778.  
  779.                    NULL);
  780.  
  781.   gtk_drag_dest_set (ideas->window,
  782.                      GTK_DEST_DEFAULT_ALL,
  783.                      drag_types, n_drag_types,
  784.                      GDK_ACTION_COPY);
  785.  
  786.   gimp_dnd_file_dest_set (ideas->window);
  787.  
  788.   dialog_register (ideas->window);
  789.   session_set_window_geometry (ideas->window, &document_index_session_info,
  790.                    TRUE);
  791.  
  792.   main_vbox = gtk_vbox_new (FALSE, 4);
  793.   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 4);
  794.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (ideas->window)->vbox),
  795.              main_vbox);
  796.   gtk_widget_show (main_vbox);
  797.  
  798.   /* Scrolled window */
  799.   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  800.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
  801.                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
  802.   gtk_box_pack_start (GTK_BOX (main_vbox), scrolled_win, TRUE, TRUE, 0); 
  803.   gtk_widget_show (scrolled_win);
  804.  
  805.   /* Setup list */
  806.   ideas->list = gtk_list_new ();
  807.   gtk_list_set_selection_mode (GTK_LIST (ideas->list), GTK_SELECTION_BROWSE);
  808.   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),
  809.                      ideas->list);
  810.   gtk_widget_show (ideas->list);
  811.  
  812.   /*  The ops buttons  */
  813.   abox = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
  814.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (ideas->window)->action_area), abox,
  815.               FALSE, FALSE, 4);
  816.   gtk_widget_show (abox);
  817.  
  818.   button_box = ops_button_box_new (ops_buttons, OPS_BUTTON_NORMAL);
  819.   gtk_container_add (GTK_CONTAINER (abox), button_box);
  820.   gtk_widget_show (button_box);
  821.  
  822.   for (i = 0; ; i++)
  823.     {
  824.       if (ops_buttons[i].widget == NULL)
  825.     break;
  826.  
  827.       gtk_misc_set_padding (GTK_MISC (GTK_BIN (ops_buttons[i].widget)->child),
  828.                 12, 0);
  829.     }
  830.  
  831.   /* Load and Show window */
  832.   load_idea_manager (ideas);
  833.  
  834.   gtk_signal_connect_after (GTK_OBJECT (ideas->list), "selection_changed",
  835.                 GTK_SIGNAL_FUNC (ops_buttons_update),
  836.                 NULL);
  837.   ops_buttons_update (NULL, NULL);
  838. }
  839.