templates-commands.c 11.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "config.h"

#include <gtk/gtk.h>

#include "libgimpwidgets/gimpwidgets.h"

Michael Natterer's avatar
Michael Natterer committed
25
#include "actions-types.h"
26

27
#include "config/gimpconfig.h"
28
#include "config/gimpconfig-utils.h"
29
#include "config/gimpcoreconfig.h"
30
31

#include "core/gimp.h"
32
#include "core/gimpcontainer.h"
33
34
35
#include "core/gimpcontext.h"
#include "core/gimptemplate.h"

36
#include "widgets/gimpcontainerview.h"
37
#include "widgets/gimpdialogfactory.h"
38
#include "widgets/gimphelp-ids.h"
39
#include "widgets/gimptemplateeditor.h"
40
#include "widgets/gimptemplateview.h"
41
#include "widgets/gimpviewabledialog.h"
42

Michael Natterer's avatar
Michael Natterer committed
43
44
45
#include "gui/dialogs.h"
#include "gui/file-new-dialog.h"

46
47
#include "templates-commands.h"

48
49
#include "gimp-intl.h"

50
51
52

/*  public functions */

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
void
templates_create_image_cmd_callback (GtkAction *action,
                                     gpointer   data)
{
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContainer       *container;
  GimpContext         *context;
  GimpTemplate        *template;

  container = gimp_container_view_get_container (editor->view);
  context   = gimp_container_view_get_context (editor->view);

  template = gimp_context_get_template (context);

  if (template && gimp_container_have (container, GIMP_OBJECT (template)))
    {
      templates_file_new_dialog (context->gimp, template, GTK_WIDGET (editor));
    }
}

73
void
74
templates_new_template_cmd_callback (GtkAction *action,
75
76
                                     gpointer   data)
{
77
78
79
80
81
82
83
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContainer       *container;
  GimpContext         *context;
  GimpTemplate        *template;

  container = gimp_container_view_get_container (editor->view);
  context   = gimp_container_view_get_context (editor->view);
84

85
86
87
88
89
90
91
  template = gimp_context_get_template (context);

  if (template && gimp_container_have (container, GIMP_OBJECT (template)))
    {
    }

  templates_new_template_dialog (context->gimp, NULL, GTK_WIDGET (editor));
92
93
94
}

void
95
templates_duplicate_template_cmd_callback (GtkAction *action,
96
97
                                           gpointer   data)
{
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContainer       *container;
  GimpContext         *context;
  GimpTemplate        *template;

  container = gimp_container_view_get_container (editor->view);
  context   = gimp_container_view_get_context (editor->view);

  template = gimp_context_get_template (context);

  if (template && gimp_container_have (container, GIMP_OBJECT (template)))
    {
      GimpTemplate *new_template;

      new_template = gimp_config_duplicate (GIMP_CONFIG (template));

      gimp_container_add (container, GIMP_OBJECT (new_template));

      gimp_context_set_by_type (context, container->children_type,
                                GIMP_OBJECT (new_template));

      templates_edit_template_dialog (context->gimp, new_template,
                                      GTK_WIDGET (editor));
121

122
123
      g_object_unref (new_template);
    }
124
125
}

126
void
127
templates_edit_template_cmd_callback (GtkAction *action,
128
129
                                      gpointer   data)
{
130
131
132
133
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContainer       *container;
  GimpContext         *context;
  GimpTemplate        *template;
134

135
136
137
138
139
140
141
142
143
144
  container = gimp_container_view_get_container (editor->view);
  context   = gimp_container_view_get_context (editor->view);

  template = gimp_context_get_template (context);

  if (template && gimp_container_have (container, GIMP_OBJECT (template)))
    {
      templates_edit_template_dialog (context->gimp, template,
                                      GTK_WIDGET (editor));
    }
145
146
}

147
148
149
typedef struct _GimpTemplateDeleteData GimpTemplateDeleteData;

struct _GimpTemplateDeleteData
150
{
151
152
153
154
155
156
157
158
159
160
161
162
163
  GimpContainer *container;
  GimpTemplate  *template;
};

static void
templates_delete_template_callback (GtkWidget *widget,
                                    gboolean   delete,
                                    gpointer   data)
{
  GimpTemplateDeleteData *delete_data = data;

  if (! delete)
    return;
164

165
166
167
168
169
170
  if (gimp_container_have (delete_data->container,
			   GIMP_OBJECT (delete_data->template)))
    {
      gimp_container_remove (delete_data->container,
			     GIMP_OBJECT (delete_data->template));
    }
171
172
173
}

void
174
templates_delete_template_cmd_callback (GtkAction *action,
175
176
                                        gpointer   data)
{
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
  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
  GimpContainer       *container;
  GimpContext         *context;
  GimpTemplate        *template;

  container = gimp_container_view_get_container (editor->view);
  context   = gimp_container_view_get_context (editor->view);

  template = gimp_context_get_template (context);

  if (template && gimp_container_have (container, GIMP_OBJECT (template)))
    {
      GimpTemplateDeleteData *delete_data;
      GtkWidget              *dialog;
      gchar                  *str;

      delete_data = g_new0 (GimpTemplateDeleteData, 1);

      delete_data->container = container;
      delete_data->template  = template;

      str = g_strdup_printf (_("Are you sure you want to delete template '%s' "
                               "from the list and from disk?"),
			     GIMP_OBJECT (template)->name);

      dialog = gimp_query_boolean_box (_("Delete Template"),
                                       GTK_WIDGET (editor),
				       gimp_standard_help_func, NULL,
				       GIMP_STOCK_QUESTION,
				       str,
				       GTK_STOCK_DELETE, GTK_STOCK_CANCEL,
				       G_OBJECT (template),
				       "disconnect",
				       templates_delete_template_callback,
				       delete_data);

      g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) g_free, delete_data);

      g_free (str);
