← Back to branch summary

~ubuntu-branches/ubuntu/maverick/gimp/maverick-updates

« back to all changes in this revision

Viewing changes to plug-ins/MapObject/mapobject_ui.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-12-09 19:44:52 UTC
  • Revision ID: james.westby@ubuntu.com-20051209194452-yggpemjlofpjqyf4
Tags: upstream-2.2.9
Import upstream version 2.2.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/MapObject/mapobject_ui.c
 
1
/**************************************************************/
 
2
/* Dialog creation and updaters, callbacks and event-handlers */
 
3
/**************************************************************/
 
4
 
 
5
#include "config.h"
 
6
 
 
7
#include <libgimp/gimp.h>
 
8
#include <libgimp/gimpui.h>
 
9
 
 
10
#include "arcball.h"
 
11
#include "mapobject_ui.h"
 
12
#include "mapobject_image.h"
 
13
#include "mapobject_apply.h"
 
14
#include "mapobject_preview.h"
 
15
#include "mapobject_main.h"
 
16
#include "mapobject_stock.h"
 
17
 
 
18
#include "libgimp/stdplugins-intl.h"
 
19
 
 
20
 
 
21
GdkGC         *gc          = NULL;
 
22
GtkWidget     *previewarea = NULL;
 
23
 
 
24
static GtkWidget   *appwin            = NULL;
 
25
static GtkNotebook *options_note_book = NULL;
 
26
 
 
27
static GtkWidget *pointlightwid;
 
28
static GtkWidget *dirlightwid;
 
29
 
 
30
static GtkObject *xadj, *yadj, *zadj;
 
31
 
 
32
static GtkWidget *box_page      = NULL;
 
33
static GtkWidget *cylinder_page = NULL;
 
34
 
 
35
static guint left_button_pressed = FALSE;
 
36
static guint light_hit           = FALSE;
 
37
 
 
38
 
 
39
static void create_main_notebook       (GtkWidget     *container);
 
40
 
 
41
static gint preview_events             (GtkWidget     *area,
 
42
                                        GdkEvent      *event);
 
43
 
 
44
static void update_light_pos_entries   (void);
 
45
 
 
46
static void double_adjustment_update   (GtkAdjustment *adjustment,
 
47
                                        gpointer       data);
 
48
 
 
49
static void toggle_update              (GtkWidget     *widget,
 
50
                                        gpointer       data);
 
51
 
 
52
static void togglegrid_update          (GtkWidget     *widget,
 
53
                                        gpointer       data);
 
54
 
 
55
static void lightmenu_callback         (GtkWidget     *widget,
 
56
                                        gpointer       data);
 
57
 
 
58
static void preview_callback           (GtkWidget     *widget,
 
59
                                        gpointer       data);
 
60
 
 
61
static gint box_constrain              (gint32         image_id,
 
62
                                        gint32         drawable_id,
 
63
                                        gpointer       data);
 
64
static gint cylinder_constrain         (gint32         image_id,
 
65
                                        gint32         drawable_id,
 
66
                                        gpointer       data);
 
67
 
 
68
static GtkWidget * create_options_page     (void);
 
69
static GtkWidget * create_light_page       (void);
 
70
static GtkWidget * create_material_page    (void);
 
71
static GtkWidget * create_orientation_page (void);
 
72
static GtkWidget * create_box_page         (void);
 
73
static GtkWidget * create_cylinder_page    (void);
 
74
 
 
75
 
 
76
/******************************************************/
 
77
/* Update angle & position (redraw grid if necessary) */
 
78
/******************************************************/
 
79
 
 
80
static void
 
81
double_adjustment_update (GtkAdjustment *adjustment,
 
82
                          gpointer       data)
 
83
{
 
84
  gimp_double_adjustment_update (adjustment, data);
 
85
 
 
86
  if (mapvals.showgrid)
 
87
    draw_preview_wireframe ();
 
88
}
 
89
 
 
90
static void
 
91
update_light_pos_entries (void)
 
92
{
 
93
  g_signal_handlers_block_by_func (xadj,
 
94
                                   gimp_double_adjustment_update,
 
95
                                   &mapvals.lightsource.position.x);
 
96
  gtk_adjustment_set_value (GTK_ADJUSTMENT (xadj),
 
97
                            mapvals.lightsource.position.x);
 
98
  g_signal_handlers_unblock_by_func (xadj,
 
99
                                     gimp_double_adjustment_update,
 
100
                                     &mapvals.lightsource.position.x);
 
101
 
 
102
  g_signal_handlers_block_by_func (yadj,
 
103
                                   gimp_double_adjustment_update,
 
104
                                   &mapvals.lightsource.position.y);
 
105
  gtk_adjustment_set_value (GTK_ADJUSTMENT (yadj),
 
106
                            mapvals.lightsource.position.x);
 
107
  g_signal_handlers_unblock_by_func (yadj,
 
108
                                     gimp_double_adjustment_update,
 
109
                                     &mapvals.lightsource.position.y);
 
110
 
 
111
  g_signal_handlers_block_by_func (zadj,
 
112
                                   gimp_double_adjustment_update,
 
113
                                   &mapvals.lightsource.position.z);
 
114
  gtk_adjustment_set_value (GTK_ADJUSTMENT (zadj),
 
115
                            mapvals.lightsource.position.z);
 
116
  g_signal_handlers_unblock_by_func (zadj,
 
117
                                     gimp_double_adjustment_update,
 
118
                                     &mapvals.lightsource.position.z);
 
119
}
 
120
 
 
121
/**********************/
 
122
/* Std. toggle update */
 
123
/**********************/
 
124
 
 
125
static void
 
126
toggle_update (GtkWidget *widget,
 
127
               gpointer   data)
 
128
{
 
129
  gimp_toggle_button_update (widget, data);
 
130
 
 
131
  draw_preview_image (TRUE);
 
132
  linetab[0].x1 = -1;
 
133
}
 
134
 
 
135
/***************************/
 
136
/* Show grid toggle update */
 
137
/***************************/
 
138
 
 
139
static void
 
140
togglegrid_update (GtkWidget *widget,
 
141
                   gpointer   data)
 
142
{
 
143
  gimp_toggle_button_update (widget, data);
 
144
 
 
145
  if (mapvals.showgrid && linetab[0].x1 == -1)
 
146
    {
 
147
      draw_preview_wireframe ();
 
148
    }
 
149
  else if (!mapvals.showgrid && linetab[0].x1 != -1)
 
150
    {
 
151
      GdkColor  color;
 
152
 
 
153
      color.red   = 0x0;
 
154
      color.green = 0x0;
 
155
      color.blue  = 0x0;
 
156
      gdk_gc_set_rgb_bg_color (gc, &color);
 
157
 
 
158
      color.red   = 0xFFFF;
 
159
      color.green = 0xFFFF;
 
160
      color.blue  = 0xFFFF;
 
161
      gdk_gc_set_rgb_fg_color (gc, &color);
 
162
 
 
163
      gdk_gc_set_function (gc, GDK_INVERT);
 
164
 
 
165
      clear_wireframe ();
 
166
      linetab[0].x1 = -1;
 
167
    }
 
168
}
 
169
 
 
170
/*****************************************/
 
171
/* Main window light type menu callback. */
 
172
/*****************************************/
 
173
 
 
174
static void
 
175
lightmenu_callback (GtkWidget *widget,
 
176
                    gpointer   data)
 
177
{
 
178
  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), (gint *) data);
 
179
 
 
180
  if (mapvals.lightsource.type == POINT_LIGHT)
 
181
    {
 
182
      gtk_widget_hide (dirlightwid);
 
183
      gtk_widget_show (pointlightwid);
 
184
    }
 
185
  else if (mapvals.lightsource.type == DIRECTIONAL_LIGHT)
 
