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