← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gimp/vivid

« back to all changes in this revision

Viewing changes to plug-ins/common/file-gif-save.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-08 18:50:03 UTC
  • mto: (1.1.26) (0.5.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 71.
  • Revision ID: package-import@ubuntu.com-20120508185003-tltkvbaysf8d2426
Import upstream version 2.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/common/file-gif-save.c
41
41
 
42
42
#define SAVE_PROC      "file-gif-save"
43
43
#define PLUG_IN_BINARY "file-gif-save"
 
44
#define PLUG_IN_ROLE   "gimp-file-gif-save"
44
45
 
45
46
 
46
47
/* Define only one of these to determine which kind of gif's you would like.
63
64
 
64
65
enum
65
66
{
 
67
  DISPOSE_STORE_VALUE_COLUMN,
 
68
  DISPOSE_STORE_LABEL_COLUMN
 
69
};
 
70
 
 
71
enum
 
72
{
66
73
  DISPOSE_UNSPECIFIED,
67
74
  DISPOSE_COMBINE,
68
75
  DISPOSE_REPLACE
77
84
  gint     default_dispose;
78
85
  gboolean always_use_default_delay;
79
86
  gboolean always_use_default_dispose;
 
87
  gboolean as_animation;
80
88
} GIFSaveVals;
81
89
 
82
90
 
131
139
  100,     /* default_delay between frames (100ms) */
132
140
  0,       /* default_dispose = "don't care"       */
133
141
  FALSE,   /* don't always use default_delay       */
134
 
  FALSE    /* don't always use default_dispose     */
 
142
  FALSE,   /* don't always use default_dispose     */
 
143
  FALSE    /* as_animation                         */
135
144
};
136
145
 
137
146
 