186
    {
 
187
      gtk_widget_hide (pointlightwid);
 
188
      gtk_widget_show (dirlightwid);
 
189
    }
 
190
  else
 
191
    {
 
192
      gtk_widget_hide (pointlightwid);
 
193
      gtk_widget_hide (dirlightwid);
 
194
    }
 
195
}
 
196
 
 
197
/***************************************/
 
198
/* Main window map type menu callback. */
 
199
/***************************************/
 
200
 
 
201
static void
 
202
mapmenu_callback (GtkWidget *widget,
 
203
                  gpointer   data)
 
204
{
 
205
  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), (gint *) data);
 
206
 
 
207
  draw_preview_image (TRUE);
 
208
 
 
209
  if (mapvals.showgrid && linetab[0].x1 == -1)
 
210
    {
 
211
      draw_preview_wireframe ();
 
212
    }
 
213
  else if (!mapvals.showgrid && linetab[0].x1 != -1)
 
214
    {
 
215
      GdkColor  color;
 
216
 
 
217
      color.red   = 0x0;
 
218
      color.green = 0x0;
 
219
      color.blue  = 0x0;
 
220
      gdk_gc_set_rgb_bg_color (gc, &color);
 
221
 
 
222
      color.red   = 0xFFFF;
 
223
      color.green = 0xFFFF;
 
224
      color.blue  = 0xFFFF;
 
225
      gdk_gc_set_rgb_fg_color (gc, &color);
 
226
 
 
227
      gdk_gc_set_function (gc, GDK_INVERT);
 
228
 
 
229
      clear_wireframe ();
 
230
      linetab[0].x1 = -1;
 
231
    }
 
232
 
 
233
  if (mapvals.maptype == MAP_BOX)
 
234
    {
 
235
      if (cylinder_page != NULL)
 
236
        {
 
237
          gtk_notebook_remove_page
 
238
            (options_note_book,
 
239
             g_list_length (options_note_book->children) - 1);
 
240
          cylinder_page = NULL;
 
241
        }
 
242
 
 
243
      if (box_page == NULL)
 
244
        {
 
245
          box_page = create_box_page ();
 
246
          gtk_notebook_append_page (options_note_book,
 
247
                                    box_page,
 
248
                                    gtk_label_new_with_mnemonic (_("_Box")));
 
249
        }
 
250
    }
 
251
  else if (mapvals.maptype == MAP_CYLINDER)
 
252
    {
 
253
      if (box_page != NULL)
 
254
        {
 
255
          gtk_notebook_remove_page
 
256
            (options_note_book,
 
257
             g_list_length (options_note_book->children) - 1);
 
258
          box_page = NULL;
 
259
        }
 
260
 
 
261
      if (cylinder_page == NULL)
 
262
        {
 
263
          cylinder_page = create_cylinder_page ();
 
264
          gtk_notebook_append_page (options_note_book,
 
265
                                    cylinder_page,
 
266
                                    gtk_label_new_with_mnemonic (_("C_ylinder")));
 
267
        }
 
268
    }
 
269
  else
 
270
    {
 
271
      if (box_page != NULL)
 
272
        {
 
273
          gtk_notebook_remove_page
 
274
            (options_note_book,
 
275
             g_list_length (options_note_book->children) - 1);
 
276
        }
 
277
 
 
278
      if (cylinder_page != NULL)
 
279
        {
 
280
          gtk_notebook_remove_page
 
281
            (options_note_book,
 
282
             g_list_length (options_note_book->children) - 1);
 
283
        }
 
284
 
 
285
      box_page = NULL;
 
286
      cylinder_page = NULL;
 
287
    }
 
288
}
 
289
 
 
290
/******************************************/
 
291
/* Main window "Preview!" button callback */
 
292
/******************************************/
 
293
 
 
294
static void
 
295
preview_callback (GtkWidget *widget,
 
296
                  gpointer   data)
 
297
{
 
298
  draw_preview_image (TRUE);
 
299
  linetab[0].x1 = -1;
 
300
}
 
301
 
 
302
/*********************************************/
 
303
/* Main window "-" (zoom in) button callback */
 
304
/*********************************************/
 
305
 
 
306
static void
 
307
zoomout_callback (GtkWidget *widget,
 
308
                  gpointer   data)
 
309
{
 
310
  if (mapvals.preview_zoom_factor < 2)
 
311
    {
 
312
      mapvals.preview_zoom_factor++;
 
313
      if (linetab[0].x1 != -1)
 
314
        clear_wireframe ();
 
315
      draw_preview_image (TRUE);
 
316
    }
 
317
}
 
318
 
 
319
/**********************************************/
 
320
/* Main window "+" (zoom out) button callback */
 
321
/**********************************************/
 
322
 
 
323
static void
 
324
zoomin_callback (GtkWidget *widget,
 
325
                 gpointer   data)
 
326
{
 
327
  if (mapvals.preview_zoom_factor > 0)
 
328
    {
 
329
      mapvals.preview_zoom_factor--;
 
330
      if (linetab[0].x1 != -1)
 
331
        clear_wireframe ();
 
332
      draw_preview_image (TRUE);
 
333
    }
 
334
}
 
335
 
 
336
/**********************************************/
 
337
/* Main window "Apply" button callback.       */
 
338
/* Render to GIMP image, close down and exit. */
 
339
/**********************************************/
 
340
 
 
341
static gint
 
342
box_constrain (gint32   image_id,
 
343
               gint32   drawable_id,
 
344
               gpointer data)
 
345
{
 
346
  if (drawable_id == -1)
 
347
    return TRUE;
 
348
 
 
349
  return (gimp_drawable_is_rgb (drawable_id) &&
 
350
          !gimp_drawable_is_indexed (drawable_id));
 
351
}
 
352
 
 
353
static gint
 
354
cylinder_constrain (gint32   image_id,
 
355
                    gint32   drawable_id,
 
356
                    gpointer data)
 
357
{
 
358
  if (drawable_id == -1)
 
359
    return TRUE;
 
360
 
 
361
  return (gimp_drawable_is_rgb (drawable_id) &&
 
362
          !gimp_drawable_is_indexed (drawable_id));
 
363
}
 
364
 
 
365
/******************************/
 
366
/* Preview area event handler */
 
367
/******************************/
 
368
 
 
369
static gint
 
370
preview_events (GtkWidget *area,
 
371
                GdkEvent  *event)
 
