1 /* $Id: menu.c,v 1.10 2005/01/27 02:54:21 meffie Exp $
2 *
3 * GNU Paint
4 * Copyright 2000-2003, 2007 Li-Cheng (Andy) Tai
5 *
6 * Authors: Li-Cheng (Andy) Tai
7 * Michael A. Meffie III <meffiem@neo.rr.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be
15 * useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
17 * PURPOSE. See the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public
20 * License along with this program; if not, write to the Free
21 * Software Foundation, Inc., 59 Temple Place, Suite 330,
22 * Boston, MA 02111-1307 USA
23 */
24
25 #ifdef HAVE_CONFIG_H
26 # include <config.h>
27 #endif
28
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "debug.h"
33 #include "canvas.h"
34 #include "image.h"
35 #include "image_processing.h"
36 #include "tool_palette.h"
37 #include "menu.h"
38 #include "print.h"
39 #include "file.h"
40 #include "text.h"
41
42 #include <gtk/gtk.h>
43
44
45 /*
46 * Save the image to a file. Show the file selection dialog if the
47 * image is untitled.
48 */
49 void
on_save_menu_activate(GtkMenuItem * menuitem,gpointer user_data)50 on_save_menu_activate (GtkMenuItem *menuitem,
51 gpointer user_data)
52 {
53 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
54 gpaint_drawing *drawing = canvas->drawing;
55
56 canvas_begin_busy_cursor(canvas);
57 if (drawing->untitled)
58 {
59 file_save_as_dialog(canvas);
60 }
61 else
62 {
63 drawing_save(drawing);
64 }
65 canvas_end_busy_cursor(canvas);
66 }
67
68 /*
69 * Same as the Save menu item.
70 */
71 void
on_save_button_clicked(GtkButton * button,gpointer user_data)72 on_save_button_clicked (GtkButton *button,
73 gpointer user_data)
74 {
75 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(button));
76 gpaint_drawing *drawing = canvas->drawing;
77
78 canvas_begin_busy_cursor(canvas);
79 if (drawing->untitled)
80 {
81 file_save_as_dialog(canvas);
82 }
83 else
84 {
85 drawing_save(drawing);
86 }
87 canvas_end_busy_cursor(canvas);
88 }
89
90 /*
91 * Select a filename to save the image.
92 */
93 void
on_save_as_menu_activate(GtkMenuItem * menuitem,gpointer user_data)94 on_save_as_menu_activate (GtkMenuItem *menuitem,
95 gpointer user_data)
96 {
97 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
98 canvas_begin_busy_cursor(canvas);
99 file_save_as_dialog(canvas);
100 canvas_end_busy_cursor(canvas);
101 }
102
103 /*
104 * Same as save as menu item.
105 */
106 void
on_save_as_button_clicked(GtkButton * button,gpointer user_data)107 on_save_as_button_clicked (GtkButton *button,
108 gpointer user_data)
109 {
110 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(button));
111 canvas_begin_busy_cursor(canvas);
112 file_save_as_dialog(canvas);
113 canvas_end_busy_cursor(canvas);
114 }
115
116
117
118 void
on_new_file_menu_activate(GtkMenuItem * menuitem,gpointer user_data)119 on_new_file_menu_activate (GtkMenuItem *menuitem,
120 gpointer user_data)
121 {
122 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
123 /* Give the user a chance to save their work before we create
124 * a new drawing! */
125 if (!drawing_prompt_to_save(canvas->drawing))
126 {
127 file_new_dialog(canvas);
128 }
129 }
130
131 void
on_open_menu_activate(GtkMenuItem * menuitem,gpointer user_data)132 on_open_menu_activate (GtkMenuItem *menuitem,
133 gpointer user_data)
134 {
135 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
136 canvas_begin_busy_cursor(canvas);
137 if (!drawing_prompt_to_save(canvas->drawing))
138 {
139 file_open_dialog(canvas);
140 }
141 canvas_end_busy_cursor(canvas);
142 }
143
144 void
on_open_button_clicked(GtkButton * button,gpointer user_data)145 on_open_button_clicked (GtkButton *button,
146 gpointer user_data)
147 {
148 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(button));
149 canvas_begin_busy_cursor(canvas);
150 if (!drawing_prompt_to_save(canvas->drawing))
151 {
152 file_open_dialog(canvas);
153 }
154 canvas_end_busy_cursor(canvas);
155 }
156
157 void
on_cut_menu_activate(GtkMenuItem * menuitem,gpointer user_data)158 on_cut_menu_activate (GtkMenuItem *menuitem,
159 gpointer user_data)
160 {
161 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
162 canvas_cut(canvas);
163 }
164
165 void
on_copy_menu_activate(GtkMenuItem * menuitem,gpointer user_data)166 on_copy_menu_activate (GtkMenuItem *menuitem,
167 gpointer user_data)
168 {
169 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
170 canvas_copy(canvas);
171 }
172
173 void
on_paste_menu_activate(GtkMenuItem * menuitem,gpointer user_data)174 on_paste_menu_activate (GtkMenuItem *menuitem,
175 gpointer user_data)
176 {
177 canvas_begin_paste_mode(canvas_lookup(GTK_WIDGET(menuitem)));
178 }
179
180
181 void
on_clear_menu_activate(GtkMenuItem * menuitem,gpointer user_data)182 on_clear_menu_activate (GtkMenuItem *menuitem,
183 gpointer user_data)
184 {
185 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
186 canvas_clear(canvas);
187 }
188
189 void
on_select_all_activate(GtkMenuItem * menuitem,gpointer user_data)190 on_select_all_activate (GtkMenuItem *menuitem,
191 gpointer user_data)
192 {
193 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
194 canvas_select_all(canvas);
195 }
196
197 static void
on_print(GtkWidget * widget,gboolean preview)198 on_print(GtkWidget *widget, gboolean preview)
199 {
200 gpaint_canvas *canvas = canvas_lookup(widget);
201 gpaint_drawing *drawing = canvas->drawing;
202 gpaint_image *image;
203
204 debug_fn();
205 canvas_begin_busy_cursor(canvas);
206 image = drawing_create_image(drawing);
207 if (preview)
208 {
209 debug("starting do_print_preview()");
210 do_print_preview(image, drawing->filename->str);
211 debug("done do_print_preview()");
212 }
213 else
214 {
215 do_print(image, drawing->filename->str);
216 }
217 image_free(image);
218 canvas_end_busy_cursor(canvas);
219 }
220
221 void
on_print_menu_activate(GtkMenuItem * menuitem,gpointer user_data)222 on_print_menu_activate (GtkMenuItem *menuitem,
223 gpointer user_data)
224 {
225 on_print(GTK_WIDGET(menuitem), FALSE);
226 }
227
228
229 void
on_print_button_clicked(GtkButton * button,gpointer user_data)230 on_print_button_clicked (GtkButton *button,
231 gpointer user_data)
232 {
233 on_print(GTK_WIDGET(button), FALSE);
234 }
235
236 void
on_print_preview_activate(GtkMenuItem * menuitem,gpointer user_data)237 on_print_preview_activate (GtkMenuItem *menuitem,
238 gpointer user_data)
239 {
240 on_print(GTK_WIDGET(menuitem), TRUE);
241 }
242
243 void
on_new_button_clicked(GtkButton * button,gpointer user_data)244 on_new_button_clicked (GtkButton *button,
245 gpointer user_data)
246 {
247 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(button));
248
249 /* Give the user a chance to save their work before we create
250 * a new drawing! */
251 if (!drawing_prompt_to_save(canvas->drawing))
252 {
253 file_new_dialog(canvas);
254 }
255 }
256
257 /*
258 * Create an X client side image from the backing pixmap and
259 * pass it to the named image processing function, then
260 * render the processed image. This function is called for each
261 * image effect menu item. The name of the menu item widget
262 * is used to select the image processing function.
263 */
264 void
on_image_effect_activate(GtkMenuItem * menuitem,gpointer user_data)265 on_image_effect_activate (GtkMenuItem *menuitem,
266 gpointer user_data)
267 {
268 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
269 const gchar *name = gtk_widget_get_name(GTK_WIDGET(menuitem));
270 gpaint_drawing *drawing = canvas->drawing;
271 gpaint_image *input;
272 gpaint_image *output;
273 ImageEffect effect;
274
275 effect = image_lookup_effect(name);
276 g_assert(effect);
277
278 input = drawing_create_image(drawing);
279 output = image_new(drawing->width, drawing->height);
280
281 (*effect)(input, output);
282
283 image_draw_on_pixmap(output, &drawing->backing_pixmap, drawing->gc);
284 drawing_modified(drawing);
285 image_free(input);
286 image_free(output);
287
288 canvas_redraw(canvas);
289 }
290
291 void
on_line_width_combo_combo_entry_changed(GtkEditable * editable,gpointer user_data)292 on_line_width_combo_combo_entry_changed(GtkEditable *editable,
293 gpointer user_data)
294 {
295 char *tmp;
296 int t;
297 GdkGCValues gcvalues;
298 gpaint_canvas *canvas;
299 gpaint_drawing *drawing;
300 int position = 0;
301
302 debug_fn();
303 canvas = canvas_lookup(GTK_WIDGET(editable));
304 drawing = canvas->drawing;
305
306 tmp = gtk_editable_get_chars(editable, 0, -1);
307 g_assert(tmp);
308 if (strlen(tmp) > 0) {
309 sscanf(tmp, "%d", &t);
310 g_free(tmp);
311 if (t > 0) {
312 gdk_gc_get_values(drawing->gc, &gcvalues);
313 gdk_gc_set_line_attributes(drawing->gc, t, gcvalues.line_style, gcvalues.cap_style, gcvalues.join_style);
314
315 /* force the line width entry widget to give up focus */
316 gtk_widget_grab_focus(GTK_WIDGET(canvas->drawing_area));
317 } else {
318 gdk_gc_get_values(drawing->gc, &gcvalues);
319 tmp = g_strdup_printf("%d", gcvalues.line_width);
320 gtk_editable_delete_text(editable, 0, -1);
321 gtk_editable_insert_text(editable, tmp, strlen(tmp), &position);
322 gtk_editable_set_position(editable, -1);
323 g_free(tmp);
324 }
325 } else {
326 g_free(tmp);
327 }
328 }
329
330 void
on_fontpicker_realize(GtkWidget * widget,gpointer user_data)331 on_fontpicker_realize (GtkWidget *widget,
332 gpointer user_data)
333 {
334 }
335
336 void
on_fontpicker_font_set(GtkFontButton * fontpicker,gchar * arg1,gpointer user_data)337 on_fontpicker_font_set (GtkFontButton *fontpicker,
338 gchar *arg1,
339 gpointer user_data)
340 {
341 gpaint_tool *tool = tool_palette_get_tool(GTK_WIDGET(fontpicker), "text");
342
343 const gchar* name = gtk_font_button_get_font_name(fontpicker);
344 debug1("font name = %s", name);
345
346
347 if (tool && tool->attribute)
348 {
349 (*tool->attribute)(tool, GpaintFont, (gpointer*)name);
350 }
351 }
352
353 void
on_fontpicker_map(GtkWidget * widget,gpointer user_data)354 on_fontpicker_map (GtkWidget *widget,
355 gpointer user_data)
356 {
357 }
358
359 gboolean
on_fontpicker_map_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)360 on_fontpicker_map_event (GtkWidget *widget,
361 GdkEvent *event,
362 gpointer user_data)
363 {
364 /*
365 GtkWidget *window = widget_get_toplevel_parent(GTK_WIDGET(widget));
366 image_buf *ibuf = widget_get_image(widget);
367 gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(ibuf->window));
368 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
369 gtk_window_set_modal (GTK_WINDOW(window), TRUE);
370 */
371 return FALSE;
372 }
373
374 void
on_font_button_clicked(GtkButton * button,gpointer user_data)375 on_font_button_clicked (GtkButton *button,
376 gpointer user_data)
377 {
378 }
379
380 void
on_bold_button_clicked(GtkButton * button,gpointer user_data)381 on_bold_button_clicked (GtkButton *button,
382 gpointer user_data)
383 {
384 }
385
386
387 void
on_italic_button_clicked(GtkButton * button,gpointer user_data)388 on_italic_button_clicked (GtkButton *button,
389 gpointer user_data)
390 {
391 }
392
393
394 void
on_underline_button_clicked(GtkButton * button,gpointer user_data)395 on_underline_button_clicked (GtkButton *button,
396 gpointer user_data)
397 {
398 }
399
400
401 void
on_get_desktop_activate(GtkMenuItem * menuitem,gpointer user_data)402 on_get_desktop_activate (GtkMenuItem *menuitem,
403 gpointer user_data)
404 {
405 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
406 /* Give the user a chance to save their work before we create
407 * a new drawing! */
408 if (!drawing_prompt_to_save(canvas->drawing))
409 {
410 gpaint_drawing *drawing = drawing_new_from_desktop(canvas->drawing_area, canvas->gc);
411 if (drawing)
412 {
413 canvas_set_drawing(canvas, drawing);
414 }
415 }
416 }
417
418 void
on_change_background_menu_activate(GtkMenuItem * menuitem,gpointer user_data)419 on_change_background_menu_activate (GtkMenuItem *menuitem,
420 gpointer user_data)
421 {
422 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
423 drawing_copy_to_desktop(canvas->drawing);
424 }
425
426 void
on_set_as_background_centered_activate(GtkMenuItem * menuitem,gpointer user_data)427 on_set_as_background_centered_activate (GtkMenuItem *menuitem,
428 gpointer user_data)
429 {
430 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
431 drawing_copy_to_desktop(canvas->drawing);
432 }
433
434
435 void
on_set_as_background_titled_activate(GtkMenuItem * menuitem,gpointer user_data)436 on_set_as_background_titled_activate (GtkMenuItem *menuitem,
437 gpointer user_data)
438 {
439 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
440 drawing_copy_to_desktop(canvas->drawing);
441 }
442
443
444 void
on_flip_x_axis_menu_activate(GtkMenuItem * menuitem,gpointer user_data)445 on_flip_x_axis_menu_activate (GtkMenuItem *menuitem,
446 gpointer user_data)
447 {
448 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
449 gpaint_drawing *drawing = canvas->drawing;
450 gpaint_image *image;
451
452 canvas_focus_lost(canvas);
453 image = drawing_create_image(drawing);
454 image_flip_x(image);
455 image_draw_on_pixmap(image, &drawing->backing_pixmap, drawing->gc);
456 image_free(image);
457 canvas_redraw(canvas);
458 canvas_focus_gained(canvas);
459 }
460
461
462 void
on_flip_y_axis_menu_activate(GtkMenuItem * menuitem,gpointer user_data)463 on_flip_y_axis_menu_activate (GtkMenuItem *menuitem,
464 gpointer user_data)
465 {
466 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
467 gpaint_drawing *drawing = canvas->drawing;
468 gpaint_image *image;
469
470 canvas_focus_lost(canvas);
471 image = drawing_create_image(drawing);
472 image_flip_y(image);
473 image_draw_on_pixmap(image, &drawing->backing_pixmap, drawing->gc);
474 image_free(image);
475 canvas_redraw(canvas);
476 canvas_focus_gained(canvas);
477 }
478
479 void
on_rotate_menu_activate(GtkMenuItem * menuitem,gpointer user_data)480 on_rotate_menu_activate (GtkMenuItem *menuitem,
481 gpointer user_data)
482 {
483 const gchar *name = gtk_widget_get_name(GTK_WIDGET(menuitem));
484 gpaint_canvas *canvas = canvas_lookup(GTK_WIDGET(menuitem));
485 char sign;
486 int degrees;
487
488 sscanf(name, "rotate_%c%d_menu", &sign, °rees);
489 debug2("sign = %c degrees = %d", sign, degrees);
490 if (sign=='n')
491 {
492 degrees *= -1;
493 }
494 canvas_focus_lost(canvas);
495 drawing_rotate(canvas->drawing, degrees);
496 canvas_resize(canvas);
497 canvas_focus_gained(canvas);
498 }
499
500