142
151
{
143
152
  static const GimpParamDef save_args[] =
144
153
  {
145
 
    { GIMP_PDB_INT32,    "run-mode",        "Interactive, non-interactive" },
 
154
    { GIMP_PDB_INT32,    "run-mode",        "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
146
155
    { GIMP_PDB_IMAGE,    "image",           "Image to save" },
147
156
    { GIMP_PDB_DRAWABLE, "drawable",        "Drawable to save" },
148
157
    { GIMP_PDB_STRING,   "filename",        "The name of the file to save the image in" },
208
217
      drawable_ID = param[2].data.d_int32;
209
218
      filename    = param[3].data.d_string;
210
219
 
211
 
      /*  eventually export the image */
212
 
      switch (run_mode)
213
 
        {
214
 
        case GIMP_RUN_INTERACTIVE:
215
 
        case GIMP_RUN_WITH_LAST_VALS:
216
 
          gimp_ui_init (PLUG_IN_BINARY, FALSE);
217
 
 
218
 
          export = gimp_export_image (&image_ID, &drawable_ID, "GIF",
219
 
                                      (GIMP_EXPORT_CAN_HANDLE_INDEXED |
220
 
                                       GIMP_EXPORT_CAN_HANDLE_GRAY |
221
 
                                       GIMP_EXPORT_CAN_HANDLE_ALPHA  |
222
 
                                       GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION));
223
 
          if (export == GIMP_EXPORT_CANCEL)
224
 
            {
225
 
              values[0].data.d_status = GIMP_PDB_CANCEL;
226
 
              return;
227
 
            }
228
 
          break;
229
 
        default:
230
 
          break;
231
 
        }
 
220
      if (run_mode == GIMP_RUN_INTERACTIVE ||
 
221
          run_mode == GIMP_RUN_WITH_LAST_VALS)
 
222
        gimp_ui_init (PLUG_IN_BINARY, FALSE);
232
223
 
233
224
      status = sanity_check (filename, image_ID, &error);
234
225
 
 
226
      /* Get the export options */
235
227
      if (status == GIMP_PDB_SUCCESS)
236
228
        {
237
229
          switch (run_mode)
269
261
            default:
270
262
              break;
271
263
            }
272
 
 
273
 
          if (status == GIMP_PDB_SUCCESS)
274
 
            {
275
 
              if (save_image (param[3].data.d_string,
276
 
                              image_ID, drawable_ID, orig_image_ID,
277
 
                              &error))
278
 
                {
279
 
                  /*  Store psvals data  */
280
 
                  gimp_set_data (SAVE_PROC, &gsvals, sizeof (GIFSaveVals));
281
 
                }
282
 
              else
283
 
                {
284
 
                  status = GIMP_PDB_EXECUTION_ERROR;
285
 
                }
 
264
        }
 
265
 
 
266
      /* Create an exportable image based on the export options */
 
267
      switch (run_mode)
 
268
        {
 
269
        case GIMP_RUN_INTERACTIVE:
 
270
        case GIMP_RUN_WITH_LAST_VALS:
 
271
          {
 
272
            GimpExportCapabilities capabilities =
 
273
              GIMP_EXPORT_CAN_HANDLE_INDEXED |
 
274
              GIMP_EXPORT_CAN_HANDLE_GRAY |
 
275
              GIMP_EXPORT_CAN_HANDLE_ALPHA;
 
276
 
 
277
            if (gsvals.as_animation)
 
278
              capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS;
 
279
 
 
280
            export = gimp_export_image (&image_ID, &drawable_ID, NULL,
 
281
                                        capabilities);
 
282
 
 
283
            if (export == GIMP_EXPORT_CANCEL)
 
284
              {
 
285
                values[0].data.d_status = GIMP_PDB_CANCEL;
 
286
                return;
 
287
              }
 
288
          }
 
289
          break;
 
290
        default:
 
291
          break;
 
292
        }
 
293
 
 
294
      /* Write the image to file */
 
295
      if (status == GIMP_PDB_SUCCESS)
 
296
        {
 
297
          if (save_image (param[3].data.d_string,
 
298
                          image_ID, drawable_ID, orig_image_ID,
 
299
                          &error))
 
300
            {
 
301
              /*  Store psvals data  */
 
302
              gimp_set_data (SAVE_PROC, &gsvals, sizeof (GIFSaveVals));
 
303
            }
 
304
          else
 
305
            {
 
306
              status = GIMP_PDB_EXECUTION_ERROR;
286
307
            }
287
308
        }
288
309
 
654
675
                                            GIMP_PARASITE_PERSISTENT,
655
676
                                            strlen (globalcomment) + 1,
656
677
                                            (void*) globalcomment);
657
 
      gimp_image_parasite_attach (orig_image_ID, comment_parasite);
 
678
      gimp_image_attach_parasite (orig_image_ID, comment_parasite);
658
679
      gimp_parasite_free (comment_parasite);
659
680
      comment_parasite = NULL;
660
681
    }
882
903
        {
883
904
          if (i > 0 && ! gsvals.always_use_default_dispose)
884
905
            {
885
 
              layer_name = gimp_drawable_get_name (layers[i - 1]);
 
906
              layer_name = gimp_item_get_name (layers[i - 1]);
886
907
              Disposal = parse_disposal_tag (layer_name);
887
908
              g_free (layer_name);
888
909
            }
891
912
              Disposal = gsvals.default_dispose;
892
913
            }
893
914
 
894
 
          layer_name = gimp_drawable_get_name (layers[i]);
 
915
          layer_name = gimp_item_get_name (layers[i]);
895
916
          Delay89 = parse_ms_tag (layer_name);
896
917
          g_free (layer_name);
897
918
 
921
942
                                          get_pixel);
922
943
        }
923
944
 
924
 
     gif_encode_image_data (outfile, cols, rows,
925
 
                            (rows > 4) ? gsvals.interlace : 0,
926
 
                            useBPP,
927
 
                            get_pixel,
928
 
                            offset_x, offset_y);
929
 
 
930
 
     gimp_drawable_detach (drawable);
931
 
 
932
 
     g_free (pixels);
933
 
  }
 
945
      gif_encode_image_data (outfile, cols, rows,
 
946
                             (rows > 4) ? gsvals.interlace : 0,
 
947
                             useBPP,
 
948
                             get_pixel,
 
949
                             offset_x, offset_y);
 
950
      gimp_progress_update (1.0);
 
951
 
 
952
      gimp_drawable_detach (drawable);
 
953
 
 
954
      g_free (pixels);
 
955
    }
934
956
 
935
957
  g_free(layers);
936
958
 
979
1001
  return crop;
980
1002
}
981
1003
 
 
1004
static GtkWidget *
 
1005
file_gif_toggle_button_init (GtkBuilder  *builder,
 
1006
                             const gchar *name,
 
1007
                             gboolean     initial_value,
 
1008
                             gboolean    *value_pointer)
 
1009
{
 
1010
  GtkWidget *toggle = NULL;
 
1011
 
 
1012
  toggle = GTK_WIDGET (gtk_builder_get_object (builder, name));
 
1013
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), initial_value);
 