372
{
 
373
  HVect pos;
 
374
/*  HMatrix RotMat;
 
375
  gdouble a,b,c; */
 
376
 
 
377
  switch (event->type)
 
378
    {
 
379
      case GDK_EXPOSE:
 
380
 
 
381
        /* Is this the first exposure? */
 
382
        /* =========================== */
 
383
 
 
384
        if (!gc)
 
385
          {
 
386
            gc = gdk_gc_new (area->window);
 
387
            draw_preview_image (TRUE);
 
388
          }
 
389
        else
 
390
          {
 
391
            draw_preview_image (FALSE);
 
392
            if (mapvals.showgrid == 1 && linetab[0].x1 != -1)
 
393
              draw_preview_wireframe ();
 
394
          }
 
395
        break;
 
396
 
 
397
      case GDK_ENTER_NOTIFY:
 
398
        break;
 
399
 
 
400
      case GDK_LEAVE_NOTIFY:
 
401
        break;
 
402
 
 
403
      case GDK_BUTTON_PRESS:
 
404
        light_hit = check_light_hit (event->button.x, event->button.y);
 
405
        if (light_hit == FALSE)
 
406
          {
 
407
            pos.x = -(2.0 * (gdouble) event->button.x /
 
408
                      (gdouble) PREVIEW_WIDTH - 1.0);
 
409
            pos.y = (2.0 * (gdouble) event->button.y /
 
410
                     (gdouble) PREVIEW_HEIGHT - 1.0);
 
411
            /*ArcBall_Mouse(pos);
 
412
            ArcBall_BeginDrag(); */
 
413
          }
 
414
        left_button_pressed = TRUE;
 
415
        break;
 
416
 
 
417
      case GDK_BUTTON_RELEASE:
 
418
        if (light_hit == TRUE)
 
419
          {
 
420
            draw_preview_image (TRUE);
 
421
          }
 
422
        else
 
423
          {
 
424
            pos.x = -(2.0 * (gdouble) event->button.x /
 
425
                      (gdouble) PREVIEW_WIDTH - 1.0);
 
426
            pos.y = (2.0 * (gdouble) event->button.y /
 
427
                     (gdouble) PREVIEW_HEIGHT - 1.0);
 
428
            /*ArcBall_Mouse(pos);
 
429
            ArcBall_EndDrag(); */
 
430
          }
 
431
        left_button_pressed = FALSE;
 
432
        break;
 
433
 
 
434
      case GDK_MOTION_NOTIFY:
 
435
        if (left_button_pressed == TRUE)
 
436
          {
 
437
            if (light_hit == TRUE)
 
438
              {
 
439
                update_light (event->motion.x, event->motion.y);
 
440
                update_light_pos_entries ();
 
441
              }
 
442
            else
 
443
              {
 
444
                pos.x = -(2.0 * (gdouble) event->motion.x /
 
445
                          (gdouble) PREVIEW_WIDTH - 1.0);
 
446
                pos.y = (2.0 * (gdouble) event->motion.y /
 
447
                         (gdouble) PREVIEW_HEIGHT - 1.0);
 
448
/*                ArcBall_Mouse(pos);
 
449
                ArcBall_Update();
 
450
                ArcBall_Values(&a,&b,&c);
 
451
                Alpha+=RadToDeg(-a);
 
452
                Beta+RadToDeg(-b);
 
453
                Gamma+=RadToDeg(-c);
 
454
                if (Alpha>180) Alpha-=360;
 
455
                if (Alpha<-180) Alpha+=360;
 
456
                if (Beta>180) Beta-=360;
 
457
                if (Beta<-180) Beta+=360;
 
458
                if (Gamma>180) Gamma-=360;
 
459
                if (Gamma<-180) Gamma+=360;
 
460
                  UpdateAngleSliders(); */
 
461
              }
 
462
          }
 
463
        break;
 
464
 
 
465
      default:
 
466
        break;
 
467
    }
 
468
 
 
469
  return FALSE;
 
470
}
 
471
 
 
472
/*******************************/
 
473
/* Create general options page */
 
474
/*******************************/
 
475
 
 
476
static GtkWidget *
 
477
create_options_page (void)
 
478
{
 
479
  GtkWidget *page;
 
480
  GtkWidget *frame;
 
481
  GtkWidget *vbox;
 
482
  GtkWidget *hbox;
 
483
  GtkWidget *label;
 
484
  GtkWidget *combo;
 
485
  GtkWidget *ebox;
 
486
  GtkWidget *toggle;
 
487
  GtkWidget *table;
 
488
  GtkWidget *spinbutton;
 
489
  GtkObject *adj;
 
490
 
 
491
  page = gtk_vbox_new (FALSE, 12);
 
492
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
493
 
 
494
  /* General options */
 
495
 
 
496
  frame = gimp_frame_new (_("General options"));
 
497
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
498
  gtk_widget_show (frame);
 
499
 
 
500
  vbox = gtk_vbox_new (FALSE, 6);
 
501
  gtk_container_add (GTK_CONTAINER (frame), vbox);
 
502
  gtk_widget_show (vbox);
 
503
 
 
504
  hbox = gtk_hbox_new (FALSE, 6);
 
505
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
506
  gtk_widget_show (hbox);
 
507
 
 
508
  label = gtk_label_new (_("Map to:"));
 
509
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
510
  gtk_widget_show (label);
 
511
 
 
512
  combo = gimp_int_combo_box_new (_("Plane"),    MAP_PLANE,
 
513
                                  _("Sphere"),   MAP_SPHERE,
 
514
                                  _("Box"),      MAP_BOX,
 
515
                                  _("Cylinder"), MAP_CYLINDER,
 
516
                                  NULL);
 
517
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), mapvals.maptype);
 
518
 
 
519
  g_signal_connect (combo, "changed",
 
520
                    G_CALLBACK (mapmenu_callback),
 
521
                    &mapvals.maptype);
 
522
 
 
523
  ebox = gtk_event_box_new ();
 
524
  gtk_container_add (GTK_CONTAINER (ebox), combo);
 
525
  gtk_widget_show (combo);
 
526
 
 
527
  gtk_box_pack_start (GTK_BOX (hbox), ebox, TRUE, TRUE, 0);
 
528
  gtk_widget_show (ebox);
 
529
 
 
530
  gimp_help_set_help_data (ebox, _("Type of object to map to"), NULL);
 
531
 
 
532
  toggle = gtk_check_button_new_with_label (_("Transparent background"));
 
533
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
 
534
                                mapvals.transparent_background);
 
535
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
 
536
  gtk_widget_show (toggle);
 
537
 
 
538
  g_signal_connect (toggle, "toggled",
 
539
                    G_CALLBACK (toggle_update),
 
540
                    &mapvals.transparent_background);
 
541
 
 
542
  gimp_help_set_help_data (toggle,
 
543
                           _("Make image transparent outside object"), NULL);
 
544
 
 
545
  toggle = gtk_check_button_new_with_label (_("Tile source image"));
 
546
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
 
547
                                mapvals.tiled);
 
548
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
 
549
  gtk_widget_show (toggle);
 
550
 
 
551
  g_signal_connect (toggle, "toggled",
 
552
                    G_CALLBACK (toggle_update),
 
553
                    &mapvals.tiled);
 
554
 
 
555
  gimp_help_set_help_data (toggle,
 
556
                           _("Tile source image: useful for infinite planes"),
 
557
                           NULL);
 
558
 
 
559
  toggle = gtk_check_button_new_with_label (_("Create new image"));
 
560
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
 
561
                                mapvals.create_new_image);
 
562
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
 
563
  gtk_widget_show (toggle);
 
564
 
 
565
  g_signal_connect (toggle, "toggled",
 
566
                    G_CALLBACK (gimp_toggle_button_update),
 
567
                    &mapvals.create_new_image);
 
568
 
 
569
  gimp_help_set_help_data (toggle,
 
570
                           _("Create a new image when applying filter"), NULL);
 
571
 
 
572
  /* Antialiasing options */
 
573
 
 
574
  frame = gimp_frame_new (NULL);
 
575
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
576
  gtk_widget_show (frame);
 
577
 
 
578
  toggle = gtk_check_button_new_with_mnemonic (_("Enable _antialiasing"));
 
579
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
 
580
                                mapvals.antialiasing);
 
581
  gtk_frame_set_label_widget (GTK_FRAME (frame), toggle);
 
582
  gtk_widget_show (toggle);
 
583
 
 
584
  gimp_help_set_help_data (toggle,
 
585
                           _("Enable/disable jagged edges removal "
 
586
                             "(antialiasing)"), NULL);
 
587
 
 
588
  g_signal_connect (toggle, "toggled",
 
589
                    G_CALLBACK (gimp_toggle_button_update),
 
590
                    &mapvals.antialiasing);
 
591
 
 
592
  table = gtk_table_new (2, 3, FALSE);
 
593
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
594
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
595
  gtk_container_add (GTK_CONTAINER (frame), table);
 
596
  gtk_widget_show (table);
 
597
 
 
598
  gtk_widget_set_sensitive (table, mapvals.antialiasing);
 
