app_procs.c 16.2 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/* The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <unistd.h>

#include "appenv.h"
#include "app_procs.h"
#include "batch.h"
#include "brushes.h"
#include "color_transfer.h"
#include "curves.h"
#include "gdisplay.h"
#include "colormaps.h"
#include "fileops.h"
#include "gimprc.h"
#include "global_edit.h"
#include "gradient.h"
#include "gximage.h"
#include "hue_saturation.h"
#include "image_render.h"
#include "interface.h"
#include "internal_procs.h"
#include "layers_dialog.h"
#include "levels.h"
#include "menus.h"
#include "paint_funcs.h"
#include "palette.h"
#include "patterns.h"
#include "plug_in.h"
#include "procedural_db.h"
#include "temp_buf.h"
#include "tile_swap.h"
#include "tips_dialog.h"
#include "tools.h"
#include "undo.h"
#include "xcf.h"
56
#include <gtk/gtk.h>
Elliot Lee's avatar
Elliot Lee committed
57

58
59
60
61
62
63
64
65
66
#define LOGO_WIDTH_MIN 350
#define LOGO_HEIGHT_MIN 110 
#define NAME "The GIMP"
#define AUTHORS "brought to you by Spencer Kimball and Peter Mattis" 
 
#define SHOW_NEVER 0
#define SHOW_LATER 1
#define SHOW_NOW 2
 
Elliot Lee's avatar
Elliot Lee committed
67
68
69
/*  Function prototype for affirmation dialog when exiting application  */
static void      really_quit_dialog (void);
static Argument* quit_invoker       (Argument *args);
70
71
static void make_initialization_status_window(void);
static void destroy_initialization_status_window(void);
72
73
74
75
76
static int splash_logo_load (GtkWidget *window);
static int splash_logo_load_size (GtkWidget *window);
static void splash_logo_draw (GtkWidget *widget);
static void splash_text_draw (GtkWidget *widget);
static void splash_logo_expose (GtkWidget *widget);
Elliot Lee's avatar
Elliot Lee committed
77
78


Tim Janik's avatar
Tim Janik committed
79
80
static gint is_app_exit_finish_done = FALSE;

Elliot Lee's avatar
Elliot Lee committed
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
static ProcArg quit_args[] =
{
  { PDB_INT32,
    "kill",
    "Flag specifying whether to kill the gimp process or exit normally" },
};

static ProcRecord quit_proc =
{
  "gimp_quit",
  "Causes the gimp to exit gracefully",
  "The internal procedure which can either be used to make the gimp quit normally, or to have the gimp clean up its resources and exit immediately. The normaly shutdown process allows for querying the user to save any dirty images.",
  "Spencer Kimball & Peter Mattis",
  "Spencer Kimball & Peter Mattis",
  "1995-1996",
  PDB_INTERNAL,
  1,
  quit_args,
  0,
  NULL,
  { { quit_invoker } },
};


void
gimp_init (int    gimp_argc,
	   char **gimp_argv)
{
  /* Initialize the application */
  app_init ();

  /* Parse the rest of the command line arguments as images to load */
  if (gimp_argc > 0)
    while (gimp_argc--)
      {
	if (*gimp_argv)
	  file_open (*gimp_argv, *gimp_argv);
	gimp_argv++;
      }

  batch_init ();
}

124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

static GtkWidget *logo_area = NULL;
static GdkPixmap *logo_pixmap = NULL;
static int logo_width = 0;
static int logo_height = 0;
static int logo_area_width = 0;
static int logo_area_height = 0;
static int show_logo = SHOW_NEVER;

static int
splash_logo_load_size (GtkWidget *window)
{
  char buf[1024];
  FILE *fp;

  if (logo_pixmap)
    return TRUE;

  sprintf (buf, "%s/gimp_splash.ppm", DATADIR);

  fp = fopen (buf, "r");
  if (!fp)
    return 0;

  fgets (buf, 1024, fp);
  if (strcmp (buf, "P6\n") != 0)
    {
      fclose (fp);
      return 0;
    }

  fgets (buf, 1024, fp);
  fgets (buf, 1024, fp);
  sscanf (buf, "%d %d", &logo_width, &logo_height);

  fclose (fp);
  return TRUE;
}