1014
  g_signal_connect (toggle, "toggled",
 
1015
                    G_CALLBACK (gimp_toggle_button_update),
 
1016
                    value_pointer);
 
1017
 
 
1018
  return toggle;
 
1019
}
 
1020
 
 
1021
static GtkWidget *
 
1022
file_gif_spin_button_int_init (GtkBuilder  *builder,
 
1023
                               const gchar *name,
 
1024
                               int          initial_value,
 
1025
                               int         *value_pointer)
 
1026
{
 
1027
  GtkWidget     *spin_button = NULL;
 
1028
  GtkAdjustment *adjustment  = NULL;
 
1029
 
 
1030
  spin_button = GTK_WIDGET (gtk_builder_get_object (builder, name));
 
1031
 
 
1032
  adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin_button));
 
1033
  gtk_adjustment_set_value (adjustment, initial_value);
 
1034
  g_signal_connect (adjustment, "value-changed",
 
1035
                    G_CALLBACK (gimp_int_adjustment_update),
 
1036
                    &gsvals.default_delay);
 
1037
 
 
1038
  return spin_button;
 
1039
}
 
1040
 
 
1041
static void
 
1042
file_gif_combo_box_int_update_value (GtkComboBox *combo,
 
1043
                                     gint        *value)
 
1044
{
 
1045
  GtkTreeIter iter;
 
1046
 
 
1047
  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
 
1048
    {
 
1049
      gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combo)),
 
1050
                          &iter,
 
1051
                          DISPOSE_STORE_VALUE_COLUMN, value,
 
1052
                          -1);
 
1053
    }
 
1054
}
 
1055
 
 
1056
static GtkWidget *
 
1057
file_gif_combo_box_int_init (GtkBuilder  *builder,
 
1058
                             const gchar *name,
 
1059
                             int          initial_value,
 
1060
                             int         *value_pointer,
 
1061
                             const gchar *first_label,
 
1062
                             gint         first_value,
 
1063
                             ...)
 
1064
{
 
1065
  GtkWidget    *combo  = NULL;
 
1066
  GtkListStore *store  = NULL;
 
1067
  const gchar  *label  = NULL;
 
1068
  gint          value  = 0;
 
1069
  GtkTreeIter   iter   = { 0, };
 
1070
  va_list       values;
 
1071
 
 
1072
  combo = GTK_WIDGET (gtk_builder_get_object (builder, name));
 
1073
  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo)));
 
1074
 
 
1075
  /* Populate */
 
1076
  va_start (values, first_value);
 
1077
  for (label = first_label, value = first_value;
 
1078
       label;
 
1079
       label = va_arg (values, const gchar *), value = va_arg (values, gint))
 
1080
    {
 
1081
      gtk_list_store_append (store, &iter);
 
1082
      gtk_list_store_set (store, &iter,
 
1083
                          DISPOSE_STORE_VALUE_COLUMN, value,
 
1084
                          DISPOSE_STORE_LABEL_COLUMN, label,
 
1085
                          -1);
 
1086
    }
 
1087
  va_end (values);
 
1088
 
 
1089
  /* Set initial value */
 
1090
  gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store),
 
1091
                                 &iter,
 
1092
                                 NULL,
 
1093
                                 initial_value);
 
1094
  gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);
 
1095
 
 
1096
  /* Arrange update of value */
 
1097
  g_signal_connect (combo, "changed",
 
1098
                    G_CALLBACK (file_gif_combo_box_int_update_value),
 
1099
                    value_pointer);
 
1100
 
 
1101
  return combo;
 
1102
}
982
1103
 