599
  g_object_set_data (G_OBJECT (toggle), "set_sensitive", table);
 
600
 
 
601
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
 
602
                              _("_Depth:"), 0, 0,
 
603
                              mapvals.maxdepth, 1.0, 5.0, 0.1, 1.0,
 
604
                              1, TRUE, 0, 0,
 
605
                              _("Antialiasing quality. Higher is better, "
 
606
                               "but slower"), NULL);
 
607
  g_signal_connect (adj, "value_changed",
 
608
                    G_CALLBACK (gimp_double_adjustment_update),
 
609
                    &mapvals.maxdepth);
 
610
 
 
611
  spinbutton = gimp_spin_button_new (&adj, mapvals.pixeltreshold,
 
612
                                     0.001, 1000, 0.1, 1, 1, 0, 3);
 
613
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
614
                             _("_Threshold:"), 0.0, 0.5,
 
615
                             spinbutton, 1, TRUE);
 
616
 
 
617
  g_signal_connect (adj, "value_changed",
 
618
                    G_CALLBACK (gimp_double_adjustment_update),
 
619
                    &mapvals.pixeltreshold);
 
620
 
 
621
  gimp_help_set_help_data (spinbutton,
 
622
                           _("Stop when pixel differences are smaller than "
 
623
                             "this value"), NULL);
 
624
 
 
625
  gtk_widget_show (page);
 
626
 
 
627
  return page;
 
628
}
 
629
 
 
630
/******************************/
 
631
/* Create light settings page */
 
632
/******************************/
 
633
 
 
634
static GtkWidget *
 
635
create_light_page (void)
 
636
{
 
637
  GtkWidget *page;
 
638
  GtkWidget *frame;
 
639
  GtkWidget *table;
 
640
  GtkWidget *combo;
 
641
  GtkWidget *ebox;
 
642
  GtkWidget *colorbutton;
 
643
  GtkWidget *spinbutton;
 
644
  GtkObject *adj;
 
645
 
 
646
  page = gtk_vbox_new (FALSE, 12);
 
647
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
648
 
 
649
  frame = gimp_frame_new (_("Light Settings"));
 
650
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
651
  gtk_widget_show (frame);
 
652
 
 
653
  table = gtk_table_new (2, 2, FALSE);
 
654
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
655
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
656
  gtk_container_add (GTK_CONTAINER (frame), table);  gtk_widget_show (table);
 
657
 
 
658
  combo = gimp_int_combo_box_new (_("Point light"),       POINT_LIGHT,
 
659
                                  _("Directional light"), DIRECTIONAL_LIGHT,
 
660
                                  _("No light"),          NO_LIGHT,
 
661
                                  NULL);
 
662
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
 
663
                                 mapvals.lightsource.type);
 
664
 
 
665
  g_signal_connect (combo, "changed",
 
666
                    G_CALLBACK (lightmenu_callback),
 
667
                    &mapvals.lightsource.type);
 
668
 
 
669
  ebox = gtk_event_box_new ();
 
670
  gtk_container_add (GTK_CONTAINER (ebox), combo);
 
671
  gtk_widget_show (combo);
 
672
 
 
673
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
 
674
                             _("Lightsource type:"), 0.0, 0.5,
 
675
                             ebox, 1, FALSE);
 
676
 
 
677
  gimp_help_set_help_data (ebox, _("Type of light source to apply"), NULL);
 
678
 
 
679
  colorbutton = gimp_color_button_new (_("Select lightsource color"),
 
680
                                       64, 16,
 
681
                                       &mapvals.lightsource.color,
 
682
                                       GIMP_COLOR_AREA_FLAT);
 
683
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
684
                             _("Lightsource color:"), 0.0, 0.5,
 
685
                             colorbutton, 1, FALSE);
 
686
 
 
687
  g_signal_connect (colorbutton, "color_changed",
 
688
                    G_CALLBACK (gimp_color_button_get_color),
 
689
                    &mapvals.lightsource.color);
 
690
 
 
691
  gimp_help_set_help_data (colorbutton,
 
692
                           _("Set light source color"), NULL);
 
693
 
 
694
  pointlightwid = gimp_frame_new (_("Position"));
 
695
  gtk_box_pack_start (GTK_BOX (page), pointlightwid, FALSE, FALSE, 0);
 
696
 
 
697
  if (mapvals.lightsource.type == POINT_LIGHT)
 
698
    gtk_widget_show (pointlightwid);
 
699
 
 
700
  table = gtk_table_new (3, 2, FALSE);
 
701
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
702
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
703
  gtk_container_add (GTK_CONTAINER (pointlightwid), table);
 
704
  gtk_widget_show (table);
 
705
 
 
706
  spinbutton = gimp_spin_button_new (&xadj, mapvals.lightsource.position.x,
 
707
                                     -G_MAXFLOAT, G_MAXFLOAT,
 
708
                                     0.1, 1.0, 1.0, 0.0, 2);
 
709
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
 
710
                             _("X:"), 0.0, 0.5,
 
711
                             spinbutton, 1, TRUE);
 
712
 
 
713
  g_signal_connect (xadj, "value_changed",
 
714
                    G_CALLBACK (gimp_double_adjustment_update),
 
715
                    &mapvals.lightsource.position.x);
 
716
 
 
717
  gimp_help_set_help_data (spinbutton,
 
718
                           _("Light source X position in XYZ space"), NULL);
 
719
 
 
720
  spinbutton = gimp_spin_button_new (&yadj, mapvals.lightsource.position.y,
 
721
                                     -G_MAXFLOAT, G_MAXFLOAT,
 
722
                                     0.1, 1.0, 1.0, 0.0, 2);
 
723
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
724
                             _("Y:"), 0.0, 0.5,
 
725
                             spinbutton, 1, TRUE);
 
726
 
 
727
  g_signal_connect (yadj, "value_changed",
 
728
                    G_CALLBACK (gimp_double_adjustment_update),
 
729
                    &mapvals.lightsource.position.y);
 
730
 
 
731
  gimp_help_set_help_data (spinbutton,
 
732
                           _("Light source Y position in XYZ space"), NULL);
 
733
 
 
734
  spinbutton = gimp_spin_button_new (&zadj, mapvals.lightsource.position.z,
 
735
                                     -G_MAXFLOAT, G_MAXFLOAT,
 
736
                                     0.1, 1.0, 1.0, 0.0, 2);
 
737
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
 
738
                             _("Z:"), 0.0, 0.5,
 
739
                             spinbutton, 1, TRUE);
 
740
 
 
741
  g_signal_connect (zadj, "value_changed",
 
742
                    G_CALLBACK (gimp_double_adjustment_update),
 
743
                    &mapvals.lightsource.position.z);
 
744
 
 
745
  gimp_help_set_help_data (spinbutton,
 
746
                           _("Light source Z position in XYZ space"), NULL);
 
747
 
 
748
 
 
749
  dirlightwid = gimp_frame_new (_("Direction Vector"));
 
750
  gtk_box_pack_start (GTK_BOX (page), dirlightwid, FALSE, FALSE, 0);
 
751
 
 
752
  if (mapvals.lightsource.type == DIRECTIONAL_LIGHT)
 
753
    gtk_widget_show (dirlightwid);
 
754
 
 
755
  table = gtk_table_new (3, 2, FALSE);
 
756
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
757
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
758
  gtk_container_add (GTK_CONTAINER (dirlightwid), table);
 
759
  gtk_widget_show (table);
 
760
 
 
761
  spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.x,
 
762
                                     -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
 
763
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
 
764
                             _("X:"), 0.0, 0.5,
 
765
                             spinbutton, 1, TRUE);
 
766
 
 
767
  g_signal_connect (adj, "value_changed",
 
768
                    G_CALLBACK (gimp_double_adjustment_update),
 
769
                    &mapvals.lightsource.direction.x);
 
