1 /*
2 * gEDA - GNU Electronic Design Automation
3 * This file is a part of gerbv.
4 *
5 * Copyright (C) 2000-2003 Stefan Petersen (spe@stacken.kth.se)
6 *
7 * $Id$
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it toowill be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
22 */
23
24 /** \file interface.c
25 \brief GUI building functions for Gerbv
26 \ingroup gerbv
27 */
28
29 #include "gerbv.h"
30
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <unistd.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <math.h>
38
39 #include <gdk/gdkkeysyms.h>
40 #include <gtk/gtk.h>
41
42 #include "common.h"
43 #include "main.h"
44 #include "callbacks.h"
45 #include "interface.h"
46 #include "render.h"
47 #include "selection.h"
48
49 #include "draw.h"
50
51 #include "gerbv_icon.h"
52 #include "icons.h"
53
54 #define dprintf if(DEBUG) printf
55
56 static const gchar *gerbv_win_title = N_("Gerbv — gEDA's Gerber Viewer");
57
58 /* Declared in callbacks.c */
59 extern const char *gerbv_coords_pattern_mils_str;
60
61 /* ---------------------------------------------- */
62 void
rename_main_window(char const * filename,GtkWidget * main_win)63 rename_main_window(char const* filename, GtkWidget *main_win)
64 {
65 GString *win_title = g_string_new(NULL);
66 static GtkWidget *win = NULL;
67
68 if (main_win != NULL)
69 win = main_win;
70
71 g_assert(win != NULL);
72
73 if (filename && filename[0] != '\0') {
74 gchar *basename = g_path_get_basename(filename);
75 g_string_printf(win_title, "%s — Gerbv", basename);
76 g_free(basename);
77 } else {
78 g_string_printf(win_title, _(gerbv_win_title));
79 }
80
81 gtk_window_set_title(GTK_WINDOW(win), win_title->str);
82 g_string_free(win_title, TRUE);
83 }
84
85 /* ---------------------------------------------- */
86 void
set_window_icon(GtkWidget * this_window)87 set_window_icon (GtkWidget * this_window)
88 {
89 GdkPixmap *pixmap;
90 GdkBitmap *mask;
91
92 pixmap = gdk_pixmap_create_from_xpm_d (this_window->window, &mask,
93 &this_window->style->bg[GTK_STATE_NORMAL], gerbv_icon_xpm);
94 gdk_window_set_icon (this_window->window, NULL, pixmap, mask);
95
96 return;
97 }
98
99 /* ---------------------------------------------- */
100 void
interface_load_accels(void)101 interface_load_accels (void)
102 {
103 gchar *accel_map_filename = g_build_filename (g_get_home_dir(), GERBV_ACCELS_RELPATH, NULL);
104 if (accel_map_filename) {
105 gtk_accel_map_load (accel_map_filename);
106 g_free (accel_map_filename);
107 }
108 }
109
110 /* ---------------------------------------------- */
111 void
interface_save_accels(void)112 interface_save_accels (void)
113 {
114 gchar *accel_map_dirname, *accel_map_filename;
115
116 accel_map_filename =
117 g_build_filename (g_get_home_dir(), GERBV_ACCELS_RELPATH, NULL);
118
119 if (!accel_map_filename)
120 return;
121
122 /* Create directory if it is not present */
123 accel_map_dirname = g_path_get_dirname (accel_map_filename);
124 g_mkdir_with_parents (accel_map_dirname,
125 S_IRUSR | S_IXUSR | S_IWUSR |
126 S_IRGRP | S_IXGRP |
127 S_IROTH | S_IXOTH);
128
129 gtk_accel_map_save (accel_map_filename);
130
131 g_free (accel_map_dirname);
132 g_free (accel_map_filename);
133 }
134
135 static void
request_label_max_size_by_text(GtkWidget * label,const gchar * str)136 request_label_max_size_by_text (GtkWidget *label, const gchar *str)
137 {
138 GtkRequisition req;
139
140 gtk_label_set_text (GTK_LABEL (label), str);
141
142 /* Reset previous size request */
143 gtk_widget_set_size_request (label, -1, -1);
144 gtk_widget_size_request (label, &req);
145 gtk_widget_set_size_request (label, req.width, req.height);
146 gtk_label_set_text (GTK_LABEL (label), "");
147 }
148
149 /* ---------------------------------------------- */
150 void
interface_create_gui(int req_width,int req_height)151 interface_create_gui (int req_width, int req_height)
152 {
153 GtkStockItem stock;
154
155 GtkWidget *mainWindow;
156 GtkWidget *vbox1;
157 GtkWidget *menubar1;
158
159 GtkWidget *menuitem_file;
160 GtkWidget *menuitem_file_menu;
161 GtkWidget *new_project;
162 GtkWidget *open;
163 GtkWidget *revert;
164 GtkWidget *save;
165 GtkWidget *save_as;
166 GtkWidget *save_layer;
167 GtkWidget *save_as_layer;
168 GtkWidget *menuitem_file_export;
169 GtkWidget *menuitem_file_export_menu;
170 GtkWidget *png, *pdf, *svg, *postscript, *geda_pcb;
171 GtkWidget *rs274x, *drill, *idrill, *rs274xm, *drillm;
172 #if HAVE_LIBDXFLIB
173 GtkWidget *dxf;
174 #endif
175
176 #if GTK_CHECK_VERSION(2,10,0)
177 GtkWidget *print;
178 #endif
179 GtkWidget *quit;
180
181 GtkWidget *menuitem_edit;
182 GtkWidget *menuitem_edit_menu;
183 GtkWidget *properties_selected;
184 GtkWidget *delete_selected;
185 GtkWidget *align, *align_layers;
186 GtkWidget *menuitem_view;
187 GtkWidget *menuitem_view_menu;
188 GtkWidget *view_fullscreen;
189 GtkWidget *show_selection_on_invisible;
190 GtkWidget *show_cross_on_drill_holes;
191 GtkWidget *show_toolbar;
192 GtkWidget *show_sidepane;
193 GtkWidget *toggle_layer_visibility_item1;
194 GtkWidget *toggle_layer_visibility_item2;
195 GtkWidget *toggle_layer_visibility_item3;
196 GtkWidget *toggle_layer_visibility_item4;
197 GtkWidget *toggle_layer_visibility_item5;
198 GtkWidget *toggle_layer_visibility_item6;
199 GtkWidget *toggle_layer_visibility_item7;
200 GtkWidget *toggle_layer_visibility_item8;
201 GtkWidget *toggle_layer_visibility_item9;
202 GtkWidget *toggle_layer_visibility_item10;
203 GtkWidget *zoom_in;
204 GtkWidget *zoom_out;
205 GtkWidget *fit_to_window;
206 GtkWidget *backgroundColor;
207 GtkWidget *menuitem_view_render, *menuitem_view_render_menu;
208 GSList *menu_view_render_group;
209 GtkWidget *render_fast, *render_fast_xor, *render_normal, *render_hq;
210 GtkWidget *menuitem_view_unit, *menuitem_view_unit_menu;
211 GSList *menu_view_unit_group;
212 GtkWidget *unit_mil, *unit_mm, *unit_in;
213 GtkWidget *menuitem_layer;
214 GtkWidget *menuitem_layer_menu;
215 GtkWidget *layer_visibility;
216 GtkWidget *layer_visibility_all_on;
217 GtkWidget *layer_visibility_all_off;
218 GtkWidget *layer_invert;
219 GtkWidget *layer_color;
220 GtkWidget *layer_reload;
221 GtkWidget *layer_edit;
222 GtkWidget *layer_format;
223 GtkWidget *layer_up;
224 GtkWidget *layer_down;
225 GtkWidget *layer_remove;
226 GtkWidget *menuitem_analyze;
227 GtkWidget *menuitem_analyze_menu;
228 GtkWidget *analyze_active_gerbers;
229 GtkWidget *analyze_active_drill;
230 GtkWidget *analyze_benchmark;
231 /*GtkWidget *control_gerber_options;*/
232 GtkWidget *menuitem_tools;
233 GtkWidget *menuitem_tools_menu;
234 GtkWidget *toggletoolbutton_pointer;
235 GtkWidget *pointer_tool;
236 GdkPixbuf *pointerpixbuf;
237 GtkWidget *pointerimage;
238 GtkWidget *pan_tool;
239 GtkWidget *zoom_tool;
240 GtkWidget *measure_tool;
241 GtkWidget *menuitem_help;
242 GtkWidget *layer_visibility_menu;
243 GtkWidget *layer_visibility_main_menu;
244 GtkWidget *menuitem_help_menu;
245 /*GtkWidget *online_manual;*/
246 GtkWidget *about;
247 GtkWidget *bugs_menuitem;
248 GtkWidget *image34;
249 GtkWidget *toolbar_hbox;
250 GtkWidget *handlebox;
251 GtkWidget *button_toolbar;
252 /*GtkIconSize tmp_toolbar_icon_size;*/
253 GtkWidget *toolbutton_new;
254 GtkWidget *toolbutton_open;
255 GtkWidget *toolbutton_revert;
256 GtkWidget *toolbutton_save;
257 GtkWidget *separatortoolitem1;
258 #if GTK_CHECK_VERSION(2,10,0)
259 GtkWidget *toolbutton_print;
260 GtkWidget *separatortoolitem2;
261 #endif
262 GtkWidget *toolbutton_zoom_in;
263 GtkWidget *toolbutton_zoom_out;
264 GtkWidget *toolbutton_zoom_fit;
265 /* Implement these tool buttons later when we have icons */
266 /* GtkWidget *separatortoolitem3; */
267 /* GtkWidget *toolbutton_analyze; */
268 /* GtkWidget *toolbutton_validate;*/
269 /* GtkWidget *toolbutton_control; */
270 GtkWidget *separatortoolitem4;
271 GtkWidget *toggletoolbutton_pan;
272 GtkWidget *toggletoolbutton_zoom;
273 GtkWidget *toggletoolbutton_measure;
274 GtkWidget *hpaned1;
275 GtkWidget *sidepane_vbox;
276 GtkWidget *sidepane_notebook;
277 GtkWidget *vbox10;
278 GtkWidget *hbox4;
279 GtkWidget *render_combobox;
280 GtkWidget *scrolledwindow1;
281 GtkWidget *hbox1;
282 GtkWidget *button4;
283 GtkWidget *image8;
284 GtkWidget *button5;
285 GtkWidget *image9;
286 GtkWidget *button6;
287 GtkWidget *image10;
288 GtkWidget *button7;
289 GtkWidget *image11;
290 GtkWidget *Layer_label;
291 GtkWidget *vbox11;
292 GtkWidget *messages_scrolledwindow;
293 GtkWidget *message_textview;
294 GtkWidget *clear_messages_button;
295 GtkWidget *Message_label;
296 GtkWidget *vbox2;
297 GtkWidget *main_view_table;
298 GtkWidget *hRuler;
299 GtkWidget *vRuler;
300 GtkWidget *hbox5;
301 GtkWidget *statusbar_label_left;
302 GtkWidget *statusUnitComboBox;
303 GtkWidget *statusbar_label_right;
304 GtkWidget *drawingarea, *hAdjustment, *vAdjustment, *hScrollbar, *vScrollbar;
305
306 GtkAccelGroup *accel_group;
307 GtkTooltips *tooltips;
308
309 /* Inline icons */
310 GdkPixbuf *zoompixbuf;
311 GtkWidget *zoomimage;
312 GdkPixbuf *measurepixbuf;
313 GtkWidget *measureimage;
314 GdkPixbuf *movepixbuf;
315 GtkWidget *moveimage;
316
317 GtkWidget *tempImage;
318
319 gchar str_coord[MAX_COORDLEN];
320
321 const GtkTargetEntry dragTargetEntries[] = {
322 { "text/uri-list", 0, 1 },
323 };
324
325 GSettingsSchema *settings_schema;
326 const gchar *settings_id = "org.geda-user.gerbv";
327 screen.settings = NULL;
328
329 /* Try to find settings schema, GSETTINGS_SCHEMA_DIR env. variable was
330 * updated with fallback schema directory */
331 settings_schema = g_settings_schema_source_lookup(
332 g_settings_schema_source_get_default(),
333 settings_id, TRUE);
334
335 if (NULL != settings_schema) {
336 g_settings_schema_unref(settings_schema);
337 screen.settings = g_settings_new(settings_id);
338 }
339
340 pointerpixbuf = gdk_pixbuf_new_from_inline(-1, pointer, FALSE, NULL);
341 movepixbuf = gdk_pixbuf_new_from_inline(-1, move, FALSE, NULL);
342 zoompixbuf = gdk_pixbuf_new_from_inline(-1, lzoom, FALSE, NULL);
343 measurepixbuf = gdk_pixbuf_new_from_inline(-1, ruler, FALSE, NULL);
344
345 tooltips = gtk_tooltips_new();
346 accel_group = gtk_accel_group_new ();
347
348 mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
349 screen.win.topLevelWindow = mainWindow;
350
351 vbox1 = gtk_vbox_new (FALSE, 0);
352 gtk_container_add (GTK_CONTAINER (mainWindow), vbox1);
353
354 menubar1 = gtk_menu_bar_new ();
355 gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
356
357 gtk_drag_dest_set (mainWindow, GTK_DEST_DEFAULT_ALL, dragTargetEntries,
358 1, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
359 gtk_signal_connect (GTK_OBJECT(mainWindow), "drag-data-received",
360 GTK_SIGNAL_FUNC(callbacks_file_drop_event), NULL);
361
362 /* --- File menu --- */
363 menuitem_file = gtk_menu_item_new_with_mnemonic (_("_File"));
364 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_file);
365
366 menuitem_file_menu = gtk_menu_new ();
367 gtk_menu_set_accel_group (GTK_MENU(menuitem_file_menu), accel_group);
368 gtk_menu_set_accel_path (GTK_MENU(menuitem_file_menu), ACCEL_FILE);
369 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_file), menuitem_file_menu);
370
371 /* File menu items dealing individual layers. */
372
373 open = gtk_menu_item_new_with_mnemonic (_("_Open"));
374 SET_ACCELS (open, ACCEL_FILE_OPEN_LAYER);
375 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), open);
376 gtk_tooltips_set_tip (tooltips, open,
377 _("Open Gerbv project, Gerber, drill, "
378 "or pick&place files"), NULL);
379
380 save_layer = gtk_menu_item_new_with_mnemonic (_("_Save active layer"));
381 screen.win.curFileMenuItem[0] = save_layer;
382 gtk_tooltips_set_tip (tooltips, save_layer, _("Save the active layer"), NULL);
383 SET_ACCELS (save_layer, ACCEL_FILE_SAVE_LAYER);
384 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), save_layer);
385
386 save_as_layer = gtk_menu_item_new_with_mnemonic (_("Save active layer _as..."));
387 screen.win.curFileMenuItem[1] = save_as_layer;
388 gtk_tooltips_set_tip (tooltips, save_as_layer, _("Save the active layer to a new file"), NULL);
389 SET_ACCELS (save_as_layer, ACCEL_FILE_SAVE_LAYER_AS);
390 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), save_as_layer);
391
392 revert = gtk_image_menu_item_new_from_stock (GTK_STOCK_REVERT_TO_SAVED, NULL);
393 /* Change stock label */
394 gtk_menu_item_set_label (GTK_MENU_ITEM (revert), _("_Revert all"));
395 screen.win.curFileMenuItem[2] = revert;
396 SET_ACCELS_FROM_STOCK (revert, GTK_STOCK_REVERT_TO_SAVED, ACCEL_FILE_REVERT);
397 gtk_tooltips_set_tip (tooltips, revert, _("Reload all layers"), NULL);
398 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), revert);
399
400 /* File menu items dealing with exporting different types of files. */
401
402 gtk_container_add (GTK_CONTAINER (menuitem_file_menu),
403 gtk_separator_menu_item_new ());
404
405 menuitem_file_export = gtk_menu_item_new_with_mnemonic (_("_Export"));
406 screen.win.curFileMenuItem[3] = menuitem_file_export;
407 gtk_tooltips_set_tip (tooltips, menuitem_file_export,
408 _("Export to a new format"), NULL);
409 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), menuitem_file_export);
410
411 menuitem_file_export_menu = gtk_menu_new ();
412 gtk_menu_set_accel_group (GTK_MENU(menuitem_file_export_menu), accel_group);
413 gtk_menu_set_accel_path (GTK_MENU(menuitem_file_export_menu), ACCEL_FILE_EXPORT);
414 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_file_export), menuitem_file_export_menu);
415
416 png = gtk_menu_item_new_with_mnemonic (_("P_NG..."));
417 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), png);
418 gtk_tooltips_set_tip (tooltips, png, _("Export visible layers to a PNG file"), NULL);
419
420 pdf = gtk_menu_item_new_with_mnemonic (_("P_DF..."));
421 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), pdf);
422 gtk_tooltips_set_tip (tooltips, pdf, _("Export visible layers to a PDF file"), NULL);
423
424 svg = gtk_menu_item_new_with_mnemonic (_("_SVG..."));
425 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), svg);
426 gtk_tooltips_set_tip (tooltips, svg, _("Export visible layers to a SVG file"), NULL);
427
428 postscript = gtk_menu_item_new_with_mnemonic (_("_PostScript..."));
429 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), postscript);
430 gtk_tooltips_set_tip (tooltips, postscript, _("Export visible layers to a PostScript file"), NULL);
431
432 #if HAVE_LIBDXFLIB
433 dxf = gtk_menu_item_new_with_mnemonic (_("D_XF..."));
434 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), dxf);
435 gtk_tooltips_set_tip (tooltips, dxf,
436 _("Export active layer to a DXF file"), NULL);
437 #endif
438
439 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu),
440 gtk_separator_menu_item_new ());
441
442 rs274x = gtk_menu_item_new_with_mnemonic (_("RS-274X (_Gerber)..."));
443 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), rs274x);
444 gtk_tooltips_set_tip (tooltips, rs274x,
445 _("Export active layer to a RS-274X (Gerber) file"), NULL);
446
447 rs274xm = gtk_menu_item_new_with_mnemonic (_("RS-274X merge (Gerber)..."));
448 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), rs274xm);
449 gtk_tooltips_set_tip (tooltips, rs274xm,
450 _("Export merged visible Gerber layers to "
451 "a RS-274X (Gerber) file"), NULL);
452
453 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu),
454 gtk_separator_menu_item_new ());
455
456 drill = gtk_menu_item_new_with_mnemonic (_("_Excellon drill..."));
457 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), drill);
458 gtk_tooltips_set_tip (tooltips, drill,
459 _("Export active layer to an Excellon drill file"), NULL);
460
461 drillm = gtk_menu_item_new_with_mnemonic (_("Excellon drill merge..."));
462 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), drillm);
463 gtk_tooltips_set_tip (tooltips, drillm,
464 _("Export merged visible drill layers to "
465 "an Excellon drill file"), NULL);
466
467 idrill = gtk_menu_item_new_with_mnemonic (_("_ISEL NCP drill..."));
468 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), idrill);
469 gtk_tooltips_set_tip (tooltips, idrill,
470 _("Export active layer to an ISEL Automation NCP drill file"),
471 NULL);
472
473 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu),
474 gtk_separator_menu_item_new ());
475
476 geda_pcb = gtk_menu_item_new_with_mnemonic (_("gEDA P_CB (beta)..."));
477 gtk_container_add (GTK_CONTAINER (menuitem_file_export_menu), geda_pcb);
478 gtk_tooltips_set_tip (tooltips, geda_pcb,
479 _("Export active layer to a gEDA PCB file"), NULL);
480
481 /* File menu items dealing with a gerbv project. */
482
483 gtk_container_add (GTK_CONTAINER (menuitem_file_menu),
484 gtk_separator_menu_item_new ());
485
486 new_project = gtk_image_menu_item_new_with_mnemonic (_("_New project"));
487 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), new_project);
488 gtk_tooltips_set_tip (tooltips, new_project, _("Close all layers and start a new project"), NULL);
489 tempImage = gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU);
490 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (new_project), tempImage);
491
492 save = gtk_image_menu_item_new_with_mnemonic (_("Save project"));
493 screen.win.curFileMenuItem[4] = save;
494 gtk_tooltips_set_tip (tooltips, save, _("Save the current project"), NULL);
495 tempImage = gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU);
496 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (save), tempImage);
497 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), save);
498
499 save_as = gtk_image_menu_item_new_with_mnemonic (_("Save project as..."));
500 screen.win.curFileMenuItem[5] = save_as;
501 gtk_tooltips_set_tip (tooltips, save_as, _("Save the current project to a new file"), NULL);
502 tempImage = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
503 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (save_as), tempImage);
504 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), save_as);
505
506 /* File menu items dealing with printing and quitting. */
507
508 gtk_container_add (GTK_CONTAINER (menuitem_file_menu),
509 gtk_separator_menu_item_new ());
510
511 #if GTK_CHECK_VERSION(2,10,0)
512 if (gtk_stock_lookup(GTK_STOCK_PRINT, &stock)) {
513 gchar new[] = N_("_Print...");
514 stock.label = _(new);
515 gtk_stock_add(&stock, 1);
516 }
517
518 print = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
519 screen.win.curFileMenuItem[6] = print;
520 SET_ACCELS_FROM_STOCK (print, GTK_STOCK_PRINT, ACCEL_FILE_PRINT);
521 gtk_tooltips_set_tip (tooltips, print, _("Print the visible layers"), NULL);
522 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), print);
523 gtk_container_add (GTK_CONTAINER (menuitem_file_menu),
524 gtk_separator_menu_item_new ());
525 #endif
526
527 quit = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
528 SET_ACCELS_FROM_STOCK (quit, GTK_STOCK_QUIT, ACCEL_FILE_QUIT);
529 gtk_tooltips_set_tip (tooltips, quit, _("Quit Gerbv"), NULL);
530 gtk_container_add (GTK_CONTAINER (menuitem_file_menu), quit);
531
532 /* --- Next menu item (Edit) --- */
533 menuitem_edit = gtk_menu_item_new_with_mnemonic (_("_Edit"));
534 screen.win.curEditMenuItem = menuitem_edit;
535 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_edit);
536
537 menuitem_edit_menu = gtk_menu_new ();
538 gtk_menu_set_accel_group (GTK_MENU(menuitem_edit_menu), accel_group);
539 gtk_menu_set_accel_path (GTK_MENU(menuitem_edit_menu), ACCEL_EDIT);
540 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_edit), menuitem_edit_menu);
541
542 properties_selected = gtk_image_menu_item_new_with_mnemonic (_("Display _properties of selected object(s)"));
543 SET_ACCELS_FROM_STOCK (properties_selected, GTK_STOCK_PROPERTIES, ACCEL_EDIT_PROPERTIES);
544 gtk_tooltips_set_tip (tooltips, properties_selected, _("Examine the properties of the selected object"), NULL);
545 tempImage = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES, GTK_ICON_SIZE_MENU);
546 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (properties_selected), tempImage);
547 gtk_container_add (GTK_CONTAINER (menuitem_edit_menu), properties_selected);
548
549 delete_selected = gtk_image_menu_item_new_with_mnemonic (_("_Delete selected object(s)"));
550 SET_ACCELS_FROM_STOCK (delete_selected, GTK_STOCK_REMOVE, ACCEL_EDIT_DELETE);
551 gtk_tooltips_set_tip (tooltips, delete_selected, _("Delete selected objects"), NULL);
552 tempImage = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU);
553 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (delete_selected), tempImage);
554 gtk_container_add (GTK_CONTAINER (menuitem_edit_menu), delete_selected);
555
556 align = gtk_menu_item_new_with_mnemonic (_("_Align layers"));
557 screen.win.curEditAlingMenuItem = align;
558 gtk_tooltips_set_tip (tooltips, align,
559 _("Align two layers by two selected objects"), NULL);
560 gtk_widget_set_sensitive (align, FALSE);
561 gtk_container_add (GTK_CONTAINER (menuitem_edit_menu), align);
562
563 align_layers = gtk_menu_new ();
564 screen.win.curEditAlingItem[0] = gtk_menu_item_new_with_mnemonic ("");
565 screen.win.curEditAlingItem[1] = gtk_menu_item_new_with_mnemonic ("");
566 gtk_menu_item_set_submenu (GTK_MENU_ITEM (align), align_layers);
567 gtk_container_add (GTK_CONTAINER (align_layers),
568 screen.win.curEditAlingItem[0]);
569 gtk_container_add (GTK_CONTAINER (align_layers),
570 screen.win.curEditAlingItem[1]);
571
572 #if 0
573 /* Include these after they are coded. */
574 tempMenuItem = gtk_image_menu_item_new_with_label (_("Edit object properties"));
575 gtk_menu_shell_append ((GtkMenuShell *)screen.win.drawWindowPopupMenu, tempMenuItem);
576 gtk_tooltips_set_tip (tooltips, tempMenuItem, _("Edit the properties of the selected object"), NULL);
577 g_signal_connect ((gpointer) tempMenuItem, "activate",
578 G_CALLBACK (callbacks_edit_object_properties_clicked), NULL);
579
580 tempMenuItem = gtk_image_menu_item_new_with_label (_("Move object(s)"));
581 gtk_menu_shell_append ((GtkMenuShell *)screen.win.drawWindowPopupMenu, tempMenuItem);
582 gtk_tooltips_set_tip (tooltips, tempMenuItem, _("Move the selected object(s)"),NULL);
583 g_signal_connect ((gpointer) tempMenuItem, "activate",
584 G_CALLBACK (callbacks_move_objects_clicked), NULL);
585
586 tempMenuItem = gtk_image_menu_item_new_with_label (_("Reduce area"));
587 gtk_menu_shell_append ((GtkMenuShell *)screen.win.drawWindowPopupMenu, tempMenuItem);
588 gtk_tooltips_set_tip (tooltips, tempMenuItem, _("Reduce the area of the object (e.g. to prevent component floating)"),NULL);
589 g_signal_connect ((gpointer) tempMenuItem, "activate",
590 G_CALLBACK (callbacks_reduce_object_area_clicked), NULL);
591 #endif
592
593 /* Use the "Edit" menu as right click popup menu for the drawing area */
594 screen.win.drawWindowPopupMenu = menuitem_edit_menu;
595
596 /* --- Next menu item (View) --- */
597 menuitem_view = gtk_menu_item_new_with_mnemonic (_("_View"));
598 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_view);
599
600 menuitem_view_menu = gtk_menu_new ();
601 gtk_menu_set_accel_group (GTK_MENU(menuitem_view_menu), accel_group);
602 gtk_menu_set_accel_path (GTK_MENU(menuitem_view_menu), ACCEL_VIEW);
603 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_view), menuitem_view_menu);
604
605 view_fullscreen = gtk_check_menu_item_new_with_mnemonic (_("Fullscr_een"));
606 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (view_fullscreen), FALSE);
607 gtk_tooltips_set_tip (tooltips, view_fullscreen, _("Toggle between fullscreen and normal view"), NULL);
608 SET_ACCELS (view_fullscreen, ACCEL_VIEW_FULLSCREEN);
609 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), view_fullscreen);
610
611 show_toolbar = gtk_check_menu_item_new_with_mnemonic (_("Show _Toolbar"));
612 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_toolbar), TRUE);
613 gtk_tooltips_set_tip (tooltips, show_toolbar, _("Toggle visibility of the toolbar"), NULL);
614 SET_ACCELS (show_toolbar, ACCEL_VIEW_TOOLBAR);
615 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), show_toolbar);
616
617 show_sidepane = gtk_check_menu_item_new_with_mnemonic (_("Show _Sidepane"));
618 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_sidepane), TRUE);
619 gtk_tooltips_set_tip (tooltips, show_sidepane, _("Toggle visibility of the sidepane"), NULL);
620 SET_ACCELS (show_sidepane, ACCEL_VIEW_SIDEPANE);
621 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), show_sidepane);
622
623 gtk_container_add (GTK_CONTAINER (menuitem_view_menu),
624 gtk_separator_menu_item_new ());
625
626 layer_visibility_main_menu = gtk_menu_item_new_with_mnemonic (_("Toggle layer _visibility"));
627 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), layer_visibility_main_menu);
628
629 show_selection_on_invisible = gtk_check_menu_item_new_with_mnemonic (_("Show all se_lection"));
630 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_selection_on_invisible), FALSE);
631 gtk_tooltips_set_tip (tooltips, show_selection_on_invisible, _("Show selected objects on invisible layers"), NULL);
632 SET_ACCELS (show_selection_on_invisible, ACCEL_VIEW_ALL_SELECTION);
633 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), show_selection_on_invisible);
634
635 show_cross_on_drill_holes = gtk_check_menu_item_new_with_mnemonic (_("Show _cross on drill holes"));
636 gtk_tooltips_set_tip (tooltips, show_cross_on_drill_holes,
637 _("Show cross on drill holes"), NULL);
638 SET_ACCELS (show_cross_on_drill_holes, ACCEL_VIEW_CROSS_ON_DRILL_HOLES);
639 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), show_cross_on_drill_holes);
640 if (screen.settings) {
641 g_settings_bind (screen.settings, "cross-on-drill-holes",
642 show_cross_on_drill_holes, "active",
643 G_SETTINGS_BIND_DEFAULT);
644 screenRenderInfo.show_cross_on_drill_holes =
645 gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (
646 show_cross_on_drill_holes));
647 }
648
649 layer_visibility_menu = gtk_menu_new ();
650 gtk_menu_set_accel_group (GTK_MENU(layer_visibility_menu), accel_group);
651 gtk_menu_set_accel_path (GTK_MENU(layer_visibility_menu), ACCEL_VIEW_VIS);
652 gtk_menu_item_set_submenu (GTK_MENU_ITEM (layer_visibility_main_menu), layer_visibility_menu);
653
654 toggle_layer_visibility_item1 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 1"));
655 SET_ACCELS (toggle_layer_visibility_item1, ACCEL_VIEW_VIS_LAYER1);
656 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item1);
657
658 toggle_layer_visibility_item2 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 2"));
659 SET_ACCELS (toggle_layer_visibility_item2, ACCEL_VIEW_VIS_LAYER2);
660 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item2);
661
662 toggle_layer_visibility_item3 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 3"));
663 SET_ACCELS (toggle_layer_visibility_item3, ACCEL_VIEW_VIS_LAYER3);
664 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item3);
665
666 toggle_layer_visibility_item4 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 4"));
667 SET_ACCELS (toggle_layer_visibility_item4, ACCEL_VIEW_VIS_LAYER4);
668 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item4);
669
670 toggle_layer_visibility_item5 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 5"));
671 SET_ACCELS (toggle_layer_visibility_item5, ACCEL_VIEW_VIS_LAYER5);
672 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item5);
673
674 toggle_layer_visibility_item6 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 6"));
675 SET_ACCELS (toggle_layer_visibility_item6, ACCEL_VIEW_VIS_LAYER6);
676 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item6);
677
678 toggle_layer_visibility_item7 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 7"));
679 SET_ACCELS (toggle_layer_visibility_item7, ACCEL_VIEW_VIS_LAYER7);
680 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item7);
681
682 toggle_layer_visibility_item8 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 8"));
683 SET_ACCELS (toggle_layer_visibility_item8, ACCEL_VIEW_VIS_LAYER8);
684 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item8);
685
686 toggle_layer_visibility_item9 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 9"));
687 SET_ACCELS (toggle_layer_visibility_item9, ACCEL_VIEW_VIS_LAYER9);
688 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item9);
689
690 toggle_layer_visibility_item10 = gtk_menu_item_new_with_label (_("Toggle visibility of layer 10"));
691 SET_ACCELS (toggle_layer_visibility_item10, ACCEL_VIEW_VIS_LAYER10);
692 gtk_container_add (GTK_CONTAINER (layer_visibility_menu), toggle_layer_visibility_item10);
693
694 gtk_container_add (GTK_CONTAINER (menuitem_view_menu),
695 gtk_separator_menu_item_new ());
696
697 zoom_in = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL);
698 SET_ACCELS_FROM_STOCK (zoom_in, GTK_STOCK_ZOOM_IN, ACCEL_VIEW_ZOOM_IN);
699 gtk_tooltips_set_tip (tooltips, zoom_in, _("Zoom in"), NULL);
700 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), zoom_in);
701
702 zoom_out = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL);
703 SET_ACCELS_FROM_STOCK (zoom_out, GTK_STOCK_ZOOM_OUT, ACCEL_VIEW_ZOOM_OUT);
704 gtk_tooltips_set_tip (tooltips, zoom_out, _("Zoom out"), NULL);
705 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), zoom_out);
706
707 fit_to_window = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_FIT, NULL);
708 gtk_tooltips_set_tip (tooltips, fit_to_window, _("Zoom to fit all visible layers in the window"), NULL);
709 SET_ACCELS_FROM_STOCK (fit_to_window, GTK_STOCK_ZOOM_FIT, ACCEL_VIEW_ZOOM_FIT);
710 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), fit_to_window);
711
712 gtk_container_add (GTK_CONTAINER (menuitem_view_menu),
713 gtk_separator_menu_item_new ());
714
715 backgroundColor = gtk_image_menu_item_new_with_mnemonic (_("Background color"));
716 gtk_tooltips_set_tip (tooltips, backgroundColor, _("Change the background color"), NULL);
717 tempImage = gtk_image_new_from_stock (GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU);
718 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (backgroundColor), tempImage);
719 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), backgroundColor);
720
721 /* Restore saved background color */
722 if (screen.settings
723 && !screen.background_is_from_cmdline
724 && !screen.background_is_from_project) {
725 guint clr;
726
727 clr = g_settings_get_uint (screen.settings, "background-color");
728 mainProject->background.blue = (clr & 0xff)*257;
729 clr >>= 8;
730 mainProject->background.green = (clr & 0xff)*257;
731 clr >>= 8;
732 mainProject->background.red = (clr & 0xff)*257;
733 }
734
735 { // rendering submenu
736 menuitem_view_render = gtk_menu_item_new_with_mnemonic (_("_Rendering"));
737 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), menuitem_view_render);
738
739 menuitem_view_render_menu = gtk_menu_new ();
740 gtk_menu_set_accel_group (GTK_MENU(menuitem_view_render_menu), accel_group);
741 gtk_menu_set_accel_path (GTK_MENU(menuitem_view_render_menu), ACCEL_VIEW_RENDER);
742 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_view_render), menuitem_view_render_menu);
743
744 menu_view_render_group = NULL;
745
746 render_fast = gtk_radio_menu_item_new_with_mnemonic (menu_view_render_group, _("_Fast"));
747 menu_view_render_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (render_fast));
748 gtk_container_add (GTK_CONTAINER (menuitem_view_render_menu), render_fast);
749
750 render_fast_xor = gtk_radio_menu_item_new_with_mnemonic (menu_view_render_group, _("Fast (_XOR)"));
751 menu_view_render_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (render_fast_xor));
752 gtk_container_add (GTK_CONTAINER (menuitem_view_render_menu), render_fast_xor);
753
754 render_normal = gtk_radio_menu_item_new_with_mnemonic (menu_view_render_group, _("_Normal"));
755 menu_view_render_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (render_normal));
756 gtk_container_add (GTK_CONTAINER (menuitem_view_render_menu), render_normal);
757
758 render_hq = gtk_radio_menu_item_new_with_mnemonic (menu_view_render_group, _("High _Quality"));
759 menu_view_render_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (render_hq));
760 gtk_container_add (GTK_CONTAINER (menuitem_view_render_menu), render_hq);
761
762 screen.win.menu_view_render_group = malloc(4*sizeof(GtkWidget *));
763 if(screen.win.menu_view_render_group == NULL)
764 GERB_FATAL_ERROR("malloc for rendering type synchronization failed in %s()", __FUNCTION__);
765
766 screen.win.menu_view_render_group[GERBV_RENDER_TYPE_GDK] = GTK_CHECK_MENU_ITEM(render_fast);
767 screen.win.menu_view_render_group[GERBV_RENDER_TYPE_GDK_XOR] = GTK_CHECK_MENU_ITEM(render_fast_xor);
768 screen.win.menu_view_render_group[GERBV_RENDER_TYPE_CAIRO_NORMAL] = GTK_CHECK_MENU_ITEM(render_normal);
769 screen.win.menu_view_render_group[GERBV_RENDER_TYPE_CAIRO_HIGH_QUALITY] = GTK_CHECK_MENU_ITEM(render_hq);
770 }
771
772 { // units submenu
773 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (render_fast), TRUE);
774
775 menuitem_view_unit = gtk_menu_item_new_with_mnemonic (_("U_nits"));
776 gtk_container_add (GTK_CONTAINER (menuitem_view_menu), menuitem_view_unit);
777
778 menuitem_view_unit_menu = gtk_menu_new ();
779 gtk_menu_set_accel_group (GTK_MENU(menuitem_view_unit_menu), accel_group);
780 gtk_menu_set_accel_path (GTK_MENU(menuitem_view_unit_menu), ACCEL_VIEW_UNITS);
781 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_view_unit), menuitem_view_unit_menu);
782
783 menu_view_unit_group = NULL;
784
785 unit_mil = gtk_radio_menu_item_new_with_mnemonic (menu_view_unit_group, _("mi_l"));
786 menu_view_unit_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (unit_mil));
787 gtk_container_add (GTK_CONTAINER (menuitem_view_unit_menu), unit_mil);
788
789 unit_mm = gtk_radio_menu_item_new_with_mnemonic (menu_view_unit_group, _("_mm"));
790 menu_view_unit_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (unit_mm));
791 gtk_container_add (GTK_CONTAINER (menuitem_view_unit_menu), unit_mm);
792
793 unit_in = gtk_radio_menu_item_new_with_mnemonic (menu_view_unit_group, _("_in"));
794 menu_view_unit_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (unit_in));
795 gtk_container_add (GTK_CONTAINER (menuitem_view_unit_menu), unit_in);
796
797 screen.win.menu_view_unit_group = malloc(3*sizeof(GtkWidget *));
798 if(screen.win.menu_view_unit_group == NULL)
799 GERB_FATAL_ERROR("malloc for display unit synchronization failed in %s()", __FUNCTION__);
800
801 screen.win.menu_view_unit_group[GERBV_MILS] = GTK_CHECK_MENU_ITEM(unit_mil);
802 screen.win.menu_view_unit_group[GERBV_MMS] = GTK_CHECK_MENU_ITEM(unit_mm);
803 screen.win.menu_view_unit_group[GERBV_INS] = GTK_CHECK_MENU_ITEM(unit_in);
804 }
805
806 /* --- Next menu item (Current Layer) --- */
807 menuitem_layer = gtk_menu_item_new_with_mnemonic (_("_Layer"));
808 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_layer);
809
810 menuitem_layer_menu = gtk_menu_new ();
811 gtk_menu_set_accel_group (GTK_MENU (menuitem_layer_menu), accel_group);
812 gtk_menu_set_accel_path (GTK_MENU (menuitem_layer_menu), ACCEL_LAYER);
813 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_layer), menuitem_layer_menu);
814
815 layer_visibility = gtk_menu_item_new_with_mnemonic (_("Toggle _visibility"));
816 gtk_tooltips_set_tip (tooltips, layer_visibility,
817 _("Toggles the visibility of the active layer"), NULL);
818 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_visibility);
819
820 layer_visibility_all_on = gtk_image_menu_item_new_with_mnemonic (_("All o_n"));
821 SET_ACCELS (layer_visibility_all_on, ACCEL_LAYER_ALL_ON);
822 gtk_tooltips_set_tip (tooltips, layer_visibility_all_on, _("Turn on visibility of all layers"), NULL);
823 tempImage = gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_MENU);
824 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_visibility_all_on), tempImage);
825 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_visibility_all_on);
826
827 layer_visibility_all_off = gtk_image_menu_item_new_with_mnemonic (_("All _off"));
828 SET_ACCELS (layer_visibility_all_off, ACCEL_LAYER_ALL_OFF);
829 gtk_tooltips_set_tip (tooltips, layer_visibility_all_off, _("Turn off visibility of all layers"), NULL);
830 tempImage = gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_MENU);
831 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_visibility_all_off), tempImage);
832 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_visibility_all_off);
833
834 layer_invert = gtk_menu_item_new_with_mnemonic (_("_Invert color"));
835 gtk_tooltips_set_tip (tooltips, layer_invert,
836 _("Invert the display polarity of the active layer"), NULL);
837 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_invert);
838
839 layer_color = gtk_image_menu_item_new_with_mnemonic (_("_Change color"));
840 SET_ACCELS (layer_color, ACCEL_LAYER_COLOR);
841 gtk_tooltips_set_tip (tooltips, layer_color,
842 _("Change the display color of the active layer"), NULL);
843 tempImage = gtk_image_new_from_stock (GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU);
844 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_color), tempImage);
845 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_color);
846
847 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu),
848 gtk_separator_menu_item_new ());
849
850 layer_reload = gtk_image_menu_item_new_with_mnemonic (_("_Reload layer"));
851 gtk_tooltips_set_tip (tooltips, layer_reload,
852 _("Reload the active layer from disk"), NULL);
853 tempImage = gtk_image_new_from_stock (GTK_STOCK_REVERT_TO_SAVED, GTK_ICON_SIZE_MENU);
854 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_reload), tempImage);
855 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_reload);
856
857 layer_edit = gtk_image_menu_item_new_with_mnemonic (_("_Edit layer"));
858 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_edit);
859 gtk_tooltips_set_tip (tooltips, layer_edit,
860 _("Translate, scale, rotate or mirror the active layer"), NULL);
861 tempImage = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
862 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_edit), tempImage);
863
864 layer_format = gtk_image_menu_item_new_with_mnemonic (_("Edit file _format"));
865 gtk_tooltips_set_tip (tooltips, layer_format,
866 _("View and edit the numerical format used to parse "
867 "the active layer"), NULL);
868 tempImage = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
869 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_format), tempImage);
870 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_format);
871
872 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu),
873 gtk_separator_menu_item_new ());
874
875 layer_up = gtk_image_menu_item_new_with_mnemonic (_("Move u_p"));
876 gtk_tooltips_set_tip (tooltips, layer_up,
877 _("Move the active layer one step up"), NULL);
878 tempImage = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU);
879 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_up), tempImage);
880 SET_ACCELS (layer_up, ACCEL_LAYER_UP);
881 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_up);
882
883 layer_down = gtk_image_menu_item_new_with_mnemonic (_("Move dow_n"));
884 gtk_tooltips_set_tip (tooltips, layer_down,
885 _("Move the active layer one step down"), NULL);
886 tempImage = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU);
887 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_down), tempImage);
888 SET_ACCELS (layer_down, ACCEL_LAYER_DOWN);
889 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_down);
890
891 layer_remove = gtk_image_menu_item_new_with_mnemonic (_("_Delete"));
892 gtk_tooltips_set_tip (tooltips, layer_remove,
893 _("Remove the active layer"), NULL);
894 tempImage = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU);
895 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (layer_remove), tempImage);
896 SET_ACCELS (layer_remove, ACCEL_LAYER_DELETE);
897 gtk_container_add (GTK_CONTAINER (menuitem_layer_menu), layer_remove);
898
899 /* The callbacks need this reference to grey the layer menu out, if there are none loaded. */
900 screen.win.curLayerMenuItem = menuitem_layer;
901
902 /* Use the "Current Layer" menu as right click popup menu for layer tree */
903 screen.win.layerTreePopupMenu = menuitem_layer_menu;
904
905 /* --- Next menu item (Analyze) --- */
906 menuitem_analyze = gtk_menu_item_new_with_mnemonic (_("_Analyze"));
907 screen.win.curAnalyzeMenuItem = menuitem_analyze;
908 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_analyze);
909
910 screen.selectionInfo.selectedNodeArray = selection_new_array ();
911
912 menuitem_analyze_menu = gtk_menu_new ();
913 gtk_menu_set_accel_group (GTK_MENU(menuitem_analyze_menu), accel_group);
914 gtk_menu_set_accel_path (GTK_MENU(menuitem_analyze_menu), ACCEL_ANAL);
915 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_analyze), menuitem_analyze_menu);
916
917 analyze_active_gerbers = gtk_menu_item_new_with_mnemonic (
918 _("Analyze visible _Gerber layers"));
919 gtk_tooltips_set_tip (tooltips, analyze_active_gerbers,
920 _("Examine a detailed analysis of the contents "
921 "of all visible Gerber layers"), NULL);
922 gtk_container_add (GTK_CONTAINER (menuitem_analyze_menu),
923 analyze_active_gerbers);
924
925 analyze_active_drill = gtk_menu_item_new_with_mnemonic (
926 _("Analyze visible _drill layers"));
927 gtk_tooltips_set_tip (tooltips, analyze_active_drill,
928 _("Examine a detailed analysis of the contents "
929 "of all visible drill layers"), NULL);
930 gtk_container_add (GTK_CONTAINER (menuitem_analyze_menu),
931 analyze_active_drill);
932
933 analyze_benchmark = gtk_menu_item_new_with_mnemonic (_("_Benchmark"));
934 gtk_tooltips_set_tip (tooltips, analyze_benchmark,
935 _("Benchmark different rendering methods. Will make "
936 "the application unresponsive for 1 minute!"), NULL);
937 gtk_container_add (GTK_CONTAINER (menuitem_analyze_menu),
938 gtk_separator_menu_item_new ());
939 gtk_container_add (GTK_CONTAINER (menuitem_analyze_menu),
940 analyze_benchmark);
941
942 /* Wait and add in for 2.1??
943 control_gerber_options = gtk_menu_item_new_with_mnemonic (_("Control Gerber options..."));
944 gtk_tooltips_set_tip (tooltips, control_gerber_options, _("Set which Gerber features should be displayed"), NULL);
945 gtk_container_add (GTK_CONTAINER (menuitem_analyze_menu), control_gerber_options);
946 */
947 menuitem_tools = gtk_menu_item_new_with_mnemonic (_("_Tools"));
948 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_tools);
949
950 menuitem_tools_menu = gtk_menu_new ();
951 gtk_menu_set_accel_group (GTK_MENU(menuitem_tools_menu), accel_group);
952 gtk_menu_set_accel_path (GTK_MENU(menuitem_tools_menu), ACCEL_TOOLS);
953 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_tools), menuitem_tools_menu);
954 pointer_tool = gtk_image_menu_item_new_with_mnemonic (_("_Pointer Tool"));
955 tempImage = gtk_image_new_from_pixbuf (pointerpixbuf);
956 gtk_image_menu_item_set_image ((GtkImageMenuItem *)pointer_tool, tempImage);
957 SET_ACCELS (pointer_tool, ACCEL_TOOLS_POINTER);
958 gtk_container_add (GTK_CONTAINER (menuitem_tools_menu), pointer_tool);
959 gtk_tooltips_set_tip (tooltips, pointer_tool, _("Select objects on the screen"), NULL);
960 pan_tool = gtk_image_menu_item_new_with_mnemonic (_("Pa_n Tool"));
961 tempImage = gtk_image_new_from_pixbuf (movepixbuf);
962 gtk_image_menu_item_set_image ((GtkImageMenuItem *)pan_tool, tempImage);
963 SET_ACCELS (pan_tool, ACCEL_TOOLS_PAN);
964 gtk_container_add (GTK_CONTAINER (menuitem_tools_menu), pan_tool);
965 gtk_tooltips_set_tip (tooltips, pan_tool, _("Pan by left clicking and dragging"), NULL);
966
967 zoom_tool = gtk_image_menu_item_new_with_mnemonic (_("_Zoom Tool"));
968 tempImage = gtk_image_new_from_pixbuf (zoompixbuf);
969 gtk_image_menu_item_set_image ((GtkImageMenuItem *)zoom_tool, tempImage);
970 SET_ACCELS (zoom_tool, ACCEL_TOOLS_ZOOM);
971 gtk_container_add (GTK_CONTAINER (menuitem_tools_menu), zoom_tool);
972 gtk_tooltips_set_tip (tooltips, zoom_tool, _("Zoom by left clicking or dragging"), NULL);
973
974 measure_tool = gtk_image_menu_item_new_with_mnemonic (_("_Measure Tool"));
975 tempImage = gtk_image_new_from_pixbuf (measurepixbuf);
976 gtk_image_menu_item_set_image ((GtkImageMenuItem *)measure_tool, tempImage);
977 SET_ACCELS (measure_tool, ACCEL_TOOLS_MEASURE);
978 gtk_container_add (GTK_CONTAINER (menuitem_tools_menu), measure_tool);
979 gtk_tooltips_set_tip (tooltips, measure_tool, _("Measure distances on the screen"), NULL);
980
981 menuitem_help = gtk_menu_item_new_with_mnemonic (_("_Help"));
982 gtk_container_add (GTK_CONTAINER (menubar1), menuitem_help);
983
984 menuitem_help_menu = gtk_menu_new ();
985 gtk_menu_set_accel_group (GTK_MENU(menuitem_help_menu), accel_group);
986 gtk_menu_set_accel_path (GTK_MENU(menuitem_help_menu), ACCEL_HELP);
987 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem_help), menuitem_help_menu);
988
989 /* Not ready for 2.0
990 online_manual = gtk_menu_item_new_with_mnemonic (_("_Online Manual..."));
991 gtk_container_add (GTK_CONTAINER (menuitem_help_menu), online_manual);
992 gtk_tooltips_set_tip (tooltips, online_manual, _("View the online help documentation"), NULL);
993 */
994
995 about = gtk_image_menu_item_new_with_mnemonic (_("_About Gerbv..."));
996 gtk_container_add (GTK_CONTAINER (menuitem_help_menu), about);
997 gtk_tooltips_set_tip (tooltips, about, _("View information about Gerbv"), NULL);
998 image34 = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_MENU);
999 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (about), image34);
1000
1001 bugs_menuitem = gtk_image_menu_item_new_with_mnemonic (_("Known _bugs in this version..."));
1002 tempImage = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU);
1003 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (bugs_menuitem), tempImage);
1004 gtk_tooltips_set_tip (tooltips, bugs_menuitem, _("View list of known Gerbv bugs"), NULL);
1005 gtk_container_add (GTK_CONTAINER (menuitem_help_menu), bugs_menuitem);
1006
1007 /* Create toolbar (button bar) beneath main menu */
1008 toolbar_hbox = gtk_hbox_new (FALSE, 0);
1009 gtk_box_pack_start (GTK_BOX (vbox1), toolbar_hbox, FALSE, FALSE, 0);
1010
1011 handlebox = gtk_handle_box_new ();
1012
1013 gtk_box_pack_start (GTK_BOX (toolbar_hbox), handlebox, TRUE, TRUE, 0);
1014
1015 button_toolbar = gtk_toolbar_new ();
1016 gtk_widget_set_size_request (button_toolbar, 500, -1);
1017 gtk_container_add (GTK_CONTAINER (handlebox), button_toolbar);
1018 gtk_toolbar_set_style (GTK_TOOLBAR (button_toolbar), GTK_TOOLBAR_ICONS);
1019 /*tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (button_toolbar));*/
1020
1021 toolbutton_new = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
1022 gtk_tooltips_set_tip (tooltips, toolbutton_new, _("Close all layers and start a new project"), NULL);
1023 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_new);
1024
1025 toolbutton_open = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_OPEN);
1026 gtk_tooltips_set_tip (tooltips, toolbutton_open,
1027 _("Open Gerbv project, Gerber, drill, "
1028 "or pick&place files"), NULL);
1029 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_open);
1030
1031 toolbutton_revert = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_REVERT_TO_SAVED);
1032 gtk_tooltips_set_tip (tooltips, toolbutton_revert, _("Reload all layers in project"), NULL);
1033 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_revert);
1034
1035 toolbutton_save = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_SAVE);
1036 gtk_tooltips_set_tip (tooltips, toolbutton_save, _("Save the current project"), NULL);
1037 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_save);
1038
1039 separatortoolitem1 = (GtkWidget*) gtk_separator_tool_item_new ();
1040 gtk_container_add (GTK_CONTAINER (button_toolbar), separatortoolitem1);
1041 #if GTK_CHECK_VERSION(2,10,0)
1042 toolbutton_print = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_PRINT);
1043 gtk_tooltips_set_tip (tooltips, toolbutton_print, _("Print the visible layers"), NULL);
1044 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_print);
1045
1046 separatortoolitem2 = (GtkWidget*) gtk_separator_tool_item_new ();
1047 gtk_container_add (GTK_CONTAINER (button_toolbar), separatortoolitem2);
1048 #endif
1049 toolbutton_zoom_in = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_IN);
1050 gtk_tooltips_set_tip (tooltips, toolbutton_zoom_in, _("Zoom in"), NULL);
1051 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_zoom_in);
1052
1053 toolbutton_zoom_out = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_OUT);
1054 gtk_tooltips_set_tip (tooltips, toolbutton_zoom_out, _("Zoom out"), NULL);
1055 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_zoom_out);
1056
1057 toolbutton_zoom_fit = (GtkWidget*) gtk_tool_button_new_from_stock (GTK_STOCK_ZOOM_FIT);
1058 gtk_tooltips_set_tip (tooltips, toolbutton_zoom_fit, _("Zoom to fit all visible layers in the window"), NULL);
1059 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_zoom_fit);
1060
1061 /* Turn these on later when we have icons for these buttons */
1062 /*
1063 separatortoolitem3 = (GtkWidget*) gtk_separator_tool_item_new ();
1064 gtk_container_add (GTK_CONTAINER (button_toolbar), separatortoolitem3);
1065
1066 toolbutton_analyze = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-apply");
1067 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_analyze);
1068
1069 toolbutton_validate = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-apply");
1070 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_validate);
1071
1072 toolbutton_control = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-apply");
1073 gtk_container_add (GTK_CONTAINER (button_toolbar), toolbutton_control);
1074 */
1075
1076 separatortoolitem4 = (GtkWidget*) gtk_separator_tool_item_new ();
1077 gtk_container_add (GTK_CONTAINER (button_toolbar), separatortoolitem4);
1078 toggletoolbutton_pointer = (GtkWidget*) gtk_toggle_tool_button_new();
1079 pointerimage = gtk_image_new_from_pixbuf(pointerpixbuf);
1080 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toggletoolbutton_pointer),
1081 pointerimage);
1082 gtk_tooltips_set_tip (tooltips, toggletoolbutton_pointer, _("Select objects on the screen"), NULL);
1083 gtk_container_add (GTK_CONTAINER (button_toolbar), toggletoolbutton_pointer);
1084 toggletoolbutton_pan = (GtkWidget*) gtk_toggle_tool_button_new();
1085 moveimage = gtk_image_new_from_pixbuf(movepixbuf);
1086 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toggletoolbutton_pan),
1087 moveimage);
1088 gtk_tooltips_set_tip (tooltips, toggletoolbutton_pan, _("Pan by left clicking and dragging"), NULL);
1089 gtk_container_add (GTK_CONTAINER (button_toolbar), toggletoolbutton_pan);
1090
1091
1092 toggletoolbutton_zoom = (GtkWidget*) gtk_toggle_tool_button_new();
1093 zoomimage = gtk_image_new_from_pixbuf(zoompixbuf);
1094 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toggletoolbutton_zoom),
1095 zoomimage);
1096 gtk_tooltips_set_tip (tooltips, toggletoolbutton_zoom, _("Zoom by left clicking or dragging"), NULL);
1097 gtk_container_add (GTK_CONTAINER (button_toolbar), toggletoolbutton_zoom);
1098
1099 toggletoolbutton_measure = (GtkWidget*) gtk_toggle_tool_button_new();
1100 measureimage = gtk_image_new_from_pixbuf(measurepixbuf);
1101 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toggletoolbutton_measure),
1102 measureimage);
1103 gtk_tooltips_set_tip (tooltips, toggletoolbutton_measure, _("Measure distances on the screen"), NULL);
1104 gtk_container_add (GTK_CONTAINER (button_toolbar), toggletoolbutton_measure);
1105
1106 hpaned1 = gtk_hpaned_new ();
1107 gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
1108 gtk_paned_set_position (GTK_PANED (hpaned1), 225);
1109
1110 sidepane_vbox = gtk_vbox_new (FALSE, 0);
1111 gtk_widget_set_size_request (sidepane_vbox, 150, -1);
1112
1113 gtk_paned_pack1 (GTK_PANED (hpaned1), sidepane_vbox, FALSE, FALSE);
1114 gtk_container_set_border_width (GTK_CONTAINER (sidepane_vbox), 5);
1115
1116 sidepane_notebook = gtk_notebook_new ();
1117 gtk_widget_set_size_request (sidepane_notebook, 100, -1);
1118 gtk_box_pack_start (GTK_BOX (sidepane_vbox), sidepane_notebook, TRUE, TRUE, 0);
1119
1120 vbox10 = gtk_vbox_new (FALSE, 3);
1121 gtk_container_add (GTK_CONTAINER (sidepane_notebook), vbox10);
1122 gtk_widget_set_size_request (vbox10, 82, -1);
1123 gtk_container_set_border_width (GTK_CONTAINER (vbox10), 4);
1124
1125 hbox4 = gtk_hbox_new (FALSE, 0);
1126 gtk_box_pack_start (GTK_BOX (vbox10), hbox4, FALSE, FALSE, 0);
1127
1128 render_combobox = gtk_combo_box_new_text ();
1129 gtk_box_pack_start (GTK_BOX (hbox4), render_combobox, TRUE, TRUE, 0);
1130 gtk_tooltips_set_tip (tooltips, render_combobox,
1131 _("Rendering type"), NULL);
1132
1133 gtk_combo_box_append_text (GTK_COMBO_BOX (render_combobox), _("Fast"));
1134 gtk_combo_box_append_text (GTK_COMBO_BOX (render_combobox), _("Fast, with XOR"));
1135 gtk_combo_box_append_text (GTK_COMBO_BOX (render_combobox), _("Normal"));
1136 gtk_combo_box_append_text (GTK_COMBO_BOX (render_combobox), _("High quality"));
1137
1138 if (screen.settings) {
1139 g_settings_bind (screen.settings, "visual-rendering-type",
1140 render_combobox, "active",
1141 G_SETTINGS_BIND_DEFAULT);
1142
1143 /* Sync menu item render type */
1144 screenRenderInfo.renderType =
1145 gtk_combo_box_get_active (
1146 GTK_COMBO_BOX (render_combobox));
1147 if ((unsigned int)screenRenderInfo.renderType <
1148 GERBV_RENDER_TYPE_MAX) {
1149 gtk_check_menu_item_set_active (
1150 screen.win.menu_view_render_group[
1151 screenRenderInfo.renderType],
1152 TRUE);
1153 }
1154 } else {
1155 gtk_combo_box_set_active (GTK_COMBO_BOX(render_combobox),
1156 screenRenderInfo.renderType);
1157 }
1158
1159 scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
1160 gtk_box_pack_start (GTK_BOX (vbox10), scrolledwindow1, TRUE, TRUE, 0);
1161 gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow1), 2);
1162 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1),
1163 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1164 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1),
1165 GTK_SHADOW_IN);
1166
1167 hbox1 = gtk_hbox_new (TRUE, 0);
1168 gtk_box_pack_start (GTK_BOX (vbox10), hbox1, FALSE, FALSE, 0);
1169
1170 button4 = gtk_button_new ();
1171 gtk_box_pack_start (GTK_BOX (hbox1), button4, FALSE, TRUE, 0);
1172
1173 image8 = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON);
1174 gtk_container_add (GTK_CONTAINER (button4), image8);
1175 gtk_tooltips_set_tip (tooltips, button4,
1176 _("Open Gerbv project, Gerber, drill, "
1177 "or pick&place files"), NULL);
1178
1179 button5 = gtk_button_new ();
1180 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, TRUE, 0);
1181
1182 image9 = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON);
1183 gtk_container_add (GTK_CONTAINER (button5), image9);
1184 gtk_tooltips_set_tip (tooltips, button5,
1185 _("Move the active layer one step down"), NULL);
1186
1187 button6 = gtk_button_new ();
1188 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, TRUE, 0);
1189
1190 image10 = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON);
1191 gtk_container_add (GTK_CONTAINER (button6), image10);
1192 gtk_tooltips_set_tip (tooltips, button6,
1193 _("Move the active layer one step up"), NULL);
1194
1195 button7 = gtk_button_new ();
1196 gtk_box_pack_start (GTK_BOX (hbox1), button7, FALSE, TRUE, 0);
1197
1198 image11 = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON);
1199 gtk_container_add (GTK_CONTAINER (button7), image11);
1200 gtk_tooltips_set_tip (tooltips, button7,
1201 _("Remove the active layer"), NULL);
1202
1203 Layer_label = gtk_label_new (_("Layers"));
1204 gtk_notebook_set_tab_label (GTK_NOTEBOOK (sidepane_notebook),
1205 gtk_notebook_get_nth_page (GTK_NOTEBOOK (sidepane_notebook), 0),
1206 Layer_label);
1207
1208 vbox11 = gtk_vbox_new (FALSE, 2);
1209 gtk_container_add (GTK_CONTAINER (sidepane_notebook), vbox11);
1210 gtk_container_set_border_width (GTK_CONTAINER (vbox11), 3);
1211
1212 messages_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
1213 gtk_box_pack_start (GTK_BOX (vbox11), messages_scrolledwindow, TRUE, TRUE, 0);
1214 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messages_scrolledwindow),
1215 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1216
1217 message_textview = gtk_text_view_new ();
1218 gtk_container_add (GTK_CONTAINER (messages_scrolledwindow), message_textview);
1219 gtk_text_view_set_editable (GTK_TEXT_VIEW (message_textview), FALSE);
1220 gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (message_textview), GTK_WRAP_WORD);
1221 gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (message_textview), FALSE);
1222
1223 clear_messages_button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
1224 gtk_tooltips_set_tip (tooltips, clear_messages_button,
1225 _("Clear all messages and accumulated sum"), NULL);
1226 gtk_box_pack_start (GTK_BOX (vbox11), clear_messages_button, FALSE, FALSE, 0);
1227
1228 Message_label = gtk_label_new (_("Messages"));
1229 gtk_notebook_set_tab_label (GTK_NOTEBOOK (sidepane_notebook),
1230 gtk_notebook_get_nth_page (GTK_NOTEBOOK (sidepane_notebook), 1),
1231 Message_label);
1232
1233 vbox2 = gtk_vbox_new (FALSE, 4);
1234 gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, FALSE);
1235 gtk_container_set_border_width (GTK_CONTAINER (vbox2), 4);
1236
1237 main_view_table = gtk_table_new (3, 3, FALSE);
1238 gtk_box_pack_start (GTK_BOX (vbox2), main_view_table, TRUE, TRUE, 0);
1239
1240 hRuler = gtk_hruler_new ();
1241 gtk_table_attach (GTK_TABLE (main_view_table), hRuler, 1, 2, 0, 1,
1242 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1243 (GtkAttachOptions) (GTK_FILL), 0, 0);
1244 gtk_ruler_set_range (GTK_RULER (hRuler), 0, 100, 8.56051, 1000);
1245
1246 vRuler = gtk_vruler_new ();
1247 gtk_table_attach (GTK_TABLE (main_view_table), vRuler, 0, 1, 1, 2,
1248 (GtkAttachOptions) (GTK_FILL),
1249 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
1250 gtk_ruler_set_range (GTK_RULER (vRuler), 0, 100, 8.37341, 1000);
1251
1252 drawingarea = gtk_drawing_area_new();
1253 gtk_table_attach (GTK_TABLE (main_view_table), drawingarea, 1, 2, 1, 2,
1254 (GtkAttachOptions) (GTK_FILL),
1255 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
1256
1257 hAdjustment = (GtkWidget *) gtk_adjustment_new (0.0, -1000.0, 1000.0, 1000.0, 1000.0, 500.0);
1258 vAdjustment = (GtkWidget *) gtk_adjustment_new (0.0, -1000.0, 1000.0, 1000.0, 1000.0, 500.0);
1259
1260 hScrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (hAdjustment));
1261 gtk_table_attach (GTK_TABLE (main_view_table), hScrollbar, 1, 2, 2, 3,
1262 (GtkAttachOptions) (GTK_FILL),
1263 (GtkAttachOptions) (GTK_FILL), 0, 0);
1264
1265 vScrollbar = gtk_vscrollbar_new (GTK_ADJUSTMENT (vAdjustment));
1266 gtk_table_attach (GTK_TABLE (main_view_table), vScrollbar, 2, 3, 1, 2,
1267 (GtkAttachOptions) (GTK_FILL),
1268 (GtkAttachOptions) (GTK_FILL), 0, 0);
1269
1270 hbox5 = gtk_hbox_new (FALSE, 10);
1271 gtk_box_pack_start (GTK_BOX (vbox2), hbox5, FALSE, FALSE, 0);
1272
1273 statusbar_label_left = gtk_label_new ("");
1274 gtk_box_pack_start (GTK_BOX (hbox5), statusbar_label_left, FALSE, FALSE, 0);
1275 gtk_label_set_justify (GTK_LABEL (statusbar_label_left), GTK_JUSTIFY_CENTER);
1276
1277 statusUnitComboBox = gtk_combo_box_new_text ();
1278 gtk_box_pack_start (GTK_BOX (hbox5), statusUnitComboBox, FALSE, FALSE, 0);
1279 gtk_combo_box_append_text (GTK_COMBO_BOX (statusUnitComboBox), _("mil"));
1280 gtk_combo_box_append_text (GTK_COMBO_BOX (statusUnitComboBox), _("mm"));
1281 gtk_combo_box_append_text (GTK_COMBO_BOX (statusUnitComboBox), _("in"));
1282 screen.win.statusUnitComboBox = statusUnitComboBox;
1283
1284 /* 1. Set default unit */
1285 int screen_unit_orig = screen.unit;
1286 /* Trigger change */
1287
1288 gtk_combo_box_set_active (GTK_COMBO_BOX (statusUnitComboBox),
1289 screen_unit_orig);
1290 /* Update unit item in menu */
1291 callbacks_statusbar_unit_combo_box_changed (
1292 GTK_COMBO_BOX (statusUnitComboBox),
1293 GINT_TO_POINTER (TRUE));
1294
1295 /* 2. Try to set unit from stored settings */
1296 if (screen.settings) {
1297 g_settings_bind (screen.settings, "visual-unit",
1298 statusUnitComboBox, "active",
1299 G_SETTINGS_BIND_DEFAULT);
1300 /* Update unit item in menu */
1301 callbacks_statusbar_unit_combo_box_changed (
1302 GTK_COMBO_BOX (statusUnitComboBox),
1303 GINT_TO_POINTER (TRUE));
1304 }
1305
1306 /* 3. Override unit from cmdline */
1307 if (screen.unit_is_from_cmdline) {
1308 gtk_combo_box_set_active (GTK_COMBO_BOX (statusUnitComboBox),
1309 screen_unit_orig);
1310 /* Update unit item in menu */
1311 callbacks_statusbar_unit_combo_box_changed (
1312 GTK_COMBO_BOX (statusUnitComboBox),
1313 GINT_TO_POINTER (TRUE));
1314 }
1315
1316 statusbar_label_right = gtk_label_new ("");
1317 gtk_box_pack_start (GTK_BOX (hbox5), statusbar_label_right, TRUE, TRUE, 0);
1318 gtk_label_set_ellipsize (GTK_LABEL (statusbar_label_right), PANGO_ELLIPSIZE_END);
1319 gtk_misc_set_alignment (GTK_MISC (statusbar_label_right), 0, 0.5);
1320
1321 /*
1322 * Connect signals to widgets
1323 */
1324
1325 /* --- File menu --- */
1326 g_signal_connect ((gpointer) new_project, "activate",
1327 G_CALLBACK (callbacks_new_project_activate),
1328 NULL);
1329 g_signal_connect ((gpointer) open, "activate",
1330 G_CALLBACK (callbacks_open_activate),
1331 NULL);
1332 g_signal_connect ((gpointer) revert, "activate",
1333 G_CALLBACK (callbacks_revert_activate),
1334 NULL);
1335 g_signal_connect ((gpointer) save_layer, "activate",
1336 G_CALLBACK (callbacks_save_layer_activate),
1337 NULL);
1338 g_signal_connect ((gpointer) save_as_layer, "activate",
1339 G_CALLBACK (callbacks_generic_save_activate),
1340 (gpointer) CALLBACKS_SAVE_LAYER_AS);
1341 g_signal_connect ((gpointer) save, "activate",
1342 G_CALLBACK (callbacks_save_project_activate),
1343 NULL);
1344 g_signal_connect ((gpointer) save_as, "activate",
1345 G_CALLBACK (callbacks_generic_save_activate),
1346 (gpointer) CALLBACKS_SAVE_PROJECT_AS);
1347 g_signal_connect ((gpointer) png, "activate",
1348 G_CALLBACK (callbacks_generic_save_activate),
1349 (gpointer) CALLBACKS_SAVE_FILE_PNG);
1350
1351 g_signal_connect ((gpointer) pdf, "activate",
1352 G_CALLBACK (callbacks_generic_save_activate),
1353 (gpointer) CALLBACKS_SAVE_FILE_PDF);
1354 g_signal_connect ((gpointer) svg, "activate",
1355 G_CALLBACK (callbacks_generic_save_activate),
1356 (gpointer) CALLBACKS_SAVE_FILE_SVG);
1357 g_signal_connect ((gpointer) postscript, "activate",
1358 G_CALLBACK (callbacks_generic_save_activate),
1359 (gpointer) CALLBACKS_SAVE_FILE_PS);
1360 g_signal_connect ((gpointer) geda_pcb, "activate",
1361 G_CALLBACK (callbacks_generic_save_activate),
1362 (gpointer) CALLBACKS_SAVE_FILE_GEDA_PCB);
1363 #if HAVE_LIBDXFLIB
1364 g_signal_connect ((gpointer) dxf, "activate",
1365 G_CALLBACK (callbacks_generic_save_activate),
1366 (gpointer) CALLBACKS_SAVE_FILE_DXF);
1367 #endif
1368 g_signal_connect ((gpointer) rs274x, "activate",
1369 G_CALLBACK (callbacks_generic_save_activate),
1370 (gpointer) CALLBACKS_SAVE_FILE_RS274X);
1371 g_signal_connect ((gpointer) drill, "activate",
1372 G_CALLBACK (callbacks_generic_save_activate),
1373 (gpointer) CALLBACKS_SAVE_FILE_DRILL);
1374 g_signal_connect ((gpointer) idrill, "activate",
1375 G_CALLBACK (callbacks_generic_save_activate),
1376 (gpointer) CALLBACKS_SAVE_FILE_IDRILL);
1377 g_signal_connect ((gpointer) rs274xm, "activate",
1378 G_CALLBACK (callbacks_generic_save_activate),
1379 (gpointer) CALLBACKS_SAVE_FILE_RS274XM);
1380 g_signal_connect ((gpointer) drillm, "activate",
1381 G_CALLBACK (callbacks_generic_save_activate),
1382 (gpointer) CALLBACKS_SAVE_FILE_DRILLM);
1383
1384 #if GTK_CHECK_VERSION(2,10,0)
1385 g_signal_connect ((gpointer) print, "activate",
1386 G_CALLBACK (callbacks_print_activate),
1387 NULL);
1388 #endif
1389 g_signal_connect ((gpointer) quit, "activate",
1390 G_CALLBACK (callbacks_quit_activate),
1391 NULL);
1392
1393 /* --- Edit menu --- */
1394 g_signal_connect ((gpointer) delete_selected, "activate",
1395 G_CALLBACK (callbacks_delete_objects_clicked),
1396 NULL);
1397 g_signal_connect ((gpointer) properties_selected, "activate",
1398 G_CALLBACK (callbacks_display_object_properties_clicked),
1399 NULL);
1400 g_signal_connect ((gpointer) screen.win.curEditAlingItem[0], "activate",
1401 G_CALLBACK (callbacks_align_files_from_sel_clicked),
1402 GINT_TO_POINTER(0));
1403 g_signal_connect ((gpointer) screen.win.curEditAlingItem[1], "activate",
1404 G_CALLBACK (callbacks_align_files_from_sel_clicked),
1405 GINT_TO_POINTER(1));
1406
1407 /* --- View menu --- */
1408 g_signal_connect ((gpointer) view_fullscreen, "activate",
1409 G_CALLBACK (callbacks_fullscreen_toggled),
1410 GINT_TO_POINTER(0));
1411 g_signal_connect ((gpointer) show_toolbar, "toggled",
1412 G_CALLBACK (callbacks_show_toolbar_toggled),
1413 toolbar_hbox);
1414 g_signal_connect ((gpointer) show_sidepane, "toggled",
1415 G_CALLBACK (callbacks_show_sidepane_toggled),
1416 sidepane_vbox);
1417 g_signal_connect ((gpointer) show_selection_on_invisible, "toggled",
1418 G_CALLBACK (callbacks_show_selection_on_invisible),
1419 NULL);
1420 g_signal_connect ((gpointer) show_cross_on_drill_holes, "toggled",
1421 G_CALLBACK (callbacks_show_cross_on_drill_holes),
1422 NULL);
1423 g_signal_connect ((gpointer) toggle_layer_visibility_item1, "activate",
1424 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1425 GINT_TO_POINTER(0));
1426 g_signal_connect ((gpointer) toggle_layer_visibility_item2, "activate",
1427 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1428 GINT_TO_POINTER(1));
1429 g_signal_connect ((gpointer) toggle_layer_visibility_item3, "activate",
1430 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1431 GINT_TO_POINTER(2));
1432 g_signal_connect ((gpointer) toggle_layer_visibility_item4, "activate",
1433 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1434 GINT_TO_POINTER(3));
1435 g_signal_connect ((gpointer) toggle_layer_visibility_item5, "activate",
1436 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1437 GINT_TO_POINTER(4));
1438 g_signal_connect ((gpointer) toggle_layer_visibility_item6, "activate",
1439 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1440 GINT_TO_POINTER(5));
1441 g_signal_connect ((gpointer) toggle_layer_visibility_item7, "activate",
1442 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1443 GINT_TO_POINTER(6));
1444 g_signal_connect ((gpointer) toggle_layer_visibility_item8, "activate",
1445 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1446 GINT_TO_POINTER(7));
1447 g_signal_connect ((gpointer) toggle_layer_visibility_item9, "activate",
1448 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1449 GINT_TO_POINTER(8));
1450 g_signal_connect ((gpointer) toggle_layer_visibility_item10, "activate",
1451 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1452 GINT_TO_POINTER(9));
1453 g_signal_connect ((gpointer) zoom_in, "activate",
1454 G_CALLBACK (callbacks_zoom_in_activate),
1455 NULL);
1456 g_signal_connect ((gpointer) zoom_out, "activate",
1457 G_CALLBACK (callbacks_zoom_out_activate),
1458 NULL);
1459 g_signal_connect ((gpointer) fit_to_window, "activate",
1460 G_CALLBACK (callbacks_fit_to_window_activate),
1461 NULL);
1462 g_signal_connect ((gpointer) backgroundColor, "activate",
1463 G_CALLBACK (callbacks_change_background_color_clicked),
1464 NULL);
1465 g_signal_connect ((gpointer) unit_mil, "activate",
1466 G_CALLBACK (callbacks_viewmenu_units_changed),
1467 GINT_TO_POINTER(GERBV_MILS));
1468 g_signal_connect ((gpointer) unit_mm, "activate",
1469 G_CALLBACK (callbacks_viewmenu_units_changed),
1470 GINT_TO_POINTER(GERBV_MMS));
1471 g_signal_connect ((gpointer) unit_in, "activate",
1472 G_CALLBACK (callbacks_viewmenu_units_changed),
1473 GINT_TO_POINTER(GERBV_INS));
1474
1475 /* --- Current Layer menu --- */
1476 g_signal_connect ((gpointer) layer_visibility, "activate",
1477 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1478 GINT_TO_POINTER (LAYER_SELECTED));
1479 g_signal_connect ((gpointer) layer_visibility_all_on, "activate",
1480 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1481 GINT_TO_POINTER (LAYER_ALL_ON));
1482 g_signal_connect ((gpointer) layer_visibility_all_off, "activate",
1483 G_CALLBACK (callbacks_toggle_layer_visibility_activate),
1484 GINT_TO_POINTER (LAYER_ALL_OFF));
1485 g_signal_connect ((gpointer) layer_invert, "activate", G_CALLBACK (callbacks_invert_layer_clicked), NULL);
1486 g_signal_connect ((gpointer) layer_color, "activate", G_CALLBACK (callbacks_change_layer_color_clicked), NULL);
1487 g_signal_connect ((gpointer) layer_reload, "activate", G_CALLBACK (callbacks_reload_layer_clicked), NULL);
1488 g_signal_connect ((gpointer) layer_edit, "activate", G_CALLBACK (callbacks_change_layer_edit_clicked), NULL);
1489 g_signal_connect ((gpointer) layer_format, "activate", G_CALLBACK (callbacks_change_layer_format_clicked), NULL);
1490 g_signal_connect ((gpointer) layer_remove, "activate", G_CALLBACK (callbacks_remove_layer_button_clicked), NULL);
1491 g_signal_connect ((gpointer) layer_up, "activate", G_CALLBACK (callbacks_move_layer_up_menu_activate), NULL);
1492 g_signal_connect ((gpointer) layer_down, "activate", G_CALLBACK (callbacks_move_layer_down_menu_activate), NULL);
1493
1494 /* --- Analyze menu --- */
1495 g_signal_connect ((gpointer) analyze_active_gerbers, "activate",
1496 G_CALLBACK (callbacks_analyze_active_gerbers_activate),
1497 NULL);
1498 g_signal_connect ((gpointer) analyze_active_drill, "activate",
1499 G_CALLBACK (callbacks_analyze_active_drill_activate),
1500 NULL);
1501 g_signal_connect ((gpointer) analyze_benchmark, "activate",
1502 G_CALLBACK (callbacks_benchmark_clicked),
1503 NULL);
1504
1505
1506 /* Wait for 2.1
1507 g_signal_connect ((gpointer) control_gerber_options, "activate",
1508 G_CALLBACK (callbacks_control_gerber_options_activate),
1509 NULL);
1510 */
1511
1512 /* --- Tools menu --- */
1513 g_signal_connect ((gpointer) pointer_tool, "activate",
1514 G_CALLBACK (callbacks_change_tool), (gpointer) 0);
1515 g_signal_connect ((gpointer) pan_tool, "activate",
1516 G_CALLBACK (callbacks_change_tool), (gpointer) 1);
1517 g_signal_connect ((gpointer) zoom_tool, "activate",
1518 G_CALLBACK (callbacks_change_tool), (gpointer) 2);
1519 g_signal_connect ((gpointer) measure_tool, "activate",
1520 G_CALLBACK (callbacks_change_tool), (gpointer) 3);
1521
1522 /* --- Help menu --- */
1523 /*
1524 g_signal_connect ((gpointer) online_manual, "activate",
1525 G_CALLBACK (callbacks_online_manual_activate),
1526 NULL);
1527 */
1528 g_signal_connect ((gpointer) about, "activate",
1529 G_CALLBACK (callbacks_about_activate),
1530 NULL);
1531
1532 g_signal_connect ((gpointer) bugs_menuitem, "activate",
1533 G_CALLBACK (callbacks_bugs_activate),
1534 NULL);
1535
1536 /* End of Glade generated code */
1537 g_signal_connect ((gpointer) toolbutton_new, "clicked",
1538 G_CALLBACK (callbacks_new_project_activate),
1539 NULL);
1540 g_signal_connect ((gpointer) toolbutton_save, "clicked",
1541 G_CALLBACK (callbacks_save_project_activate),
1542 NULL);
1543 g_signal_connect ((gpointer) toolbutton_open, "clicked",
1544 G_CALLBACK (callbacks_open_activate),
1545 NULL);
1546 g_signal_connect ((gpointer) toolbutton_revert, "clicked",
1547 G_CALLBACK (callbacks_revert_activate),
1548 NULL);
1549 g_signal_connect ((gpointer) clear_messages_button, "clicked",
1550 G_CALLBACK (callbacks_clear_messages_button_clicked),
1551 NULL);
1552 #if GTK_CHECK_VERSION(2,10,0)
1553 g_signal_connect ((gpointer) toolbutton_print, "clicked",
1554 G_CALLBACK (callbacks_print_activate),
1555 NULL);
1556 #endif
1557 g_signal_connect ((gpointer) toolbutton_zoom_in, "clicked",
1558 G_CALLBACK (callbacks_zoom_in_activate),
1559 NULL);
1560 g_signal_connect ((gpointer) toolbutton_zoom_out, "clicked",
1561 G_CALLBACK (callbacks_zoom_out_activate),
1562 NULL);
1563 g_signal_connect ((gpointer) toolbutton_zoom_fit, "clicked",
1564 G_CALLBACK (callbacks_fit_to_window_activate),
1565 NULL);
1566 g_signal_connect ((gpointer) toggletoolbutton_pointer, "clicked",
1567 G_CALLBACK (callbacks_change_tool), (gpointer) 0);
1568 g_signal_connect ((gpointer) toggletoolbutton_pan, "clicked",
1569 G_CALLBACK (callbacks_change_tool), (gpointer) 1);
1570 g_signal_connect ((gpointer) toggletoolbutton_zoom, "clicked",
1571 G_CALLBACK (callbacks_change_tool), (gpointer) 2);
1572 g_signal_connect ((gpointer) toggletoolbutton_measure, "clicked",
1573 G_CALLBACK (callbacks_change_tool), (gpointer) 3);
1574
1575 g_signal_connect ((gpointer) statusUnitComboBox, "changed",
1576 G_CALLBACK (callbacks_statusbar_unit_combo_box_changed),
1577 NULL);
1578
1579 g_signal_connect ((gpointer) button4, "clicked",
1580 G_CALLBACK (callbacks_add_layer_button_clicked), NULL);
1581 g_signal_connect ((gpointer) button7, "clicked",
1582 G_CALLBACK (callbacks_remove_layer_button_clicked), NULL);
1583 g_signal_connect ((gpointer) button5, "clicked",
1584 G_CALLBACK (callbacks_move_layer_down_button_clicked), NULL);
1585 g_signal_connect ((gpointer) button6, "clicked",
1586 G_CALLBACK (callbacks_move_layer_up_button_clicked), NULL);
1587
1588 g_signal_connect ((gpointer) hAdjustment, "value-changed",
1589 G_CALLBACK (callbacks_hadjustment_value_changed), NULL);
1590 g_signal_connect ((gpointer) vAdjustment, "value-changed",
1591 G_CALLBACK (callbacks_vadjustment_value_changed), NULL);
1592 g_signal_connect ((gpointer) hScrollbar, "button-press-event",
1593 G_CALLBACK (callbacks_scrollbar_button_pressed), NULL);
1594 g_signal_connect ((gpointer) hScrollbar, "button-release-event",
1595 G_CALLBACK (callbacks_scrollbar_button_released), NULL);
1596 g_signal_connect ((gpointer) vScrollbar, "button-press-event",
1597 G_CALLBACK (callbacks_scrollbar_button_pressed), NULL);
1598 g_signal_connect ((gpointer) vScrollbar, "button-release-event",
1599 G_CALLBACK (callbacks_scrollbar_button_released), NULL);
1600
1601 gtk_window_add_accel_group (GTK_WINDOW (mainWindow), accel_group);
1602
1603 GtkListStore *list_store;
1604
1605 list_store = gtk_list_store_new (4, G_TYPE_BOOLEAN,
1606 GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
1607
1608 GtkWidget *tree;
1609
1610 tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
1611 GtkCellRenderer *renderer;
1612 GtkTreeViewColumn *column;
1613
1614 renderer = gtk_cell_renderer_toggle_new ();
1615 column = gtk_tree_view_column_new_with_attributes ("Visible",
1616 renderer,
1617 "active", 0,
1618 NULL);
1619 gtk_tree_view_column_set_min_width ((GtkTreeViewColumn *)column, 25);
1620 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1621
1622 renderer = gtk_cell_renderer_pixbuf_new ();
1623 column = gtk_tree_view_column_new_with_attributes ("Color",
1624 renderer,
1625 "pixbuf", 1, NULL);
1626 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1627
1628 renderer = gtk_cell_renderer_text_new ();
1629 g_object_set (G_OBJECT (renderer), "foreground", "red", "xalign", 0.5,
1630 "family", "Times", "size-points", 12.0, NULL);
1631 column = gtk_tree_view_column_new_with_attributes ("Modified",
1632 renderer,
1633 "text", 3,
1634 NULL);
1635 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1636 gtk_tree_view_column_set_min_width ((GtkTreeViewColumn *)column,20);
1637
1638 renderer = gtk_cell_renderer_text_new ();
1639 column = gtk_tree_view_column_new_with_attributes ("Name",
1640 renderer,
1641 "markup", 2,
1642 NULL);
1643 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1644
1645 gtk_tree_view_set_headers_visible ((GtkTreeView *)tree, FALSE);
1646 gtk_signal_connect(GTK_OBJECT(tree), "key-press-event",
1647 GTK_SIGNAL_FUNC(callbacks_layer_tree_key_press), NULL);
1648 gtk_signal_connect(GTK_OBJECT(tree), "button-press-event",
1649 GTK_SIGNAL_FUNC(callbacks_layer_tree_button_press), NULL);
1650 gtk_container_add (GTK_CONTAINER (scrolledwindow1), tree);
1651
1652 GtkTreeSelection *selection;
1653 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
1654 gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1655 gtk_tree_view_set_enable_search (GTK_TREE_VIEW (tree), FALSE);
1656 gtk_tree_view_set_reorderable (GTK_TREE_VIEW (tree), TRUE);
1657
1658 g_signal_connect (G_OBJECT(list_store), "row-inserted",
1659 G_CALLBACK (callbacks_layer_tree_row_inserted), NULL);
1660 /* steal the focus to the tree to make sure none of the buttons are focused */
1661 gtk_widget_grab_focus (tree);
1662 /*
1663 * Connect all events on drawing area
1664 */
1665 gtk_signal_connect(GTK_OBJECT(drawingarea), "expose_event",
1666 GTK_SIGNAL_FUNC(callbacks_drawingarea_expose_event), NULL);
1667 gtk_signal_connect(GTK_OBJECT(drawingarea),"configure_event",
1668 GTK_SIGNAL_FUNC(callbacks_drawingarea_configure_event), NULL);
1669 gtk_signal_connect(GTK_OBJECT(drawingarea), "motion_notify_event",
1670 GTK_SIGNAL_FUNC(callbacks_drawingarea_motion_notify_event), NULL);
1671 gtk_signal_connect(GTK_OBJECT(drawingarea), "button_press_event",
1672 GTK_SIGNAL_FUNC(callbacks_drawingarea_button_press_event), NULL);
1673 gtk_signal_connect(GTK_OBJECT(drawingarea), "button_release_event",
1674 GTK_SIGNAL_FUNC(callbacks_drawingarea_button_release_event), NULL);
1675 gtk_signal_connect_after(GTK_OBJECT(mainWindow), "key_press_event",
1676 GTK_SIGNAL_FUNC(callbacks_window_key_press_event), NULL);
1677 gtk_signal_connect_after(GTK_OBJECT(mainWindow), "key_release_event",
1678 GTK_SIGNAL_FUNC(callbacks_window_key_release_event), NULL);
1679 gtk_signal_connect_after(GTK_OBJECT(mainWindow), "scroll_event",
1680 GTK_SIGNAL_FUNC(callbacks_window_scroll_event), NULL);
1681 gtk_signal_connect_after(GTK_OBJECT(mainWindow), "delete_event",
1682 GTK_SIGNAL_FUNC(callbacks_quit_activate), NULL);
1683
1684 gtk_widget_set_events(drawingarea, GDK_EXPOSURE_MASK
1685 | GDK_LEAVE_NOTIFY_MASK
1686 | GDK_ENTER_NOTIFY_MASK
1687 | GDK_BUTTON_PRESS_MASK
1688 | GDK_BUTTON_RELEASE_MASK
1689 | GDK_KEY_PRESS_MASK
1690 | GDK_KEY_RELEASE_MASK
1691 | GDK_POINTER_MOTION_MASK
1692 | GDK_POINTER_MOTION_HINT_MASK
1693 | GDK_SCROLL_MASK
1694 );
1695
1696 /*
1697 * Setup some GTK+ defaults.
1698 * These should really be somewhere else.
1699 */
1700 GdkColor zoom_outline_color = {0, 50000, 50000, 50000};
1701 GdkColor dist_measure_color = {0, 60000, 30000, 65000};
1702 GdkColor selection_color = {0, 65000, 65000, 65000};
1703
1704 screen.zoom_outline_color = zoom_outline_color;
1705 screen.dist_measure_color = dist_measure_color;
1706 screen.selection_color = selection_color;
1707
1708 screen.length_sum = 0;
1709
1710 screen.drawing_area = drawingarea;
1711 screen.win.hAdjustment = hAdjustment;
1712 screen.win.vAdjustment = vAdjustment;
1713 screen.win.hRuler = hRuler;
1714 screen.win.vRuler = vRuler;
1715 screen.win.sidepane_notebook = sidepane_notebook;
1716 screen.win.sidepaneRenderComboBox = GTK_COMBO_BOX(render_combobox);
1717 screen.win.toolButtonPointer = toggletoolbutton_pointer;
1718 screen.win.toolButtonPan = toggletoolbutton_pan;
1719 screen.win.toolButtonZoom = toggletoolbutton_zoom;
1720 screen.win.toolButtonMeasure = toggletoolbutton_measure;
1721
1722 /* make sure tooltips show on gtk <2.12 systems */
1723 gtk_tooltips_enable (tooltips);
1724
1725 gint width, height;
1726
1727 /* Good defaults according to Ales. Gives aspect ratio
1728 * of 1.3333... */
1729 if (req_width != -1 && req_height != -1) {
1730 width = req_width;
1731 height = req_height;
1732 } else {
1733 GdkScreen *screen;
1734 int nmonitors;
1735
1736 screen = gdk_screen_get_default();
1737 nmonitors = gdk_screen_get_n_monitors(screen);
1738
1739 width = gdk_screen_get_width(screen) * 3/4 / nmonitors;
1740 height = gdk_screen_get_height(screen) * 3/4 / nmonitors;
1741 }
1742
1743 gtk_window_set_default_size(GTK_WINDOW(mainWindow), width, height);
1744
1745 /* Restore main window size */
1746 if (screen.settings && req_width == -1 && req_height == -1) {
1747 GVariant *var;
1748 const gint32 *xy;
1749 gsize num;
1750 gboolean is_max;
1751
1752 var = g_settings_get_value (screen.settings, "window-size");
1753 xy = g_variant_get_fixed_array (var, &num, sizeof (*xy));
1754 if (num == 2)
1755 gtk_window_set_default_size (GTK_WINDOW (mainWindow),
1756 xy[0], xy[1]);
1757 g_variant_unref (var);
1758
1759 var = g_settings_get_value (screen.settings, "window-position");
1760 xy = g_variant_get_fixed_array (var, &num, sizeof (*xy));
1761 if (num == 2)
1762 gtk_window_move (GTK_WINDOW (mainWindow), xy[0], xy[1]);
1763 g_variant_unref (var);
1764
1765 is_max = g_settings_get_boolean (
1766 screen.settings, "window-maximized");
1767 if (is_max)
1768 gtk_window_maximize (GTK_WINDOW (mainWindow));
1769 }
1770
1771 g_object_set (G_OBJECT(gtk_settings_get_default()),
1772 "gtk-can-change-accels", TRUE, NULL);
1773 interface_load_accels ();
1774
1775 gtk_widget_show_all (mainWindow);
1776
1777 screen.win.messageTextView = message_textview;
1778 screen.win.statusMessageLeft = statusbar_label_left;
1779 screen.win.statusMessageRight = statusbar_label_right;
1780 screen.win.layerTree = tree;
1781 screen.win.treeIsUpdating = FALSE;
1782
1783 /* Request label largest width: negative mils coords require largest space */
1784 utf8_snprintf (str_coord, MAX_COORDLEN, _(gerbv_coords_pattern_mils_str),
1785 COORD2MILS (-screenRenderInfo.displayWidth/2.0/GERBV_SCALE_MIN),
1786 COORD2MILS (-screenRenderInfo.displayHeight/2.0/GERBV_SCALE_MIN));
1787
1788 request_label_max_size_by_text (screen.win.statusMessageLeft, str_coord);
1789
1790 callbacks_change_tool (NULL, (gpointer) 0);
1791 rename_main_window("",mainWindow);
1792
1793 set_window_icon (mainWindow);
1794 callbacks_update_layer_tree ();
1795
1796 /* Set GTK error log handler */
1797 g_log_set_handler (NULL,
1798 G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION | G_LOG_LEVEL_MASK,
1799 callbacks_handle_log_messages, NULL);
1800
1801 /* Output temporary stored log messages */
1802 extern GArray *log_array_tmp;
1803 struct log_struct log_item;
1804 int i;
1805
1806 for (i = 0; i < log_array_tmp->len; i++) {
1807 log_item = g_array_index (log_array_tmp, struct log_struct, i);
1808 callbacks_handle_log_messages (log_item.domain, log_item.level,
1809 log_item.message, NULL);
1810 g_free(log_item.domain);
1811 g_free(log_item.message);
1812 }
1813 g_array_free (log_array_tmp, TRUE);
1814
1815 /* connect this signals as late as possible to avoid triggering them before
1816 the gui is drawn */
1817 g_signal_connect ((gpointer) render_fast, "activate",
1818 G_CALLBACK (callbacks_viewmenu_rendertype_changed),
1819 GINT_TO_POINTER(GERBV_RENDER_TYPE_GDK));
1820 g_signal_connect ((gpointer) render_fast_xor, "activate",
1821 G_CALLBACK (callbacks_viewmenu_rendertype_changed),
1822 GINT_TO_POINTER(GERBV_RENDER_TYPE_GDK_XOR));
1823 g_signal_connect ((gpointer) render_normal, "activate",
1824 G_CALLBACK (callbacks_viewmenu_rendertype_changed),
1825 GINT_TO_POINTER(GERBV_RENDER_TYPE_CAIRO_NORMAL));
1826 g_signal_connect ((gpointer) render_hq, "activate",
1827 G_CALLBACK (callbacks_viewmenu_rendertype_changed),
1828 GINT_TO_POINTER(GERBV_RENDER_TYPE_CAIRO_HIGH_QUALITY));
1829 g_signal_connect ((gpointer) render_combobox, "changed",
1830 G_CALLBACK (callbacks_sidepane_render_type_combo_box_changed),
1831 NULL);
1832 gtk_main();
1833 interface_save_accels ();
1834 }
1835
1836 /* ---------------------------------------------------- */
1837 void
interface_set_render_type(int t)1838 interface_set_render_type (int t)
1839 {
1840 if (t >= GERBV_RENDER_TYPE_MAX)
1841 return;
1842
1843 screenRenderInfo.renderType = t;
1844
1845 /* make sure the interface is already up before calling
1846 * gtk_combo_box_set_active()
1847 */
1848 if (!screen.win.sidepaneRenderComboBox)
1849 return;
1850
1851 gtk_combo_box_set_active (GTK_COMBO_BOX (screen.win.sidepaneRenderComboBox), t);
1852 gtk_check_menu_item_set_active (screen.win.menu_view_render_group[t], TRUE);
1853 }
1854
1855 /* ---------------------------------------------------- */
1856 /**
1857 * This dialog box shows a message and two buttons:
1858 * "True" and "False". It returns gboolean 1 if the
1859 * user clicked "True", and gboolean 0 if the user
1860 * clicked "False".
1861 *
1862 */
1863
1864 gboolean
interface_get_alert_dialog_response(const gchar * primaryText,const gchar * secondaryText,gboolean show_checkbox,gboolean * ask_to_show_again,const gchar * true_button_label,const gchar * false_button_label)1865 interface_get_alert_dialog_response (const gchar *primaryText,
1866 const gchar *secondaryText,
1867 gboolean show_checkbox,
1868 gboolean *ask_to_show_again,
1869 const gchar *true_button_label,
1870 const gchar *false_button_label)
1871 /* This fcn returns TRUE if the user presses the OK button,
1872 otherwise it returns FALSE. */
1873 {
1874 /* Set show_checkbox = TRUE to show "do not show this again" checkbox. */
1875 /* Point ask_to_show_again to the variable to set to not show the checkbox. */
1876 GtkWidget *dialog1;
1877 GtkWidget *dialog_vbox1;
1878 GtkWidget *hbox1;
1879 GtkWidget *image1;
1880 GtkWidget *label1;
1881 GtkWidget *checkbox=NULL;
1882 GtkWidget *dialog_action_area1;
1883 GtkWidget *true_button, *false_button;
1884 gboolean returnVal = FALSE;
1885
1886 dialog1 = gtk_dialog_new ();
1887 gtk_window_set_title (GTK_WINDOW (dialog1), _("Gerbv Alert"));
1888 gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
1889 gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
1890 gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
1891 gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE);
1892
1893 dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
1894
1895 hbox1 = gtk_hbox_new (FALSE, 12);
1896 gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
1897 gtk_container_set_border_width (GTK_CONTAINER (hbox1), 6);
1898
1899 image1 = gtk_image_new_from_icon_name (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
1900 gtk_box_pack_start (GTK_BOX (hbox1), image1, TRUE, TRUE, 0);
1901 gtk_misc_set_alignment (GTK_MISC (image1), 0.5, 0);
1902
1903 gchar *labelMessage = g_strconcat ("<span weight=\"bold\" size=\"larger\">", _(primaryText),
1904 "</span>\n<span/>\n", _(secondaryText), NULL);
1905 label1 = gtk_label_new (labelMessage);
1906 g_free (labelMessage);
1907 GtkWidget *vbox9 = gtk_vbox_new (FALSE, 0);
1908 gtk_box_pack_start (GTK_BOX (vbox9), label1, FALSE, FALSE, 0);
1909 gtk_box_pack_start (GTK_BOX (hbox1), vbox9, FALSE, FALSE, 0);
1910 gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
1911 gtk_label_set_line_wrap (GTK_LABEL (label1), TRUE);
1912
1913 // even with no checkbox, this extra hbox gives the recommended 24 px space between the
1914 // label and the buttons
1915 GtkWidget *hbox2 = gtk_hbox_new (FALSE, 12);
1916 if (show_checkbox) {
1917 GtkWidget *label3 = gtk_label_new (" ");
1918
1919 checkbox = gtk_check_button_new_with_label(_("Do not show this dialog again."));
1920 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(checkbox), FALSE);
1921 gtk_box_pack_start (GTK_BOX (hbox2), label3, FALSE, FALSE, 0);
1922 gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
1923 }
1924 gtk_box_pack_start (GTK_BOX (vbox9), hbox2, FALSE, FALSE, 12);
1925
1926 dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
1927 gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
1928
1929 if (false_button_label) {
1930 false_button = gtk_button_new_from_stock (false_button_label);
1931 gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1932 false_button, GTK_RESPONSE_CANCEL);
1933 GTK_WIDGET_SET_FLAGS (false_button, GTK_CAN_DEFAULT);
1934 gtk_widget_grab_default (false_button);
1935 gtk_widget_grab_focus (false_button);
1936 }
1937
1938 if (true_button_label) {
1939 true_button = gtk_button_new_from_stock (true_button_label);
1940 gtk_dialog_add_action_widget (GTK_DIALOG (dialog1),
1941 true_button, GTK_RESPONSE_OK);
1942 GTK_WIDGET_SET_FLAGS (true_button, GTK_CAN_DEFAULT);
1943 }
1944
1945 gtk_widget_show_all (dialog1);
1946
1947 if (gtk_dialog_run ((GtkDialog*)dialog1) == GTK_RESPONSE_OK) {
1948 /* check to see if user clicked on "do not show again" box */
1949 if ((show_checkbox == TRUE) &&
1950 (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox)) == TRUE) &&
1951 (ask_to_show_again != NULL) ) {
1952 /* The user clicked the "do not show again box". Set corresponding
1953 * flag to FALSE. */
1954 *ask_to_show_again = FALSE;
1955 }
1956 returnVal = TRUE;
1957 }
1958 gtk_widget_destroy (dialog1);
1959
1960 return returnVal;
1961 }
1962
1963 static void
interface_reopen_question_callback_select_all(GtkWidget * checkbox,gpointer user_data)1964 interface_reopen_question_callback_select_all (GtkWidget *checkbox,
1965 gpointer user_data)
1966 {
1967
1968 /* Set select all checkbox if it was inconsistent. */
1969 if (gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (checkbox)))
1970 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
1971
1972 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (checkbox), FALSE);
1973
1974 for (GSList *cb = user_data; cb; cb = cb->next) {
1975 gtk_toggle_button_set_active (cb->data,
1976 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbox)));
1977 }
1978 }
1979
1980 struct interface_reopen_question_struct {
1981 GtkWidget *set_all_checkbox;
1982 GSList *checkbox_list;
1983 };
1984
1985 static void
interface_reopen_question_callback_checkbox(GtkWidget * checkbox,gpointer user_data)1986 interface_reopen_question_callback_checkbox(GtkWidget *checkbox,
1987 gpointer user_data)
1988 {
1989 struct interface_reopen_question_struct *st = user_data;
1990 gboolean all_set = TRUE, all_clear = TRUE;
1991
1992 if (st->set_all_checkbox == NULL)
1993 return;
1994
1995 for (GSList *cb = st->checkbox_list; cb; cb = cb->next) {
1996 if (gtk_toggle_button_get_active(cb->data))
1997 all_clear = FALSE;
1998 else
1999 all_set = FALSE;
2000 }
2001
2002 gtk_toggle_button_set_inconsistent (
2003 GTK_TOGGLE_BUTTON (st->set_all_checkbox), FALSE);
2004
2005 if (all_set)
2006 gtk_toggle_button_set_active (
2007 GTK_TOGGLE_BUTTON (st->set_all_checkbox), TRUE);
2008 else if (all_clear)
2009 gtk_toggle_button_set_active (
2010 GTK_TOGGLE_BUTTON (st->set_all_checkbox), FALSE);
2011 else
2012 gtk_toggle_button_set_inconsistent (
2013 GTK_TOGGLE_BUTTON (st->set_all_checkbox), TRUE);
2014 }
2015
2016 /* Add checkboxes for filenames and return list with checkbox widgets */
2017 static GSList *
interface_reopen_question_add_filename_checkboxes(GSList * fns,GSList * fns_is_mod,GSList * fns_cnt,GSList * fns_lay_num,GtkWidget * box)2018 interface_reopen_question_add_filename_checkboxes (
2019 GSList *fns, GSList *fns_is_mod,
2020 GSList *fns_cnt, GSList *fns_lay_num, GtkWidget *box)
2021 {
2022 GtkWidget *scrl_win, *vbox;
2023 GSList *checkboxes = NULL;
2024
2025 scrl_win = gtk_scrolled_window_new (NULL, NULL);
2026 gtk_box_pack_start (GTK_BOX (box), scrl_win, TRUE, TRUE, 0);
2027 gtk_container_set_border_width (GTK_CONTAINER (scrl_win), 2);
2028 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrl_win),
2029 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2030
2031 vbox = gtk_vbox_new (FALSE, 2);
2032 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrl_win), vbox);
2033
2034 for (unsigned int i = 0; i < g_slist_length (fns); i++) {
2035 GtkWidget *cb;
2036 GString *g_str = g_string_new (NULL);
2037 gchar *bn = g_path_get_basename (g_slist_nth_data (fns, i));
2038 int cnt = GPOINTER_TO_INT (g_slist_nth_data (fns_cnt, i));
2039 int lay_num = 1 + GPOINTER_TO_INT (g_slist_nth_data (fns_lay_num, i));
2040
2041 if (GPOINTER_TO_INT (g_slist_nth_data (fns_is_mod, i))) {
2042 /* Layer is modified */
2043 if (cnt > 1)
2044 g_string_printf (g_str, ngettext(
2045 "<b>%d</b> *<i>%s</i> (<b>changed</b>, %d layer)",
2046 "<b>%d</b> *<i>%s</i> (<b>changed</b>, %d layers)", cnt),
2047 lay_num, bn, cnt);
2048 else
2049 g_string_printf (g_str, _("<b>%d</b> *<i>%s</i> (<b>changed</b>)"),
2050 lay_num, bn);
2051 } else {
2052 /* Layer is not modified */
2053 if (cnt > 1)
2054 g_string_printf (g_str, ngettext(
2055 "<b>%d</b> %s (%d layer)",
2056 "<b>%d</b> %s (%d layers)", cnt), lay_num, bn, cnt);
2057 else
2058 g_string_printf (g_str, _("<b>%d</b> %s"), lay_num, bn);
2059 }
2060 g_free (bn);
2061
2062 cb = gtk_check_button_new_with_label ("");
2063 gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child (GTK_BIN (cb))),
2064 g_str->str);
2065 g_string_free (g_str, TRUE);
2066 checkboxes = g_slist_append (checkboxes, cb);
2067 gtk_box_pack_start (GTK_BOX (vbox), cb, FALSE, FALSE, 0);
2068 }
2069
2070 return checkboxes;
2071 }
2072
2073
2074 /* ---------------------------------------------------- */
2075 /**
2076 * This dialog box shows a text message with three buttons in the case
2077 * if the file to be open was already loaded:
2078 * "Reload" (the already loaded file)
2079 * "Open as new layer"
2080 * "Skip loading"
2081 */
2082 int
interface_reopen_question(GSList * fns,GSList * fns_is_mod,GSList * fns_cnt,GSList * fns_lay_num)2083 interface_reopen_question (GSList *fns, GSList *fns_is_mod,
2084 GSList *fns_cnt, GSList *fns_lay_num)
2085 {
2086 GtkDialog *dialog;
2087 GtkWidget *hbox, *vbox_main, *image,
2088 *selectAllCheckBox = NULL;
2089 GSList *fnCheckButtons = NULL;
2090 GtkWidget *label, *reloadButton, *openAsNewButton;
2091 struct interface_reopen_question_struct checkboxes_struct;
2092 GString *g_str = g_string_new (NULL);
2093 guint fns_len;
2094 gint ret = 0;
2095
2096 fns_len = g_slist_length (fns);
2097 if (0 == fns_len)
2098 return GTK_RESPONSE_NONE;
2099
2100 dialog = GTK_DIALOG (gtk_dialog_new());
2101 gtk_window_set_title (GTK_WINDOW (dialog), _("Gerbv — Reload Files"));
2102 gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
2103 gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
2104 gtk_dialog_set_has_separator (dialog, FALSE);
2105
2106 hbox = gtk_hbox_new (FALSE, 12);
2107 gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, TRUE, TRUE, 0);
2108 gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
2109
2110 image = gtk_image_new_from_icon_name (GTK_STOCK_DIALOG_WARNING,
2111 GTK_ICON_SIZE_DIALOG);
2112 gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
2113 gtk_misc_set_alignment (GTK_MISC (image), 0, 0);
2114
2115 vbox_main = gtk_vbox_new (FALSE, 0);
2116 gtk_box_pack_start (GTK_BOX (hbox), vbox_main, TRUE, TRUE, 0);
2117
2118 g_string_printf (g_str, "<span size=\"larger\">");
2119 g_string_append_printf (g_str, ngettext(
2120 "%u file is already loaded from directory",
2121 "%u files are already loaded from directory",
2122 fns_len), fns_len);
2123 g_string_append_printf (g_str, "</span>\n\"%s\"",
2124 g_path_get_dirname (fns->data));
2125
2126 /* Add title */
2127 label = gtk_label_new (g_str->str);
2128 gtk_box_pack_start (GTK_BOX (vbox_main), label, FALSE, FALSE, 0);
2129 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
2130 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
2131 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2132 gtk_label_set_selectable (GTK_LABEL (label), TRUE);
2133 g_string_free (g_str, TRUE);
2134
2135 fnCheckButtons = interface_reopen_question_add_filename_checkboxes (
2136 fns, fns_is_mod,
2137 fns_cnt, fns_lay_num, vbox_main);
2138
2139 /* Add "Select all" checkbox */
2140 if (fns_len > 1) {
2141 selectAllCheckBox =
2142 gtk_check_button_new_with_mnemonic (_("Select _all"));
2143
2144 g_signal_connect ((gpointer) selectAllCheckBox, "toggled",
2145 G_CALLBACK (interface_reopen_question_callback_select_all),
2146 fnCheckButtons);
2147
2148 gtk_box_pack_start (GTK_BOX(vbox_main), selectAllCheckBox, FALSE, FALSE, 0);
2149 }
2150
2151 /* Select all chekboxes by default */
2152 if (fns_len > 1) {
2153 gtk_toggle_button_set_active (
2154 GTK_TOGGLE_BUTTON(selectAllCheckBox), TRUE);
2155 } else {
2156 /* Only one checkbox in list */
2157 gtk_toggle_button_set_active (
2158 GTK_TOGGLE_BUTTON(fnCheckButtons->data), TRUE);
2159 }
2160
2161 checkboxes_struct.checkbox_list = fnCheckButtons;
2162 checkboxes_struct.set_all_checkbox = selectAllCheckBox;
2163
2164 /* Set callback for each file checkbox */
2165 for (GSList *cb = checkboxes_struct.checkbox_list; cb; cb = cb->next) {
2166 g_signal_connect ((gpointer) cb->data, "toggled",
2167 G_CALLBACK (interface_reopen_question_callback_checkbox),
2168 &checkboxes_struct);
2169 }
2170
2171 gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog->action_area),
2172 GTK_BUTTONBOX_END);
2173
2174 reloadButton = gtk_button_new_with_mnemonic (_("_Reload"));
2175 gtk_widget_set_tooltip_text (reloadButton,
2176 _("Reload layers with selected files"));
2177 gtk_dialog_add_action_widget (dialog, reloadButton, GTK_RESPONSE_YES);
2178 GTK_WIDGET_SET_FLAGS (reloadButton, GTK_CAN_DEFAULT);
2179
2180 openAsNewButton = gtk_button_new_with_mnemonic (_("Add as _new"));
2181 gtk_widget_set_tooltip_text (openAsNewButton,
2182 _("Add selected files as new layers"));
2183 gtk_dialog_add_action_widget (dialog, openAsNewButton, GTK_RESPONSE_OK);
2184
2185 gtk_dialog_add_action_widget (dialog,
2186 gtk_button_new_from_stock (GTK_STOCK_CANCEL), GTK_RESPONSE_CANCEL);
2187
2188 gtk_widget_show_all (GTK_WIDGET(dialog));
2189
2190 ret = gtk_dialog_run (dialog);
2191
2192 /* Mark with NULL filenames list data with unchecked filenames */
2193 for (GSList *cb = fnCheckButtons, *fn = fns;
2194 cb && fn; cb = cb->next, fn = fn->next) {
2195 if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cb->data)))
2196 fn->data = NULL;
2197 }
2198
2199 g_slist_free_full (fnCheckButtons, (GDestroyNotify)gtk_widget_destroy);
2200 gtk_widget_destroy (GTK_WIDGET(dialog));
2201
2202 return ret;
2203 }
2204
2205
2206 /* ---------------------------------------------------- */
2207 /**
2208 * This dialog box shows a textmessage and one button:
2209 * "OK". It does not return anything.
2210 *
2211 */
2212 void
interface_show_alert_dialog(gchar * primaryText,gchar * secondaryText,gboolean show_checkbox,gboolean * ask_to_show_again)2213 interface_show_alert_dialog (gchar *primaryText, gchar *secondaryText,
2214 gboolean show_checkbox, gboolean *ask_to_show_again )
2215 /* This fcn tells the user something, and only displays "OK" */
2216 {
2217 /* Set show_checkbox = TRUE to show "do not show this again" checkbox. */
2218 /* Point ask_to_show_again to the variable to set to not show the checkbox. */
2219 GtkWidget *dialog1;
2220 GtkWidget *dialog_vbox1;
2221 GtkWidget *hbox1;
2222 GtkWidget *image1;
2223 GtkWidget *label1;
2224 GtkWidget *checkbox=NULL;
2225 GtkWidget *dialog_action_area1;
2226 GtkWidget *okbutton1;
2227
2228 dialog1 = gtk_dialog_new ();
2229 gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
2230 gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
2231 gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
2232 gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE);
2233
2234 dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
2235
2236 hbox1 = gtk_hbox_new (FALSE, 12);
2237 gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
2238 gtk_container_set_border_width (GTK_CONTAINER (hbox1), 6);
2239
2240 image1 = gtk_image_new_from_icon_name (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
2241 gtk_box_pack_start (GTK_BOX (hbox1), image1, TRUE, TRUE, 0);
2242 gtk_misc_set_alignment (GTK_MISC (image1), 0.5, 0);
2243
2244 gchar *labelMessage = g_strconcat ("<span weight=\"bold\" size=\"larger\">", _(primaryText),
2245 "</span>\n<span/>\n", _(secondaryText), NULL);
2246 label1 = gtk_label_new (labelMessage);
2247 g_free (labelMessage);
2248
2249 GtkWidget *vbox9 = gtk_vbox_new (FALSE, 0);
2250 gtk_box_pack_start (GTK_BOX (vbox9), label1, FALSE, FALSE, 0);
2251 gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
2252 gtk_label_set_line_wrap (GTK_LABEL (label1), TRUE);
2253 gtk_box_pack_start (GTK_BOX (hbox1), vbox9, FALSE, FALSE, 0);
2254
2255 GtkWidget *hbox2 = gtk_hbox_new (FALSE, 12);
2256 if (show_checkbox) {
2257 GtkWidget *label3 = gtk_label_new (" ");
2258
2259 checkbox = gtk_check_button_new_with_label(_("Do not show this dialog again."));
2260 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(checkbox), FALSE);
2261 gtk_box_pack_start (GTK_BOX (hbox2), label3, FALSE, FALSE, 0);
2262 gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
2263 }
2264 gtk_box_pack_start (GTK_BOX (vbox9), hbox2, FALSE, FALSE, 12);
2265
2266 dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
2267 gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
2268
2269 okbutton1 = gtk_button_new_from_stock (GTK_STOCK_OK);
2270 gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
2271 GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
2272
2273 gtk_widget_show_all (dialog1);
2274
2275 /* check to see if user clicked on "do not show again" box */
2276 if ((show_checkbox == TRUE) &&
2277 (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox)) == TRUE) &&
2278 (ask_to_show_again != NULL) ) {
2279 /* The user clicked the "do not show again box". Set corresponding
2280 * flag to FALSE. */
2281 *ask_to_show_again = FALSE;
2282 }
2283
2284 gtk_dialog_run (GTK_DIALOG(dialog1));
2285 gtk_widget_destroy (dialog1);
2286
2287 return;
2288 }
2289
2290 static int focused_widget_num = 0;
2291
2292 void
focus_in_event_callback(int * widget_num)2293 focus_in_event_callback (int *widget_num)
2294 {
2295 focused_widget_num = *widget_num;
2296 }
2297
2298 void
interface_show_layer_edit_dialog(gerbv_user_transformation_t * transforms[],gerbv_unit_t screenUnit)2299 interface_show_layer_edit_dialog (gerbv_user_transformation_t *transforms[],
2300 gerbv_unit_t screenUnit) {
2301 GtkWidget *dialog;
2302 GtkWidget *check1,*check2,*tempWidget,*tempWidget2,*tableWidget;
2303 GtkWidget *spin1,*spin2,*spin3,*spin4,*spin5;
2304 GtkAdjustment *adj;
2305 /* NOTE: transforms[0] is selected layer, other in array is visible. */
2306 /* Copy _selected_ layer transformation to use as initial. */
2307 gerbv_user_transformation_t trans_init = *transforms[0],
2308 *trans = &trans_init;
2309
2310 #if 0
2311 /* TODO: cancel, backup array of initial transforms */
2312 gerbv_user_transformation_t startTransform = trans;
2313 #endif
2314 GtkWidget **focus_widgets[] = {&spin1, &spin2, &spin3, &spin4, &spin5, &check1, &check2, NULL};
2315 int focus_nums[G_N_ELEMENTS(focus_widgets)];
2316 int i;
2317
2318 dialog = gtk_dialog_new_with_buttons (_("Edit layer"),
2319 GTK_WINDOW (screen.win.topLevelWindow),
2320 GTK_DIALOG_DESTROY_WITH_PARENT,
2321 _("Apply to _active"), GTK_RESPONSE_APPLY,
2322 /* Yes -- apply to all visible */
2323 _("Apply to _visible"), GTK_RESPONSE_YES,
2324 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2325 NULL);
2326
2327 gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
2328 gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
2329 gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
2330 gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
2331
2332 tableWidget = gtk_table_new (16,3,FALSE);
2333 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tableWidget, FALSE, FALSE, 0);
2334
2335 tempWidget = gtk_label_new (NULL);
2336 gtk_label_set_markup (GTK_LABEL (tempWidget), _("<span weight=\"bold\">Translation</span>"));
2337 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2338 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,0,2,0,1,GTK_EXPAND|GTK_FILL,0,0,5);
2339
2340 tempWidget = gtk_label_new ("");
2341 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,0,1,1,2,GTK_EXPAND|GTK_FILL,0,0,0);
2342 gdouble translateX, translateY;
2343
2344 if (screenUnit == (gerbv_unit_t) GERBV_MILS) {
2345 tempWidget = gtk_label_new (_("X (mils):"));
2346 tempWidget2 = gtk_label_new (_("Y (mils):"));
2347 translateX = trans->translateX * 1000;
2348 translateY = trans->translateY * 1000;
2349 }
2350 else if (screen.unit == (gerbv_gui_unit_t) GERBV_MMS) {
2351 tempWidget = gtk_label_new (_("X (mm):"));
2352 tempWidget2 = gtk_label_new (_("Y (mm):"));
2353 translateX = trans->translateX * 25.4;
2354 translateY = trans->translateY * 25.4;
2355 }
2356 else {
2357 tempWidget = gtk_label_new (_("X (inches):"));
2358 tempWidget2 = gtk_label_new (_("Y (inches):"));
2359 translateX = trans->translateX;
2360 translateY = trans->translateY;
2361 }
2362
2363 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2364 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,1,2,GTK_FILL,0,5,0);
2365 gtk_misc_set_alignment (GTK_MISC (tempWidget2), 0.0, 0.5);
2366 gtk_table_attach ((GtkTable *) tableWidget, tempWidget2,1,2,2,3,GTK_FILL,0,5,0);
2367 adj = (GtkAdjustment *) gtk_adjustment_new (translateX, -1000000, 1000000, 1, 10, 0.0);
2368 spin1 = (GtkWidget *) gtk_spin_button_new (adj, 0.1, 4);
2369 gtk_table_attach ((GtkTable *) tableWidget, spin1,2,3,1,2,GTK_FILL,0,0,0);
2370 adj = (GtkAdjustment *) gtk_adjustment_new (translateY, -1000000, 1000000, 1, 10, 0.0);
2371 spin2 = (GtkWidget *) gtk_spin_button_new (adj, 0.1, 4);
2372 gtk_table_attach ((GtkTable *) tableWidget, spin2,2,3,2,3,GTK_FILL,0,0,0);
2373
2374 gtk_table_set_row_spacing ((GtkTable *) tableWidget, 3, 8);
2375 tempWidget = gtk_label_new (NULL);
2376 gtk_label_set_markup (GTK_LABEL (tempWidget), _("<span weight=\"bold\">Scale</span>"));
2377 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2378 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,0,2,4,5,GTK_EXPAND|GTK_FILL,0,0,5);
2379
2380 tempWidget = gtk_label_new (_("X direction:"));
2381 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2382 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,5,6,GTK_FILL,0,5,0);
2383 tempWidget = gtk_label_new (_("Y direction:"));
2384 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2385 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,6,7,GTK_FILL,0,5,0);
2386 adj = (GtkAdjustment *) gtk_adjustment_new (trans->scaleX, -1000000, 1000000, 1, 10, 0.0);
2387 spin3 = (GtkWidget *) gtk_spin_button_new (adj, 1, 3);
2388 gtk_table_attach ((GtkTable *) tableWidget, spin3,2,3,5,6,GTK_FILL,0,0,0);
2389 adj = (GtkAdjustment *) gtk_adjustment_new (trans->scaleY, -1000000, 1000000, 1, 10, 0.0);
2390 spin4 = (GtkWidget *) gtk_spin_button_new (adj, 1, 3);
2391 gtk_table_attach ((GtkTable *) tableWidget, spin4,2,3,6,7,GTK_FILL,0,0,0);
2392
2393 gtk_table_set_row_spacing ((GtkTable *) tableWidget, 7, 8);
2394
2395 tempWidget = gtk_label_new (NULL);
2396 gtk_label_set_markup (GTK_LABEL (tempWidget), _("<span weight=\"bold\">Rotation</span>"));
2397 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2398 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,0,2,8,9,GTK_EXPAND|GTK_FILL,0,0,5);
2399
2400 tempWidget = gtk_label_new (_("Rotation (degrees):"));
2401 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2402 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,9,10,GTK_FILL,0,5,0);
2403 spin5 = gtk_combo_box_new_text();
2404 gtk_combo_box_append_text (GTK_COMBO_BOX(spin5), _("None"));
2405 gtk_combo_box_append_text (GTK_COMBO_BOX(spin5), _("90 deg CCW"));
2406 gtk_combo_box_append_text (GTK_COMBO_BOX(spin5), _("180 deg CCW"));
2407 gtk_combo_box_append_text (GTK_COMBO_BOX(spin5), _("270 deg CCW"));
2408 gdouble rot_deg = RAD2DEG(trans->rotation);
2409 if (rot_deg < 135 && rot_deg >= 45)
2410 gtk_combo_box_set_active (GTK_COMBO_BOX(spin5), 1);
2411 else if (rot_deg < 225 && rot_deg >= 135)
2412 gtk_combo_box_set_active (GTK_COMBO_BOX(spin5), 2);
2413 else if (rot_deg < 315 && rot_deg >= 225)
2414 gtk_combo_box_set_active (GTK_COMBO_BOX(spin5), 3);
2415 else
2416 gtk_combo_box_set_active (GTK_COMBO_BOX(spin5), 0);
2417 #if 0
2418 adj = (GtkAdjustment *) gtk_adjustment_new (RAD2DEG(trans->rotation), -1000000, 1000000,
2419 1, 10, 0.0);
2420 spin5 = (GtkWidget *) gtk_spin_button_new (adj, 0, 3);
2421 #endif
2422
2423 gtk_table_attach ((GtkTable *) tableWidget, spin5,2,3,9,10,GTK_FILL,0,0,0);
2424
2425 gtk_table_set_row_spacing ((GtkTable *) tableWidget, 10, 8);
2426 tempWidget = gtk_label_new (NULL);
2427 gtk_label_set_markup (GTK_LABEL (tempWidget), _("<span weight=\"bold\">Mirroring</span>"));
2428 gtk_misc_set_alignment (GTK_MISC (tempWidget), 0.0, 0.5);
2429 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,0,2,11,12,GTK_EXPAND|GTK_FILL,0,0,5);
2430
2431 tempWidget = gtk_label_new (_("About X axis:"));
2432 gtk_misc_set_alignment (GTK_MISC (tempWidget), 1.0, 0.5);
2433 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,12,13,GTK_FILL,0,5,0);
2434 check1 = (GtkWidget *) gtk_check_button_new ();
2435 gtk_toggle_button_set_active ((GtkToggleButton *) check1, trans->mirrorAroundX);
2436 gtk_table_attach ((GtkTable *) tableWidget, check1,2,3,12,13,0,0,0,2);
2437
2438 tempWidget = gtk_label_new (_("About Y axis:"));
2439 gtk_misc_set_alignment (GTK_MISC (tempWidget), 1.0, 0.5);
2440 gtk_table_attach ((GtkTable *) tableWidget, tempWidget,1,2,13,14,GTK_FILL,0,5,0);
2441 check2 = (GtkWidget *) gtk_check_button_new ();
2442 gtk_toggle_button_set_active ((GtkToggleButton *) check2, trans->mirrorAroundY);
2443 gtk_table_attach ((GtkTable *) tableWidget, check2,2,3,13,14,0,0,0,2);
2444
2445 for (i = 0; focus_widgets[i] != NULL; i++) {
2446 /* Set stored focus */
2447 if (i == focused_widget_num) {
2448 gtk_widget_grab_focus (*focus_widgets[i]);
2449 }
2450
2451 /* Set focus-in-event callback */
2452 focus_nums[i] = i;
2453 g_signal_connect_swapped ((gpointer)(*focus_widgets[i]), "focus-in-event",
2454 G_CALLBACK (focus_in_event_callback), (gpointer)(focus_nums + i));
2455 }
2456
2457 gtk_table_set_row_spacing ((GtkTable *) tableWidget, 14, 8);
2458 gtk_widget_show_all (dialog);
2459 gint result = GTK_RESPONSE_APPLY;
2460
2461 /* Each time the user selects "apply" or "apply to all", update the
2462 * screen and re-enter the dialog loop */
2463 while (result == GTK_RESPONSE_APPLY || result == GTK_RESPONSE_YES) {
2464 result = gtk_dialog_run (GTK_DIALOG(dialog));
2465 if (result != GTK_RESPONSE_CLOSE) {
2466 /* Extract all the parameters */
2467 if (screenUnit == (gerbv_unit_t) GERBV_MILS) {
2468 trans->translateX = gtk_spin_button_get_value ((GtkSpinButton *) spin1)/
2469 1000;
2470 trans->translateY = gtk_spin_button_get_value ((GtkSpinButton *) spin2)/
2471 1000;
2472 } else if (screen.unit == (gerbv_gui_unit_t) GERBV_MMS) {
2473 trans->translateX = gtk_spin_button_get_value ((GtkSpinButton *) spin1)/
2474 25.4;
2475 trans->translateY = gtk_spin_button_get_value ((GtkSpinButton *) spin2)/
2476 25.4;
2477 } else {
2478 trans->translateX = gtk_spin_button_get_value ((GtkSpinButton *) spin1);
2479 trans->translateY = gtk_spin_button_get_value ((GtkSpinButton *) spin2);
2480 }
2481
2482 trans->scaleX = gtk_spin_button_get_value ((GtkSpinButton *)spin3);
2483 trans->scaleY = gtk_spin_button_get_value ((GtkSpinButton *)spin4);
2484 gint rotationIndex = gtk_combo_box_get_active ((GtkComboBox *)spin5);
2485
2486 if (rotationIndex == 0)
2487 trans->rotation = 0;
2488 else if (rotationIndex == 1)
2489 trans->rotation = M_PI_2;
2490 else if (rotationIndex == 2)
2491 trans->rotation = M_PI;
2492 else if (rotationIndex == 3)
2493 trans->rotation = M_PI + M_PI_2;
2494
2495 trans->mirrorAroundX = gtk_toggle_button_get_active ((GtkToggleButton *) check1);
2496 trans->mirrorAroundY = gtk_toggle_button_get_active ((GtkToggleButton *) check2);
2497
2498 if (result == GTK_RESPONSE_APPLY) {
2499 /* Apply to selected layer */
2500 *transforms[0] = *trans;
2501 } else if (result == GTK_RESPONSE_YES) {
2502 /* Apply to all visible layers (but not selected one) */
2503 i = 1;
2504 while (transforms[i] != NULL) {
2505 *transforms[i++] = *trans;
2506 }
2507 }
2508
2509 render_refresh_rendered_image_on_screen ();
2510 callbacks_update_layer_tree ();
2511 }
2512 }
2513 #if 0
2514 /* TODO: restore from backup array */
2515 if (result == GTK_RESPONSE_CANCEL) {
2516 // revert back to the start values if the user cancelled
2517 *transform = startTransform;
2518 }
2519 #endif
2520
2521 gtk_widget_destroy (dialog);
2522
2523 return;
2524 }
2525
2526