216

217
218
      gtk_widget_show (dialog);
    }
219
}
220
221

static void
222
223
224
templates_new_template_response (GtkWidget *widget,
                                 gint       response_id,
                                 GtkWidget *dialog)
225
{
226
227
228
229
  if (response_id == GTK_RESPONSE_OK)
    {
      GimpTemplate *template;
      Gimp         *gimp;
230

231
232
      template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
      gimp     = g_object_get_data (G_OBJECT (dialog), "gimp");
233

234
235
236
      gimp_container_add (gimp->templates, GIMP_OBJECT (template));
      gimp_context_set_template (gimp_get_user_context (gimp), template);
    }
237
238
239
240
241

  gtk_widget_destroy (dialog);
}

void
242
templates_new_template_dialog (Gimp         *gimp,
243
244
                               GimpTemplate *unused,
                               GtkWidget    *parent)
245
246
247
248
249
250
{
  GimpTemplate *template;
  GtkWidget    *dialog;
  GtkWidget    *main_vbox;
  GtkWidget    *editor;

251
  dialog = gimp_viewable_dialog_new (NULL,
252
                                     _("New Template"), "gimp-template-new",
253
254
                                     GIMP_STOCK_TEMPLATE,
                                     _("Create a New Template"),
255
                                     parent,
256
257
                                     gimp_standard_help_func,
                                     GIMP_HELP_TEMPLATE_NEW,
258

259
260
                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                     GTK_STOCK_OK,     GTK_RESPONSE_OK,
261

262
                                     NULL);
263

264
265
266
  g_signal_connect (dialog, "response",
                    G_CALLBACK (templates_new_template_response),
                    dialog);
267

268
269
  main_vbox = gtk_vbox_new (FALSE, 12);
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
270
271
272
273
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox,
                      TRUE, TRUE, 0);
  gtk_widget_show (main_vbox);

274
275
  template = gimp_config_duplicate (GIMP_CONFIG (gimp->config->default_image));
  gimp_object_set_name (GIMP_OBJECT (template), _("Unnamed"));
276

277
  editor = gimp_template_editor_new (template, gimp, TRUE);
278

279
280
281
282
  g_object_unref (template);

  g_object_set_data (G_OBJECT (dialog), "gimp",          gimp);
  g_object_set_data (G_OBJECT (dialog), "gimp-template", template);
283

284
285
  gtk_box_pack_start (GTK_BOX (main_vbox), editor, FALSE, FALSE, 0);
  gtk_widget_show (editor);
286
287
288
289
290

  gtk_widget_show (dialog);
}

static void
291
292
293
templates_edit_template_response (GtkWidget *widget,
                                  gint       response_id,
                                  GtkWidget *dialog)
294
{
295
296
297
298
299
  if (response_id == GTK_RESPONSE_OK)
    {
      GimpTemplateEditor *editor;
      GimpTemplate       *template;
      Gimp               *gimp;
300

301
302
303
      editor   = g_object_get_data (G_OBJECT (dialog), "gimp-template-editor");
      template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
      gimp     = g_object_get_data (G_OBJECT (dialog), "gimp");
304

305
306
307
      gimp_config_sync (GIMP_CONFIG (editor->template),
                        GIMP_CONFIG (template), 0);
    }
308
309
310
311
312
313

  gtk_widget_destroy (dialog);
}

void
templates_edit_template_dialog (Gimp         *gimp,
314
315
                                GimpTemplate *template,
                                GtkWidget    *parent)
316
317
318
319
320
{
  GtkWidget *dialog;
  GtkWidget *main_vbox;
  GtkWidget *editor;

321
  dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (template),
322
                                     _("Edit Template"), "gimp-template-edit",
323
324
                                     GIMP_STOCK_EDIT,
                                     _("Edit Template"),
325
                                     parent,
326
327
                                     gimp_standard_help_func,
                                     GIMP_HELP_TEMPLATE_EDIT,
328

329
330
                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                     GTK_STOCK_OK,     GTK_RESPONSE_OK,
331

332
                                     NULL);
333

334
335
336
  g_signal_connect (dialog, "response",
                    G_CALLBACK (templates_edit_template_response),
                    dialog);
337

338
339
  main_vbox = gtk_vbox_new (FALSE, 12);
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
340
341
342
343
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox,
                      TRUE, TRUE, 0);
  gtk_widget_show (main_vbox);

344
345
346
347
348
349
350
351
352
  g_object_set_data (G_OBJECT (dialog), "gimp",          gimp);
  g_object_set_data (G_OBJECT (dialog), "gimp-template", template);

  template = gimp_config_duplicate (GIMP_CONFIG (template));

  editor = gimp_template_editor_new (template, gimp, TRUE);

  g_object_unref (template);

353
354
355
356
357
358
359
360
361
362
  gtk_box_pack_start (GTK_BOX (main_vbox), editor, FALSE, FALSE, 0);
  gtk_widget_show (editor);

  g_object_set_data (G_OBJECT (dialog), "gimp-template-editor", editor);

  gtk_widget_show (dialog);
}

void
templates_file_new_dialog (Gimp         *gimp,
363
364
                           GimpTemplate *template,
                           GtkWidget    *parent)
365
{
366
367
368
  GtkWidget *dialog;

  dialog = gimp_dialog_factory_dialog_new (global_dialog_factory,
369
                                           gtk_widget_get_screen (parent),
370
                                           "gimp-file-new-dialog", -1, FALSE);
371
372

  if (dialog)
373
374
375
376
377
    {
      file_new_dialog_set (dialog, NULL, template);

      gtk_window_present (GTK_WINDOW (dialog));
    }
378
}