770
 
 
771
  gimp_help_set_help_data (spinbutton,
 
772
                           _("Light source X direction in XYZ space"), NULL);
 
773
 
 
774
  spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.y,
 
775
                                     -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
 
776
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
777
                             _("Y:"), 0.0, 0.5,
 
778
                             spinbutton, 1, TRUE);
 
779
 
 
780
  g_signal_connect (adj, "value_changed",
 
781
                    G_CALLBACK (gimp_double_adjustment_update),
 
782
                    &mapvals.lightsource.direction.y);
 
783
 
 
784
  gimp_help_set_help_data (spinbutton,
 
785
                           _("Light source Y direction in XYZ space"), NULL);
 
786
 
 
787
  spinbutton = gimp_spin_button_new (&adj, mapvals.lightsource.direction.z,
 
788
                                     -1.0, 1.0, 0.01, 0.1, 1.0, 0.0, 2);
 
789
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
 
790
                             _("Z:"), 0.0, 0.5,
 
791
                             spinbutton, 1, TRUE);
 
792
 
 
793
  g_signal_connect (adj, "value_changed",
 
794
                    G_CALLBACK (gimp_double_adjustment_update),
 
795
                    &mapvals.lightsource.direction.z);
 
796
 
 
797
  gimp_help_set_help_data (spinbutton,
 
798
                           _("Light source Z direction in XYZ space"), NULL);
 
799
 
 
800
  gtk_widget_show (page);
 
801
 
 
802
  return page;
 
803
}
 
804
 
 
805
/*********************************/
 
806
/* Create material settings page */
 
807
/*********************************/
 
808
 
 
809
static GtkWidget *
 
810
create_material_page (void)
 
811
{
 
812
  GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
813
  GtkWidget    *page;
 
814
  GtkWidget    *frame;
 
815
  GtkWidget    *table;
 
816
  GtkWidget    *label;
 
817
  GtkWidget    *hbox;
 
818
  GtkWidget    *spinbutton;
 
819
  GtkWidget    *image;
 
820
  GtkObject    *adj;
 
821
 
 
822
  page = gtk_vbox_new (FALSE, 12);
 
823
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
824
 
 
825
  frame = gimp_frame_new (_("Intensity Levels"));
 
826
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
827
  gtk_widget_show (frame);
 
828
 
 
829
  hbox = gtk_hbox_new (FALSE, 6);
 
830
  gtk_container_add (GTK_CONTAINER (frame), hbox);
 
831
  gtk_widget_show (hbox);
 
832
 
 
833
  table = gtk_table_new (2, 4, FALSE);
 
834
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
835
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
836
  gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
 
837
  gtk_widget_show (table);
 
838
 
 
839
  /* Ambient intensity */
 
840
 
 
841
  image = gtk_image_new_from_stock (STOCK_INTENSITY_AMBIENT_LOW,
 
842
                                    GTK_ICON_SIZE_BUTTON);
 
843
  label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
 
844
                                     _("Ambient:"), 0.0, 0.5,
 
845
                                     image, 1, FALSE);
 
846
  gtk_size_group_add_widget (group, label);
 
847
 
 
848
  spinbutton = gimp_spin_button_new (&adj, mapvals.material.ambient_int,
 
849
                                     0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
 
850
  gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 0, 1,
 
851
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
852
  gtk_widget_show (spinbutton);
 
853
 
 
854
  g_signal_connect (adj, "value_changed",
 
855
                    G_CALLBACK (gimp_double_adjustment_update),
 
856
                    &mapvals.material.ambient_int);
 
857
 
 
858
  gimp_help_set_help_data (spinbutton,
 
859
                           _("Amount of original color to show where no "
 
860
                             "direct light falls"), NULL);
 
861
 
 
862
  image = gtk_image_new_from_stock (STOCK_INTENSITY_AMBIENT_HIGH,
 
863
                                    GTK_ICON_SIZE_BUTTON);
 
864
  gtk_table_attach (GTK_TABLE (table), image, 3, 4, 0, 1,
 
865
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
866
  gtk_widget_show (image);
 
867
 
 
868
  /* Diffuse intensity */
 
869
 
 
870
  image = gtk_image_new_from_stock (STOCK_INTENSITY_DIFFUSE_LOW,
 
871
                                    GTK_ICON_SIZE_BUTTON);
 
872
  label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
873
                                     _("Diffuse:"), 0.0, 0.5,
 
874
                                     image, 1, FALSE);
 
875
  gtk_size_group_add_widget (group, label);
 
876
 
 
877
  spinbutton = gimp_spin_button_new (&adj, mapvals.material.diffuse_int,
 
878
                                     0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
 
879
  gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 1, 2,
 
880
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
881
  gtk_widget_show (spinbutton);
 
882
 
 
883
  g_signal_connect (adj, "value_changed",
 
884
                    G_CALLBACK (gimp_double_adjustment_update),
 
885
                    &mapvals.material.diffuse_int);
 
886
 
 
887
  gimp_help_set_help_data (spinbutton,
 
888
                           _("Intensity of original color when lit by a light "
 
889
                             "source"), NULL);
 
890
 
 
891
  image = gtk_image_new_from_stock (STOCK_INTENSITY_DIFFUSE_HIGH,
 
892
                                    GTK_ICON_SIZE_BUTTON);
 
893
  gtk_table_attach (GTK_TABLE (table), image, 3, 4, 1, 2,
 
894
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
895
  gtk_widget_show (image);
 
896
 
 
897
  frame = gimp_frame_new (_("Reflectivity"));
 
898
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
899
  gtk_widget_show (frame);
 
900
 
 
901
  hbox = gtk_hbox_new (FALSE, 6);
 
902
  gtk_container_add (GTK_CONTAINER (frame), hbox);
 
903
  gtk_widget_show (hbox);
 
904
 
 
905
  table = gtk_table_new (3, 4, FALSE);
 
906
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
907
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
908
  gtk_box_pack_start (GTK_BOX (hbox), table, FALSE, FALSE, 0);
 
909
  gtk_widget_show (table);
 
910
 
 
911
  /* Diffuse reflection */
 
912
 
 
913
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_DIFFUSE_LOW,
 
914
                                    GTK_ICON_SIZE_BUTTON);
 
915
  label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
 
916
                                     _("Diffuse:"), 0.0, 0.5,
 
917
                                     image, 1, FALSE);
 
918
  gtk_size_group_add_widget (group, label);
 
919
 
 
920
  spinbutton = gimp_spin_button_new (&adj, mapvals.material.diffuse_ref,
 
921
                                     0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
 
922
  gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 0, 1,
 
923
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
924
  gtk_widget_show (spinbutton);
 
925
 
 
926
  g_signal_connect (adj, "value_changed",
 
927
                    G_CALLBACK (gimp_double_adjustment_update),
 
928
                    &mapvals.material.diffuse_ref);
 
929
 
 
930
  gimp_help_set_help_data (spinbutton,
 
931
                           _("Higher values makes the object reflect more "
 
932
                             "light (appear lighter)"), NULL);
 
933
 
 
934
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_DIFFUSE_HIGH,
 
935
                                    GTK_ICON_SIZE_BUTTON);
 
936
  gtk_table_attach (GTK_TABLE (table), image, 3, 4, 0, 1,
 
937
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
938
  gtk_widget_show (image);
 
939
 
 
940
  /* Specular reflection */
 
941
 
 
942
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_SPECULAR_LOW,
 
943
                                    GTK_ICON_SIZE_BUTTON);
 
944
  label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
 
945
                                     _("Specular:"), 0.0, 0.5,
 
946
                                     image, 1, FALSE);
 
947
  gtk_size_group_add_widget (group, label);
 
