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

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

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
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)))
    {
69
      templates_image_new_dialog (context->gimp, template, GTK_WIDGET (editor));
70 71 72
    }
}

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
  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
362 363 364
templates_image_new_dialog (Gimp         *gimp,
                            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-image-new-dialog", -1, FALSE);
371 372

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

      gtk_window_present (GTK_WINDOW (dialog));
    }
378
}