983
1104
static gint
984
1105
save_dialog (gint32 image_ID)
985
1106
{
 
1107
  GtkBuilder    *builder = NULL;
 
1108
  gchar         *ui_file = NULL;
 
1109
  GError        *error   = NULL;
986
1110
  GtkWidget     *dialog;
987
 
  GtkWidget     *main_vbox;
988
 
  GtkWidget     *toggle;
989
 
  GtkWidget     *label;
990
 
  GtkWidget     *spinbutton;
991
 
  GtkObject     *adj;
992
1111
  GtkWidget     *text_view;
993
1112
  GtkTextBuffer *text_buffer;
 
1113
  GtkWidget     *toggle;
994
1114
  GtkWidget     *frame;
995
 
  GtkWidget     *vbox;
996
 
  GtkWidget     *hbox;
997
 
  GtkWidget     *align;
998
 
  GtkWidget     *combo;
999
 
  GtkWidget     *scrolled_window;
1000
1115
#ifdef FACEHUGGERS
1001
1116
  GimpParasite  *GIF2_CMNT;
1002
1117
#endif
1003
1118
  gint32         nlayers;
 
1119
  gboolean       animation_supported = FALSE;
1004
1120
  gboolean       run;
1005
1121
 
1006
1122
  gimp_image_get_layers (image_ID, &nlayers);
1007
 
 
1008
 
  dialog = gimp_dialog_new (_("Save as GIF"), PLUG_IN_BINARY,
1009
 
                            NULL, 0,
1010
 
                            gimp_standard_help_func, SAVE_PROC,
1011
 
 
1012
 
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1013
 
                            GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
1014
 
 
1015
 
                            NULL);
1016
 
 
1017
 
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
1018
 
                                           GTK_RESPONSE_OK,
1019
 
                                           GTK_RESPONSE_CANCEL,
1020
 
                                           -1);
1021
 
 
1022
 
  gimp_window_set_transient (GTK_WINDOW (dialog));
1023
 
 
1024
 
  main_vbox = gtk_vbox_new (FALSE, 12);
1025
 
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
1026
 
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
1027
 
  gtk_widget_show (main_vbox);
 
1123
  animation_supported = nlayers > 1;
 
1124
 
 
1125
  dialog = gimp_export_dialog_new (_("GIF"), PLUG_IN_BINARY, SAVE_PROC);
 
1126
 
 
1127
  /* GtkBuilder init */
 
1128
  builder = gtk_builder_new ();
 
1129
  ui_file = g_build_filename (gimp_data_directory (),
 
1130
                              "ui/plug-ins/plug-in-file-gif.ui",
 
1131
                              NULL);
 
1132
  if (! gtk_builder_add_from_file (builder, ui_file, &error))
 
1133
    g_printerr (_("Error loading UI file '%s':\n%s"),
 
1134
                ui_file, error ? error->message : "???");
 
1135
  g_free (ui_file);
 
1136
 
 
1137
  /* Main vbox */
 
1138
  gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
 
1139
                      GTK_WIDGET (gtk_builder_get_object (builder, "main-vbox")),
 
1140
                      TRUE, TRUE, 0);
1028
1141
 
1029
1142
  /*  regular gif parameter settings  */
1030
 
  frame = gimp_frame_new (_("GIF Options"));
1031
 
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
1032
 
 
1033
 
  vbox = gtk_vbox_new (FALSE, 6);
1034
 
  gtk_container_add (GTK_CONTAINER (frame), vbox);
1035
 
 
1036
 
  toggle = gtk_check_button_new_with_mnemonic (_("I_nterlace"));
1037
 
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
1038
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gsvals.interlace);
1039
 
  gtk_widget_show (toggle);
1040
 
 
1041
 
  g_signal_connect (toggle, "toggled",
1042
 
                    G_CALLBACK (gimp_toggle_button_update),
1043
 
                    &gsvals.interlace);
1044
 
 
1045
 
  hbox = gtk_hbox_new (FALSE, 6);
1046
 
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
1047
 
 
1048
 
  align = gtk_alignment_new (0.0, 0.0, 0, 0);
1049
 
  gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0);
1050
 
  gtk_widget_show (align);
1051
 
 
1052
 
  toggle = gtk_check_button_new_with_mnemonic (_("_GIF comment:"));
1053
 
  gtk_container_add (GTK_CONTAINER (align), toggle);
1054
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
1055
 
                                gsvals.save_comment);
1056
 
  gtk_widget_show (toggle);
1057
 
 
1058
 
  g_signal_connect (toggle, "toggled",
1059
 
                    G_CALLBACK (gimp_toggle_button_update),
1060
 
                    &gsvals.save_comment);
1061
 
 
1062
 
  /* the comment text_view in a gtk_scrolled_window */
1063
 
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1064
 
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
1065
 
                                       GTK_SHADOW_IN);
1066
 
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1067
 
                                  GTK_POLICY_AUTOMATIC,
1068
 
                                  GTK_POLICY_AUTOMATIC);
1069
 
  gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0);
1070
 
  gtk_widget_show (scrolled_window);
