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