948
 
 
949
  spinbutton = gimp_spin_button_new (&adj, mapvals.material.specular_ref,
 
950
                                     0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
 
951
  gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 1, 2,
 
952
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
953
  gtk_widget_show (spinbutton);
 
954
 
 
955
  g_signal_connect (adj, "value_changed",
 
956
                    G_CALLBACK (gimp_double_adjustment_update),
 
957
                    &mapvals.material.specular_ref);
 
958
 
 
959
  gimp_help_set_help_data (spinbutton,
 
960
                           _("Controls how intense the highlights will be"),
 
961
                           NULL);
 
962
 
 
963
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_SPECULAR_HIGH,
 
964
                                    GTK_ICON_SIZE_BUTTON);
 
965
  gtk_table_attach (GTK_TABLE (table), image, 3, 4, 1, 2,
 
966
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
967
  gtk_widget_show (image);
 
968
 
 
969
  /* Highlight */
 
970
 
 
971
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_HIGHLIGHT_LOW,
 
972
                                    GTK_ICON_SIZE_BUTTON);
 
973
  label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
 
974
                                     _("Highlight:"), 0.0, 0.5,
 
975
                                     image, 1, FALSE);
 
976
  gtk_size_group_add_widget (group, label);
 
977
 
 
978
  spinbutton = gimp_spin_button_new (&adj, mapvals.material.highlight,
 
979
                                     0, G_MAXFLOAT, 0.1, 1.0, 1.0, 0.0, 2);
 
980
  gtk_table_attach (GTK_TABLE (table), spinbutton, 2, 3, 2, 3,
 
981
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
982
  gtk_widget_show (spinbutton);
 
983
 
 
984
  g_signal_connect (adj, "value_changed",
 
985
                    G_CALLBACK (gimp_double_adjustment_update),
 
986
                    &mapvals.material.highlight);
 
987
 
 
988
  gimp_help_set_help_data (spinbutton,
 
989
                           _("Higher values makes the highlights more focused"),
 
990
                           NULL);
 
991
 
 
992
  image = gtk_image_new_from_stock (STOCK_REFLECTIVITY_HIGHLIGHT_HIGH,
 
993
                                    GTK_ICON_SIZE_BUTTON);
 
994
  gtk_table_attach (GTK_TABLE (table), image, 3, 4, 2, 3,
 
995
                    GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
 
996
  gtk_widget_show (image);
 
997
 
 
998
  gtk_widget_show (page);
 
999
 
 
1000
  g_object_unref (group);
 
1001
 
 
1002
  return page;
 
1003
}
 
1004
 
 
1005
/****************************************/
 
1006
/* Create orientation and position page */
 
1007
/****************************************/
 
1008
 
 
1009
static GtkWidget *
 
1010
create_orientation_page (void)
 
1011
{
 
1012
  GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
1013
  GtkWidget    *page;
 
1014
  GtkWidget    *frame;
 
1015
  GtkWidget    *table;
 
1016
  GtkObject    *adj;
 
1017
 
 
1018
  page = gtk_vbox_new (FALSE, 12);
 
1019
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
1020
 
 
1021
  frame = gimp_frame_new (_("Position"));
 
1022
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
1023
  gtk_widget_show (frame);
 
1024
 
 
1025
  table = gtk_table_new (3, 3, FALSE);
 
1026
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
1027
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
1028
  gtk_container_add (GTK_CONTAINER (frame), table);
 
1029
  gtk_widget_show (table);
 
1030
 
 
1031
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
 
1032
                              _("X:"), 0, 0,
 
1033
                              mapvals.position.x, -1.0, 2.0, 0.01, 0.1, 5,
 
1034
                              TRUE, 0, 0,
 
1035
                              _("Object X position in XYZ space"), NULL);
 
1036
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1037
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1038
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.01, 5);
 
1039
 
 
1040
  g_signal_connect (adj, "value_changed",
 
1041
                    G_CALLBACK (double_adjustment_update),
 
1042
                    &mapvals.position.x);
 
1043
 
 
1044
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
 
1045
                              _("Y:"), 0, 0,
 
1046
                              mapvals.position.y, -1.0, 2.0, 0.01, 0.1, 5,
 
1047
                              TRUE, 0, 0,
 
1048
                              _("Object Y position in XYZ space"), NULL);
 
1049
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1050
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1051
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.01, 5);
 
1052
 
 
1053
  g_signal_connect (adj, "value_changed",
 
1054
                    G_CALLBACK (double_adjustment_update),
 
1055
                    &mapvals.position.y);
 
1056
 
 
1057
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
 
1058
                              _("Z:"), 0, 0,
 
1059
                              mapvals.position.z, -1.0, 2.0, 0.01, 0.1, 5,
 
1060
                              TRUE, 0, 0,
 
1061
                              _("Object Z position in XYZ space"), NULL);
 
1062
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1063
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1064
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.01, 5);
 
1065
 
 
1066
  g_signal_connect (adj, "value_changed",
 
1067
                    G_CALLBACK (double_adjustment_update),
 
1068
                    &mapvals.position.z);
 
1069
 
 
1070
  frame = gimp_frame_new (_("Rotation"));
 
1071
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
1072
  gtk_widget_show (frame);
 
1073
 
 
1074
  table = gtk_table_new (3, 3, FALSE);
 
1075
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
1076
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
1077
  gtk_container_add (GTK_CONTAINER (frame), table);
 
1078
  gtk_widget_show (table);
 
1079
 
 
1080
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
 
1081
                              _("X:"), 0, 0,
 
1082
                              mapvals.alpha, -180.0, 180.0, 1.0, 15.0, 1,
 
1083
                              TRUE, 0, 0,
 
1084
                              _("Rotation angle about X axis"), NULL);
 
1085
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1086
 
 
1087
  g_signal_connect (adj, "value_changed",
 
1088
                    G_CALLBACK (double_adjustment_update),
 
1089
                    &mapvals.alpha);
 
1090
 
 
1091
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
 
1092
                              _("Y:"), 0, 0,
 
1093
                              mapvals.beta, -180.0, 180.0, 1.0, 15.0, 1,
 
1094
                              TRUE, 0, 0,
 
1095
                              _("Rotation angle about Y axis"), NULL);
 
1096
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1097
 
 
1098
  g_signal_connect (adj, "value_changed",
 
1099
                    G_CALLBACK (double_adjustment_update),
 
1100
                    &mapvals.beta);
 
1101
 
 
1102
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
 
1103
                              _("Z:"), 0, 0,
 
1104
                              mapvals.gamma, -180.0, 180.0, 1.0, 15.0, 1,
 
1105
                              TRUE, 0, 0,
 
1106
                              _("Rotation angle about Z axis"), NULL);
 
1107
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_SPINBUTTON (adj));
 
1108
 
 
1109
  g_signal_connect (adj, "value_changed",
 
1110
                    G_CALLBACK (double_adjustment_update),
 
1111
                    &mapvals.gamma);
 
1112
 
 
1113
  gtk_widget_show (page);
 
1114
 
 
1115
  g_object_unref (group);
 
1116
 
 
1117
  return page;
 
1118
}
 
1119
 
 
1120
static GtkWidget *
 
1121
create_box_page (void)
 