1071
 
 
1072
 
  text_buffer = gtk_text_buffer_new (NULL);
1073
 
 
1074
 
  text_view = gtk_text_view_new_with_buffer (text_buffer);
1075
 
  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
1076
 
  gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
1077
 
  gtk_widget_show (text_view);
1078
 
 
1079
 
  g_object_unref (text_buffer);
 
1143
  file_gif_toggle_button_init (builder, "interlace",
 
1144
                               gsvals.interlace, &gsvals.interlace);
 
1145
  file_gif_toggle_button_init (builder, "save-comment",
 
1146
                               gsvals.save_comment, &gsvals.save_comment);
 
1147
  file_gif_toggle_button_init (builder, "as-animation",
 
1148
                               gsvals.as_animation, &gsvals.as_animation);
 
1149
 
 
1150
  text_view   = GTK_WIDGET (gtk_builder_get_object (builder, "comment"));
 
1151
  text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
1080
1152
 
1081
1153
  if (globalcomment)
1082
1154
    g_free (globalcomment);
1083
1155
 
1084
1156
#ifdef FACEHUGGERS
1085
 
  GIF2_CMNT = gimp_image_parasite_find (image_ID, "gimp-comment");
 
1157
  GIF2_CMNT = gimp_image_get_parasite (image_ID, "gimp-comment");
1086
1158
  if (GIF2_CMNT)
1087
1159
    globalcomment = g_strndup (gimp_parasite_data (GIF2_CMNT),
1088
1160
                               gimp_parasite_data_size (GIF2_CMNT));
1101
1173
                    G_CALLBACK (comment_entry_callback),
1102
1174
                    NULL);
1103
1175
 
1104
 
  gtk_widget_show (hbox);
1105
 
 
1106
 
  gtk_widget_show (vbox);
1107
 
  gtk_widget_show (frame);
1108
 
 
1109
1176
  /*  additional animated gif parameter settings  */
1110
 
  frame = gimp_frame_new (_("Animated GIF Options"));
1111
 
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
1112
 
 
1113
 
  vbox = gtk_vbox_new (FALSE, 6);
1114
 
  gtk_container_add (GTK_CONTAINER (frame), vbox);
1115
 
 
1116
 
  toggle = gtk_check_button_new_with_mnemonic (_("_Loop forever"));
1117
 
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
1118
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gsvals.loop);
1119
 
  gtk_widget_show (toggle);
1120
 
 
1121
 
  g_signal_connect (toggle, "toggled",
1122
 
                    G_CALLBACK (gimp_toggle_button_update),
1123
 
                    &gsvals.loop);
 
1177
  file_gif_toggle_button_init (builder, "loop-forever",
 
1178
                               gsvals.loop, &gsvals.loop);
1124
1179
 
1125
1180
  /* default_delay entry field */
1126
 
  hbox = gtk_hbox_new (FALSE, 6);
1127
 
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1128
 
 
1129
 
  label = gtk_label_new_with_mnemonic (_("_Delay between frames where unspecified:"));
1130
 
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1131
 
  gtk_widget_show (label);
1132
 
 
1133
 
  spinbutton = gimp_spin_button_new (&adj, gsvals.default_delay,
1134
 
                                     0, 65000, 10, 100, 0, 1, 0);
1135
 
  gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
1136
 
  gtk_widget_show (spinbutton);
1137
 
 
1138
 
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
1139
 
 
1140
 
  g_signal_connect (adj, "value-changed",
1141
 
                    G_CALLBACK (gimp_int_adjustment_update),
1142
 
                    &gsvals.default_delay);
1143
 
 
1144
 
  label = gtk_label_new (_("milliseconds"));
1145
 
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1146
 
  gtk_widget_show (label);
1147
 
 
1148
 
  gtk_widget_show (hbox);
 
1181
  file_gif_spin_button_int_init (builder, "delay-spin",
 
1182
                                 gsvals.default_delay, &gsvals.default_delay);
1149
1183
 
1150
1184
  /* Disposal selector */
1151
 
  hbox = gtk_hbox_new (FALSE, 6);
1152
 
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1153
 
 
1154
 
  label = gtk_label_new_with_mnemonic (_("_Frame disposal where unspecified:"));
1155
 
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1156
 
  gtk_widget_show (label);
