home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / Lighting / lighting_ui.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-29  |  38.5 KB  |  1,259 lines
  1. /* Lighting Effects - A plug-in for GIMP
  2.  *
  3.  * Dialog creation and updaters, callbacks and event-handlers
  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 of the License, or
  8.  * (at your option) 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.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. #include <gtk/gtk.h>
  21.  
  22. #include <libgimp/gimp.h>
  23. #include <libgimp/gimpui.h>
  24.  
  25. #include <gck/gck.h>
  26.  
  27. #include "lighting_ui.h"
  28. #include "lighting_main.h"
  29. #include "lighting_image.h"
  30. #include "lighting_apply.h"
  31. #include "lighting_preview.h"
  32.  
  33. #include "config.h"
  34. #include "libgimp/stdplugins-intl.h"
  35.  
  36. #include "amb1.xpm"
  37. #include "amb2.xpm"
  38. #include "diffint1.xpm"
  39. #include "diffint2.xpm"
  40. #include "diffref1.xpm"
  41. #include "diffref2.xpm"
  42. #include "specref1.xpm"
  43. #include "specref2.xpm"
  44. #include "high1.xpm"
  45. #include "high2.xpm"
  46. /*
  47. #include "pixmaps/zoom_in.xpm"
  48. #include "pixmaps/zoom_out.xpm"
  49. */
  50. extern LightingValues mapvals;
  51.  
  52. GckVisualInfo *visinfo = NULL;
  53.  
  54. static GtkWidget   *appwin            = NULL;
  55. static GtkNotebook *options_note_book = NULL;
  56.  
  57. /*
  58. static GtkWidget   *bump_page         = NULL;
  59. static GtkWidget   *env_page          = NULL;
  60. */
  61.  
  62. GdkGC     *gc          = NULL;
  63. GtkWidget *previewarea = NULL;
  64.  
  65. static GtkWidget *pointlightwid = NULL;
  66. static GtkWidget *dirlightwid   = NULL;
  67. /*
  68. static gint bump_page_pos = -1;
  69. static gint env_page_pos  = -1;
  70. */
  71. static guint left_button_pressed = FALSE;
  72. static guint light_hit           = FALSE;
  73.  
  74. static gboolean run = FALSE;
  75.  
  76.  
  77. static void create_main_notebook      (GtkWidget *container);
  78.  
  79. static gint preview_events            (GtkWidget *area,
  80.                        GdkEvent  *event);
  81.  
  82. #ifdef _LIGHTNING_UNUSED_CODE
  83. static void xyzval_update             (GtkEntry *entry);
  84. #endif
  85.  
  86. static void toggle_update             (GtkWidget *widget,
  87.                        gpointer   data);
  88. /*
  89. static void togglebump_update         (GtkWidget *widget,
  90.                        gpointer   data);
  91.  
  92. static void toggleenvironment_update  (GtkWidget *widget,
  93.                        gpointer   data);
  94. */
  95.  
  96. static void lightmenu_callback        (GtkWidget *widget,
  97.                        gpointer   data);
  98.  
  99. static void preview_callback          (GtkWidget *widget);
  100. static void apply_callback            (GtkWidget *widget);
  101.  
  102. static gint bumpmap_constrain         (gint32   image_id,
  103.                        gint32   drawable_id,
  104.                        gpointer data);
  105. static void bumpmap_drawable_callback (gint32   id,
  106.                        gpointer data);
  107.  
  108. static gint envmap_constrain          (gint32   image_id,
  109.                        gint32   drawable_id,
  110.                        gpointer data);
  111. static void envmap_drawable_callback  (gint32   id,
  112.                        gpointer data);
  113. /*
  114. static GtkWidget *create_bump_page        (void);
  115.  
  116. static GtkWidget *create_environment_page (void);
  117. */
  118.  
  119. #ifdef _LIGHTNING_UNUSED_CODE
  120. /**********************************************************/
  121. /* Update entry fields that affect the preview parameters */
  122. /**********************************************************/
  123.  
  124. static void xyzval_update(GtkEntry *entry)
  125. {
  126.   gdouble *valueptr;
  127.   gdouble value;
  128.  
  129.   valueptr=(gdouble *)gtk_object_get_data(GTK_OBJECT(entry),"ValuePtr");
  130.   value = atof(gtk_entry_get_text(entry));
  131.  
  132.   *valueptr=value;
  133. }
  134. #endif
  135.  
  136. /**********************/
  137. /* Std. toggle update */
  138. /**********************/
  139.  
  140. static void
  141. toggle_update (GtkWidget *widget,
  142.            gpointer   data)
  143. {
  144.   gimp_toggle_button_update (widget, data);
  145.  
  146.   draw_preview_image (TRUE);
  147. }
  148.  
  149. /*****************************/
  150. /* Toggle bumpmapping update */
  151. /*****************************/
  152. /*
  153. static void
  154. togglebump_update (GtkWidget *widget,
  155.            gpointer   data)
  156. {
  157.   gimp_toggle_button_update (widget, data);
  158.   
  159.   if (mapvals.bump_mapped)
  160.     {
  161.       bump_page_pos = g_list_length (options_note_book->children);
  162.  
  163.       bump_page = create_bump_page ();
  164.       gtk_notebook_append_page (options_note_book, bump_page,
  165.                 gtk_label_new (_("Bumpmap")));
  166.     }
  167.   else
  168.     {
  169.       gtk_notebook_remove_page (options_note_book, bump_page_pos);
  170.       if (bump_page_pos < env_page_pos)
  171.         env_page_pos--;
  172.       bump_page_pos = 0;
  173.     }
  174. }
  175. */
  176. /*************************************/
  177. /* Toggle environment mapping update */
  178. /*************************************/
  179. /*
  180. static void
  181. toggleenvironment_update (GtkWidget *widget,
  182.               gpointer   data)
  183. {
  184.   gimp_toggle_button_update (widget, data);
  185.  
  186.   if (mapvals.env_mapped)
  187.     {
  188.       env_page_pos = g_list_length (options_note_book->children);
  189.  
  190.       env_page = create_environment_page ();
  191.       gtk_notebook_append_page (options_note_book, env_page,
  192.                 gtk_label_new (_("Environment")));
  193.     }
  194.   else
  195.     {
  196.       gtk_notebook_remove_page (options_note_book, env_page_pos);
  197.       if (env_page_pos < bump_page_pos)
  198.         bump_page_pos--;
  199.       env_page_pos = 0;
  200.     }
  201. }
  202. */
  203. /*****************************************/
  204. /* Main window light type menu callback. */
  205. /*****************************************/
  206.  
  207. static void
  208. lightmenu_callback (GtkWidget *widget,
  209.             gpointer   data)
  210. {
  211.   gimp_menu_item_update (widget, data);
  212.  
  213.   if (mapvals.lightsource.type == POINT_LIGHT)
  214.     {
  215.       gtk_widget_hide (dirlightwid);
  216.       gtk_widget_show (pointlightwid);
  217.     }
  218.   else if (mapvals.lightsource.type == DIRECTIONAL_LIGHT)
  219.     {
  220.       gtk_widget_hide (pointlightwid);
  221.       gtk_widget_show (dirlightwid);
  222.     }
  223.   else
  224.     {
  225.       gtk_widget_hide (pointlightwid);
  226.       gtk_widget_hide (dirlightwid);
  227.     }
  228. }
  229.  
  230. static void
  231. mapmenu2_callback (GtkWidget *widget,
  232.            gpointer   data)
  233. {
  234.   gimp_menu_item_update (widget, data);
  235.  
  236.   draw_preview_image (TRUE);
  237. }
  238.  
  239. /******************************************/
  240. /* Main window "Preview!" button callback */
  241. /******************************************/
  242.  
  243. static void
  244. preview_callback (GtkWidget *widget)
  245. {
  246.   draw_preview_image (TRUE);
  247. }
  248.  
  249. /*********************************************/
  250. /* Main window "-" (zoom in) button callback */
  251. /*********************************************/
  252. /*
  253. static void
  254. zoomout_callback (GtkWidget *widget)
  255. {
  256.   mapvals.preview_zoom_factor *= 0.5;
  257.   draw_preview_image (TRUE);
  258. }
  259. */
  260. /*********************************************/
  261. /* Main window "+" (zoom out) button callback */
  262. /*********************************************/
  263. /*
  264. static void
  265. zoomin_callback (GtkWidget *widget)
  266. {
  267.   mapvals.preview_zoom_factor *= 2.0;
  268.   draw_preview_image (TRUE);
  269. }
  270. */
  271. /**********************************************/
  272. /* Main window "Apply" button callback.       */ 
  273. /* Render to GIMP image, close down and exit. */
  274. /**********************************************/
  275.  
  276. static void
  277. apply_callback (GtkWidget *widget)
  278. {
  279.   run = TRUE;
  280.  
  281.   gtk_main_quit ();
  282. }
  283.  
  284. static gint
  285. bumpmap_constrain (gint32   image_id,
  286.            gint32   drawable_id,
  287.            gpointer data)
  288. {
  289.   if (drawable_id == -1)
  290.     return TRUE;
  291.  
  292.   return (gimp_drawable_is_gray (drawable_id) &&
  293.       !gimp_drawable_has_alpha (drawable_id) &&
  294.           (gimp_drawable_width (drawable_id) ==
  295.        gimp_drawable_width (mapvals.drawable_id)) &&
  296.           (gimp_drawable_height (drawable_id) ==
  297.        gimp_drawable_height (mapvals.drawable_id)));
  298. }
  299.  
  300. static void
  301. bumpmap_drawable_callback (gint32   id,
  302.                gpointer data)
  303. {
  304.   mapvals.bumpmap_id = id;
  305. }
  306.  
  307. static gint
  308. envmap_constrain (gint32   image_id,
  309.           gint32   drawable_id,
  310.           gpointer data)
  311. {
  312.   if (drawable_id == -1)
  313.     return TRUE;
  314.  
  315.   return (!gimp_drawable_is_gray (drawable_id) &&
  316.       !gimp_drawable_has_alpha (drawable_id));
  317. }
  318.  
  319. static void
  320. envmap_drawable_callback (gint32   id,
  321.               gpointer data)
  322. {
  323.   mapvals.envmap_id = id;
  324.   env_width = gimp_drawable_width (mapvals.envmap_id);
  325.   env_height = gimp_drawable_height (mapvals.envmap_id);
  326. }
  327.  
  328. /******************************/
  329. /* Preview area event handler */
  330. /******************************/
  331.  
  332. static gint
  333. preview_events (GtkWidget *area,
  334.         GdkEvent  *event)
  335. {
  336.   switch (event->type)
  337.     {
  338.       case GDK_EXPOSE:
  339.  
  340.         /* Is this the first exposure? */
  341.         /* =========================== */
  342.  
  343.         if (!gc)
  344.           {
  345.             gc = gdk_gc_new (area->window);
  346.             draw_preview_image (TRUE);
  347.           }
  348.         else
  349.           draw_preview_image (FALSE);
  350.         break; 
  351.       case GDK_ENTER_NOTIFY:
  352.         break;
  353.       case GDK_LEAVE_NOTIFY:
  354.         break;
  355.       case GDK_BUTTON_PRESS:
  356.         light_hit = check_light_hit (event->button.x, event->button.y);
  357.         left_button_pressed = TRUE;
  358.         break;
  359.       case GDK_BUTTON_RELEASE:
  360.         if (light_hit == TRUE)
  361.           draw_preview_image (TRUE);
  362.         left_button_pressed = FALSE;
  363.         break;
  364.       case GDK_MOTION_NOTIFY:
  365.         if (left_button_pressed == TRUE && light_hit == TRUE)
  366.           update_light (event->motion.x, event->motion.y);
  367.         break;
  368.       default:
  369.         break;
  370.     }
  371.  
  372.   return FALSE;
  373. }
  374.  
  375. /***********************/
  376. /* Dialog constructors */
  377. /***********************/
  378.  
  379. static GtkWidget *
  380. create_options_page (void)
  381. {
  382.   GtkWidget *page;
  383.   GtkWidget *frame;
  384.   GtkWidget *vbox;
  385.   GtkWidget *toggle;
  386.   GtkWidget *table;
  387.   /*GtkWidget *spinbutton;*/
  388.   GtkObject *adj;
  389.  
  390.   page = gtk_vbox_new (FALSE, 4);
  391.   gtk_container_set_border_width (GTK_CONTAINER (page), 4);
  392.  
  393.   /* General options */
  394.  
  395.   frame = gtk_frame_new (_("General Options"));
  396.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  397.   gtk_widget_show (frame);
  398.  
  399.   vbox = gtk_vbox_new (FALSE, 2);
  400.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  401.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  402.   gtk_widget_show (vbox);
  403.   /*
  404.   toggle = gtk_check_button_new_with_label (_("Use Bump Mapping"));
  405.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  406.                 mapvals.bump_mapped);
  407.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  408.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  409.               GTK_SIGNAL_FUNC (togglebump_update),
  410.               &mapvals.bump_mapped);
  411.   gtk_widget_show (toggle);
  412.  
  413.   gimp_help_set_help_data (toggle,
  414.                _("Enable/disable bump-mapping (image depth)"),
  415.                NULL);
  416.   
  417.   toggle = gtk_check_button_new_with_label (_("Use Environment Mapping"));
  418.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  419.                 mapvals.env_mapped);
  420.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  421.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  422.               GTK_SIGNAL_FUNC (toggleenvironment_update),
  423.               &mapvals.env_mapped);
  424.   gtk_widget_show (toggle);
  425.  
  426.   gimp_help_set_help_data (toggle,
  427.                _("Enable/disable environment mapping (reflection)"),
  428.                NULL);
  429.   */
  430.   toggle = gtk_check_button_new_with_label (_("Transparent Background"));
  431.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  432.                 mapvals.transparent_background);
  433.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  434.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  435.               GTK_SIGNAL_FUNC (toggle_update),
  436.               &mapvals.transparent_background);
  437.   gtk_widget_show (toggle);
  438.  
  439.   gimp_help_set_help_data (toggle,
  440.                _("Make destination image transparent where bump "
  441.                  "height is zero"),NULL);
  442.  
  443.   toggle = gtk_check_button_new_with_label (_("Create New Image"));
  444.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  445.                 mapvals.create_new_image);
  446.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  447.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  448.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  449.               &mapvals.create_new_image);
  450.   gtk_widget_show (toggle);
  451.  
  452.   gimp_help_set_help_data (toggle,
  453.                _("Create a new image when applying filter"), NULL);
  454.  
  455.   toggle = gtk_check_button_new_with_label (_("High Quality Preview"));
  456.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  457.                 mapvals.previewquality);
  458.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  459.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  460.               GTK_SIGNAL_FUNC (toggle_update),
  461.               &mapvals.previewquality);
  462.   gtk_widget_show (toggle);
  463.  
  464.   gimp_help_set_help_data (toggle,
  465.                _("Enable/disable high quality preview"), NULL);
  466.  
  467.   /* Antialiasing options */
  468.  
  469.   frame = gtk_frame_new (_("Antialiasing Options"));
  470.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  471.   gtk_widget_show (frame);
  472.  
  473.   vbox = gtk_vbox_new (FALSE, 4);
  474.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  475.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  476.   gtk_widget_show (vbox);
  477.  
  478.   toggle = gtk_check_button_new_with_label (_("Enable Antialiasing"));
  479.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  480.                 mapvals.antialiasing);
  481.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  482.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  483.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  484.               &mapvals.antialiasing);
  485.   gtk_widget_show (toggle);
  486.  
  487.   gimp_help_set_help_data (toggle,
  488.                _("Enable/disable jagged edges removal"
  489.                  "(antialiasing)"), NULL);
  490.  
  491.   table = gtk_table_new (2, 3, FALSE);
  492.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  493.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  494.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  495.   gtk_widget_show (table);
  496.  
  497.   gtk_widget_set_sensitive (table, mapvals.antialiasing);
  498.   gtk_object_set_data (GTK_OBJECT (toggle), "set_sensitive", table);
  499.  
  500.   adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  501.                   _("Depth:"), 0, 0,
  502.                   mapvals.max_depth, 1.0, 5.0, 0.5, 1.0,
  503.                   1, TRUE, 0, 0,
  504.                   _("Antialiasing quality. Higher is better, "
  505.                 "but slower"), NULL);
  506.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  507.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  508.               &mapvals.max_depth);
  509.   
  510.  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
  511.                   _("Threshold:"), 0, 0,
  512.                   mapvals.pixel_treshold, 0.01, 1000.0, 1.0, 15.0, 2,
  513.                   TRUE, 0, 0,
  514.                   _("Stop when pixel differences are smaller than "
  515.                     "this value"), NULL);
  516.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  517.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  518.               &mapvals.pixel_treshold);
  519.  
  520.   /*
  521.   spinbutton = gimp_spin_button_new (&adj, mapvals.pixel_treshold,
  522.                      0.001, 1000, 0.1, 1, 1, 0, 3);
  523.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  524.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  525.               &mapvals.pixel_treshold);
  526.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  527.                  _("Threshold:"), 1.0, 1.0,
  528.                  spinbutton, 1, TRUE);
  529.  
  530.   gimp_help_set_help_data (spinbutton,
  531.                _("Stop when pixel differences are smaller than "
  532.                  "this value"), NULL);
  533.   */
  534.   gtk_widget_show (page);
  535.  
  536.   return page;
  537. }
  538.  
  539. /******************************/
  540. /* Create light settings page */
  541. /******************************/
  542.  
  543. static GtkWidget *
  544. create_light_page (void)
  545. {
  546.   GtkWidget *page;
  547.   GtkWidget *frame;
  548.   GtkWidget *table;
  549.   GtkWidget *optionmenu;
  550.   GtkWidget *colorbutton;
  551.   GtkWidget *spinbutton;
  552.   GtkObject *adj;
  553.  
  554.   page = gtk_vbox_new (FALSE, 4);
  555.   gtk_container_set_border_width (GTK_CONTAINER (page), 4);
  556.  
  557.   frame = gtk_frame_new (_("Light Settings"));
  558.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  559.   gtk_widget_show (frame);
  560.  
  561.   table = gtk_table_new (2, 2, FALSE);
  562.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  563.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  564.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  565.   gtk_container_add (GTK_CONTAINER (frame), table);
  566.   gtk_widget_show (table);
  567.  
  568.   optionmenu = gimp_option_menu_new2 (FALSE, lightmenu_callback,
  569.                       &mapvals.lightsource.type,
  570.                       (gpointer) mapvals.lightsource.type,
  571.  
  572.                       _("None"),
  573.                       (gpointer) NO_LIGHT, NULL,
  574.                       _("Directional"),
  575.                       (gpointer) DIRECTIONAL_LIGHT, NULL,
  576.                       _("Point"),
  577.                       (gpointer) POINT_LIGHT, NULL,
  578.                       _("Spot"),
  579.                       (gpointer) SPOT_LIGHT, NULL,
  580.  
  581.                       NULL);
  582.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  583.                  _("Light Type:"), 1.0, 0.5,
  584.                  optionmenu, 1, TRUE);
  585.  
  586.   gimp_help_set_help_data (optionmenu, _("Type of light source to apply"), NULL);
  587.  
  588.   colorbutton = gimp_color_button_double_new (_("Select Lightsource Color"),
  589.                           64, 16,
  590.                           &mapvals.lightsource.color.r, 3);
  591.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  592.                  _("Light Color:"), 1.0, 0.5,
  593.                  colorbutton, 1, TRUE);
  594.  
  595.   gimp_help_set_help_data (colorbutton,
  596.                _("Set light source color"), NULL);
  597.  
  598.   pointlightwid = gtk_frame_new (_("Position"));
  599.   gtk_box_pack_start (GTK_BOX (page), pointlightwid, FALSE, FALSE, 0);
  600.  
  601.   if (mapvals.lightsource.type == POINT_LIGHT)
  602.     gtk_widget_show (pointlightwid);
  603.  
  604.   table = gtk_table_new (3, 2, FALSE);
  605.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  606.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  607.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  608.   gtk_container_add (GTK_CONTAINER (pointlightwid), table);
  609.   gtk_widget_show (table);
  610.  
  611.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.position.x,
  612.                      -G_MAXFLOAT, G_MAXFLOAT,
  613.                      0.1, 1.0, 1.0, 0.0, 2);
  614.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  615.                  _("X:"), 1.0, 0.5,
  616.                  spinbutton, 1, TRUE);
  617.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  618.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  619.               &mapvals.lightsource.position.x);
  620.  
  621.   gimp_help_set_help_data (spinbutton,
  622.                _("Light source X position in XYZ space"), NULL);
  623.  
  624.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.position.y,
  625.                      -G_MAXFLOAT, G_MAXFLOAT,
  626.                      0.1, 1.0, 1.0, 0.0, 2);
  627.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  628.                  _("Y:"), 1.0, 0.5,
  629.                  spinbutton, 1, TRUE);
  630.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  631.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  632.               &mapvals.lightsource.position.y);
  633.  
  634.   gimp_help_set_help_data (spinbutton,
  635.                _("Light source Y position in XYZ space"), NULL);
  636.  
  637.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.position.z,
  638.                      -G_MAXFLOAT, G_MAXFLOAT,
  639.                      0.1, 1.0, 1.0, 0.0, 2);
  640.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  641.                  _("Z:"), 1.0, 0.5,
  642.                  spinbutton, 1, TRUE);
  643.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  644.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  645.               &mapvals.lightsource.position.z);
  646.  
  647.   gimp_help_set_help_data (spinbutton,
  648.                _("Light source Z position in XYZ space"), NULL);
  649.  
  650.  
  651.   dirlightwid = gtk_frame_new (_("Direction Vector"));
  652.   gtk_box_pack_start (GTK_BOX (page), dirlightwid, FALSE, FALSE, 0);
  653.  
  654.   if (mapvals.lightsource.type == DIRECTIONAL_LIGHT)
  655.     gtk_widget_show (dirlightwid);
  656.  
  657.   table = gtk_table_new (3, 2, FALSE);
  658.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  659.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  660.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  661.   gtk_container_add (GTK_CONTAINER (dirlightwid), table);
  662.   gtk_widget_show (table);
  663.  
  664.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.x,
  665.                      -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
  666.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  667.                  _("X:"), 1.0, 0.5,
  668.                  spinbutton, 1, TRUE);
  669.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  670.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  671.               &mapvals.lightsource.direction.x);
  672.  
  673.   gimp_help_set_help_data (spinbutton,
  674.                _("Light source X direction in XYZ space"), NULL);
  675.  
  676.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.y,
  677.                      -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
  678.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  679.                  _("Y:"), 1.0, 0.5,
  680.                  spinbutton, 1, TRUE);
  681.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  682.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  683.               &mapvals.lightsource.direction.y);
  684.  
  685.   gimp_help_set_help_data (spinbutton,
  686.                _("Light source Y direction in XYZ space"), NULL);
  687.  
  688.   spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.z,
  689.                      -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
  690.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  691.                  _("Z:"), 1.0, 0.5,
  692.                  spinbutton, 1, TRUE);
  693.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  694.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  695.               &mapvals.lightsource.direction.z);
  696.  
  697.   gimp_help_set_help_data (spinbutton,
  698.                _("Light source Z direction in XYZ space"), NULL);
  699.  
  700.   gtk_widget_show (page);
  701.  
  702.   return page;  
  703. }
  704.  
  705. /*********************************/
  706. /* Create material settings page */
  707. /*********************************/
  708.  
  709. static GtkWidget *
  710. create_material_page (void)
  711. {
  712.   GtkWidget *page;
  713.   GtkWidget *frame;
  714.   GtkWidget *table;
  715.   GtkWidget *hbox;
  716.   GtkWidget *spinbutton;
  717.   GtkObject *adj;
  718.   GtkWidget *pixmap;
  719.  
  720.   page = gtk_vbox_new (FALSE, 4);
  721.   gtk_container_set_border_width (GTK_CONTAINER (page), 4);
  722.  
  723.   frame = gtk_frame_new (_("Intensity Levels"));
  724.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  725.   gtk_widget_show (frame);
  726.  
  727.   hbox = gtk_hbox_new (FALSE, 0);
  728.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  729.   gtk_container_add (GTK_CONTAINER (frame), hbox);
  730.   gtk_widget_show (hbox);
  731.  
  732.   table = gtk_table_new (2, 4, FALSE);
  733.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  734.   gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
  735.   gtk_widget_show (table);
  736.  
  737.   /* Ambient intensity */
  738.  
  739.   pixmap = gimp_pixmap_new (amb1_xpm);
  740.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  741.                  _("Ambient:"), 1.0, 0.5,
  742.                  pixmap, 1, FALSE);
  743.  
  744.   spinbutton = gimp_spin_button_new (&adj, mapvals.material.ambient_int,
  745.                      0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
  746.   gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 0, 1,
  747.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  748.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  749.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  750.               &mapvals.material.ambient_int);
  751.   gtk_widget_show (spinbutton);
  752.  
  753.   gimp_help_set_help_data (spinbutton,
  754.                _("Amount of original color to show where no "
  755.                  "direct light falls"), NULL);
  756.  
  757.   pixmap = gimp_pixmap_new (amb2_xpm);
  758.   gtk_table_attach (GTK_TABLE (table), pixmap, 3, 4, 0, 1,
  759.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  760.   gtk_widget_show (pixmap);
  761.  
  762.   /* Diffuse intensity */
  763.  
  764.   pixmap = gimp_pixmap_new (diffint1_xpm);
  765.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  766.                  _("Diffuse:"), 1.0, 0.5,
  767.                  pixmap, 1, FALSE);
  768.  
  769.   spinbutton = gimp_spin_button_new (&adj, mapvals.material.diffuse_int,
  770.                      0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
  771.   gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 1, 2,
  772.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  773.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  774.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  775.               &mapvals.material.diffuse_int);
  776.   gtk_widget_show (spinbutton);
  777.  
  778.   gimp_help_set_help_data (spinbutton,
  779.                _("Intensity of original color when lit by a light "
  780.                  "source"), NULL);
  781.  
  782.   pixmap = gimp_pixmap_new (diffint2_xpm);
  783.   gtk_table_attach (GTK_TABLE (table), pixmap, 3, 4, 1, 2,
  784.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  785.   gtk_widget_show (pixmap);
  786.  
  787.   frame = gtk_frame_new (_("Reflectivity"));
  788.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  789.   gtk_widget_show (frame);
  790.  
  791.   hbox = gtk_hbox_new (FALSE, 0);
  792.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  793.   gtk_container_add (GTK_CONTAINER (frame), hbox);
  794.   gtk_widget_show (hbox);
  795.  
  796.   table = gtk_table_new (3, 4, FALSE);
  797.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  798.   gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
  799.   gtk_widget_show (table);
  800.  
  801.   /* Diffuse reflection */
  802.  
  803.   pixmap = gimp_pixmap_new (diffref1_xpm);
  804.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  805.                  _("Diffuse:"), 1.0, 0.5,
  806.                  pixmap, 1, FALSE);
  807.  
  808.   spinbutton = gimp_spin_button_new (&adj, mapvals.material.diffuse_ref,
  809.                      0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
  810.   gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 0, 1,
  811.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  812.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  813.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  814.               &mapvals.material.diffuse_ref);
  815.   gtk_widget_show (spinbutton);
  816.  
  817.   gimp_help_set_help_data (spinbutton,
  818.                _("Higher values makes the object reflect more "
  819.                  "light (appear lighter)"), NULL);
  820.  
  821.   pixmap = gimp_pixmap_new (diffref2_xpm);
  822.   gtk_table_attach (GTK_TABLE (table), pixmap, 3, 4, 0, 1,
  823.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  824.   gtk_widget_show (pixmap);
  825.  
  826.   /* Specular reflection */
  827.  
  828.   pixmap = gimp_pixmap_new (specref1_xpm);
  829.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  830.                  _("Specular:"), 1.0, 0.5,
  831.                  pixmap, 1, FALSE);
  832.  
  833.   spinbutton = gimp_spin_button_new (&adj, mapvals.material.specular_ref,
  834.                      0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
  835.   gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 1, 2,
  836.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  837.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  838.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  839.               &mapvals.material.specular_ref);
  840.   gtk_widget_show (spinbutton);
  841.  
  842.   gimp_help_set_help_data (spinbutton,
  843.                _("Controls how intense the highlights will be"),
  844.                NULL);
  845.  
  846.   pixmap = gimp_pixmap_new (specref2_xpm);
  847.   gtk_table_attach (GTK_TABLE (table), pixmap, 3, 4, 1, 2,
  848.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  849.   gtk_widget_show (pixmap);
  850.  
  851.   /* Highlight */
  852.  
  853.   pixmap = gimp_pixmap_new (high1_xpm);
  854.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  855.                  _("Highlight:"), 1.0, 0.5,
  856.                  pixmap, 1, FALSE);
  857.  
  858.   spinbutton = gimp_spin_button_new (&adj, mapvals.material.highlight,
  859.                      0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
  860.   gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 2, 3,
  861.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  862.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  863.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  864.               &mapvals.material.highlight);
  865.   gtk_widget_show (spinbutton);
  866.  
  867.   gimp_help_set_help_data (spinbutton,
  868.                _("Higher values makes the highlights more focused"),
  869.                NULL);
  870.  
  871.   pixmap = gimp_pixmap_new (high2_xpm);
  872.   gtk_table_attach (GTK_TABLE (table), pixmap, 3, 4, 2, 3,
  873.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  874.   gtk_widget_show (pixmap);
  875.  
  876.   gtk_widget_show (page);
  877.   
  878.   return page;
  879. }
  880.  
  881. /* Create Bump mapping page */
  882.  
  883. static GtkWidget *
  884. create_bump_page (void)
  885. {
  886.   GtkWidget *page;
  887.   GtkWidget *vbox;
  888.   GtkWidget *toggle;
  889.   GtkWidget *frame;
  890.   GtkWidget *table;
  891.   GtkWidget *optionmenu;
  892.   GtkWidget *menu;
  893.   GtkWidget *spinbutton;
  894.   GtkObject *adj;
  895.  
  896.   page = gtk_vbox_new (FALSE, 4);
  897.   gtk_container_set_border_width (GTK_CONTAINER (page), 4);
  898.   frame = gtk_frame_new (_("Bumpmap Settings"));
  899.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  900.   gtk_widget_show (frame);
  901.  
  902.   vbox = gtk_vbox_new (FALSE, 4);
  903.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  904.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  905.   gtk_widget_show (vbox);
  906.  
  907.   toggle = gtk_check_button_new_with_label (_("Enable Bump Mapping"));
  908.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  909.                 mapvals.bump_mapped);
  910.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  911.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  912.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  913.               &mapvals.bump_mapped);
  914.   gtk_widget_show (toggle);
  915.  
  916.   gimp_help_set_help_data (toggle,
  917.                _("Enable/disable bump-mapping (image depth)"),
  918.                NULL);
  919.  
  920.   table = gtk_table_new (6, 2, FALSE);
  921.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  922.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  923.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  924.   gtk_widget_show (table);
  925.  
  926.   gtk_widget_set_sensitive (table, mapvals.bump_mapped);
  927.   gtk_object_set_data (GTK_OBJECT (toggle), "set_sensitive", table);
  928.  
  929.   optionmenu = gtk_option_menu_new ();
  930.   menu = gimp_drawable_menu_new (bumpmap_constrain, bumpmap_drawable_callback,
  931.                  NULL, mapvals.bumpmap_id);
  932.   gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
  933.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  934.                  _("Bumpmap Image:"), 1.0, 0.5,
  935.                  optionmenu, 1, TRUE);
  936.  
  937.   optionmenu =
  938.     gimp_option_menu_new2 (FALSE, mapmenu2_callback,
  939.                &mapvals.bumpmaptype,
  940.                (gpointer) mapvals.bumpmaptype,
  941.  
  942.                _("Linear"),      (gpointer) LINEAR_MAP, NULL,
  943.                _("Logarithmic"), (gpointer) LOGARITHMIC_MAP, NULL,
  944.                _("Sinusoidal"),  (gpointer) SINUSOIDAL_MAP, NULL,
  945.                _("Spherical"),   (gpointer) SPHERICAL_MAP, NULL,
  946.  
  947.                NULL);
  948.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  949.                  _("Curve:"), 1.0, 0.5,
  950.                  optionmenu, 1, TRUE);
  951.  
  952.   spinbutton = gimp_spin_button_new (&adj, mapvals.bumpmax,
  953.                      0, G_MAXFLOAT, 0.01, 0.1, 1.0, 0.0, 2);
  954.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  955.                  _("Maximum Height:"), 1.0, 0.5,
  956.                  spinbutton, 1, TRUE);
  957.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  958.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  959.               &mapvals.bumpmax);
  960.  
  961.   gimp_help_set_help_data (spinbutton,
  962.                _("Maximum height for bumps"),
  963.                NULL);
  964.  
  965.   spinbutton = gimp_spin_button_new (&adj, mapvals.bumpmin,
  966.                      0, G_MAXFLOAT, 0.01, 0.1, 1.0, 0.0, 2);
  967.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
  968.                  _("Minimum Height:"), 1.0, 0.5,
  969.                  spinbutton, 1, TRUE);
  970.   gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
  971.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  972.               &mapvals.bumpmin);
  973.  
  974.    gimp_help_set_help_data (spinbutton,
  975.                _("Minimum height for bumps"),
  976.                NULL);
  977.  
  978.   toggle = gtk_check_button_new_with_label (_("Autostretch to Fit Value Range"));
  979.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  980.                 mapvals.bumpstretch);
  981.   gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 2, 4, 5);
  982.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  983.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  984.               &mapvals.bumpstretch);
  985.   gtk_widget_show (toggle);
  986.  
  987.   gimp_help_set_help_data (toggle,
  988.                _("Fit into value range"),
  989.                NULL);
  990.   
  991.   gtk_widget_show (page);
  992.  
  993.   return page;
  994. }
  995.  
  996. static GtkWidget *
  997. create_environment_page (void)
  998. {
  999.   GtkWidget *page;
  1000.   GtkWidget *toggle;
  1001.   GtkWidget *table;
  1002.   GtkWidget *frame;
  1003.   GtkWidget *vbox;
  1004.   GtkWidget *optionmenu;
  1005.   GtkWidget *menu;
  1006.  
  1007.   page = gtk_vbox_new (FALSE, 4);
  1008.   gtk_container_set_border_width (GTK_CONTAINER (page), 4);
  1009.   frame = gtk_frame_new (_("Environment Settings"));
  1010.   gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
  1011.   gtk_widget_show (frame);
  1012.  
  1013.   vbox = gtk_vbox_new (FALSE, 4);
  1014.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  1015.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  1016.   gtk_widget_show (vbox);
  1017.  
  1018.   toggle = gtk_check_button_new_with_label (_("Enable Environment Mapping"));
  1019.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  1020.                 mapvals.env_mapped);
  1021.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  1022.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  1023.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  1024.               &mapvals.env_mapped);
  1025.   gtk_widget_show (toggle);
  1026.  
  1027.   gimp_help_set_help_data (toggle,
  1028.                _("Enable/disable environment-mapping (reflection)"),
  1029.                NULL);
  1030.  
  1031.   table = gtk_table_new (3, 2, FALSE);
  1032.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  1033.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  1034.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  1035.   gtk_widget_show (table);
  1036.  
  1037.   gtk_widget_set_sensitive (table, mapvals.env_mapped);
  1038.   gtk_object_set_data (GTK_OBJECT (toggle), "set_sensitive", table);
  1039.  
  1040.   optionmenu = gtk_option_menu_new ();
  1041.   menu = gimp_drawable_menu_new (envmap_constrain, envmap_drawable_callback,
  1042.                  NULL, mapvals.envmap_id);
  1043.   gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
  1044.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  1045.                  _("Environment Image:"), 1.0, 0.5,
  1046.                  optionmenu, 1, TRUE);
  1047.  
  1048.   gimp_help_set_help_data (optionmenu,
  1049.                _("Environment image to use"),
  1050.                NULL);
  1051.  
  1052.   gtk_widget_show (page);
  1053.  
  1054.   return page;
  1055. }
  1056.  
  1057. /*****************************/
  1058. /* Create notebook and pages */
  1059. /*****************************/
  1060.  
  1061. static void
  1062. create_main_notebook (GtkWidget *container)
  1063. {
  1064.   GtkWidget *page;
  1065.  
  1066.   options_note_book = GTK_NOTEBOOK (gtk_notebook_new ());
  1067.   gtk_container_add (GTK_CONTAINER (container),
  1068.              GTK_WIDGET (options_note_book));
  1069.  
  1070.   page = create_options_page ();
  1071.   gtk_notebook_append_page (options_note_book, page,
  1072.                 gtk_label_new (_("Options")));
  1073.  
  1074.   page = create_light_page ();
  1075.   gtk_notebook_append_page (options_note_book, page,
  1076.                 gtk_label_new (_("Light")));
  1077.  
  1078.   page = create_material_page ();
  1079.   gtk_notebook_append_page (options_note_book, page,
  1080.                 gtk_label_new (_("Material")));
  1081.  
  1082.   page = create_bump_page ();
  1083.   gtk_notebook_append_page (options_note_book, page,
  1084.                 gtk_label_new (_("Bump Map")));
  1085.  
  1086.   page = create_environment_page ();
  1087.   gtk_notebook_append_page (options_note_book, page,
  1088.                 gtk_label_new (_("Environment Map")));
  1089.  
  1090.   /*
  1091.   if (mapvals.bump_mapped == TRUE)
  1092.     {
  1093.       bump_page = create_bump_page ();
  1094.       bump_page_pos = g_list_length (options_note_book->children);
  1095.       gtk_notebook_append_page (options_note_book, bump_page,
  1096.                 gtk_label_new (_("Bumpmap")));
  1097.     }
  1098.   
  1099.   if (mapvals.env_mapped == TRUE)
  1100.     {
  1101.       env_page = create_environment_page ();
  1102.       env_page_pos = g_list_length (options_note_book->children);
  1103.       gtk_notebook_append_page (options_note_book, env_page,
  1104.                 gtk_label_new (_("Environment")));
  1105.     }
  1106.   */
  1107.   gtk_widget_show (GTK_WIDGET (options_note_book));
  1108. }
  1109.  
  1110. /********************************/
  1111. /* Create and show main dialog. */
  1112. /********************************/
  1113.  
  1114. gboolean
  1115. main_dialog (GimpDrawable *drawable)
  1116. {
  1117.   GtkWidget *main_hbox;
  1118.   GtkWidget *vbox;
  1119.   GtkWidget *hbox;
  1120.   GtkWidget *frame;
  1121.   GtkWidget *button;
  1122.   gchar **argv;
  1123.   gint    argc;
  1124.  
  1125.   argc    = 1;
  1126.   argv    = g_new (gchar *, 1);
  1127.   argv[0] = g_strdup ("MapObject");
  1128.  
  1129.   gtk_init (&argc, &argv);
  1130.   gtk_rc_parse (gimp_gtkrc ());
  1131.  
  1132.   if (! gimp_use_xshm ())
  1133.     gdk_set_use_xshm (FALSE);
  1134.  
  1135.   visinfo = gck_visualinfo_new ();
  1136.  
  1137.   appwin = gimp_dialog_new (_("Lighting Effects"), "Lighting",
  1138.                 gimp_standard_help_func,
  1139.                 "filters/lighting.html",
  1140.                 GTK_WIN_POS_MOUSE,
  1141.                 FALSE, TRUE, FALSE,
  1142.  
  1143.                 _("OK"), apply_callback,
  1144.                 NULL, NULL, NULL, TRUE, FALSE,
  1145.                 _("Cancel"), gtk_main_quit,
  1146.                 NULL, NULL, NULL, FALSE, TRUE,
  1147.  
  1148.                 NULL);
  1149.  
  1150.   gimp_help_init ();
  1151.  
  1152.   main_hbox = gtk_hbox_new (FALSE, 6);
  1153.   gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 6);
  1154.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (appwin)->vbox), main_hbox,
  1155.               FALSE, FALSE, 0);
  1156.   gtk_widget_show (main_hbox);
  1157.  
  1158.   /* Create the Preview */
  1159.   /* ================== */
  1160.  
  1161.   frame = gtk_frame_new (_("Preview"));
  1162.   gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
  1163.   gtk_widget_show (frame);
  1164.  
  1165.   vbox = gtk_vbox_new (FALSE, 4);
  1166.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  1167.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  1168.   gtk_widget_show (vbox);
  1169.  
  1170.   /* Add preview widget and various buttons to the first part */
  1171.   /* ======================================================== */
  1172.  
  1173.   frame = gtk_frame_new (NULL);
  1174.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  1175.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  1176.   gtk_widget_show (frame);
  1177.  
  1178.   gtk_widget_realize (appwin);
  1179.  
  1180.   previewarea = gtk_drawing_area_new ();
  1181.   gtk_drawing_area_size (GTK_DRAWING_AREA (previewarea),
  1182.              PREVIEW_WIDTH, PREVIEW_HEIGHT);
  1183.   gtk_widget_set_events (previewarea, (GDK_EXPOSURE_MASK |
  1184.                        GDK_BUTTON1_MOTION_MASK |
  1185.                        GDK_BUTTON_PRESS_MASK | 
  1186.                        GDK_BUTTON_RELEASE_MASK));
  1187.   gtk_signal_connect (GTK_OBJECT (previewarea), "event",
  1188.               GTK_SIGNAL_FUNC (preview_events),
  1189.               (gpointer) previewarea);
  1190.   gtk_container_add (GTK_CONTAINER (frame), previewarea);
  1191.   gtk_widget_show (previewarea);
  1192.  
  1193.   hbox = gtk_hbox_new (FALSE, 4);
  1194.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  1195.   gtk_widget_show (hbox);
  1196.  
  1197.   button = gtk_button_new_with_label (_("Update Preview"));
  1198.   gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
  1199.   gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
  1200.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  1201.               GTK_SIGNAL_FUNC (preview_callback),
  1202.               NULL);
  1203.   gtk_widget_show (button);
  1204.  
  1205.   gimp_help_set_help_data (button, _("Recompute preview image"), NULL);
  1206.  
  1207.   /*
  1208.   button = gimp_pixmap_button_new (zoom_out_xpm, NULL);
  1209.   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
  1210.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  1211.               GTK_SIGNAL_FUNC (zoomout_callback),
  1212.               NULL);
  1213.   gtk_widget_show (button);
  1214.  
  1215.   gimp_help_set_help_data (button, _("Zoom out (make image smaller)"), NULL);
  1216.  
  1217.   button = gimp_pixmap_button_new (zoom_in_xpm, NULL);
  1218.   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
  1219.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  1220.               GTK_SIGNAL_FUNC (zoomin_callback),
  1221.               NULL);
  1222.   gtk_widget_show (button);
  1223.  
  1224.   gimp_help_set_help_data (button, _("Zoom in (make image bigger)"), NULL);
  1225.   */
  1226.  
  1227.   create_main_notebook (main_hbox);
  1228.  
  1229.   gtk_widget_show (appwin);
  1230.  
  1231.   {
  1232.     GdkCursor *newcursor;
  1233.  
  1234.     newcursor = gdk_cursor_new (GDK_HAND2);
  1235.     gdk_window_set_cursor (previewarea->window, newcursor);
  1236.     gdk_cursor_destroy (newcursor);
  1237.     gdk_flush ();
  1238.   }
  1239.  
  1240.   image_setup (drawable, TRUE);
  1241.  
  1242.   gtk_main ();
  1243.  
  1244.   if (preview_rgb_data != NULL)
  1245.     g_free (preview_rgb_data);
  1246.  
  1247.   if (image != NULL)
  1248.     gdk_image_destroy (image);
  1249.  
  1250.   gck_visualinfo_destroy (visinfo);
  1251.   gtk_widget_destroy (appwin);
  1252.  
  1253.   gimp_help_free ();
  1254.  
  1255.   gdk_flush ();
  1256.  
  1257.   return run;
  1258. }
  1259.