← Back to branch summary

~ubuntu-branches/ubuntu/hoary/gimp/hoary

« back to all changes in this revision

Viewing changes to app/actions/dockable-commands.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-04-04 14:51:23 UTC
  • Revision ID: james.westby@ubuntu.com-20050404145123-9py049eeelfymur8
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/actions/dockable-commands.c
 
1
/* The GIMP -- an image manipulation program
 
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 2 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 */
 
18
 
 
19
#include "config.h"
 
20
 
 
21
#include <string.h>
 
22
 
 
23
#include <gtk/gtk.h>
 
24
 
 
25
#include "libgimpwidgets/gimpwidgets.h"
 
26
 
 
27
#include "actions-types.h"
 
28
 
 
29
#include "widgets/gimpcontainerview.h"
 
30
#include "widgets/gimpcontainerview-utils.h"
 
31
#include "widgets/gimpdialogfactory.h"
 
32
#include "widgets/gimpdockable.h"
 
33
#include "widgets/gimpdockbook.h"
 
34
#include "widgets/gimpimagedock.h"
 
35
#include "widgets/gimpsessioninfo.h"
 
36
 
 
37
#include "dialogs/dialogs.h"
 
38
 
 
39
#include "dockable-commands.h"
 
40
 
 
41
 
 
42
/*  local function prototypes  */
 
43
 
 
44
static void   dockable_change_screen_confirm_callback (GtkWidget *dialog,
 
45
                                                       gint       value,
 
46
                                                       gpointer   data);
 
47
static void   dockable_change_screen_destroy_callback (GtkWidget *dialog,
 
48
                                                       GtkWidget *dock);
 
49
 
 
50
 
 
51
/*  public functions  */
 
52
 
 
53
void
 
54
dockable_add_tab_cmd_callback (GtkAction   *action,
 
55
                               const gchar *value,
 
56
                               gpointer     data)
 
57
{
 
58
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
59
 
 
60
  if (value)
 
61
    {
 
62
      GtkWidget *dockable;
 
63
      gchar     *identifier;
 
64
      gchar     *p;
 
65
 
 
66
      identifier = g_strdup (value);
 
67
 
 
68
      p = strchr (identifier, '|');
 
69
 
 
70
      if (p)
 
71
        *p = '\0';
 
72
 
 
73
      dockable =
 
74
        gimp_dialog_factory_dockable_new (dockbook->dock->dialog_factory,
 
75
                                          dockbook->dock,
 
76
                                          identifier, -1);
 
77
 
 
78
      g_free (identifier);
 
79
 
 
80
      /*  Maybe gimp_dialog_factory_dockable_new() returned an already
 
81
       *  existing singleton dockable, so check if it already is
 
82
       *  attached to a dockbook.
 
83
       */
 
84
      if (dockable && ! GIMP_DOCKABLE (dockable)->dockbook)
 
85
        gimp_dockbook_add (dockbook, GIMP_DOCKABLE (dockable), -1);
 
86
    }
 
87
}
 
88
 
 
89
void
 
90
dockable_close_tab_cmd_callback (GtkAction *action,
 
91
                                 gpointer   data)
 
92
{
 
93
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
94
  GimpDockable *dockable;
 
95
  gint          page_num;
 
96
 
 
97
  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
 
98
 
 
99
  dockable = (GimpDockable *)
 
100
    gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
 
101
 
 
102
  if (dockable)
 
103
    gimp_dockbook_remove (dockbook, dockable);
 
104
}
 
105
 
 
106
void
 
107
dockable_detach_tab_cmd_callback (GtkAction *action,
 
108
                                  gpointer   data)
 
109
{
 
110
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
111
  GimpDockable *dockable;
 
112
  gint          page_num;
 
113
 
 
114
  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
 
115
 
 
116
  dockable = (GimpDockable *)
 
117
    gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
 
118
 
 
119
  if (dockable)
 
120
    gimp_dockable_detach (dockable);
 
121
}
 
122
 
 
123
void
 
124
dockable_toggle_view_cmd_callback (GtkAction *action,
 
125
                                   GtkAction *current,
 
126
                                   gpointer   data)
 