static int
splash_logo_load (GtkWidget *window)
{
  GtkWidget *preview;
167
  GdkGC *gc;
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
  char buf[1024];
  unsigned char *pixelrow;
  FILE *fp;
  int count;
  int i;

  if (logo_pixmap)
    return TRUE;

  sprintf (buf, "%s/gimp_splash.ppm", DATADIR);

  fp = fopen (buf, "r");
  if (!fp)
    return 0;

  fgets (buf, 1024, fp);
  if (strcmp (buf, "P6\n") != 0)
    {
      fclose (fp);
      return 0;
    }

  fgets (buf, 1024, fp);
  fgets (buf, 1024, fp);
  sscanf (buf, "%d %d", &logo_width, &logo_height);

  fgets (buf, 1024, fp);
  if (strcmp (buf, "255\n") != 0)
    {
      fclose (fp);
      return 0;
    }

  preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  gtk_preview_size (GTK_PREVIEW (preview), logo_width, logo_height);
  pixelrow = g_new (guchar, logo_width * 3);

  for (i = 0; i < logo_height; i++)
    {
      count = fread (pixelrow, sizeof (unsigned char), logo_width * 3, fp);
      if (count != (logo_width * 3))
	{
	  gtk_widget_destroy (preview);
	  g_free (pixelrow);
	  fclose (fp);
	  return 0;
	}
      gtk_preview_draw_row (GTK_PREVIEW (preview), pixelrow, 0, i, logo_width);
    }

  gtk_widget_realize (window);
219
220
221
  logo_pixmap = gdk_pixmap_new (window->window, logo_width, logo_height,
				gtk_preview_get_visual ()->depth);
  gc = gdk_gc_new (logo_pixmap);
222
  gtk_preview_put (GTK_PREVIEW (preview),
223
		   logo_pixmap, gc,
224
		   0, 0, 0, 0, logo_width, logo_height);
225
  gdk_gc_destroy (gc);
226

227
  gtk_widget_unref (preview);
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
  g_free (pixelrow);

  fclose (fp);
  return TRUE;
}

static void
splash_text_draw (GtkWidget *widget)
{
  GdkFont *font = NULL;

  font = gdk_font_load ("-Adobe-Helvetica-Bold-R-Normal--*-140-*-*-*-*-*-*");
  gdk_draw_string (widget->window,
		   font,
		   widget->style->black_gc,
		   ((logo_area_width - gdk_string_width (font, NAME)) / 2), 
		   (0.3 * logo_area_height),
		   NAME);

  font = gdk_font_load ("-Adobe-Helvetica-Bold-R-Normal--*-120-*-*-*-*-*-*");
  gdk_draw_string (widget->window,
		   font,
		   widget->style->black_gc,
		   ((logo_area_width - gdk_string_width (font, VERSION)) / 2), 
		   (0.5 * logo_area_height),
		   VERSION);
  gdk_draw_string (widget->window,
		   font,
		   widget->style->black_gc,
		   ((logo_area_width - gdk_string_width (font, AUTHORS)) / 2), 
		   (0.7 * logo_area_height),
		   AUTHORS);
}

static void
splash_logo_draw (GtkWidget *widget)
{
  gdk_draw_pixmap (widget->window,
		   widget->style->black_gc,
		   logo_pixmap, 
		   0, 0,
		   ((logo_area_width - logo_width) / 2), ((logo_area_height - logo_height) / 2),
		   logo_width, logo_height);
}

static void
splash_logo_expose (GtkWidget *widget)
{
  switch (show_logo) {
     case SHOW_NEVER: 
     case SHOW_LATER:
       splash_text_draw (widget);
       break;
     case SHOW_NOW:
       splash_logo_draw (widget);
  }
}

286
287
288
289
290
291
292
293
294
295
296
297
static GtkWidget *win_initstatus = NULL;
static GtkWidget *label1 = NULL;
static GtkWidget *label2 = NULL;
static GtkWidget *pbar = NULL;
static gint idle_tag = -1;

static void
destroy_initialization_status_window(void)
{
  if(win_initstatus)
    {
      gtk_widget_destroy(win_initstatus);
298
299
      win_initstatus = label1 = label2 = pbar = logo_area = NULL;
      logo_pixmap = NULL;
300
301
302
303
      gtk_idle_remove(idle_tag);
    }
}