1122
{
 
1123
  GtkWidget *page;
 
1124
  GtkWidget *frame;
 
1125
  GtkWidget *vbox;
 
1126
  GtkWidget *table;
 
1127
  GtkObject *adj;
 
1128
  gint       i;
 
1129
 
 
1130
  static gchar *labels[] =
 
1131
  {
 
1132
    N_("Front:"), N_("Back:"),
 
1133
    N_("Top:"),   N_("Bottom:"),
 
1134
    N_("Left:"),  N_("Right:")
 
1135
  };
 
1136
 
 
1137
  page = gtk_vbox_new (FALSE, 12);
 
1138
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
1139
 
 
1140
  frame = gimp_frame_new (_("Map Images to Box Faces"));
 
1141
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
1142
  gtk_widget_show (frame);
 
1143
 
 
1144
  vbox = gtk_vbox_new (FALSE, 12);
 
1145
  gtk_container_add (GTK_CONTAINER (frame), vbox);
 
1146
  gtk_widget_show (vbox);
 
1147
 
 
1148
  table = gtk_table_new (6, 2, FALSE);
 
1149
  gtk_table_set_row_spacings (GTK_TABLE(table), 6);
 
1150
  gtk_table_set_col_spacings (GTK_TABLE(table), 6);
 
1151
  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 5);
 
1152
  gtk_widget_show (table);
 
1153
 
 
1154
  for (i = 0; i < 6; i++)
 
1155
    {
 
1156
      GtkWidget *combo;
 
1157
 
 
1158
      combo = gimp_drawable_combo_box_new (box_constrain, NULL);
 
1159
      gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
 
1160
                                  mapvals.boxmap_id[i],
 
1161
                                  G_CALLBACK (gimp_int_combo_box_get_active),
 
1162
                                  &mapvals.boxmap_id[i]);
 
1163
 
 
1164
      gimp_table_attach_aligned (GTK_TABLE (table), 0, i,
 
1165
                                 gettext (labels[i]), 0.0, 0.5,
 
1166
                                 combo, 1, FALSE);
 
1167
    }
 
1168
 
 
1169
  /* Scale scales */
 
1170
 
 
1171
  table = gtk_table_new (3, 3, FALSE);
 
1172
  gtk_table_set_row_spacings (GTK_TABLE(table), 6);
 
1173
  gtk_table_set_col_spacings (GTK_TABLE(table), 6);
 
1174
  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
 
1175
  gtk_widget_show (table);
 
1176
 
 
1177
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
 
1178
                              _("Scale X:"), 0, 0,
 
1179
                              mapvals.scale.x, 0.0, 5.0, 0.01, 0.1, 2,
 
1180
                              TRUE, 0, 0,
 
1181
                              _("X scale (size)"), NULL);
 
1182
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1183
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.1, 2);
 
1184
 
 
1185
  g_signal_connect (adj, "value_changed",
 
1186
                    G_CALLBACK (double_adjustment_update),
 
1187
                    &mapvals.scale.x);
 
1188
 
 
1189
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
 
1190
                              _("Y:"), 0, 0,
 
1191
                              mapvals.scale.y, 0.0, 5.0, 0.01, 0.1, 2,
 
1192
                              TRUE, 0, 0,
 
1193
                              _("Y scale (size)"), NULL);
 
1194
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1195
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.1, 2);
 
1196
 
 
1197
  g_signal_connect (adj, "value_changed",
 
1198
                    G_CALLBACK (double_adjustment_update),
 
1199
                    &mapvals.scale.y);
 
1200
 
 
1201
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
 
1202
                              _("Z:"), 0, 0,
 
1203
                              mapvals.scale.z, 0.0, 5.0, 0.01, 0.1, 2,
 
1204
                              TRUE, 0, 0,
 
1205
                              _("Z scale (size)"), NULL);
 
1206
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1207
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.1, 2);
 
1208
 
 
1209
  g_signal_connect (adj, "value_changed",
 
1210
                    G_CALLBACK (double_adjustment_update),
 
1211
                    &mapvals.scale.z);
 
1212
 
 
1213
  gtk_widget_show (page);
 
1214
 
 
1215
  return page;
 
1216
}
 
1217
 
 
1218
static GtkWidget *
 
1219
create_cylinder_page (void)
 
1220
{
 
1221
  GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
1222
  GtkWidget    *page;
 
1223
  GtkWidget    *frame;
 
1224
  GtkWidget    *table;
 
1225
  GtkObject    *adj;
 
1226
  gint          i;
 
1227
 
 
1228
  static gchar *labels[] = { N_("_Top:"), N_("_Bottom:") };
 
1229
 
 
1230
  page = gtk_vbox_new (FALSE, 12);
 
1231
  gtk_container_set_border_width (GTK_CONTAINER (page), 12);
 
1232
 
 
1233
  frame = gimp_frame_new (_("Images for the Cap Faces"));
 
1234
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
1235
  gtk_widget_show (frame);
 
1236
 
 
1237
  table = gtk_table_new (2, 2, FALSE);
 
1238
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
1239
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
1240
  gtk_container_add (GTK_CONTAINER (frame), table);
 
1241
  gtk_widget_show (table);
 
1242
 
 
1243
  /* Option menus */
 
1244
 
 
1245
  for (i = 0; i < 2; i++)
 
1246
    {
 
1247
      GtkWidget *combo;
 
1248
      GtkWidget *label;
 
1249
 
 
1250
      combo = gimp_drawable_combo_box_new (cylinder_constrain, NULL);
 
1251
      gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
 
1252
                                  mapvals.cylindermap_id[i],
 
1253
                                  G_CALLBACK (gimp_int_combo_box_get_active),
 
1254
                                  &mapvals.cylindermap_id[i]);
 
1255
 
 
1256
      label = gimp_table_attach_aligned (GTK_TABLE (table), 0, i,
 
1257
                                         gettext (labels[i]), 0.0, 0.5,
 
1258
                                         combo, 1, FALSE);
 
1259
      gtk_size_group_add_widget (group, label);
 
1260
    }
 
1261
 
 
1262
  frame = gimp_frame_new (_("Size"));
 
1263
  gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
 
1264
  gtk_widget_show (frame);
 
1265
 
 
1266
  table = gtk_table_new (2, 3, FALSE);
 
1267
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
 
1268
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
 
1269
  gtk_container_add (GTK_CONTAINER (frame), table);
 
1270
  gtk_widget_show (table);
 
1271
 
 
1272
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
 
1273
                              _("R_adius:"), 0, 0,
 
1274
                              mapvals.cylinder_radius,
 
1275
                              0.0, 2.0, 0.01, 0.1, 2,
 
1276
                              TRUE, 0, 0,
 
1277
                              _("Cylinder radius"), NULL);
 
1278
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
 
1279
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1280
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.1, 2);
 
1281
 
 
1282
  g_signal_connect (adj, "value_changed",
 
1283
                    G_CALLBACK (double_adjustment_update),
 
1284
                    &mapvals.cylinder_radius);
 
1285
 
 
1286
  adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
 
1287
                              _("L_ength:"), 0, 0,
 
1288
                              mapvals.cylinder_length,
 
1289
                              0.0, 2.0, 0.01, 0.1, 2,
 
1290
                              TRUE, 0, 0,
 
1291
                              _("Cylinder length"), NULL);
 
1292
  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
 
1293
  gtk_spin_button_configure (GIMP_SCALE_ENTRY_SPINBUTTON (adj),
 
1294
                             GIMP_SCALE_ENTRY_SPINBUTTON_ADJ (adj), 0.1, 2);
 
1295
 
 
1296
  g_signal_connect (adj, "value_changed",
 
1297
                    G_CALLBACK (double_adjustment_update),
 
1298
                    &mapvals.cylinder_length);
 
1299
 
 
1300
  gtk_widget_show (page);
 
1301
 
 
1302
  g_object_unref (group);
 
1303
 
 
1304
  return page;
 
1305
}
 
1306
 
 
1307
/****************************/
 
1308
/* Create notbook and pages */
 
1309
/****************************/
 
1310
 
 
1311
static void
 
1312
create_main_notebook (GtkWidget *container)
 