127
{
 
128
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
129
  GimpDockable *dockable;
 
130
  GimpViewType  view_type;
 
131
  gint          page_num;
 
132
 
 
133
  view_type = (GimpViewType)
 
134
    gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
 
135
 
 
136
  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
 
137
 
 
138
  dockable = (GimpDockable *)
 
139
    gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
 
140
 
 
141
  if (dockable)
 
142
    {
 
143
      GimpDialogFactoryEntry *entry;
 
144
 
 
145
      gimp_dialog_factory_from_widget (GTK_WIDGET (dockable), &entry);
 
146
 
 
147
      if (entry)
 
148
        {
 
149
          gchar *identifier;
 
150
          gchar *substring = NULL;
 
151
 
 
152
          identifier = g_strdup (entry->identifier);
 
153
 
 
154
          substring = strstr (identifier, "grid");
 
155
 
 
156
          if (substring && view_type == GIMP_VIEW_TYPE_GRID)
 
157
            return;
 
158
 
 
159
          if (! substring)
 
160
            {
 
161
              substring = strstr (identifier, "list");
 
162
 
 
163
              if (substring && view_type == GIMP_VIEW_TYPE_LIST)
 
164
                return;
 
165
            }
 
166
 
 
167
          if (substring)
 
168
            {
 
169
              GimpContainerView *old_view;
 
170
              GtkWidget         *new_dockable;
 
171
              gint               preview_size = -1;
 
172
 
 
173
              if (view_type == GIMP_VIEW_TYPE_LIST)
 
174
                memcpy (substring, "list", 4);
 
175
              else if (view_type == GIMP_VIEW_TYPE_GRID)
 
176
                memcpy (substring, "grid", 4);
 
177
 
 
178
              old_view = gimp_container_view_get_by_dockable (dockable);
 
179
 
 
180
              if (old_view)
 
181
                preview_size = gimp_container_view_get_preview_size (old_view,
 
182
                                                                     NULL);
 
183
 
 
184
              new_dockable =
 
185
                gimp_dialog_factory_dockable_new (dockbook->dock->dialog_factory,
 
186
                                                  dockbook->dock,
 
187
                                                  identifier,
 
188
                                                  preview_size);
 
189
 
 
190
              /*  Maybe gimp_dialog_factory_dockable_new() returned
 
191
               *  an already existing singleton dockable, so check
 
192
               *  if it already is attached to a dockbook.
 
193
               */
 
194
              if (new_dockable && ! GIMP_DOCKABLE (new_dockable)->dockbook)
 
195
                {
 
196
                  gimp_dockbook_add (dockbook, GIMP_DOCKABLE (new_dockable),
 
197
                                     page_num);
 
198
 
 
199
                  gimp_dockbook_remove (dockbook, dockable);
 
200
 
 
201
                  gtk_notebook_set_current_page (GTK_NOTEBOOK (dockbook),
 
202
                                                 page_num);
 
203
                }
 
204
            }
 
205
 
 
206
          g_free (identifier);
 
207
        }
 
208
    }
 
209
}
 
210
 
 
211
void
 
212
dockable_preview_size_cmd_callback (GtkAction *action,
 
213
                                    GtkAction *current,
 
214
                                    gpointer   data)
 
215
{
 
216
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
217
  GimpDockable *dockable;
 
218
  gint          preview_size;
 
219
  gint          page_num;
 
220
 
 
221
  preview_size = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
 
222
 
 
223
  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
 
224
 
 
225
  dockable = (GimpDockable *)
 
226
    gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
 
227
 
 
228
  if (dockable)
 
229
    {
 
230
      GimpContainerView *view = gimp_container_view_get_by_dockable (dockable);
 
231
 
 
232
      if (view)
 
233
        {
 
234
          gint old_size;
 
235
          gint border_width;
 
236
 
 
237
          old_size = gimp_container_view_get_preview_size (view,
 
238
                                                           &border_width);
 
239
 
 
240
          if (old_size != preview_size)
 
241
            gimp_container_view_set_preview_size (view, preview_size,
 
242
                                                  border_width);
 
243
        }
 
244
    }
 
245
}
 
246
 
 
247
void
 
248
dockable_tab_style_cmd_callback (GtkAction *action,
 
249
                                 GtkAction *current,
 
250
                                 gpointer   data)
 