304
305
static void 
my_idle_proc(void)
306
307
308
309
310
311
312
313
{
  /* Do nothing. This is needed to stop the GIMP
     from blocking in gtk_main_iteration() */
}

static void
make_initialization_status_window(void)
{
314
  if (no_interface == FALSE)
315
    {
316
317
318
319
      get_standard_colormaps ();
      if (no_splash == FALSE)
	{
	  GtkWidget *vbox;
320

321
322
323
324
	  win_initstatus = gtk_window_new(GTK_WINDOW_DIALOG);
	  gtk_window_set_wmclass (GTK_WINDOW(win_initstatus), "gimp_startup", "Gimp");
	  gtk_window_set_title(GTK_WINDOW(win_initstatus),
		               "GIMP Startup");
325

326
327
328
329
	  if (no_splash_image == FALSE && splash_logo_load_size (win_initstatus)) 
	    {
	      show_logo = SHOW_LATER;
	    }
330

331
332
	  vbox = gtk_vbox_new(FALSE, 4);
	  gtk_container_add(GTK_CONTAINER(win_initstatus), vbox);
333

334
335
	  gtk_widget_push_visual (gtk_preview_get_visual ());
	  gtk_widget_push_colormap  (gtk_preview_get_cmap ());
336

337
	  logo_area = gtk_drawing_area_new ();
338

339
340
	  gtk_widget_pop_colormap ();
	  gtk_widget_pop_visual ();
341

342
343
344
345
346
347
	  gtk_signal_connect (GTK_OBJECT (logo_area), "expose_event",
			      (GtkSignalFunc) splash_logo_expose, NULL);
	  logo_area_width = ( logo_width > LOGO_WIDTH_MIN ) ? logo_width : LOGO_WIDTH_MIN;
	  logo_area_height = ( logo_height > LOGO_HEIGHT_MIN ) ? logo_height : LOGO_HEIGHT_MIN;
	  gtk_drawing_area_size (GTK_DRAWING_AREA (logo_area), logo_area_width, logo_area_height);
	  gtk_box_pack_start_defaults(GTK_BOX(vbox), logo_area);
348

349
350
351
352
	  label1 = gtk_label_new("");
	  gtk_box_pack_start_defaults(GTK_BOX(vbox), label1);
	  label2 = gtk_label_new("");
	  gtk_box_pack_start_defaults(GTK_BOX(vbox), label2);
353
      
354
355
	  pbar = gtk_progress_bar_new();
	  gtk_box_pack_start_defaults(GTK_BOX(vbox), pbar);
356
      
357
358
359
360
361
	  gtk_widget_show(vbox);
	  gtk_widget_show (logo_area);
	  gtk_widget_show(label1);
	  gtk_widget_show(label2);
	  gtk_widget_show(pbar);
362
      
363
364
	  gtk_window_position(GTK_WINDOW(win_initstatus),
			      GTK_WIN_POS_CENTER);
365
      
366
	  gtk_widget_show(win_initstatus);
367

368
369
	  gtk_window_set_policy (GTK_WINDOW (win_initstatus), FALSE, TRUE, FALSE);
	}
370
371
372
373
374
375
376
377
    }
}

void
app_init_update_status(char *label1val,
		       char *label2val,
		       float pct_progress)
{
378
  if(no_interface == FALSE && no_splash == FALSE && win_initstatus)
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
    {
      GdkRectangle area = {0, 0, -1, -1};
      if(label1val
	 && strcmp(label1val, GTK_LABEL(label1)->label))
	{
	  gtk_label_set(GTK_LABEL(label1), label1val);
	}
      if(label2val
	 && strcmp(label2val, GTK_LABEL(label2)->label))
	{
	  gtk_label_set(GTK_LABEL(label2), label2val);
	}
      if(pct_progress >= 0
	 && GTK_PROGRESS_BAR(pbar)->percentage != pct_progress)
	{
	  gtk_progress_bar_update(GTK_PROGRESS_BAR(pbar), pct_progress);
	}
      gtk_widget_draw(win_initstatus, &area);
Manish Singh's avatar
Manish Singh committed
397
      idle_tag = gtk_idle_add((GtkFunction) my_idle_proc, NULL);
398
399
400
401
402
403
404
405
      gtk_main_iteration();
      gtk_idle_remove(idle_tag);
    }
}