1157
 
 
1158
 
  combo = gimp_int_combo_box_new (_("I don't care"),
1159
 
                                  DISPOSE_UNSPECIFIED,
1160
 
                                  _("Cumulative layers (combine)"),
1161
 
                                  DISPOSE_COMBINE,
1162
 
                                  _("One frame per layer (replace)"),
1163
 
                                  DISPOSE_REPLACE,
1164
 
                                  NULL);
1165
 
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
1166
 
                                 gsvals.default_dispose);
1167
 
 
1168
 
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
1169
 
 
1170
 
  g_signal_connect (combo, "changed",
1171
 
                    G_CALLBACK (gimp_int_combo_box_get_active),
1172
 
                    &gsvals.default_dispose);
1173
 
 
1174
 
  gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
1175
 
  gtk_widget_show (combo);
 
1185
  file_gif_combo_box_int_init (builder, "dispose-combo",
 
1186
                               gsvals.default_dispose, &gsvals.default_dispose,
 
1187
                               _("I don't care"),
 
1188
                               DISPOSE_UNSPECIFIED,
 
1189
                               _("Cumulative layers (combine)"),
 
1190
                               DISPOSE_COMBINE,
 
1191
                               _("One frame per layer (replace)"),
 
1192
                               DISPOSE_REPLACE,
 
1193
                               NULL);
1176
1194
 
1177
1195
  /* The "Always use default values" toggles */
1178
 
  toggle = gtk_check_button_new_with_mnemonic (_("_Use delay entered above for all frames"));
1179
 
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
1180
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
1181
 
                                gsvals.always_use_default_delay);
1182
 
  gtk_widget_show (toggle);
1183
 
 
1184
 
  g_signal_connect (G_OBJECT (toggle), "toggled",
1185
 
                    G_CALLBACK (gimp_toggle_button_update),
1186
 
                    &gsvals.always_use_default_delay);
1187
 
 
1188
 
  toggle = gtk_check_button_new_with_mnemonic (_("U_se disposal entered above for all frames"));
1189
 
  gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
1190
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
1191
 
                                gsvals.always_use_default_dispose);
1192
 
  gtk_widget_show (toggle);
1193
 
 
1194
 
  g_signal_connect (G_OBJECT (toggle), "toggled",
1195
 
                    G_CALLBACK (gimp_toggle_button_update),
1196
 
                    &gsvals.always_use_default_dispose);
1197
 
 
1198
 
  gtk_widget_show (hbox);
1199
 
  gtk_widget_show (vbox);
1200
 
 
1201
 
  /* If the image has only one layer it can't be animated, so
1202
 
     desensitize the animation options. */
1203
 
 
1204
 
  if (nlayers == 1)
1205
 
    gtk_widget_set_sensitive (frame, FALSE);
1206
 
 
1207
 
  gtk_widget_show (frame);
 
1196
  file_gif_toggle_button_init (builder, "use-default-delay",
 
1197
                               gsvals.always_use_default_delay,
 
1198
                               &gsvals.always_use_default_delay);
 
1199
  file_gif_toggle_button_init (builder, "use-default-dispose",
 
1200
                               gsvals.always_use_default_dispose,
 
1201
                               &gsvals.always_use_default_dispose);
 
1202
 
 
1203
  frame  = GTK_WIDGET (gtk_builder_get_object (builder, "animation-frame"));
 
1204
  toggle = GTK_WIDGET (gtk_builder_get_object (builder, "as-animation"));
 
1205
  gtk_widget_set_sensitive (toggle, animation_supported);
 
1206
  if (! animation_supported)
 
1207
    gimp_help_set_help_data (toggle,
 
1208
                             _("You can only export as animation when the "
 
1209
                               "image has more than one layer. The image "
 
1210
                               "you are trying to export only has one "
 
1211
                               "layer."),
 
1212
                             NULL);
 
1213
 
 
1214
  g_object_bind_property (toggle, "active",
 
1215
                          frame,  "sensitive",
 
1216
                          G_BINDING_SYNC_CREATE);
 
1217
 
1208
1218
  gtk_widget_show (dialog);
1209
1219
 
1210
1220
  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