1313
{
 
1314
  GtkWidget *page;
 
1315
 
 
1316
  options_note_book = GTK_NOTEBOOK (gtk_notebook_new ());
 
1317
  gtk_container_add (GTK_CONTAINER (container),
 
1318
                     GTK_WIDGET (options_note_book));
 
1319
 
 
1320
  page = create_options_page ();
 
1321
  gtk_notebook_append_page (options_note_book, page,
 
1322
                            gtk_label_new_with_mnemonic (_("O_ptions")));
 
1323
 
 
1324
  page = create_light_page ();
 
1325
  gtk_notebook_append_page (options_note_book, page,
 
1326
                            gtk_label_new_with_mnemonic (_("_Light")));
 
1327
 
 
1328
  page = create_material_page ();
 
1329
  gtk_notebook_append_page (options_note_book, page,
 
1330
                            gtk_label_new_with_mnemonic (_("_Material")));
 
1331
 
 
1332
  page = create_orientation_page ();
 
1333
  gtk_notebook_append_page (options_note_book, page,
 
1334
                            gtk_label_new_with_mnemonic (_("O_rientation")));
 
1335
 
 
1336
  if (mapvals.maptype == MAP_BOX)
 
1337
    {
 
1338
      box_page = create_box_page ();
 
1339
      gtk_notebook_append_page (options_note_book, box_page,
 
1340
                                gtk_label_new_with_mnemonic (_("_Box")));
 
1341
    }
 
1342
  else if (mapvals.maptype == MAP_CYLINDER)
 
1343
    {
 
1344
      cylinder_page = create_cylinder_page ();
 
1345
      gtk_notebook_append_page (options_note_book, cylinder_page,
 
1346
                                gtk_label_new_with_mnemonic (_("C_ylinder")));
 
1347
    }
 
1348
 
 
1349
  gtk_widget_show (GTK_WIDGET (options_note_book));
 
1350
}
 
1351
 
 
1352
/********************************/
 
1353
/* Create and show main dialog. */
 
1354
/********************************/
 
1355
 
 
1356
gboolean
 
1357
main_dialog (GimpDrawable *drawable)
 
1358
{
 
1359
  GtkWidget *main_hbox;
 
1360
  GtkWidget *vbox;
 
1361
  GtkWidget *hbox;
 
1362
  GtkWidget *frame;
 
1363
  GtkWidget *button;
 
1364
  GtkWidget *image;
 
1365
  GtkWidget *toggle;
 
1366
  gboolean   run = FALSE;
 
1367
 
 
1368
  gimp_ui_init ("MapObject", FALSE);
 
1369
 
 
1370
  appwin = gimp_dialog_new (_("Map to Object"), "MapObject",
 
1371
                            NULL, 0,
 
1372
                            gimp_standard_help_func, "plug-in-map-object",
 
1373
 
 
1374
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
1375
                            GTK_STOCK_OK,     GTK_RESPONSE_OK,
 
1376
 
 
1377
                            NULL);
 
1378
 
 
1379
  main_hbox = gtk_hbox_new (FALSE, 12);
 
1380
  gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
 
1381
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (appwin)->vbox), main_hbox,
 
1382
                      FALSE, FALSE, 0);
 
1383
  gtk_widget_show (main_hbox);
 
1384
 
 
1385
  /* Create the Preview */
 
1386
 
 
1387
  vbox = gtk_vbox_new (FALSE, 6);
 
1388
  gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
 
1389
  gtk_widget_show (vbox);
 
1390
 
 
1391
  /* Add preview widget and various buttons to the first part */
 
1392
 
 
1393
  frame = gtk_frame_new (NULL);
 
1394
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
 
1395
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
1396
  gtk_widget_show (frame);
 
1397
 
 
1398
  gtk_widget_realize (appwin);
 
1399
  previewarea = gtk_drawing_area_new ();
 
1400
  gtk_widget_set_size_request (previewarea, PREVIEW_WIDTH, PREVIEW_HEIGHT);
 
1401
  gtk_widget_set_events (previewarea, (GDK_EXPOSURE_MASK |
 
1402
                                       GDK_BUTTON1_MOTION_MASK |
 
1403
                                       GDK_BUTTON_PRESS_MASK |
 
1404
                                       GDK_BUTTON_RELEASE_MASK));
 
1405
  gtk_container_add (GTK_CONTAINER (frame), previewarea);
 
1406
  gtk_widget_show (previewarea);
 
1407
 
 
1408
  g_signal_connect (previewarea, "event",
 
1409
                    G_CALLBACK (preview_events),
 
1410
                    previewarea);
 
1411
 
 
1412
  hbox = gtk_hbox_new (FALSE, 6);
 
1413
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
1414
  gtk_widget_show (hbox);
 
1415
 
 
1416
  button = gtk_button_new_with_mnemonic (_("_Preview!"));
 
1417
  gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
 
1418
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
1419
  gtk_widget_show (button);
 
1420
 
 
1421
  g_signal_connect (button, "clicked",
 
1422
                    G_CALLBACK (preview_callback),
 
1423
                    NULL);
 
1424
 
 
1425
  gimp_help_set_help_data (button, _("Recompute preview image"), NULL);
 
1426
 
 
1427
  button = gtk_button_new ();
 
1428
  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
1429
  gtk_widget_show (button);
 
1430
 
 
1431
  image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU);
 
1432
  gtk_container_add (GTK_CONTAINER (button), image);
 
1433
  gtk_widget_show (image);
 
1434
 
 
1435
  g_signal_connect (button, "clicked",
 
1436
                    G_CALLBACK (zoomout_callback),
 
1437
                    NULL);
 
1438
 
 
1439
  gimp_help_set_help_data (button, _("Zoom out (make image smaller)"), NULL);
 
1440
 
 
1441
  button = gtk_button_new ();
 
1442
  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
1443
  gtk_widget_show (button);
 
1444
 
 
1445
  image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU);
 
1446
  gtk_container_add (GTK_CONTAINER (button), image);
 
1447
  gtk_widget_show (image);
 
1448
 
 
1449
  g_signal_connect (button, "clicked",
 
1450
                    G_CALLBACK (zoomin_callback),
 
1451
                    NULL);
 
1452
 
 
1453
  gimp_help_set_help_data (button, _("Zoom in (make image bigger)"), NULL);
 
1454
 
 
1455
  toggle = gtk_check_button_new_with_mnemonic (_("Show preview _wireframe"));
 
1456
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), mapvals.showgrid);
 
1457
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
 
1458
  gtk_widget_show (toggle);
 
1459
 
 
1460
  g_signal_connect (toggle, "toggled",
 
1461
                    G_CALLBACK (togglegrid_update),
 
1462
                    &mapvals.showgrid);
 
1463
 
 
1464
  gimp_help_set_help_data (toggle, _("Show/hide preview wireframe"), NULL);
 
1465
 
 
1466
  create_main_notebook (main_hbox);
 
1467
 
 
1468
  /* Endmarkers for line table */
 
1469
 
 
1470
  linetab[0].x1 = -1;
 
1471
 
 
1472
  gtk_widget_show (appwin);
 
1473
 
 
1474
  {
 
1475
    GdkCursor *cursor;
 
1476
 
 
1477
    cursor = gdk_cursor_new_for_display (gtk_widget_get_display (previewarea),
 
1478
                                         GDK_HAND2);
 
1479
    gdk_window_set_cursor (previewarea->window, cursor);
 
1480
    gdk_cursor_unref (cursor);
 
1481
  }
 
1482
 
 
1483
  image_setup (drawable, TRUE);
 
1484
 
 
1485
  if (gimp_dialog_run (GIMP_DIALOG (appwin)) == GTK_RESPONSE_OK)
 
1486
    run = TRUE;
 
1487
 
 
1488
  gtk_widget_destroy (appwin);
 
1489
  g_free (preview_rgb_data);
 
1490
 
 
1491
  return run;
 
1492
}