/* #define RESET_BAR() app_init_update_status("", "", 0) */
#define RESET_BAR()

Elliot Lee's avatar
Elliot Lee committed
406
407
408
409
410
411
412
void
app_init ()
{
  char filename[MAXPATHLEN];
  char *gimp_dir;
  char *path;

413
  make_initialization_status_window();
414
415
416
417
  if (no_interface == FALSE && no_splash == FALSE && win_initstatus) {
    splash_text_draw (logo_area);
  }
    
Elliot Lee's avatar
Elliot Lee committed
418
419
420
421
422
423
  /*
   *  Initialize the procedural database
   *    We need to do this first because any of the init
   *    procedures might install or query it as needed.
   */
  procedural_db_init ();
424
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
425
  internal_procs_init ();
426
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
427
428
429
430
431
432
  procedural_db_register (&quit_proc);

  gimp_dir = gimp_directory ();
  if (gimp_dir[0] != '\000')
    {
      sprintf (filename, "%s/gtkrc", gimp_dir);
433
434

      if (be_verbose == TRUE)
Elliot Lee's avatar
Elliot Lee committed
435
      g_print ("parsing \"%s\"\n", filename);
436
      app_init_update_status("Resource configuration", filename, -1);
437

Elliot Lee's avatar
Elliot Lee committed
438
439
440
      gtk_rc_parse (filename);
    }

441
442
443
444
445
446
447
448
449
450
451
452
  RESET_BAR();
  parse_gimprc ();         /*  parse the local GIMP configuration file  */

  /* Now we are ready to draw the splash-screen-image to the start-up window */
  if (no_interface == FALSE)
    {
      if (no_splash_image == FALSE && show_logo && splash_logo_load (win_initstatus)) {
	show_logo = SHOW_NOW;
	splash_logo_draw (logo_area);
      }
    }

453
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
454
  file_ops_pre_init ();    /*  pre-initialize the file types  */
455
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
456
457
458
  xcf_init ();             /*  initialize the xcf file format routines */
  if (no_data == FALSE)
    {
459
      RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
460
      brushes_init ();         /*  initialize the list of gimp brushes  */
461
      RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
462
      patterns_init ();        /*  initialize the list of gimp patterns  */
463
      RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
464
      palettes_init ();        /*  initialize the list of gimp palettes  */
465
      RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
466
467
      gradients_init ();       /*  initialize the list of gimp gradients  */
    }
468
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
469
  plug_in_init ();         /*  initialize the plug in structures  */
470
  RESET_BAR();
Elliot Lee's avatar
Elliot Lee committed
471
472
473
474
475
476
477
478
479
480
  file_ops_post_init ();   /*  post-initialize the file types  */

  /* Add the swap file  */
  if (swap_path == NULL)
    swap_path = "/tmp";
  path = g_new (gchar, strlen (swap_path) + 32);
  sprintf (path, "%s/gimpswap.%ld", swap_path, (long)getpid ());
  tile_swap_add (path, NULL, NULL);
  g_free (path);

481
482
  destroy_initialization_status_window();

Elliot Lee's avatar
Elliot Lee committed
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
  /*  Things to do only if there is an interface  */
  if (no_interface == FALSE)
    {
      create_toolbox ();
      gximage_init ();
      render_setup (transparency_type, transparency_size);
      tools_options_dialog_new ();
      tools_select (RECT_SELECT);
      if (show_tips)
	tips_dialog_create ();
    }

  color_transfer_init ();
  get_active_brush ();
  get_active_pattern ();
  paint_funcs_setup ();
499

Elliot Lee's avatar
Elliot Lee committed
500
501
}

Elliot Lee's avatar
Elliot Lee committed
502
int
Tim Janik's avatar
Tim Janik committed
503
504
505
506
507
app_exit_finish_done (void)
{
  return is_app_exit_finish_done;
}