251
{
 
252
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
253
  GimpDockable *dockable;
 
254
  GimpTabStyle  tab_style;
 
255
  gint          page_num;
 
256
 
 
257
  tab_style = (GimpTabStyle)
 
258
    gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
 
259
 
 
260
  page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
 
261
 
 
262
  dockable = (GimpDockable *)
 
263
    gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
 
264
 
 
265
  if (dockable && dockable->tab_style != tab_style)
 
266
    {
 
267
      GtkWidget *tab_widget;
 
268
 
 
269
      gimp_dockable_set_tab_style (dockable, tab_style);
 
270
 
 
271
      tab_widget = gimp_dockbook_get_tab_widget (dockbook, dockable);
 
272
 
 
273
      gtk_notebook_set_tab_label (GTK_NOTEBOOK (dockbook),
 
274
                                  GTK_WIDGET (dockable),
 
275
                                  tab_widget);
 
276
    }
 
277
}
 
278
 
 
279
void
 
280
dockable_toggle_image_menu_cmd_callback (GtkAction *action,
 
281
                                         gpointer   data)
 
282
{
 
283
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
284
  gboolean      active;
 
285
 
 
286
  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 
287
 
 
288
  if (GIMP_IS_IMAGE_DOCK (dockbook->dock))
 
289
    gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dockbook->dock),
 
290
                                         active);
 
291
}
 
292
 
 
293
void
 
294
dockable_toggle_auto_cmd_callback (GtkAction *action,
 
295
                                   gpointer   data)
 
296
{
 
297
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
298
  gboolean      active;
 
299
 
 
300
  active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 
301
 
 
302
  if (GIMP_IS_IMAGE_DOCK (dockbook->dock))
 
303
    gimp_image_dock_set_auto_follow_active (GIMP_IMAGE_DOCK (dockbook->dock),
 
304
                                            active);
 
305
}
 
306
 
 
307
void
 
308
dockable_change_screen_cmd_callback (GtkAction *action,
 
309
                                     gpointer   data)
 
310
{
 
311
  GimpDockbook *dockbook = GIMP_DOCKBOOK (data);
 
312
  GtkWidget    *dock;
 
313
  GdkScreen    *screen;
 
314
  GdkDisplay   *display;
 
315
  gint          cur_screen;
 
316
  gint          num_screens;
 
317
  GtkWidget    *dialog;
 
318
 
 
319
  dock = GTK_WIDGET (dockbook->dock);
 
320
 
 
321
  dialog = g_object_get_data (G_OBJECT (dock), "gimp-change-screen-dialog");
 
322
 
 
323
  if (dialog)
 
324
    {
 
325
      gtk_window_present (GTK_WINDOW (dialog));
 
326
      return;
 
327
    }
 
328
 
 
329
  screen  = gtk_widget_get_screen (dock);
 
330
  display = gtk_widget_get_display (dock);
 
331
 
 
332
  cur_screen  = gdk_screen_get_number (screen);
 
333
  num_screens = gdk_display_get_n_screens (display);
 
334
 
 
335
  dialog = gimp_query_int_box ("Move Dock to Screen",
 
336
                               dock,
 
337
                               NULL, NULL,
 
338
                               "Enter destination screen",
 
339
                               cur_screen, 0, num_screens - 1,
 
340
                               G_OBJECT (dock), "destroy",
 
341
                               dockable_change_screen_confirm_callback,
 
342
                               dock);
 
343
 
 
344
  g_object_set_data (G_OBJECT (dock), "gimp-change-screen-dialog", dialog);
 
345
 
 
346
  g_signal_connect (dialog, "destroy",
 
347
                    G_CALLBACK (dockable_change_screen_destroy_callback),
 
348
                    dock);
 
349
 
 
350
  gtk_widget_show (dialog);
 
351
}
 
352
 
 
353
 
 
354
/*  private functions  */
 
355
 
 
356
static void
 
357
dockable_change_screen_confirm_callback (GtkWidget *dialog,
 
358
                                         gint       value,
 
359
                                         gpointer   data)
 
360
{
 
361
  GdkScreen *screen;
 
362
 
 
363
  screen = gdk_display_get_screen (gtk_widget_get_display (GTK_WIDGET (data)),
 
364
                                   value);
 
365
 
 
366
  if (screen)
 
367
    gtk_window_set_screen (GTK_WINDOW (data), screen);
 
368
}
 
369
 
 
370
static void
 
371
dockable_change_screen_destroy_callback (GtkWidget *dialog,
 
372
                                         GtkWidget *dock)
 
373
{
 
374
  g_object_set_data (G_OBJECT (dock), "gimp-change-screen-dialog", NULL);
 
375
}