1389
1399
{
1390
1400
  int B;
1391
1401
  int RWidth, RHeight;
1392
 
  int LeftOfs, TopOfs;
1393
1402
  int Resolution;
1394
1403
  int ColorMapSize;
1395
 
  int InitCodeSize;
1396
1404
  int i;
1397
1405
 
1398
1406
  ColorMapSize = 1 << BitsPerPixel;
1399
1407
 
1400
1408
  RWidth = Width = GWidth;
1401
1409
  RHeight = Height = GHeight;
1402
 
  LeftOfs = TopOfs = 0;
1403
1410
 
1404
1411
  Resolution = BitsPerPixel;
1405
1412
 
1414
1421
  Pass = 0;
1415
1422
 
1416
1423
  /*
1417
 
   * The initial code size
1418
 
   */
1419
 
  if (BitsPerPixel <= 1)
1420
 
    InitCodeSize = 2;
1421
 
  else
1422
 
    InitCodeSize = BitsPerPixel;
1423
 
 
1424
 
  /*
1425
1424
   * Set up the current x and y position
1426
1425
   */
1427
1426
  curx = cury = 0;
1490
1489
                                int      BitsPerPixel,
1491
1490
                                ifunptr  get_pixel)
1492
1491
{
1493
 
  int RWidth, RHeight;
1494
 
  int LeftOfs, TopOfs;
1495
 
  int Resolution;
1496
 
  int ColorMapSize;
1497
 
  int InitCodeSize;
1498
 
 
1499
 
  ColorMapSize = 1 << BitsPerPixel;
1500
 
 
1501
 
  RWidth = Width = GWidth;
1502
 
  RHeight = Height = GHeight;
1503
 
  LeftOfs = TopOfs = 0;
1504
 
 
1505
 
  Resolution = BitsPerPixel;
 
1492
  Width = GWidth;
 
1493
  Height = GHeight;
1506
1494
 
1507
1495
  /*
1508
1496
   * Calculate number of bits we are expecting
1515
1503
  Pass = 0;
1516
1504
 
1517
1505
  /*
1518
 
   * The initial code size
1519
 
   */
1520
 
  if (BitsPerPixel <= 1)
1521
 
    InitCodeSize = 2;
1522
 
  else
1523
 
    InitCodeSize = BitsPerPixel;
1524
 
 
1525
 
  /*
1526
1506
   * Set up the current x and y position
1527
1507
   */
1528
1508
  curx = cury = 0;
1570
1550
                       gint     offset_x,
1571
1551
                       gint     offset_y)
1572
1552
{
1573
 
  int RWidth, RHeight;
1574
1553
  int LeftOfs, TopOfs;
1575
 
  int Resolution;
1576
 
  int ColorMapSize;
1577
1554
  int InitCodeSize;
1578
1555
 
1579
1556
  Interlace = GInterlace;
1580
1557
 
1581
 
  ColorMapSize = 1 << BitsPerPixel;
1582
 
 
1583
 
  RWidth = Width = GWidth;
1584
 
  RHeight = Height = GHeight;
 
1558
  Width = GWidth;
 
1559
  Height = GHeight;
1585
1560
  LeftOfs = (int) offset_x;
1586
1561
  TopOfs = (int) offset_y;
1587
1562
 
1588
 
  Resolution = BitsPerPixel;
1589
 
 
1590
1563
  /*
1591
1564
   * Calculate number of bits we are expecting
1592
1565
   */
1650
1623
#if 0
1651
1624
  /***************************/
1652
1625
  Interlace = GInterlace;
1653
 
  ColorMapSize = 1 << BitsPerPixel;
1654
 
  RWidth = Width = GWidth;
1655
 
  RHeight = Height = GHeight;
 
1626
  Width = GWidth;
 
1627
  Height = GHeight;
1656
1628
  LeftOfs = TopOfs = 0;
1657
 
  Resolution = BitsPerPixel;
1658
1629
 
1659
1630
  CountDown = (long) Width *(long) Height;
1660
1631
  Pass = 0;
2406
2377
  gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter);
2407
2378
  text = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE);
2408
2379
 
2409
 
  if (strlen (text) > 240)
 
2380
#define MAX_COMMENT 240
 
2381
 
 
2382
  if (strlen (text) > MAX_COMMENT)
2410
2383
    {
2411
 
      g_message (_("The default comment is limited to %d characters."), 240);
 
2384
      /* translators: the %d is *always* 240 here */
 
2385
      g_message (_("The default comment is limited to %d characters."),
 
2386
                 MAX_COMMENT);
2412
2387
 
2413
 
      gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, 240 - 1);
 
2388
      gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, MAX_COMMENT - 1);
2414
2389
      gtk_text_buffer_get_end_iter (buffer, &end_iter);
2415
2390
 
2416
2391
      /*  this calls us recursivaly, but in the else branch