508
void
Elliot Lee's avatar
Elliot Lee committed
509
510
app_exit_finish ()
{
Tim Janik's avatar
Tim Janik committed
511
512
513
  if (app_exit_finish_done ())
    return;
  is_app_exit_finish_done = TRUE;
514

Elliot Lee's avatar
Elliot Lee committed
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
  lc_dialog_free ();
  gdisplays_delete ();
  global_edit_free ();
  named_buffers_free ();
  swapping_free ();
  brushes_free ();
  patterns_free ();
  palettes_free ();
  gradients_free ();
  hue_saturation_free ();
  curves_free ();
  levels_free ();
  brush_select_dialog_free ();
  pattern_select_dialog_free ();
  palette_free ();
  paint_funcs_free ();
  procedural_db_free ();
  plug_in_kill ();
  menus_quit ();
  tile_swap_exit ();

  /*  Things to do only if there is an interface  */
  if (no_interface == FALSE)
    {
      gximage_free ();
      render_free ();
      tools_options_dialog_free ();
    }
543
544
  /*  gtk_exit (0); */
  gtk_main_quit();
Elliot Lee's avatar
Elliot Lee committed
545
546
547
548
549
550
551
552
}

void
app_exit (int kill_it)
{
  /*  If it's the user's perogative, and there are dirty images  */
  if (kill_it == 0 && gdisplays_dirty () && no_interface == FALSE)
    really_quit_dialog ();
Tim Janik's avatar
Tim Janik committed
553
  else if (no_interface == FALSE)
554
    toolbox_free ();
Tim Janik's avatar
Tim Janik committed
555
556
  else
    app_exit_finish ();
Elliot Lee's avatar
Elliot Lee committed
557
558
559
560
561
562
563
564
565
566
567
}

/********************************************************
 *   Routines to query exiting the application          *
 ********************************************************/

static void
really_quit_callback (GtkButton *button,
		      GtkWidget *dialog)
{
  gtk_widget_destroy (dialog);
568
  toolbox_free ();
Elliot Lee's avatar
Elliot Lee committed
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
}

static void
really_quit_cancel_callback (GtkButton *button,
			     GtkWidget *dialog)
{
  menus_set_sensitive ("<Toolbox>/File/Quit", TRUE);
  menus_set_sensitive ("<Image>/File/Quit", TRUE);
  gtk_widget_destroy (dialog);
}

static gint
really_quit_delete_callback (GtkWidget *widget,
			     GdkEvent  *event,
			     gpointer client_data) 
{
  really_quit_cancel_callback (GTK_BUTTON(widget), (GtkWidget *) client_data);

  return FALSE;
}

static void
really_quit_dialog ()
{
  GtkWidget *dialog;
  GtkWidget *button;
  GtkWidget *label;

  menus_set_sensitive ("<Toolbox>/File/Quit", FALSE);
  menus_set_sensitive ("<Image>/File/Quit", FALSE);

  dialog = gtk_dialog_new ();
601
  gtk_window_set_wmclass (GTK_WINDOW (dialog), "really_quit", "Gimp");
Elliot Lee's avatar
Elliot Lee committed
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
  gtk_window_set_title (GTK_WINDOW (dialog), "Really Quit?");
  gtk_window_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
  gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 2);

  gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
		      (GtkSignalFunc) really_quit_delete_callback,
		      dialog);
 
  button = gtk_button_new_with_label ("Yes");
  GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) really_quit_callback,
		      dialog);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE, TRUE, 0);
  gtk_widget_grab_default (button);
  gtk_widget_show (button);

  button = gtk_button_new_with_label ("No");
  GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      (GtkSignalFunc) really_quit_cancel_callback,
		      dialog);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE, TRUE, 0);
  gtk_widget_show (button);

  label = gtk_label_new ("Some files unsaved.  Quit the GIMP?");
  gtk_misc_set_padding (GTK_MISC (label), 10, 1);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, TRUE, TRUE, 0);
  gtk_widget_show (label);

  gtk_widget_show (dialog);
}

static Argument*
quit_invoker (Argument *args)
{
  Argument *return_args;
  int kill_it;

  kill_it = args[0].value.pdb_int;
  app_exit (kill_it);

  return_args = procedural_db_return_args (&quit_proc, TRUE);

  return return_args;
}