?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gerbv_open_image() can now take a zip archive as an argument.
[geda-gerbv/spe.git] / src / callbacks.c
blobfcb7b0d776e7a104d9d0dc35434be6d951388c70
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 will 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24 /** \file callbacks.c
25 \brief Callback functions for the GUI widgets
26 \ingroup gerbv
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif
32
33 #include <glib.h>
34 #include <gtk/gtk.h>
35 #include <gdk/gdk.h>
36 #ifndef WIN32
37 #include <gdk/gdkx.h>
38 #endif
39 #include <gdk/gdkkeysyms.h>
40
41 #ifdef HAVE_STDLIB_H
42 #include <stdlib.h>
43 #endif
44
45 #ifdef HAVE_STRING_H
46 #include <string.h>
47 #endif
48
49 #ifdef HAVE_TIME_H
50 #include <time.h>
51 #endif
52
53 #ifdef HAVE_UNISTD_H
54 #include <unistd.h>
55 #endif
56
57 #include <math.h>
58 #include "common.h"
59 #include "gerbv.h"
60 #include "main.h"
61 #include "callbacks.h"
62 #include "interface.h"
63 #include "attribute.h"
64 #include "render.h"
65
66 #include "draw-gdk.h"
67
68 #include "draw.h"
69 #ifdef WIN32
70 #include <cairo-win32.h>
71 #else
72 #include <cairo-xlib.h>
73 #endif
74
75
76 #define dprintf if(DEBUG) printf
77
78 /* This default extension should really not be changed, but if it absolutely
79 * must change, the ../win32/gerbv.nsi.in *must* be changed to reflect that.
80 * Just grep for the extension (gvp) and change it in two places in that file.
81 */
82 #define GERBV_PROJECT_FILE_NAME "Gerbv Project"
83 #define GERBV_PROJECT_FILE_EXT ".gvp"
84 #define GERBV_PROJECT_FILE_PAT "*.gvp"
85
86 #define SAVE_PROJECT 0
87 #define SAVE_AS_PROJECT 1
88 #define OPEN_PROJECT 2
89 # define _(String) (String)
90
91 /**Global variable to keep track of what's happening on the screen.
92 Declared extern in gerbv_screen.h
93 */
94 extern gerbv_screen_t screen;
95 extern gerbv_render_info_t screenRenderInfo;
96
97
98 /* These are the names of the valid apertures. These
99 * values are used in several places in this file.
100 * Please keep this in sync with the gerbv_aperture_type_t
101 * enum defined in gerbv.h */
102 char *ap_names[] = {"NONE",
103 "CIRCLE",
104 "RECTANGLE",
105 "OVAL", /* an ovular (obround) aperture */
106 "POLYGON", /* a polygon aperture */
107 "MACRO", /* a RS274X macro */
108 "MACRO_CIRCLE", /* a RS274X circle macro */
109 "MACRO_OUTLINE", /* a RS274X outline macro */
110 "MACRO_POLYGON", /* a RS274X polygon macro */
111 "MACRO_MOIRE", /* a RS274X moire macro */
112 "MACRO_THERMAL", /* a RS274X thermal macro */
113 "MACRO_LINE20", /* a RS274X line (code 20) macro */
114 "MACRO_LINE21", /* a RS274X line (code 21) macro */
115 "MACRO_LINE22" /* a RS274X line (code 22) macro */
116 };
117
118 gint callbacks_get_selected_row_index (void);
119
120 /* --------------------------------------------------------- */
121 GtkWidget *
122 callbacks_generate_alert_dialog (gchar *primaryText, gchar *secondaryText){
123 GtkWidget *dialog, *label;
124
125 dialog = gtk_dialog_new_with_buttons (primaryText,
126 (GtkWindow *)screen.win.topLevelWindow,
127 GTK_DIALOG_DESTROY_WITH_PARENT,
128 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
129 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
130 NULL);
131 label = gtk_label_new (secondaryText);
132 /* Add the label, and show everything we've added to the dialog. */
133 gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
134 label);
135 gtk_widget_show_all (dialog);
136 return dialog;
137 }
138
139 /* --------------------------------------------------------- */
140 /**
141 * The file -> new menu item was selected. Create new
142 * project.
143 *
144 */
145 void
146 callbacks_new_activate (GtkMenuItem *menuitem,
147 gpointer user_data)
148 {
149 if (mainProject->last_loaded >= 0) {
150 if (!interface_get_alert_dialog_response (
151 "Do you want to close any open layers and start a new project?",
152 "Starting a new project will cause all currently open layers to be closed. Any unsaved changes will be lost.",
153 FALSE,
154 NULL))
155 return;
156 }
157 /* Unload all layers and then clear layer window */
158 gerbv_unload_all_layers (mainProject);
159 callbacks_update_layer_tree ();
160 render_clear_selection_buffer ();
161
162 /* Destroy project info */
163 if (mainProject->project) {
164 g_free(mainProject->project);
165 mainProject->project = NULL;
166 }
167 render_refresh_rendered_image_on_screen();
168 }
169
170
171 /* --------------------------------------------------------- */
172 /**
173 * The file -> open menu item was selected. Open a
174 * project file.
175 *
176 */
177 void
178 callbacks_open_project_activate (GtkMenuItem *menuitem,
179 gpointer user_data)
180 {
181 gchar *filename=NULL;
182 GtkFileFilter * filter;
183
184 if (mainProject->last_loaded >= 0) {
185 if (!interface_get_alert_dialog_response (
186 "Do you want to close any open layers and load an existing project?",
187 "Loading a project will cause all currently open layers to be closed. Any unsaved changes will be lost.",
188 FALSE,
189 NULL))
190 return;
191 }
192
193 screen.win.gerber =
194 gtk_file_chooser_dialog_new ("Open project file...",
195 NULL,
196 GTK_FILE_CHOOSER_ACTION_OPEN,
197 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
198 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
199 NULL);
200 gtk_file_chooser_set_current_folder ((GtkFileChooser *) screen.win.gerber,
201 mainProject->path);
202
203 filter = gtk_file_filter_new();
204 gtk_file_filter_set_name(filter, GERBV_PROJECT_FILE_NAME);
205 gtk_file_filter_add_pattern(filter, GERBV_PROJECT_FILE_PAT);
206 gtk_file_chooser_add_filter ((GtkFileChooser *) screen.win.gerber,
207 filter);
208
209 filter = gtk_file_filter_new();
210 gtk_file_filter_set_name(filter, "All");
211 gtk_file_filter_add_pattern(filter, "*");
212 gtk_file_chooser_add_filter ((GtkFileChooser *) screen.win.gerber,
213 filter);
214
215 gtk_widget_show (screen.win.gerber);
216 if (gtk_dialog_run ((GtkDialog*)screen.win.gerber) == GTK_RESPONSE_ACCEPT) {
217 filename =
218 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (screen.win.gerber));
219 /* update the last folder */
220 g_free (mainProject->path);
221 mainProject->path = gtk_file_chooser_get_current_folder ((GtkFileChooser *) screen.win.gerber);
222 }
223 gtk_widget_destroy (screen.win.gerber);
224
225 if (filename) {
226 gerbv_unload_all_layers (mainProject);
227 main_open_project_from_filename (mainProject, filename);
228 }
229 gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
230 render_refresh_rendered_image_on_screen();
231 callbacks_update_layer_tree();
232
233 return;
234 }
235
236
237 /* --------------------------------------------------------- */
238 /**
239 * The file -> open layer menu item was selected. Open a
240 * layer (or layers) from a file.
241 *
242 */
243 void
244 callbacks_open_layer_activate (GtkMenuItem *menuitem,
245 gpointer user_data)
246 {
247 GSList *filenames=NULL;
248 GSList *filename=NULL;
249
250 screen.win.gerber =
251 gtk_file_chooser_dialog_new ("Open Gerber, drill, or pick & place file(s)...",
252 NULL,
253 GTK_FILE_CHOOSER_ACTION_OPEN,
254 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
255 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
256 NULL);
257
258 gtk_file_chooser_set_select_multiple((GtkFileChooser *) screen.win.gerber, TRUE);
259 gtk_file_chooser_set_current_folder ((GtkFileChooser *) screen.win.gerber,
260 mainProject->path);
261 gtk_widget_show (screen.win.gerber);
262 if (gtk_dialog_run ((GtkDialog*)screen.win.gerber) == GTK_RESPONSE_ACCEPT) {
263 filenames =
264 gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER (screen.win.gerber));
265 /* update the last folder */
266 g_free (mainProject->path);
267 mainProject->path = gtk_file_chooser_get_current_folder ((GtkFileChooser *) screen.win.gerber);
268 }
269 gtk_widget_destroy (screen.win.gerber);
270
271 /* Now try to open all gerbers specified */
272 for (filename=filenames; filename; filename=filename->next) {
273 gerbv_open_layer_from_filename(mainProject, filename->data, NULL);
274 }
275 g_slist_free(filenames);
276
277 gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
278 render_refresh_rendered_image_on_screen();
279 callbacks_update_layer_tree();
280
281 return;
282 }
283
284
285 /* --------------------------------------------------------- */
286 /**
287 * The file -> open zip file menu item was selected. Open a
288 * zip file and read in all file name.
289 *
290 */
291 void
292 callbacks_open_zip_activate(GtkMenuItem *menuitem,
293 gpointer user_data)
294 {
295 gchar *zipname = NULL;
296 GSList *filename = NULL;
297 GSList *filenames = NULL;
298 GtkFileFilter *filter;
299
300 screen.win.gerber =
301 gtk_file_chooser_dialog_new ("Open a zip file with Gerber, drill, or pick & place file(s)...",
302 NULL,
303 GTK_FILE_CHOOSER_ACTION_OPEN,
304 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
305 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
306 NULL);
307
308 filter = gtk_file_filter_new();
309 gtk_file_filter_set_name(filter,"Zip Files (*.zip)");
310 gtk_file_filter_add_pattern(filter, "*.zip");
311 gtk_file_chooser_add_filter((GtkFileChooser *) screen.win.gerber, filter);
312
313 filter = gtk_file_filter_new();
314 gtk_file_filter_set_name(filter,"All Files (*.*)");
315 gtk_file_filter_add_pattern(filter, "*.*");
316 gtk_file_chooser_add_filter((GtkFileChooser *) screen.win.gerber, filter);
317
318 gtk_file_chooser_set_current_folder ((GtkFileChooser *) screen.win.gerber,
319 mainProject->path);
320 gtk_widget_show (screen.win.gerber);
321
322 if (gtk_dialog_run ((GtkDialog*)screen.win.gerber) == GTK_RESPONSE_ACCEPT) {
323 zipname =
324 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (screen.win.gerber));
325 /* update the last folder */
326 g_free (mainProject->path);
327 mainProject->path = gtk_file_chooser_get_current_folder ((GtkFileChooser *) screen.win.gerber);
328 }
329 gtk_widget_destroy (screen.win.gerber);
330
331 gerb_filenames_in_zip(zipname, &filenames);
332
333 for (filename = filenames; filename; filename = filename->next) {
334 gerbv_open_layer_from_filename (mainProject, filename->data, zipname);
335 }
336 g_slist_free(filenames);
337
338 gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
339 render_refresh_rendered_image_on_screen();
340 callbacks_update_layer_tree();
341
342 return;
343 }
344
345 /* --------------------------------------------------------- */
346 void
347 callbacks_revert_activate (GtkMenuItem *menuitem,
348 gpointer user_data)
349 {
350 gerbv_revert_all_files (mainProject);
351 render_clear_selection_buffer();
352 callbacks_update_selected_object_message(FALSE);
353 render_refresh_rendered_image_on_screen();
354 callbacks_update_layer_tree();
355 }
356
357 /* --------------------------------------------------------- */
358 void
359 callbacks_save_project_activate (GtkMenuItem *menuitem,
360 gpointer user_data)
361 {
362 if (mainProject->project)
363 main_save_project_from_filename (mainProject, mainProject->project);
364 else
365 callbacks_generic_save_activate (menuitem, (gpointer) CALLBACKS_SAVE_PROJECT_AS);
366 callbacks_update_layer_tree();
367 return;
368 }
369
370 /* --------------------------------------------------------- */
371 void
372 callbacks_save_layer_activate (GtkMenuItem *menuitem,
373 gpointer user_data)
374 {
375 /* first figure out which layer in the layer side menu is selected */
376 gint index=callbacks_get_selected_row_index();
377
378 /* Now save that layer */
379 if (index >= 0) {
380 if (!gerbv_save_layer_from_index (mainProject, index, mainProject->file[index]->fullPathname)) {
381 interface_show_alert_dialog("Gerbv cannot export this file type",
382 NULL,
383 FALSE,
384 NULL);
385 mainProject->file[index]->layer_dirty = FALSE;
386 callbacks_update_layer_tree();
387 return;
388 }
389 }
390 callbacks_update_layer_tree();
391 return;
392 }
393
394 /* --------------------------------------------------------- */
395 void
396 callbacks_generic_save_activate (GtkMenuItem *menuitem,
397 gpointer user_data)
398 {
399 gchar *filename=NULL;
400 gint processType = GPOINTER_TO_INT (user_data);
401 gchar *windowTitle=NULL;
402 GtkFileFilter * filter;
403
404 if (processType == CALLBACKS_SAVE_PROJECT_AS)
405 windowTitle = g_strdup ("Save project as...");
406 else if (processType == CALLBACKS_SAVE_FILE_PS)
407 windowTitle = g_strdup ("Export PS file as...");
408 else if (processType == CALLBACKS_SAVE_FILE_PDF)
409 windowTitle = g_strdup ("Export PDF file as...");
410 else if (processType == CALLBACKS_SAVE_FILE_SVG)
411 windowTitle = g_strdup ("Export SVG file as...");
412 else if (processType == CALLBACKS_SAVE_FILE_PNG)
413 windowTitle = g_strdup ("Export PNG file as...");
414 else if (processType == CALLBACKS_SAVE_FILE_RS274X)
415 windowTitle = g_strdup ("Export RS-274X file as...");
416 else if (processType == CALLBACKS_SAVE_FILE_DRILL)
417 windowTitle = g_strdup ("Export Excellon drill file as...");
418 else if (processType == CALLBACKS_SAVE_LAYER_AS)
419 windowTitle = g_strdup ("Save layer as...");
420
421 screen.win.gerber =
422 gtk_file_chooser_dialog_new (windowTitle, NULL,
423 GTK_FILE_CHOOSER_ACTION_SAVE,
424 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
425 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
426 NULL);
427 g_free (windowTitle);
428
429 /* if we're saving or exporting a layer, start off in the location of the
430 loaded file */
431 if (processType != CALLBACKS_SAVE_PROJECT_AS) {
432 gint index=callbacks_get_selected_row_index();
433 if (index >= 0) {
434 gchar *dirName = g_path_get_dirname (mainProject->file[index]->fullPathname);
435 gtk_file_chooser_set_current_folder ((GtkFileChooser *) screen.win.gerber,
436 dirName);
437 g_free (dirName);
438 }
439 }
440
441 if (processType == CALLBACKS_SAVE_PROJECT_AS) {
442 filter = gtk_file_filter_new();
443 gtk_file_filter_set_name(filter, GERBV_PROJECT_FILE_NAME);
444 gtk_file_filter_add_pattern(filter, GERBV_PROJECT_FILE_PAT);
445 gtk_file_chooser_add_filter ((GtkFileChooser *) screen.win.gerber,
446 filter);
447
448 filter = gtk_file_filter_new();
449 gtk_file_filter_set_name(filter, "All");
450 gtk_file_filter_add_pattern(filter, "*");
451 gtk_file_chooser_add_filter ((GtkFileChooser *) screen.win.gerber,
452 filter);
453
454 gtk_file_chooser_set_current_name ((GtkFileChooser *) screen.win.gerber,
455 "untitled" GERBV_PROJECT_FILE_EXT );
456 }
457
458 gtk_widget_show (screen.win.gerber);
459 if (gtk_dialog_run ((GtkDialog*)screen.win.gerber) == GTK_RESPONSE_ACCEPT) {
460 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (screen.win.gerber));
461 }
462 gtk_widget_destroy (screen.win.gerber);
463
464 if (filename) {
465 if (processType == CALLBACKS_SAVE_PROJECT_AS) {
466 main_save_as_project_from_filename (mainProject, filename);
467 rename_main_window(filename, NULL);
468 }
469 else if (processType == CALLBACKS_SAVE_FILE_PS)
470 gerbv_export_postscript_file_from_project_autoscaled (mainProject, filename);
471 else if (processType == CALLBACKS_SAVE_FILE_PDF)
472 gerbv_export_pdf_file_from_project_autoscaled (mainProject, filename);
473 else if (processType == CALLBACKS_SAVE_FILE_SVG)
474 gerbv_export_svg_file_from_project_autoscaled (mainProject, filename);
475 else if (processType == CALLBACKS_SAVE_FILE_PNG)
476 gerbv_export_png_file_from_project_autoscaled (mainProject,
477 screenRenderInfo.displayWidth, screenRenderInfo.displayHeight,
478 filename);
479 else if (processType == CALLBACKS_SAVE_LAYER_AS) {
480 gint index=callbacks_get_selected_row_index();
481
482 gerbv_save_layer_from_index (mainProject, index, filename);
483 /* rename the file path in the index, so future saves will reference the new file path */
484 g_free (mainProject->file[index]->fullPathname);
485 mainProject->file[index]->fullPathname = g_strdup (filename);
486 g_free (mainProject->file[index]->name);
487 mainProject->file[index]->name = g_path_get_basename (filename);
488 }
489 else if (processType == CALLBACKS_SAVE_FILE_RS274X) {
490 gint index=callbacks_get_selected_row_index();
491
492 gerbv_export_rs274x_file_from_image (filename, mainProject->file[index]->image,
493 &mainProject->file[index]->transform);
494 }
495 else if (processType == CALLBACKS_SAVE_FILE_DRILL) {
496 gint index=callbacks_get_selected_row_index();
497
498 gerbv_export_drill_file_from_image (filename, mainProject->file[index]->image,
499 &mainProject->file[index]->transform);
500 }
501 }
502 g_free (filename);
503 callbacks_update_layer_tree();
504 return;
505 }
506
507 /* --------------------------------------------------------- */
508 #if GTK_CHECK_VERSION(2,10,0)
509
510 static void
511 callbacks_begin_print (GtkPrintOperation *operation, GtkPrintContext *context,
512 gpointer user_data) {
513 gtk_print_operation_set_n_pages (operation, 1);
514 }
515
516
517 /* --------------------------------------------------------- */
518 static void
519 callbacks_print_render_page (GtkPrintOperation *operation,
520 GtkPrintContext *context,
521 gint page_nr,
522 gpointer user_data)
523 {
524 GtkPrintSettings *pSettings = gtk_print_operation_get_print_settings (operation);
525 gerbv_render_info_t renderInfo = {1.0, 1.0, 0, 0, 3,
526 (gint) gtk_print_context_get_width (context),
527 (gint) gtk_print_context_get_height (context)};
528 cairo_t *cr;
529 int i;
530
531 /* have to assume x and y resolutions are the same for now, since we
532 don't support differing scales in the gerb_render_info_t struct yet */
533 gdouble xres = gtk_print_context_get_dpi_x (context);
534 gdouble yres = gtk_print_context_get_dpi_y (context);
535 gdouble scalePercentage = gtk_print_settings_get_scale (pSettings);
536 renderInfo.scaleFactorX = scalePercentage / 100 * xres;
537 renderInfo.scaleFactorY = scalePercentage / 100 * yres;
538
539 gerbv_render_translate_to_fit_display (mainProject, &renderInfo);
540 cr = gtk_print_context_get_cairo_context (context);
541 for(i = 0; i <= mainProject->last_loaded; i++) {
542 if (mainProject->file[i] && mainProject->file[i]->isVisible) {
543 //cairo_push_group (cr);
544 gerbv_render_layer_to_cairo_target (cr, mainProject->file[i], &renderInfo);
545 //cairo_pop_group_to_source (cr);
546 //cairo_paint_with_alpha (cr, screen.file[i]->alpha);
547 }
548 }
549 }
550
551 /* --------------------------------------------------------- */
552 void
553 callbacks_print_activate (GtkMenuItem *menuitem, gpointer user_data)
554 {
555 GtkPrintOperation *print;
556 GtkPrintOperationResult res;
557
558 print = gtk_print_operation_new ();
559
560 g_signal_connect (print, "begin_print", G_CALLBACK (callbacks_begin_print), NULL);
561 g_signal_connect (print, "draw_page", G_CALLBACK (callbacks_print_render_page), NULL);
562
563 //GtkPrintSettings *pSettings = gtk_print_operation_get_print_settings (print);
564
565 res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
566 (GtkWindow *) screen.win.topLevelWindow , NULL);
567
568 g_object_unref (print);
569 }
570 #endif /* GTK_CHECK_VERSION(2,10,0) */
571
572 /* --------------------------------------------------------- */
573 void
574 callbacks_zoom_in_activate (GtkMenuItem *menuitem,
575 gpointer user_data)
576 {
577 render_zoom_display (ZOOM_IN, 0, 0, 0);
578 }
579
580 /* --------------------------------------------------------- */
581 void
582 callbacks_zoom_out_activate (GtkMenuItem *menuitem,
583 gpointer user_data)
584 {
585 render_zoom_display (ZOOM_OUT, 0, 0, 0);
586 }
587
588 /* --------------------------------------------------------- */
589 void
590 callbacks_fit_to_window_activate (GtkMenuItem *menuitem,
591 gpointer user_data)
592 {
593 gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
594 render_refresh_rendered_image_on_screen();
595 }
596
597
598 /* --------------------------------------------------------- */
599 /**
600 * The analyze -> analyze Gerbers menu item was selected.
601 * Compile statistics on all open Gerber layers and then display
602 * them.
603 *
604 */
605 void
606 callbacks_analyze_active_gerbers_activate(GtkMenuItem *menuitem,
607 gpointer user_data)
608 {
609 gerbv_stats_t *stats_report;
610 GString *G_report_string = g_string_new(NULL);
611 GString *D_report_string = g_string_new(NULL);
612 GString *M_report_string = g_string_new(NULL);
613 GString *misc_report_string = g_string_new(NULL);
614 GString *general_report_string = g_string_new(NULL);
615 GString *error_report_string = g_string_new(NULL);
616 gerbv_error_list_t *my_error_list;
617 gchar *error_level = NULL;
618 GString *aperture_def_report_string = g_string_new(NULL);
619 GString *aperture_use_report_string = g_string_new(NULL);
620 gerbv_aperture_list_t *my_aperture_list;
621 int idx;
622
623 /* First get a report of stats & errors accumulated from all layers */
624 stats_report = generate_gerber_analysis();
625
626 /* General info report */
627 g_string_printf(general_report_string,
628 "General information\n");
629 g_string_append_printf(general_report_string,
630 " Active layer count = %d\n",
631 stats_report->layer_count);
632 g_string_append_printf(general_report_string,
633 "\n\n%-45s %-10s\n",
634 "Files processed",
635 "Layer number");
636 for (idx = 0; idx <= mainProject->last_loaded; idx++) {
637 if (mainProject->file[idx] &&
638 mainProject->file[idx]->isVisible &&
639 (mainProject->file[idx]->image->layertype == GERBV_LAYERTYPE_RS274X) ) {
640 g_string_append_printf(general_report_string,
641 " %-45s %-10d\n", mainProject->file[idx]->name, idx+1);
642 }
643 }
644
645 /* Error report (goes into general report tab) */
646 if (stats_report->layer_count == 0) {
647 g_string_printf(error_report_string,
648 "\n\nNo Gerber files active (visible)!\n");
649 } else if (stats_report->error_list->error_text == NULL) {
650 g_string_printf(error_report_string,
651 "\n\nNo errors found in active Gerber file(s)!\n");
652 } else {
653 g_string_printf(error_report_string,
654 "\n\nErrors found in active Gerber file(s):\n");
655 for(my_error_list = stats_report->error_list;
656 my_error_list != NULL;
657 my_error_list = my_error_list->next) {
658 switch(my_error_list->type) {
659 case GERBV_MESSAGE_FATAL: /* We should never get this one since the
660 * program should terminate first.... */
661 error_level = g_strdup_printf("FATAL: ");
662 break;
663 case GERBV_MESSAGE_ERROR:
664 error_level = g_strdup_printf("ERROR: ");
665 break;
666 case GERBV_MESSAGE_WARNING:
667 error_level = g_strdup_printf("WARNING: ");
668 break;
669 case GERBV_MESSAGE_NOTE:
670 error_level = g_strdup_printf("NOTE: ");
671 break;
672 }
673 g_string_append_printf(error_report_string,
674 " Layer %d: %s %s",
675 my_error_list->layer,
676 error_level,
677 my_error_list->error_text );
678 g_free(error_level);
679 }
680 }
681
682
683 g_string_append_printf(general_report_string,
684 "%s",
685 error_report_string->str);
686 g_string_free(error_report_string, TRUE);
687
688 /* Now compile stats related to reading G codes */
689 g_string_printf(G_report_string,
690 "G code statistics (all active layers)\n");
691 g_string_append_printf(G_report_string,
692 "<code> = <number of incidences>\n");
693 g_string_append_printf(G_report_string,
694 "G0 = %-6d (%s)\n",
695 stats_report->G0,
696 "Move");
697 g_string_append_printf(G_report_string,
698 "G1 = %-6d (%s)\n",
699 stats_report->G1,
700 "1X linear interpolation");
701 g_string_append_printf(G_report_string,
702 "G2 = %-6d (%s)\n",
703 stats_report->G2,
704 "CW interpolation");
705 g_string_append_printf(G_report_string,
706 "G3 = %-6d (%s)\n",
707 stats_report->G3,
708 "CCW interpolation");
709 g_string_append_printf(G_report_string,
710 "G4 = %-6d (%s)\n",
711 stats_report->G4,
712 "Comment/ignore block");
713 g_string_append_printf(G_report_string,
714 "G10 = %-6d (%s)\n",
715 stats_report->G10,
716 "10X linear interpolation");
717 g_string_append_printf(G_report_string,
718 "G11 = %-6d (%s)\n",
719 stats_report->G11,
720 "0.1X linear interpolation");
721 g_string_append_printf(G_report_string,
722 "G12 = %-6d (%s)\n",
723 stats_report->G12,
724 "0.01X linear interpolation");
725 g_string_append_printf(G_report_string,
726 "G36 = %-6d (%s)\n",
727 stats_report->G36,
728 "Poly fill on");
729 g_string_append_printf(G_report_string,
730 "G37 = %-6d (%s)\n",
731 stats_report->G37,
732 "Poly fill off");
733 g_string_append_printf(G_report_string,
734 "G54 = %-6d (%s)\n",
735 stats_report->G54,
736 "Tool prepare");
737 g_string_append_printf(G_report_string,
738 "G55 = %-6d (%s)\n",
739 stats_report->G55,
740 "Flash prepare");
741 g_string_append_printf(G_report_string,
742 "G70 = %-6d (%s)\n",
743 stats_report->G70,
744 "Units = inches");
745 g_string_append_printf(G_report_string,
746 "G71 = %-6d (%s)\n",
747 stats_report->G71,
748 "Units = mm");
749 g_string_append_printf(G_report_string,
750 "G74 = %-6d (%s)\n",
751 stats_report->G74,
752 "Disable 360 circ. interpolation");
753 g_string_append_printf(G_report_string,
754 "G75 = %-6d (%s)\n",
755 stats_report->G75,
756 "Enable 360 circ. interpolation");
757 g_string_append_printf(G_report_string,
758 "G90 = %-6d (%s)\n",
759 stats_report->G90,
760 "Absolute units");
761 g_string_append_printf(G_report_string,
762 "G91 = %-6d (%s)\n",
763 stats_report->G91,
764 "Incremental units");
765 g_string_append_printf(G_report_string,
766 "Unknown G codes = %d\n",
767 stats_report->G_unknown);
768
769
770 g_string_printf(D_report_string, "D code statistics (all active layers)\n");
771 g_string_append_printf(D_report_string,
772 "<code> = <number of incidences>\n");
773 g_string_append_printf(D_report_string,
774 "D1 = %-6d (%s)\n",
775 stats_report->D1,
776 "Exposure on");
777 g_string_append_printf(D_report_string,
778 "D2 = %-6d (%s)\n",
779 stats_report->D2,
780 "Exposure off");
781 g_string_append_printf(D_report_string,
782 "D3 = %-6d (%s)\n",
783 stats_report->D3,
784 "Flash aperture");
785 g_string_append_printf(D_report_string,
786 "Undefined D codes = %d\n",
787 stats_report->D_unknown);
788 g_string_append_printf(D_report_string,
789 "D code Errors = %d\n",
790 stats_report->D_error);
791
792
793 g_string_printf(M_report_string, "M code statistics (all active layers)\n");
794 g_string_append_printf(M_report_string,
795 "<code> = <number of incidences>\n");
796 g_string_append_printf(M_report_string,
797 "M0 = %-6d (%s)\n",
798 stats_report->M0,
799 "Program start");
800 g_string_append_printf(M_report_string,
801 "M1 = %-6d (%s)\n",
802 stats_report->M1,
803 "Program stop");
804 g_string_append_printf(M_report_string,
805 "M2 = %-6d (%s)\n",
806 stats_report->M2,
807 "Program end");
808 g_string_append_printf(M_report_string,
809 "Unknown M codes = %d\n",
810 stats_report->M_unknown);
811
812
813 g_string_printf(misc_report_string, "Misc code statistics (all active layers)\n");
814 g_string_append_printf(misc_report_string,
815 "<code> = <number of incidences>\n");
816 g_string_append_printf(misc_report_string,
817 "X = %d\n", stats_report->X);
818 g_string_append_printf(misc_report_string,
819 "Y = %d\n", stats_report->Y);
820 g_string_append_printf(misc_report_string,
821 "I = %d\n", stats_report->I);
822 g_string_append_printf(misc_report_string,
823 "J = %d\n", stats_report->J);
824 g_string_append_printf(misc_report_string,
825 "* = %d\n", stats_report->star);
826 g_string_append_printf(misc_report_string,
827 "Unknown codes = %d\n",
828 stats_report->unknown);
829
830 /* Report apertures defined in input files. */
831
832 if (stats_report->aperture_list->number == -1) {
833 g_string_printf(aperture_def_report_string,
834 "No aperture definitions found in Gerber file(s)!\n");
835 } else {
836 g_string_printf(aperture_def_report_string,
837 "Apertures defined in Gerber file(s) (by layer)\n");
838 g_string_append_printf(aperture_def_report_string,
839 " %-6s %-8s %12s %8s %8s %8s\n",
840 "Layer",
841 "D code",
842 "Aperture",
843 "Param[0]",
844 "Param[1]",
845 "Param[2]"
846 );
847 for(my_aperture_list = stats_report->aperture_list;
848 my_aperture_list != NULL;
849 my_aperture_list = my_aperture_list->next) {
850
851 g_string_append_printf(aperture_def_report_string,
852 " %-6d D%-4d%13s %8.3f %8.3f %8.3f\n",
853 my_aperture_list->layer,
854 my_aperture_list->number,
855 ap_names[my_aperture_list->type],
856 my_aperture_list->parameter[0],
857 my_aperture_list->parameter[1],
858 my_aperture_list->parameter[2]
859 );
860 }
861 }
862
863 /* Report apertures usage count in input files. */
864 if (stats_report->D_code_list->number == -1) {
865 g_string_printf(aperture_use_report_string,
866 "No apertures used in Gerber file(s)!\n");
867 } else {
868
869 /* Now add list of user-defined D codes (apertures) */
870
871 g_string_printf(aperture_use_report_string,
872 "Apertures used in Gerber file(s) (all active layers)\n");
873 g_string_append_printf(aperture_use_report_string,
874 "<aperture code> = <number of uses>\n");
875 for (my_aperture_list = stats_report->D_code_list;
876 my_aperture_list != NULL;
877 my_aperture_list = my_aperture_list->next) {
878
879 g_string_append_printf(aperture_use_report_string,
880 " D%d = %-6d\n",
881 my_aperture_list->number,
882 my_aperture_list->count
883 );
884 }
885 }
886
887
888 /* Create top level dialog window for report */
889 GtkWidget *analyze_active_gerbers;
890 analyze_active_gerbers = gtk_dialog_new_with_buttons("Gerber codes report",
891 NULL,
892 GTK_DIALOG_DESTROY_WITH_PARENT,
893 GTK_STOCK_OK,
894 GTK_RESPONSE_ACCEPT,
895 NULL);
896 gtk_container_set_border_width (GTK_CONTAINER (analyze_active_gerbers), 5);
897
898 gtk_dialog_set_default_response (GTK_DIALOG(analyze_active_gerbers),
899 GTK_RESPONSE_ACCEPT);
900 g_signal_connect (G_OBJECT(analyze_active_gerbers),
901 "response",
902 G_CALLBACK (gtk_widget_destroy),
903 GTK_WIDGET(analyze_active_gerbers));
904
905 /* Use fixed width font for all reports */
906 PangoFontDescription *font =
907 pango_font_description_from_string ("monospace");
908
909 /* Create GtkLabel to hold general report text */
910 GtkWidget *general_report_label = gtk_label_new (general_report_string->str);
911 g_string_free (general_report_string, TRUE);
912 gtk_misc_set_alignment(GTK_MISC(general_report_label), 0, 0);
913 gtk_misc_set_padding(GTK_MISC(general_report_label), 13, 13);
914 gtk_label_set_selectable(GTK_LABEL(general_report_label), TRUE);
915 gtk_widget_modify_font (GTK_WIDGET(general_report_label),
916 font);
917 /* Put general report text into scrolled window */
918 GtkWidget *general_code_report_window = gtk_scrolled_window_new (NULL, NULL);
919 /* This throws a warning. Must find different approach.... */
920 gtk_widget_set_size_request(GTK_WIDGET(general_code_report_window),
921 200,
922 300);
923 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(general_code_report_window),
924 GTK_WIDGET(general_report_label));
925
926 /* Create GtkLabel to hold G code text */
927 GtkWidget *G_report_label = gtk_label_new (G_report_string->str);
928 g_string_free (G_report_string, TRUE);
929 gtk_misc_set_alignment(GTK_MISC(G_report_label), 0, 0);
930 gtk_misc_set_padding(GTK_MISC(G_report_label), 13, 13);
931 gtk_label_set_selectable(GTK_LABEL(G_report_label), TRUE);
932 gtk_widget_modify_font (GTK_WIDGET(G_report_label),
933 font);
934
935 /* Create GtkLabel to hold D code text */
936 GtkWidget *D_report_label = gtk_label_new (D_report_string->str);
937 g_string_free (D_report_string, TRUE);
938 gtk_misc_set_alignment(GTK_MISC(D_report_label), 0, 0);
939 gtk_misc_set_padding(GTK_MISC(D_report_label), 13, 13);
940 gtk_label_set_selectable(GTK_LABEL(D_report_label), TRUE);
941 gtk_widget_modify_font (GTK_WIDGET(D_report_label),
942 font);
943
944 /* Create GtkLabel to hold M code text */
945 GtkWidget *M_report_label = gtk_label_new (M_report_string->str);
946 g_string_free (M_report_string, TRUE);
947 gtk_misc_set_alignment(GTK_MISC(M_report_label), 0, 0);
948 gtk_misc_set_padding(GTK_MISC(M_report_label), 13, 13);
949 gtk_label_set_selectable(GTK_LABEL(M_report_label), TRUE);
950 gtk_widget_modify_font (GTK_WIDGET(M_report_label),
951 font);
952
953 /* Create GtkLabel to hold misc code text */
954 GtkWidget *misc_report_label = gtk_label_new (misc_report_string->str);
955 g_string_free (misc_report_string, TRUE);
956 gtk_misc_set_alignment(GTK_MISC(misc_report_label), 0, 0);
957 gtk_misc_set_padding(GTK_MISC(misc_report_label), 13, 13);
958 gtk_label_set_selectable(GTK_LABEL(misc_report_label), TRUE);
959 gtk_widget_modify_font (GTK_WIDGET(misc_report_label),
960 font);
961
962 /* Create GtkLabel to hold aperture defintion text */
963 GtkWidget *aperture_def_report_label = gtk_label_new (aperture_def_report_string->str);
964 g_string_free (aperture_def_report_string, TRUE);
965 gtk_misc_set_alignment(GTK_MISC(aperture_def_report_label), 0, 0);
966 gtk_misc_set_padding(GTK_MISC(aperture_def_report_label), 13, 13);
967 gtk_label_set_selectable(GTK_LABEL(aperture_def_report_label), TRUE);
968 gtk_widget_modify_font (GTK_WIDGET(aperture_def_report_label),
969 font);
970 /* Put aperture definintion text into scrolled window */
971 GtkWidget *aperture_def_report_window = gtk_scrolled_window_new (NULL, NULL);
972 /* This throws a warning. Must find different approach.... */
973 gtk_widget_set_size_request(GTK_WIDGET(aperture_def_report_window),
974 200,
975 300);
976 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(aperture_def_report_window),
977 GTK_WIDGET(aperture_def_report_label));
978
979 /* Create GtkLabel to hold aperture use text */
980 GtkWidget *aperture_use_report_label = gtk_label_new (aperture_use_report_string->str);
981 g_string_free (aperture_use_report_string, TRUE);
982 gtk_misc_set_alignment(GTK_MISC(aperture_use_report_label), 0, 0);
983 gtk_misc_set_padding(GTK_MISC(aperture_use_report_label), 13, 13);
984 gtk_label_set_selectable(GTK_LABEL(aperture_use_report_label), TRUE);
985 gtk_widget_modify_font (GTK_WIDGET(aperture_use_report_label),
986 font);
987 /* Put aperture definintion text into scrolled window */
988 GtkWidget *aperture_use_report_window = gtk_scrolled_window_new (NULL, NULL);
989 /* This throws a warning. Must find different approach.... */
990 gtk_widget_set_size_request(GTK_WIDGET(aperture_use_report_window),
991 200,
992 300);
993 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(aperture_use_report_window),
994 GTK_WIDGET(aperture_use_report_label));
995
996 /* Create tabbed notebook widget and add report label widgets. */
997 GtkWidget *notebook = gtk_notebook_new();
998
999 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1000 GTK_WIDGET(general_code_report_window),
1001 gtk_label_new("General"));
1002
1003 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1004 GTK_WIDGET(G_report_label),
1005 gtk_label_new("G codes"));
1006
1007 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1008 GTK_WIDGET(D_report_label),
1009 gtk_label_new("D codes"));
1010
1011 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1012 GTK_WIDGET(M_report_label),
1013 gtk_label_new("M codes"));
1014
1015 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1016 GTK_WIDGET(misc_report_label),
1017 gtk_label_new("Misc. codes"));
1018
1019 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1020 GTK_WIDGET(aperture_def_report_window),
1021 gtk_label_new("Aperture definitions"));
1022
1023 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1024 GTK_WIDGET(aperture_use_report_window),
1025 gtk_label_new("Aperture usage"));
1026
1027
1028 /* Now put notebook into dialog window and show the whole thing */
1029 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(analyze_active_gerbers)->vbox),
1030 GTK_WIDGET(notebook));
1031
1032 gtk_widget_show_all(analyze_active_gerbers);
1033
1034 /* free the stats report */
1035 gerbv_stats_destroy (stats_report);
1036 return;
1037
1038 }
1039
1040 /* --------------------------------------------------------- */
1041 /**
1042 * The analyze -> analyze drill file menu item was selected.
1043 * Complie statistics on all open drill layers and then display
1044 * them.
1045 *
1046 */
1047 void
1048 callbacks_analyze_active_drill_activate(GtkMenuItem *menuitem,
1049 gpointer user_data)
1050 {
1051 gerbv_drill_stats_t *stats_report;
1052 GString *G_report_string = g_string_new(NULL);
1053 GString *M_report_string = g_string_new(NULL);
1054 GString *misc_report_string = g_string_new(NULL);
1055 gerbv_drill_list_t *my_drill_list;
1056 GString *drill_report_string = g_string_new(NULL);
1057 GString *general_report_string = g_string_new(NULL);
1058 GString *error_report_string = g_string_new(NULL);
1059 gerbv_error_list_t *my_error_list;
1060 gchar *error_level = NULL;
1061 int idx;
1062
1063 stats_report = (gerbv_drill_stats_t *) generate_drill_analysis();
1064
1065 /* General and error window strings */
1066 g_string_printf(general_report_string, "General information\n");
1067 g_string_append_printf(general_report_string,
1068 " Active layer count = %d\n",
1069 stats_report->layer_count);
1070
1071 g_string_append_printf(general_report_string,
1072 "\n\nFiles processed:\n");
1073 for (idx = mainProject->last_loaded; idx >= 0; idx--) {
1074 if (mainProject->file[idx] &&
1075 mainProject->file[idx]->isVisible &&
1076 (mainProject->file[idx]->image->layertype == GERBV_LAYERTYPE_DRILL) ) {
1077 g_string_append_printf(general_report_string,
1078 " %s\n",
1079 mainProject->file[idx]->name);
1080 }
1081 }
1082
1083
1084 if (stats_report->layer_count == 0) {
1085 g_string_printf(error_report_string, "\n\nNo drill files active (visible)!\n");
1086 } else if (stats_report->error_list->error_text == NULL) {
1087 g_string_printf(error_report_string,
1088 "\n\nNo errors found in active drill file(s)!\n");
1089 } else {
1090 g_string_printf(error_report_string,
1091 "\n\nErrors found in active drill file(s):\n");
1092 for(my_error_list = stats_report->error_list;
1093 my_error_list != NULL;
1094 my_error_list = my_error_list->next) {
1095 switch(my_error_list->type) {
1096 case GERBV_MESSAGE_FATAL: /* We should never get this one since the
1097 * program should terminate first.... */
1098 error_level = g_strdup_printf("FATAL: ");
1099 break;
1100 case GERBV_MESSAGE_ERROR:
1101 error_level = g_strdup_printf("ERROR: ");
1102 break;
1103 case GERBV_MESSAGE_WARNING:
1104 error_level = g_strdup_printf("WARNING: ");
1105 break;
1106 case GERBV_MESSAGE_NOTE:
1107 error_level = g_strdup_printf("NOTE: ");
1108 break;
1109 }
1110 g_string_append_printf(error_report_string,
1111 " Layer %d: %s %s",
1112 my_error_list->layer,
1113 error_level,
1114 my_error_list->error_text);
1115 }
1116 }
1117
1118 g_string_append_printf(general_report_string,
1119 "%s", error_report_string->str);
1120 g_string_free(error_report_string, TRUE);
1121
1122
1123 /* G code window strings */
1124 g_string_printf(G_report_string, "G code statistics (all active layers)\n");
1125 g_string_append_printf(G_report_string,
1126 "<code> = <number of incidences>\n");
1127 g_string_append_printf(G_report_string,
1128 "G00 = %-6d (%s)\n",
1129 stats_report->G00,
1130 "Rout mode");
1131 g_string_append_printf(G_report_string,
1132 "G01 = %-6d (%s)\n",
1133 stats_report->G01,
1134 "1X linear interpolation");
1135 g_string_append_printf(G_report_string,
1136 "G02 = %-6d (%s)\n",
1137 stats_report->G02,
1138 "CW interpolation");
1139 g_string_append_printf(G_report_string,
1140 "G03 = %-6d (%s)\n",
1141 stats_report->G03,
1142 "CCW interpolation");
1143 g_string_append_printf(G_report_string,
1144 "G04 = %-6d (%s)\n",
1145 stats_report->G04,
1146 "Variable dwell");
1147 g_string_append_printf(G_report_string,
1148 "G05 = %-6d (%s)\n",
1149 stats_report->G05,
1150 "Drill mode");
1151 g_string_append_printf(G_report_string,
1152 "G90 = %-6d (%s)\n",
1153 stats_report->G90,
1154 "Absolute units");
1155 g_string_append_printf(G_report_string,
1156 "G91 = %-6d (%s)\n",
1157 stats_report->G91,
1158 "Incremental units");
1159 g_string_append_printf(G_report_string,
1160 "G93 = %-6d (%s)\n",
1161 stats_report->G93,
1162 "Zero set");
1163 g_string_append_printf(G_report_string,
1164 "Unknown G codes = %d\n",
1165 stats_report->G_unknown);
1166
1167 /* M code window strings */
1168 g_string_printf(M_report_string, "M code statistics (all active layers)\n");
1169 g_string_append_printf(M_report_string,
1170 "<code> = <number of incidences>\n");
1171 g_string_append_printf(M_report_string,
1172 "M00 = %-6d (%s)\n",
1173 stats_report->M00,
1174 "End of program");
1175 g_string_append_printf(M_report_string,
1176 "M01 = %-6d (%s)\n",
1177 stats_report->M01,
1178 "End of pattern");
1179 g_string_append_printf(M_report_string,
1180 "M18 = %-6d (%s)\n",
1181 stats_report->M18,
1182 "Tool tip check");
1183 g_string_append_printf(M_report_string,
1184 "M25 = %-6d (%s)\n",
1185 stats_report->M25,
1186 "Begin pattern");
1187 g_string_append_printf(M_report_string,
1188 "M30 = %-6d (%s)\n",
1189 stats_report->M30,
1190 "End program rewind");
1191 g_string_append_printf(M_report_string,
1192 "M31 = %-6d (%s)\n",
1193 stats_report->M31,
1194 "Begin pattern");
1195 g_string_append_printf(M_report_string,
1196 "M45 = %-6d (%s)\n",
1197 stats_report->M45,
1198 "Long message");
1199 g_string_append_printf(M_report_string,
1200 "M47 = %-6d (%s)\n",
1201 stats_report->M47,
1202 "Operator message");
1203 g_string_append_printf(M_report_string,
1204 "M48 = %-6d (%s)\n",
1205 stats_report->M48,
1206 "Begin program header");
1207 g_string_append_printf(M_report_string,
1208 "M71 = %-6d (%s)\n",
1209 stats_report->M71,
1210 "Metric units");
1211 g_string_append_printf(M_report_string,
1212 "M72 = %-6d (%s)\n",
1213 stats_report->M72,
1214 "English units");
1215 g_string_append_printf(M_report_string,
1216 "M95 = %-6d (%s)\n",
1217 stats_report->M95,
1218 "End program header");
1219 g_string_append_printf(M_report_string,
1220 "M97 = %-6d (%s)\n",
1221 stats_report->M97,
1222 "Canned text");
1223 g_string_append_printf(M_report_string,
1224 "M98 = %-6d (%s)\n",
1225 stats_report->M98,
1226 "Canned text");
1227 g_string_append_printf(M_report_string,
1228 "Unknown M codes = %d\n",
1229 stats_report->M_unknown);
1230
1231
1232 /* misc report strings */
1233 g_string_printf(misc_report_string, "Misc code statistics (all active layers)\n");
1234 g_string_append_printf(misc_report_string,
1235 "<code> = <number of incidences>\n");
1236 g_string_append_printf(misc_report_string,
1237 "comments = %d\n",
1238 stats_report->comment);
1239 g_string_append_printf(misc_report_string,
1240 "Unknown codes = %d\n",
1241 stats_report->unknown);
1242
1243 g_string_append_printf(misc_report_string,
1244 "R = %-6d (%s)\n",
1245 stats_report->R,
1246 "Repeat hole");
1247
1248 if (stats_report->detect != NULL ) {
1249 g_string_append_printf(misc_report_string,
1250 "\n%s\n",
1251 stats_report->detect);
1252 }
1253 /* drill report window strings */
1254 g_string_printf(drill_report_string, "Drills used (all active layers)\n");
1255 g_string_append_printf(drill_report_string, "%10s %8s %8s %8s\n",
1256 "Drill no.", "Dia.", "Units", "Count");
1257 for(my_drill_list = stats_report->drill_list;
1258 my_drill_list != NULL;
1259 my_drill_list = my_drill_list->next) {
1260 if (my_drill_list->drill_num == -1) break; /* No drill list */
1261 g_string_append_printf(drill_report_string,
1262 "%10d %8.3f %8s %8d\n",
1263 my_drill_list->drill_num,
1264 my_drill_list->drill_size,
1265 my_drill_list->drill_unit,
1266 my_drill_list->drill_count);
1267 }
1268
1269 g_string_append_printf(drill_report_string, "Total drill count %d\n",
1270 stats_report->total_count);
1271
1272 /* Use fixed width font for all reports */
1273 PangoFontDescription *font =
1274 pango_font_description_from_string ("monospace");
1275
1276 /* Create top level dialog window for report */
1277 GtkWidget *analyze_active_drill;
1278 analyze_active_drill = gtk_dialog_new_with_buttons("Drill file codes report",
1279 NULL,
1280 GTK_DIALOG_DESTROY_WITH_PARENT,
1281 GTK_STOCK_OK,
1282 GTK_RESPONSE_ACCEPT,
1283 NULL);
1284 gtk_container_set_border_width (GTK_CONTAINER (analyze_active_drill), 5);
1285 gtk_dialog_set_default_response (GTK_DIALOG(analyze_active_drill),
1286 GTK_RESPONSE_ACCEPT);
1287 g_signal_connect (G_OBJECT(analyze_active_drill),
1288 "response",
1289 G_CALLBACK (gtk_widget_destroy),
1290 GTK_WIDGET(analyze_active_drill));
1291
1292 /* Create GtkLabel to hold general report text */
1293 GtkWidget *general_report_label = gtk_label_new (general_report_string->str);
1294 g_string_free(general_report_string, TRUE);
1295 gtk_misc_set_alignment(GTK_MISC(general_report_label), 0, 0);
1296 gtk_misc_set_padding(GTK_MISC(general_report_label), 13, 13);
1297 gtk_label_set_selectable(GTK_LABEL(general_report_label), TRUE);
1298 gtk_widget_modify_font (GTK_WIDGET(general_report_label),
1299 font);
1300
1301 /* Create GtkLabel to hold G code text */
1302 GtkWidget *G_report_label = gtk_label_new (G_report_string->str);
1303 g_string_free(G_report_string, TRUE);
1304 gtk_misc_set_alignment(GTK_MISC(G_report_label), 0, 0);
1305 gtk_misc_set_padding(GTK_MISC(G_report_label), 13, 13);
1306 gtk_label_set_selectable(GTK_LABEL(G_report_label), TRUE);
1307 gtk_widget_modify_font (GTK_WIDGET(G_report_label),
1308 font);
1309
1310 /* Create GtkLabel to hold M code text */
1311 GtkWidget *M_report_label = gtk_label_new (M_report_string->str);
1312 g_string_free(M_report_string, TRUE);
1313 gtk_misc_set_alignment(GTK_MISC(M_report_label), 0, 0);
1314 gtk_misc_set_padding(GTK_MISC(M_report_label), 13, 13);
1315 gtk_label_set_selectable(GTK_LABEL(M_report_label), TRUE);
1316 gtk_widget_modify_font (GTK_WIDGET(M_report_label),
1317 font);
1318
1319 /* Create GtkLabel to hold misc code text */
1320 GtkWidget *misc_report_label = gtk_label_new (misc_report_string->str);
1321 g_string_free(misc_report_string, TRUE);
1322 gtk_misc_set_alignment(GTK_MISC(misc_report_label), 0, 0);
1323 gtk_misc_set_padding(GTK_MISC(misc_report_label), 13, 13);
1324 gtk_label_set_selectable(GTK_LABEL(misc_report_label), TRUE);
1325 gtk_widget_modify_font (GTK_WIDGET(misc_report_label),
1326 font);
1327
1328 /* Create GtkLabel to hold drills used text */
1329 GtkWidget *drill_report_label = gtk_label_new (drill_report_string->str);
1330 g_string_free(drill_report_string, TRUE);
1331 gtk_misc_set_alignment(GTK_MISC(drill_report_label), 0, 0);
1332 gtk_misc_set_padding(GTK_MISC(drill_report_label), 13, 13);
1333 gtk_label_set_selectable(GTK_LABEL(drill_report_label), TRUE);
1334 gtk_widget_modify_font (GTK_WIDGET(drill_report_label),
1335 font);
1336
1337 /* Create tabbed notebook widget and add report label widgets. */
1338 GtkWidget *notebook = gtk_notebook_new();
1339
1340 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1341 GTK_WIDGET(general_report_label),
1342 gtk_label_new("General"));
1343
1344 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1345 GTK_WIDGET(G_report_label),
1346 gtk_label_new("G codes"));
1347
1348 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1349 GTK_WIDGET(M_report_label),
1350 gtk_label_new("M codes"));
1351
1352 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1353 GTK_WIDGET(misc_report_label),
1354 gtk_label_new("Misc. codes"));
1355
1356 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
1357 GTK_WIDGET(drill_report_label),
1358 gtk_label_new("Drills used"));
1359
1360 /* Now put notebook into dialog window and show the whole thing */
1361 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(analyze_active_drill)->vbox),
1362 GTK_WIDGET(notebook));
1363 gtk_widget_show_all(analyze_active_drill);
1364 gerbv_drill_stats_destroy (stats_report);
1365 return;
1366 }
1367
1368 /* --------------------------------------------------------- */
1369 void
1370 callbacks_control_gerber_options_activate (GtkMenuItem *menuitem,
1371 gpointer user_data)
1372 {
1373
1374 }
1375
1376 /* --------------------------------------------------------- */
1377 void
1378 callbacks_online_manual_activate (GtkMenuItem *menuitem,
1379 gpointer user_data)
1380 {
1381
1382 }
1383
1384 /* --------------------------------------------------------- */
1385 /**
1386 * The file -> quit menu item was selected.
1387 * Check that all changes have been saved, and then quit.
1388 *
1389 */
1390 void
1391 callbacks_quit_activate (GtkMenuItem *menuitem,
1392 gpointer user_data)
1393 {
1394 gboolean layers_dirty = FALSE;
1395 gint idx;
1396
1397 for (idx = 0; idx<=mainProject->last_loaded; idx++) {
1398 if (mainProject->file[idx] == NULL) break;
1399 layers_dirty = layers_dirty || mainProject->file[idx]->layer_dirty;
1400 }
1401
1402 if (layers_dirty &&
1403 !interface_get_alert_dialog_response(
1404 "Do you want to close all open layers and quit the program?",
1405 "Quitting the program will cause any unsaved changes to be lost.",
1406 FALSE,
1407 NULL)) {
1408 return;
1409 }
1410 gerbv_unload_all_layers (mainProject);
1411 gtk_main_quit();
1412 }
1413
1414 /* --------------------------------------------------------- */
1415 /**
1416 * The help -> about menu item was selected.
1417 * Show the about dialog.
1418 *
1419 */
1420 void
1421 callbacks_about_activate (GtkMenuItem *menuitem,
1422 gpointer user_data)
1423 {
1424 GtkWidget *aboutdialog1;
1425 /* TRANSLATORS: Replace this string with your names, one name per line. */
1426 /* gchar *translators = _("translator-credits"); */
1427
1428 gchar *string = g_strdup_printf ( "gerbv -- a Gerber (RS-274/X) viewer.\n\n"
1429 "This is gerbv version %s\n"
1430 "Compiled on %s at %s\n"
1431 "\n"
1432 "gerbv is part of the gEDA Project.\n"
1433 "\n"
1434 "For more information see:\n"
1435 " gerbv homepage: http://gerbv.gpleda.org/\n"
1436 " gEDA homepage: http://gpleda.org/\n"
1437 " gEDA Wiki: http://geda.seul.org/wiki/",
1438 VERSION, __DATE__, __TIME__);
1439 #if GTK_CHECK_VERSION(2,6,0)
1440 gchar *license = g_strdup_printf("gerbv -- a Gerber (RS-274/X) viewer.\n\n"
1441 "Copyright (C) 2000-2007 Stefan Petersen\n\n"
1442 "This program is free software: you can redistribute it and/or modify\n"
1443 "it under the terms of the GNU General Public License as published by\n"
1444 "the Free Software Foundation, either version 2 of the License, or\n"
1445 "(at your option) any later version.\n\n"
1446 "This program is distributed in the hope that it will be useful,\n"
1447 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1448 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
1449 "GNU General Public License for more details.\n\n"
1450 "You should have received a copy of the GNU General Public License\n"
1451 "along with this program. If not, see <http://www.gnu.org/licenses/>.");
1452 #include "authors.c"
1453
1454 aboutdialog1 = gtk_about_dialog_new ();
1455 gtk_container_set_border_width (GTK_CONTAINER (aboutdialog1), 5);
1456 gtk_about_dialog_set_version (GTK_ABOUT_DIALOG (aboutdialog1), VERSION);
1457 gtk_about_dialog_set_name (GTK_ABOUT_DIALOG (aboutdialog1), _("Gerbv"));
1458
1459 /* gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (aboutdialog1), translators); */
1460 gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG (aboutdialog1), string);
1461 gtk_about_dialog_set_license(GTK_ABOUT_DIALOG (aboutdialog1), license);
1462
1463 /* The authors.c file is autogenerated at build time */
1464 gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG (aboutdialog1), authors_string_array);
1465 gtk_about_dialog_set_website(GTK_ABOUT_DIALOG (aboutdialog1), "http://gerbv.gpleda.org/");
1466
1467 g_signal_connect (G_OBJECT(aboutdialog1),"response",
1468 G_CALLBACK (gtk_widget_destroy), GTK_WIDGET(aboutdialog1));
1469
1470 g_free (string);
1471 g_free (license);
1472 #else
1473 aboutdialog1 = gtk_message_dialog_new ( GTK_WINDOW (screen.win.topLevelWindow),
1474 GTK_DIALOG_DESTROY_WITH_PARENT,
1475 GTK_MESSAGE_INFO,
1476 GTK_BUTTONS_CLOSE,
1477 string
1478 );
1479
1480 gtk_window_set_title ( GTK_WINDOW (aboutdialog1), _("About Gerbv"));
1481
1482 /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
1483 g_signal_connect_swapped (aboutdialog1, "response",
1484 G_CALLBACK (gtk_widget_destroy),
1485 aboutdialog1);
1486 g_free (string);
1487 #endif
1488
1489 gtk_widget_show_all(GTK_WIDGET(aboutdialog1));
1490
1491 }
1492
1493 /* --------------------------------------------------------- */
1494 /**
1495 * The help -> bugs menu item was selected.
1496 * Show the known bugs window
1497 *
1498 */
1499 void
1500 callbacks_bugs_activate (GtkMenuItem *menuitem,
1501 gpointer user_data)
1502 {
1503 int i;
1504 #include "bugs.c"
1505
1506 /* Create the top level dialog widget with an OK button */
1507 GtkWidget *bugs_dialog = gtk_dialog_new_with_buttons("Known bugs in gerbv",
1508 NULL,
1509 GTK_DIALOG_DESTROY_WITH_PARENT,
1510 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1511 NULL);
1512 gtk_container_set_border_width (GTK_CONTAINER (bugs_dialog), 5);
1513 gtk_dialog_set_default_response (GTK_DIALOG(bugs_dialog),
1514 GTK_RESPONSE_ACCEPT);
1515 g_signal_connect (G_OBJECT(bugs_dialog), "response",
1516 G_CALLBACK (gtk_widget_destroy), GTK_WIDGET(bugs_dialog));
1517
1518 /* First create single bugs_string from bugs_string_array */
1519 GString *bugs_string = g_string_new(NULL);
1520 for (i=0; bugs_string_array[i] != NULL; i++) {
1521 g_string_append_printf(bugs_string,
1522 "%s\n",
1523 bugs_string_array[i]);
1524 }
1525
1526 /* Create GtkLabel to hold text */
1527 GtkWidget *bugs_label = gtk_label_new (bugs_string->str);
1528 g_string_free(bugs_string, TRUE);
1529 gtk_misc_set_alignment(GTK_MISC(bugs_label), 0, 0);
1530 gtk_misc_set_padding(GTK_MISC(bugs_label), 13, 13);
1531
1532 /* Put text into scrolled window */
1533 GtkWidget *bugs_window = gtk_scrolled_window_new (NULL, NULL);
1534 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(bugs_window),
1535 GTK_WIDGET(bugs_label));
1536 gtk_widget_set_size_request(GTK_WIDGET(bugs_window), 600, 300);
1537 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(bugs_dialog)->vbox),
1538 GTK_WIDGET(bugs_window));
1539
1540 gtk_widget_show_all(GTK_WIDGET(bugs_dialog));
1541 gtk_dialog_run(GTK_DIALOG(bugs_dialog));
1542
1543 }
1544
1545 /* --------------------------------------------------------- */
1546 gdouble callbacks_calculate_actual_distance (gdouble inputDimension) {
1547 gdouble returnValue = 0.0;
1548
1549 if (screen.unit == GERBV_MILS) {
1550 returnValue = COORD2MILS(inputDimension);
1551 } else if (screen.unit == GERBV_MMS) {
1552 returnValue = COORD2MMS(inputDimension);
1553 } else {
1554 returnValue = COORD2MILS(inputDimension)/1000;
1555 }
1556 return returnValue;
1557 }
1558
1559 /* --------------------------------------------------------- */
1560 void callbacks_update_ruler_pointers (void) {
1561 double xPosition, yPosition;
1562 xPosition = screenRenderInfo.lowerLeftX + (screen.last_x / screenRenderInfo.scaleFactorX);
1563 yPosition = screenRenderInfo.lowerLeftY + ((screenRenderInfo.displayHeight - screen.last_y) / screenRenderInfo.scaleFactorY);
1564
1565 if (!((screen.unit == GERBV_MILS) && ((screenRenderInfo.scaleFactorX < 80)||(screenRenderInfo.scaleFactorY < 80)))) {
1566 xPosition = callbacks_calculate_actual_distance (xPosition);
1567 yPosition = callbacks_calculate_actual_distance (yPosition);
1568 }
1569 g_object_set (G_OBJECT (screen.win.hRuler), "position", xPosition, NULL);
1570 g_object_set (G_OBJECT (screen.win.vRuler), "position", yPosition, NULL);
1571 }
1572
1573 /* --------------------------------------------------------- */
1574 void callbacks_update_ruler_scales (void) {
1575 double xStart, xEnd, yStart, yEnd;
1576
1577 xStart = screenRenderInfo.lowerLeftX;
1578 yStart = screenRenderInfo.lowerLeftY;
1579 xEnd = screenRenderInfo.lowerLeftX + (screenRenderInfo.displayWidth / screenRenderInfo.scaleFactorX);
1580 yEnd = screenRenderInfo.lowerLeftY + (screenRenderInfo.displayHeight / screenRenderInfo.scaleFactorY);
1581 /* mils can get super crowded with large boards, but inches are too
1582 large for most boards. So, we leave mils in for now and just switch
1583 to inches if the scale factor gets too small */
1584 if (!((screen.unit == GERBV_MILS) && ((screenRenderInfo.scaleFactorX < 80)||(screenRenderInfo.scaleFactorY < 80)))) {
1585 xStart = callbacks_calculate_actual_distance (xStart);
1586 xEnd = callbacks_calculate_actual_distance (xEnd);
1587 yStart = callbacks_calculate_actual_distance (yStart);
1588 yEnd = callbacks_calculate_actual_distance (yEnd);
1589 }
1590 /* make sure the widgets actually exist before setting (in case this gets
1591 called before everything is realized */
1592 if (screen.win.hRuler)
1593 gtk_ruler_set_range (GTK_RULER (screen.win.hRuler), xStart, xEnd, 0, xEnd - xStart);
1594 /* reverse y min and max, since the ruler starts at the top */
1595 if (screen.win.vRuler)
1596 gtk_ruler_set_range (GTK_RULER (screen.win.vRuler), yEnd, yStart, 0, yEnd - yStart);
1597 }
1598
1599 /* --------------------------------------------------------- */
1600 void callbacks_update_scrollbar_limits (void){
1601 gerbv_render_info_t tempRenderInfo = {0, 0, 0, 0, 3, screenRenderInfo.displayWidth,
1602 screenRenderInfo.displayHeight};
1603
1604 GtkAdjustment *hAdjust = (GtkAdjustment *)screen.win.hAdjustment;
1605 GtkAdjustment *vAdjust = (GtkAdjustment *)screen.win.vAdjustment;
1606 gerbv_render_zoom_to_fit_display (mainProject, &tempRenderInfo);
1607 hAdjust->lower = tempRenderInfo.lowerLeftX;
1608 hAdjust->page_increment = hAdjust->page_size;
1609 hAdjust->step_increment = hAdjust->page_size / 10.0;
1610 vAdjust->lower = tempRenderInfo.lowerLeftY;
1611 vAdjust->page_increment = vAdjust->page_size;
1612 vAdjust->step_increment = vAdjust->page_size / 10.0;
1613 hAdjust->upper = tempRenderInfo.lowerLeftX + (tempRenderInfo.displayWidth / tempRenderInfo.scaleFactorX);
1614 hAdjust->page_size = screenRenderInfo.displayWidth / screenRenderInfo.scaleFactorX;
1615 vAdjust->upper = tempRenderInfo.lowerLeftY + (tempRenderInfo.displayHeight / tempRenderInfo.scaleFactorY);
1616 vAdjust->page_size = screenRenderInfo.displayHeight / screenRenderInfo.scaleFactorY;
1617 callbacks_update_scrollbar_positions ();
1618 }
1619
1620 /* --------------------------------------------------------- */
1621 void callbacks_update_scrollbar_positions (void){
1622 gdouble positionX,positionY;
1623
1624 positionX = screenRenderInfo.lowerLeftX;
1625 if (positionX < ((GtkAdjustment *)screen.win.hAdjustment)->lower)
1626 positionX = ((GtkAdjustment *)screen.win.hAdjustment)->lower;
1627 if (positionX > (((GtkAdjustment *)screen.win.hAdjustment)->upper - ((GtkAdjustment *)screen.win.hAdjustment)->page_size))
1628 positionX = (((GtkAdjustment *)screen.win.hAdjustment)->upper - ((GtkAdjustment *)screen.win.hAdjustment)->page_size);
1629 gtk_adjustment_set_value ((GtkAdjustment *)screen.win.hAdjustment, positionX);
1630
1631 positionY = ((GtkAdjustment *)screen.win.vAdjustment)->upper - screenRenderInfo.lowerLeftY -
1632 ((GtkAdjustment *)screen.win.vAdjustment)->page_size +
1633 ((GtkAdjustment *)screen.win.vAdjustment)->lower;
1634 if (positionY < ((GtkAdjustment *)screen.win.vAdjustment)->lower)
1635 positionY = ((GtkAdjustment *)screen.win.vAdjustment)->lower;
1636 if (positionY > (((GtkAdjustment *)screen.win.vAdjustment)->upper - ((GtkAdjustment *)screen.win.vAdjustment)->page_size))
1637 positionY = (((GtkAdjustment *)screen.win.vAdjustment)->upper - ((GtkAdjustment *)screen.win.vAdjustment)->page_size);
1638 gtk_adjustment_set_value ((GtkAdjustment *)screen.win.vAdjustment, positionY);
1639 }
1640
1641 /* --------------------------------------------------------- */
1642 gboolean
1643 callbacks_scrollbar_button_released (GtkWidget *widget, GdkEventButton *event){
1644 screen.off_x = 0;
1645 screen.off_y = 0;
1646 screen.state = NORMAL;
1647 render_refresh_rendered_image_on_screen();
1648 return FALSE;
1649 }
1650
1651 /* --------------------------------------------------------- */
1652 gboolean
1653 callbacks_scrollbar_button_pressed (GtkWidget *widget, GdkEventButton *event){
1654 //screen.last_x = ((GtkAdjustment *)screen.win.hAdjustment)->value;
1655 screen.state = SCROLLBAR;
1656 return FALSE;
1657 }
1658
1659 /* --------------------------------------------------------- */
1660 void callbacks_hadjustment_value_changed (GtkAdjustment *adjustment, gpointer user_data){
1661 /* make sure we're actually using the scrollbar to make sure we don't reset
1662 lowerLeftX during a scrollbar redraw during something else */
1663 if (screen.state == SCROLLBAR) {
1664 screenRenderInfo.lowerLeftX = gtk_adjustment_get_value (adjustment);
1665 }
1666 }
1667
1668 /* --------------------------------------------------------- */
1669 void callbacks_vadjustment_value_changed (GtkAdjustment *adjustment, gpointer user_data){
1670 /* make sure we're actually using the scrollbar to make sure we don't reset
1671 lowerLeftY during a scrollbar redraw during something else */
1672 if (screen.state == SCROLLBAR) {
1673 screenRenderInfo.lowerLeftY = adjustment->upper -
1674 (gtk_adjustment_get_value (adjustment) + adjustment->page_size) + adjustment->lower;
1675 }
1676 }
1677
1678 /* --------------------------------------------------------- */
1679 void
1680 callbacks_layer_tree_visibility_button_toggled (GtkCellRendererToggle *cell_renderer,
1681 gchar *path,
1682 gpointer user_data){
1683 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
1684 ((GtkTreeView *) screen.win.layerTree);
1685 GtkTreeIter iter;
1686 gboolean newVisibility=TRUE;
1687 gint index;
1688
1689 gtk_tree_model_get_iter_from_string ((GtkTreeModel *)list_store, &iter, path);
1690
1691 GtkTreePath *treePath = gtk_tree_path_new_from_string (path);
1692 if (gtk_tree_model_get_iter((GtkTreeModel *)list_store, &iter, treePath)) {
1693 gint *indeces;
1694
1695 indeces = gtk_tree_path_get_indices (treePath);
1696 index = indeces[0];
1697 if (mainProject->file[index]->isVisible)
1698 newVisibility = FALSE;
1699 mainProject->file[index]->isVisible = newVisibility;
1700
1701 callbacks_update_layer_tree ();
1702 if (screenRenderInfo.renderType < 2) {
1703 render_refresh_rendered_image_on_screen();
1704 }
1705 else {
1706 render_recreate_composite_surface (screen.drawing_area);
1707 callbacks_force_expose_event_for_screen ();
1708 }
1709 }
1710 }
1711
1712 /* --------------------------------------------------------- */
1713 gint
1714 callbacks_get_col_number_from_tree_view_column (GtkTreeViewColumn *col)
1715 {
1716 GList *cols;
1717 gint num;
1718
1719 g_return_val_if_fail ( col != NULL, -1 );
1720 g_return_val_if_fail ( col->tree_view != NULL, -1 );
1721 cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(col->tree_view));
1722 num = g_list_index(cols, (gpointer) col);
1723 g_list_free(cols);
1724 return num;
1725 }
1726
1727 /* --------------------------------------------------------- */
1728 void
1729 callbacks_add_layer_button_clicked (GtkButton *button, gpointer user_data) {
1730 callbacks_open_layer_activate (NULL, NULL);
1731 }
1732
1733 /* --------------------------------------------------------- */
1734 void
1735 callbacks_unselect_all_tool_buttons (void) {
1736
1737 }
1738
1739 void
1740 callbacks_switch_to_normal_tool_cursor (gint toolNumber) {
1741 GdkCursor *cursor;
1742
1743 switch (toolNumber) {
1744 case POINTER:
1745 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1746 GERBV_DEF_CURSOR);
1747 break;
1748 case PAN:
1749 cursor = gdk_cursor_new(GDK_FLEUR);
1750 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1751 cursor);
1752 gdk_cursor_destroy(cursor);
1753 break;
1754 case ZOOM:
1755 cursor = gdk_cursor_new(GDK_SIZING);
1756 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1757 cursor);
1758 gdk_cursor_destroy(cursor);
1759 break;
1760 case MEASURE:
1761 cursor = gdk_cursor_new(GDK_CROSSHAIR);
1762 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1763 cursor);
1764 gdk_cursor_destroy(cursor);
1765 break;
1766 default:
1767 break;
1768 }
1769 }
1770
1771 /* --------------------------------------------------------- */
1772 void
1773 callbacks_switch_to_correct_cursor (void) {
1774 GdkCursor *cursor;
1775
1776 if (screen.state == IN_MOVE) {
1777 cursor = gdk_cursor_new(GDK_FLEUR);
1778 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1779 cursor);
1780 gdk_cursor_destroy(cursor);
1781 return;
1782 }
1783 else if (screen.state == IN_ZOOM_OUTLINE) {
1784 cursor = gdk_cursor_new(GDK_SIZING);
1785 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
1786 cursor);
1787 gdk_cursor_destroy(cursor);
1788 return;
1789 }
1790 callbacks_switch_to_normal_tool_cursor (screen.tool);
1791 }
1792
1793 /* --------------------------------------------------------- */
1794 void
1795 callbacks_change_tool (GtkButton *button, gpointer user_data) {
1796 gint toolNumber = GPOINTER_TO_INT (user_data);
1797
1798 /* make sure se don't get caught in endless recursion here */
1799 if (screen.win.updatingTools)
1800 return;
1801 screen.win.updatingTools = TRUE;
1802 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonPointer), FALSE);
1803 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonPan), FALSE);
1804 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonZoom), FALSE);
1805 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonMeasure), FALSE);
1806 switch (toolNumber) {
1807 case POINTER:
1808 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonPointer), TRUE);
1809 screen.tool = POINTER;
1810 screen.state = NORMAL;
1811 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
1812 "Click to select objects in the current layer. Middle click and drag to pan.");
1813 break;
1814 case PAN:
1815 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonPan), TRUE);
1816 screen.tool = PAN;
1817 screen.state = NORMAL;
1818 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
1819 "Click and drag to pan. Right click and drag to zoom.");
1820 break;
1821 case ZOOM:
1822 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonZoom), TRUE);
1823 screen.tool = ZOOM;
1824 screen.state = NORMAL;
1825 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
1826 "Click and drag to zoom in. Shift+click to zoom out.");
1827 break;
1828 case MEASURE:
1829 gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (screen.win.toolButtonMeasure), TRUE);
1830 screen.tool = MEASURE;
1831 screen.state = NORMAL;
1832 snprintf(screen.statusbar.diststr, MAX_DISTLEN, "Click and drag to measure a distance.");
1833 break;
1834 default:
1835 break;
1836 }
1837 callbacks_switch_to_normal_tool_cursor (toolNumber);
1838 callbacks_update_statusbar();
1839 screen.win.updatingTools = FALSE;
1840 callbacks_force_expose_event_for_screen();
1841 }
1842
1843 /* --------------------------------------------------------- */
1844 void
1845 callbacks_select_row (gint rowIndex) {
1846 GtkTreeSelection *selection;
1847 GtkTreeIter iter;
1848 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
1849 ((GtkTreeView *) screen.win.layerTree);
1850
1851 selection = gtk_tree_view_get_selection((GtkTreeView *) screen.win.layerTree);
1852 if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, rowIndex)) {
1853 gtk_tree_selection_select_iter (selection, &iter);
1854 }
1855 }
1856
1857 /* --------------------------------------------------------- */
1858 /**
1859 * This fcn returns the index of selected layer (selected in
1860 * the layer window on left).
1861 *
1862 */
1863 gint
1864 callbacks_get_selected_row_index (void) {
1865 GtkTreeSelection *selection;
1866 GtkTreeIter iter;
1867 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
1868 ((GtkTreeView *) screen.win.layerTree);
1869 gint index=-1,i=0;
1870
1871 /* This will only work in single or browse selection mode! */
1872 selection = gtk_tree_view_get_selection((GtkTreeView *) screen.win.layerTree);
1873 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
1874 while (gtk_tree_model_iter_nth_child ((GtkTreeModel *)list_store,
1875 &iter, NULL, i)){
1876 if (gtk_tree_selection_iter_is_selected (selection, &iter)) {
1877 return i;
1878 }
1879 i++;
1880 }
1881 }
1882 return index;
1883 }
1884
1885 /* --------------------------------------------------------- */
1886 void
1887 callbacks_remove_layer_button_clicked (GtkButton *button, gpointer user_data) {
1888 gint index=callbacks_get_selected_row_index();
1889
1890 if ((index >= 0) && (index <= mainProject->last_loaded)) {
1891 render_remove_selected_objects_belonging_to_layer (index);
1892 gerbv_unload_layer (mainProject, index);
1893 callbacks_update_layer_tree ();
1894 callbacks_select_row (0);
1895
1896 if (screenRenderInfo.renderType < 2) {
1897 render_refresh_rendered_image_on_screen();
1898 }
1899 else {
1900 render_recreate_composite_surface (screen.drawing_area);
1901 callbacks_force_expose_event_for_screen ();
1902 }
1903 }
1904 }
1905
1906 /* --------------------------------------------------------- */
1907 void
1908 callbacks_move_layer_down_button_clicked (GtkButton *button, gpointer user_data) {
1909 gint index=callbacks_get_selected_row_index();
1910
1911 if ((index >= 0) && (index < mainProject->last_loaded)) {
1912 gerbv_change_layer_order (mainProject, index, index + 1);
1913 callbacks_update_layer_tree ();
1914 callbacks_select_row (index + 1);
1915 if (screenRenderInfo.renderType < 2) {
1916 render_refresh_rendered_image_on_screen();
1917 }
1918 else {
1919 render_recreate_composite_surface (screen.drawing_area);
1920 callbacks_force_expose_event_for_screen ();
1921 }
1922 }
1923 }
1924
1925 /* --------------------------------------------------------- */
1926 void
1927 callbacks_move_layer_up_clicked (GtkButton *button, gpointer user_data) {
1928 gint index=callbacks_get_selected_row_index();
1929
1930 if (index > 0) {
1931 gerbv_change_layer_order (mainProject, index, index - 1);
1932 callbacks_update_layer_tree ();
1933 callbacks_select_row (index - 1);
1934 if (screenRenderInfo.renderType < 2) {
1935 render_refresh_rendered_image_on_screen();
1936 }
1937 else {
1938 render_recreate_composite_surface (screen.drawing_area);
1939 callbacks_force_expose_event_for_screen ();
1940 }
1941 }
1942 }
1943
1944 /* --------------------------------------------------------- */
1945 void callbacks_layer_tree_row_inserted (GtkTreeModel *tree_model, GtkTreePath *path,
1946 GtkTreeIter *oIter, gpointer user_data) {
1947 gint *indeces=NULL,oldPosition,newPosition;
1948
1949 if ((!screen.win.treeIsUpdating)&&(path != NULL)) {
1950 indeces = gtk_tree_path_get_indices (path);
1951 if (indeces) {
1952 newPosition = indeces[0];
1953 oldPosition = callbacks_get_selected_row_index ();
1954 /* compensate for the fact that the old row has already
1955 been removed */
1956 if (oldPosition < newPosition)
1957 newPosition--;
1958 else
1959 oldPosition--;
1960 gerbv_change_layer_order (mainProject, oldPosition, newPosition);
1961
1962 if (screenRenderInfo.renderType < 2) {
1963 render_refresh_rendered_image_on_screen();
1964 }
1965 else {
1966 render_recreate_composite_surface (screen.drawing_area);
1967 callbacks_force_expose_event_for_screen ();
1968 }
1969 /* select the new line */
1970 GtkTreeSelection *selection;
1971 GtkTreeIter iter;
1972 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
1973 ((GtkTreeView *) screen.win.layerTree);
1974
1975 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(screen.win.layerTree));
1976 if (gtk_tree_model_get_iter ((GtkTreeModel *)list_store, &iter, path))
1977 gtk_tree_selection_select_iter (selection, &iter);
1978 }
1979 }
1980 }
1981
1982 /* --------------------------------------------------------- */
1983 void
1984 callbacks_show_color_picker_dialog (gint index){
1985 screen.win.colorSelectionDialog = NULL;
1986 GtkColorSelectionDialog *cs= (GtkColorSelectionDialog *) gtk_color_selection_dialog_new ("Select a color");
1987 GtkColorSelection *colorsel = (GtkColorSelection *) cs->colorsel;
1988
1989 screen.win.colorSelectionDialog = (GtkWidget *) cs;
1990 screen.win.colorSelectionIndex = index;
1991 if (index >= 0)
1992 gtk_color_selection_set_current_color (colorsel, &mainProject->file[index]->color);
1993 else
1994 gtk_color_selection_set_current_color (colorsel, &mainProject->background);
1995 if ((screenRenderInfo.renderType >= 2)&&(index >= 0)) {
1996 gtk_color_selection_set_has_opacity_control (colorsel, TRUE);
1997 gtk_color_selection_set_current_alpha (colorsel, mainProject->file[index]->alpha);
1998 }
1999 gtk_widget_show_all((GtkWidget *)cs);
2000 if (gtk_dialog_run ((GtkDialog*)cs) == GTK_RESPONSE_OK) {
2001 GtkColorSelection *colorsel = (GtkColorSelection *) cs->colorsel;
2002 gint rowIndex = screen.win.colorSelectionIndex;
2003
2004 if (index >= 0) {
2005 gtk_color_selection_get_current_color (colorsel, &mainProject->file[rowIndex]->color);
2006 gdk_colormap_alloc_color(gdk_colormap_get_system(), &mainProject->file[rowIndex]->color, FALSE, TRUE);
2007 }
2008 else {
2009 gtk_color_selection_get_current_color (colorsel, &mainProject->background);
2010 gdk_colormap_alloc_color(gdk_colormap_get_system(), &mainProject->background, FALSE, TRUE);
2011 }
2012 if ((screenRenderInfo.renderType >= 2)&&(index >= 0)) {
2013 mainProject->file[rowIndex]->alpha = gtk_color_selection_get_current_alpha (colorsel);
2014 }
2015
2016 callbacks_update_layer_tree ();
2017 render_refresh_rendered_image_on_screen();
2018 }
2019 gtk_widget_destroy ((GtkWidget *)cs);
2020 screen.win.colorSelectionDialog = NULL;
2021 }
2022
2023 /* --------------------------------------------------------- */
2024 void
2025 callbacks_invert_layer_clicked (GtkButton *button, gpointer user_data) {
2026 gint index=callbacks_get_selected_row_index();
2027
2028 mainProject->file[index]->transform.inverted = !mainProject->file[index]->transform.inverted;
2029 render_refresh_rendered_image_on_screen ();
2030 callbacks_update_layer_tree ();
2031 }
2032
2033 /* --------------------------------------------------------- */
2034 void
2035 callbacks_change_layer_color_clicked (GtkButton *button, gpointer user_data) {
2036 gint index=callbacks_get_selected_row_index();
2037
2038 callbacks_show_color_picker_dialog (index);
2039 }
2040
2041 void
2042 callbacks_change_background_color_clicked (GtkButton *button, gpointer user_data) {
2043 callbacks_show_color_picker_dialog (-1);
2044 }
2045
2046 /* --------------------------------------------------------------------------- */
2047 void
2048 callbacks_reload_layer_clicked (GtkButton *button, gpointer user_data) {
2049 gint index = callbacks_get_selected_row_index();
2050
2051 render_remove_selected_objects_belonging_to_layer (index);
2052 gerbv_revert_file (mainProject, index);
2053 render_refresh_rendered_image_on_screen ();
2054 callbacks_update_layer_tree();
2055 }
2056
2057 void
2058 callbacks_change_layer_orientation_clicked (GtkButton *button, gpointer userData){
2059 gint index = callbacks_get_selected_row_index();
2060
2061 interface_show_modify_orientation_dialog(&mainProject->file[index]->transform,screen.unit);
2062 render_refresh_rendered_image_on_screen ();
2063 callbacks_update_layer_tree ();
2064 }
2065
2066 /* --------------------------------------------------------------------------- */
2067 void
2068 callbacks_change_layer_format_clicked (GtkButton *button, gpointer user_data)
2069 {
2070 gerbv_HID_Attribute *attr = NULL;
2071 int n = 0;
2072 int i;
2073 gerbv_HID_Attr_Val * results = NULL;
2074 gint index = callbacks_get_selected_row_index();
2075 gchar *type;
2076 gint rc;
2077
2078 dprintf ("%s(): index = %d\n", __FUNCTION__, index);
2079 attr = mainProject->file[index]->image->info->attr_list;
2080 n = mainProject->file[index]->image->info->n_attr;
2081 type = mainProject->file[index]->image->info->type;
2082 if (type == NULL)
2083 type = "Unknown";
2084
2085 if (attr == NULL || n == 0)
2086 {
2087 interface_show_alert_dialog("This file type does not currently have any editable features",
2088 "Format editing is currently only supported for Excellon drill file formats.",
2089 FALSE,
2090 NULL);
2091 return;
2092 }
2093
2094 dprintf ("%s(): n = %d, attr = %p\n", __FUNCTION__, n, attr);
2095 if (n > 0)
2096 {
2097 if (mainProject->file[index]->layer_dirty) {
2098 rc = interface_get_alert_dialog_response ("This layer has changed!",
2099 "Editing the file type will reload the layer, destroying your changes. Click OK to edit the file type and destroy your changes, or Cancel to leave.",
2100 TRUE,
2101 NULL);
2102 if (rc == 0) return; /* Return if user hit Cancel */
2103 }
2104
2105 results = (gerbv_HID_Attr_Val *) malloc (n * sizeof (gerbv_HID_Attr_Val));
2106 if (results == NULL)
2107 {
2108 fprintf (stderr, "%s() -- malloc failed\n", __FUNCTION__);
2109 exit (1);
2110 }
2111
2112 /* non-zero means cancel was picked */
2113 if (attribute_interface_dialog (attr, n, results,
2114 "Edit file format",
2115 type))
2116 {
2117 return;
2118 }
2119
2120 }
2121
2122 dprintf ("%s(): Reloading layer\n", __FUNCTION__);
2123 gerbv_revert_file (mainProject, index);
2124
2125 for (i = 0; i < n; i++)
2126 {
2127 if (results[i].str_value)
2128 free (results[i].str_value);
2129 }
2130
2131 if (results)
2132 free (results);
2133 render_refresh_rendered_image_on_screen();
2134 callbacks_update_layer_tree();
2135 }
2136
2137 /* --------------------------------------------------------------------------- */
2138 gboolean
2139 callbacks_layer_tree_button_press (GtkWidget *widget, GdkEventButton *event,
2140 gpointer user_data) {
2141 GtkTreePath *path;
2142 GtkTreeIter iter;
2143 GtkTreeViewColumn *column;
2144 gint x,y;
2145 gint columnIndex;
2146
2147 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
2148 ((GtkTreeView *) screen.win.layerTree);
2149 if (event->button == 1) {
2150 if (gtk_tree_view_get_path_at_pos ((GtkTreeView *) widget, event->x, event->y,
2151 &path, &column, &x, &y)) {
2152 if (gtk_tree_model_get_iter((GtkTreeModel *)list_store, &iter, path)) {
2153 gint *indeces;
2154 indeces = gtk_tree_path_get_indices (path);
2155 if (indeces) {
2156 columnIndex = callbacks_get_col_number_from_tree_view_column (column);
2157 if ((columnIndex == 1) && (indeces[0] <= mainProject->last_loaded)){
2158 callbacks_show_color_picker_dialog (indeces[0]);
2159 /* don't propagate the signal, since drag and drop can
2160 sometimes activated during color selection */
2161 return TRUE;
2162 }
2163 }
2164 }
2165 }
2166 }
2167 /* don't pop up the menu if we don't have any loaded files */
2168 else if ((event->button == 3)&&(mainProject->last_loaded >= 0)) {
2169 gtk_menu_popup(GTK_MENU(screen.win.layerTreePopupMenu), NULL, NULL, NULL, NULL,
2170 event->button, event->time);
2171 }
2172 /* always allow the click to propagate and make sure the line is activated */
2173 return FALSE;
2174 }
2175
2176 /* --------------------------------------------------------------------------- */
2177 void
2178 callbacks_update_layer_tree (void) {
2179 GtkListStore *list_store = (GtkListStore *) gtk_tree_view_get_model
2180 ((GtkTreeView *) screen.win.layerTree);
2181 gint idx;
2182 GtkTreeIter iter;
2183 GtkTreeSelection *selection;
2184 gint oldSelectedRow;
2185
2186 if (!screen.win.treeIsUpdating) {
2187 screen.win.treeIsUpdating = TRUE;
2188
2189 oldSelectedRow = callbacks_get_selected_row_index();
2190 if (oldSelectedRow < 0)
2191 oldSelectedRow = 0;
2192 gtk_list_store_clear (list_store);
2193
2194 for (idx = 0; idx <= mainProject->last_loaded; idx++) {
2195 if (mainProject->file[idx]) {
2196 GdkPixbuf *pixbuf,*blackPixbuf;
2197 guint32 color;
2198
2199 unsigned char red, green, blue, alpha;
2200
2201 red = (unsigned char) (mainProject->file[idx]->color.red * 255 / G_MAXUINT16) ;
2202 green = (unsigned char) (mainProject->file[idx]->color.green * 255 / G_MAXUINT16) ;
2203 blue = (unsigned char) (mainProject->file[idx]->color.blue *255 / G_MAXUINT16) ;
2204 alpha = (unsigned char) (mainProject->file[idx]->alpha * 255 / G_MAXUINT16) ;
2205
2206 color = (red )* (256*256*256) + (green ) * (256*256) + (blue )* (256) + (alpha );
2207 pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 20, 15);
2208 gdk_pixbuf_fill (pixbuf, color);
2209
2210 blackPixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 20, 15);
2211 color = (100 )* (256*256*256) + (100 ) * (256*256) + (100 )* (256) + (150 );
2212 gdk_pixbuf_fill (blackPixbuf, color);
2213
2214 /* copy the color area into the black pixbuf */
2215 gdk_pixbuf_copy_area (pixbuf, 1, 1, 18, 13, blackPixbuf, 1, 1);
2216 /* free the color buffer, since we don't need it anymore */
2217 g_object_unref(pixbuf);
2218
2219 gtk_list_store_append (list_store, &iter);
2220
2221 gchar startChar[2],*modifiedCode;
2222 /* terminate the letter string */
2223 startChar[1] = 0;
2224
2225 gint numberOfModifications = 0;
2226 if (mainProject->file[idx]->transform.inverted) {
2227 startChar[0] = 'I';
2228 numberOfModifications++;
2229 }
2230 if (mainProject->file[idx]->transform.mirrorAroundX ||
2231 mainProject->file[idx]->transform.mirrorAroundY) {
2232 startChar[0] = 'M';
2233 numberOfModifications++;
2234 }
2235 if ((abs(mainProject->file[idx]->transform.translateX) > 0.000001) ||
2236 (fabs(mainProject->file[idx]->transform.translateY) > 0.000001)) {
2237 startChar[0] = 'T';
2238 numberOfModifications++;
2239 }
2240 if ((abs(mainProject->file[idx]->transform.scaleX - 1) > 0.000001) ||
2241 (fabs(mainProject->file[idx]->transform.scaleY - 1) > 0.000001)) {
2242 startChar[0] = 'S';
2243 numberOfModifications++;
2244 }
2245 if ((fabs(mainProject->file[idx]->transform.rotation) > 0.000001)) {
2246 startChar[0] = 'R';
2247 numberOfModifications++;
2248 }
2249 if (numberOfModifications > 1)
2250 startChar[0] = '*';
2251 if (numberOfModifications == 0)
2252 modifiedCode = g_strdup ("");
2253 else
2254 modifiedCode = g_strdup (startChar);
2255
2256 /* display any unsaved layers differently to show the user they are
2257 unsaved */
2258 gchar *layerName;
2259 if (mainProject->file[idx]->layer_dirty == TRUE) {
2260 /* The layer has unsaved changes in it. Show layer name in italics. */
2261 layerName = g_strconcat ("*","<i>",mainProject->file[idx]->name,"</i>",NULL);
2262 }
2263 else
2264 /* layer is clean. Show layer name using normal font. */
2265 layerName = g_strdup (mainProject->file[idx]->name);
2266
2267 gtk_list_store_set (list_store, &iter,
2268 0, mainProject->file[idx]->isVisible,
2269 1, blackPixbuf,
2270 2, layerName,
2271 3, modifiedCode,
2272 -1);
2273 g_free (layerName);
2274 g_free (modifiedCode);
2275 /* pixbuf has a refcount of 2 now, as the list store has added its own reference */
2276 g_object_unref(blackPixbuf);
2277 }
2278 }
2279
2280 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(screen.win.layerTree));
2281
2282 /* if no line is selected yet, select the first row (if it has data) */
2283 /* or, select the line that was previously selected */
2284
2285 if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) {
2286 if (gtk_tree_model_iter_nth_child ((GtkTreeModel *) list_store,
2287 &iter, NULL, oldSelectedRow)) {
2288 gtk_tree_selection_select_iter (selection, &iter);
2289 }
2290 }
2291 screen.win.treeIsUpdating = FALSE;
2292 }
2293 }
2294
2295 /* --------------------------------------------------------------------------- */
2296 void
2297 callbacks_display_object_properties_clicked (GtkButton *button, gpointer user_data){
2298 int i;
2299 gchar *layer_name;
2300 gchar *net_label;
2301 gboolean validAperture;
2302
2303 gint index=callbacks_get_selected_row_index();
2304 if (index < 0)
2305 return;
2306
2307 if (screen.selectionInfo.type == GERBV_SELECTION_EMPTY) {
2308 interface_show_alert_dialog("No object is currently selected",
2309 "Objects must be selected using the pointer tool before you can view the object properties.",
2310 FALSE,
2311 NULL);
2312 return;
2313 }
2314
2315 for (i=0; i<screen.selectionInfo.selectedNodeArray->len; i++){
2316 gerbv_selection_item_t sItem = g_array_index (screen.selectionInfo.selectedNodeArray,
2317 gerbv_selection_item_t, i);
2318
2319 gerbv_net_t *net = sItem.net;
2320 gerbv_image_t *image = sItem.image;
2321 int ap_type=0;
2322
2323 /* get the aperture definition for the selected item */
2324 if (net->aperture > 0) {
2325 ap_type = image->aperture[net->aperture]->type;
2326 validAperture = TRUE;
2327 }
2328 else {
2329 validAperture = FALSE;
2330 }
2331
2332 /* Also get layer name specified in file by %LN directive
2333 * (if it exists). */
2334 if (net->layer->name == NULL) {
2335 layer_name = g_strdup("<unnamed layer>");
2336 } else {
2337 layer_name = g_strdup(net->layer->name);
2338 }
2339
2340 if (net->label == NULL) {
2341 net_label = g_strdup("<unlabeled net>");
2342 } else {
2343 net_label = g_strdup((gchar *)net->label);
2344 }
2345 if (net->interpolation == GERBV_INTERPOLATION_PAREA_START) {
2346 g_message ("Object type: Polygon\n");
2347 }
2348 else {
2349 switch (net->aperture_state){
2350 case GERBV_APERTURE_STATE_OFF:
2351 break;
2352 case GERBV_APERTURE_STATE_ON:
2353 if (i!=0) g_message ("\n"); /* Spacing for a pretty display */
2354 switch (net->interpolation) {
2355 case GERBV_INTERPOLATION_x10 :
2356 case GERBV_INTERPOLATION_LINEARx01 :
2357 case GERBV_INTERPOLATION_LINEARx001 :
2358 case GERBV_INTERPOLATION_LINEARx1 :
2359 g_message ("Object type: Line\n");
2360 break;
2361 case GERBV_INTERPOLATION_CW_CIRCULAR :
2362 case GERBV_INTERPOLATION_CCW_CIRCULAR :
2363 g_message ("Object type: Arc\n");
2364 break;
2365 default :
2366 g_message ("Object type: Unknown\n");
2367 break;
2368 }
2369 g_message (" Exposure: On\n");
2370 if (validAperture) {
2371 g_message (" Aperture used: D%d\n", net->aperture);
2372 g_message (" Aperture type: %s\n", ap_names[ap_type]);
2373 }
2374 g_message (" Start location: (%g, %g)\n", net->start_x, net->start_y);
2375 g_message (" Stop location: (%g, %g)\n", net->stop_x, net->stop_y);
2376 g_message (" Layer name: %s\n", layer_name);
2377 g_message (" Net label: %s\n", net_label);
2378 g_message (" In file: %s\n", mainProject->file[index]->name);
2379 break;
2380 case GERBV_APERTURE_STATE_FLASH:
2381 if (i!=0) g_message ("\n"); /* Spacing for a pretty display */
2382 g_message ("Object type: Flashed aperture\n");
2383 if (validAperture) {
2384 g_message (" Aperture used: D%d\n", net->aperture);
2385 g_message (" Aperture type: %s\n", ap_names[ap_type]);
2386 }
2387 g_message (" Location: (%g, %g)\n", net->stop_x, net->stop_y);
2388 g_message (" Layer name: %s\n", layer_name);
2389 g_message (" Net label: %s\n", net_label);
2390 g_message (" In file: %s\n", mainProject->file[index]->name);
2391 break;
2392 }
2393 }
2394 g_free (net_label);
2395 g_free (layer_name);
2396 }
2397 /* Use separator for different report requests */
2398 g_message ("---------------------------------------\n");
2399 }
2400
2401 void
2402 callbacks_support_benchmark (gerbv_render_info_t *renderInfo) {
2403 int i;
2404 time_t start, now;
2405 GdkPixmap *renderedPixmap = gdk_pixmap_new (NULL, renderInfo->displayWidth,
2406 renderInfo->displayHeight, 24);
2407
2408 // start by running the GDK (fast) rendering test
2409 i = 0;
2410 start = time(NULL);
2411 now = start;
2412 while( now - 30 < start) {
2413 i++;
2414 dprintf("Benchmark(): Starting redraw #%d\n", i);
2415 gerbv_render_to_pixmap_using_gdk (mainProject, renderedPixmap, renderInfo, NULL, NULL);
2416 now = time(NULL);
2417 dprintf("Elapsed time = %ld seconds\n", (long int) (now - start));
2418 }
2419 g_message("FAST mode benchmark: %d redraws in %ld seconds (%g redraws/second)\n",
2420 i, (long int) (now - start), (double) i / (double)(now - start));
2421 gdk_pixmap_unref(renderedPixmap);
2422
2423 // run the cairo (normal) render mode
2424 i = 0;
2425 start = time(NULL);
2426 now = start;
2427 renderInfo->renderType = 2;
2428 while( now - 30 < start) {
2429 i++;
2430 dprintf("Benchmark(): Starting redraw #%d\n", i);
2431 cairo_surface_t *cSurface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2432 renderInfo->displayWidth, renderInfo->displayHeight);
2433 cairo_t *cairoTarget = cairo_create (cSurface);
2434 gerbv_render_all_layers_to_cairo_target (mainProject, cairoTarget, renderInfo);
2435 cairo_destroy (cairoTarget);
2436 cairo_surface_destroy (cSurface);
2437 now = time(NULL);
2438 dprintf("Elapsed time = %ld seconds\n", (long int) (now - start));
2439 }
2440 g_message("NORMAL mode benchmark: %d redraws in %ld seconds (%g redraws/second)\n",
2441 i, (long int) (now - start), (double) i / (double)(now - start));
2442 }
2443
2444 /* --------------------------------------------------------------------------- */
2445 void
2446 callbacks_benchmark_clicked (GtkButton *button, gpointer user_data)
2447 {
2448 // prepare render size and options (canvas size width and height are last 2 variables)
2449 gerbv_render_info_t renderInfo = {1.0, 1.0, 0, 0, 0, 640, 480};
2450 // autoscale the image for now...maybe we don't want to do this in order to
2451 // allow benchmarking of different zoom levels?
2452 gerbv_render_zoom_to_fit_display (mainProject, &renderInfo);
2453
2454 g_message("Full zoom benchmarks\n");
2455 callbacks_support_benchmark (&renderInfo);
2456
2457
2458 g_message("x5 zoom benchmarks\n");
2459 renderInfo.lowerLeftX += (screenRenderInfo.displayWidth /
2460 screenRenderInfo.scaleFactorX) / 3.0;
2461 renderInfo.lowerLeftY += (screenRenderInfo.displayHeight /
2462 screenRenderInfo.scaleFactorY) / 3.0;
2463 renderInfo.scaleFactorX *= 5;
2464 renderInfo.scaleFactorY *= 5;
2465 callbacks_support_benchmark (&renderInfo);
2466 }
2467
2468 /* --------------------------------------------------------------------------- */
2469 void
2470 callbacks_edit_object_properties_clicked (GtkButton *button, gpointer user_data){
2471 }
2472
2473 /* --------------------------------------------------------------------------- */
2474 void
2475 callbacks_move_objects_clicked (GtkButton *button, gpointer user_data){
2476 /* for testing, just hard code in some translations here */
2477 gerbv_image_move_selected_objects (screen.selectionInfo.selectedNodeArray, -0.050, 0.050);
2478 callbacks_update_layer_tree();
2479 render_clear_selection_buffer ();
2480 render_refresh_rendered_image_on_screen ();
2481 }
2482
2483 /* --------------------------------------------------------------------------- */
2484 void
2485 callbacks_reduce_object_area_clicked (GtkButton *button, gpointer user_data){
2486 /* for testing, just hard code in some parameters */
2487 gerbv_image_reduce_area_of_selected_objects (screen.selectionInfo.selectedNodeArray, 0.20, 3, 3, 0.01);
2488 render_clear_selection_buffer ();
2489 render_refresh_rendered_image_on_screen ();
2490 }
2491
2492 /* --------------------------------------------------------------------------- */
2493 void
2494 callbacks_delete_objects_clicked (GtkButton *button, gpointer user_data){
2495 if (screen.selectionInfo.type == GERBV_SELECTION_EMPTY) {
2496 interface_show_alert_dialog("No object is currently selected",
2497 NULL,
2498 FALSE,
2499 NULL);
2500 return;
2501 }
2502
2503 gint index=callbacks_get_selected_row_index();
2504 if (index < 0)
2505 return;
2506
2507 if (mainProject->check_before_delete == TRUE) {
2508 if (!interface_get_alert_dialog_response(
2509 "Do you want to permanently delete the selected objects?",
2510 "Gerbv currently has no undo function, so this action cannot be undone. This action will not change the saved file unless you save the file afterwards.",
2511 TRUE,
2512 &(mainProject->check_before_delete)))
2513 return;
2514 }
2515
2516 gerbv_image_delete_selected_nets (mainProject->file[index]->image,
2517 screen.selectionInfo.selectedNodeArray);
2518 render_refresh_rendered_image_on_screen ();
2519 /* Set layer_dirty flag to TRUE */
2520 mainProject->file[index]->layer_dirty = TRUE;
2521 callbacks_update_layer_tree();
2522
2523 render_clear_selection_buffer ();
2524 callbacks_update_selected_object_message(FALSE);
2525 }
2526
2527 /* --------------------------------------------------------------------------- */
2528 gboolean
2529 callbacks_drawingarea_configure_event (GtkWidget *widget, GdkEventConfigure *event)
2530 {
2531 GdkDrawable *drawable = widget->window;
2532
2533 gdk_drawable_get_size (drawable, &screenRenderInfo.displayWidth, &screenRenderInfo.displayHeight);
2534
2535 /* set this up if cairo is compiled, since we may need to switch over to
2536 using the surface at any time */
2537 int x_off=0, y_off=0;
2538 GdkVisual *visual;
2539
2540 if (GDK_IS_WINDOW(widget->window)) {
2541 /* query the window's backbuffer if it has one */
2542 GdkWindow *window = GDK_WINDOW(widget->window);
2543 gdk_window_get_internal_paint_info (window, &drawable, &x_off, &y_off);
2544 }
2545 visual = gdk_drawable_get_visual (drawable);
2546 if (screen.windowSurface)
2547 cairo_surface_destroy ((cairo_surface_t *)
2548 screen.windowSurface);
2549 #ifdef WIN32
2550 cairo_t *cairoTarget = gdk_cairo_create (GDK_WINDOW(widget->window));
2551
2552 screen.windowSurface = cairo_get_target (cairoTarget);
2553 /* increase surface reference by one so it isn't freed when the cairo_t
2554 is destroyed next */
2555 screen.windowSurface = cairo_surface_reference (screen.windowSurface);
2556 cairo_destroy (cairoTarget);
2557 #else
2558 screen.windowSurface = (gpointer) cairo_xlib_surface_create (GDK_DRAWABLE_XDISPLAY (drawable),
2559 GDK_DRAWABLE_XID (drawable),
2560 GDK_VISUAL_XVISUAL (visual),
2561 screenRenderInfo.displayWidth,
2562 screenRenderInfo.displayHeight);
2563 #endif
2564 /* if this is the first time, go ahead and call autoscale even if we don't
2565 have a model loaded */
2566 if ((screenRenderInfo.scaleFactorX < 0.001)||(screenRenderInfo.scaleFactorY < 0.001)) {
2567 gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
2568 }
2569 render_refresh_rendered_image_on_screen();
2570 return TRUE;
2571 }
2572
2573 /* --------------------------------------------------------- */
2574 gboolean
2575 callbacks_drawingarea_expose_event (GtkWidget *widget, GdkEventExpose *event)
2576 {
2577 if (screenRenderInfo.renderType < 2) {
2578 GdkPixmap *new_pixmap;
2579 GdkGC *gc = gdk_gc_new(widget->window);
2580
2581 /*
2582 * Create a pixmap with default background
2583 */
2584 new_pixmap = gdk_pixmap_new(widget->window,
2585 widget->allocation.width,
2586 widget->allocation.height,
2587 -1);
2588
2589 gdk_gc_set_foreground(gc, &mainProject->background);
2590
2591 gdk_draw_rectangle(new_pixmap, gc, TRUE,
2592 event->area.x, event->area.y,
2593 event->area.width, event->area.height);
2594
2595 /*
2596 * Copy gerber pixmap onto background if we have one to copy.
2597 * Do translation at the same time.
2598 */
2599 if (screen.pixmap != NULL) {
2600 gdk_draw_pixmap(new_pixmap,
2601 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
2602 screen.pixmap,
2603 event->area.x - screen.off_x,
2604 event->area.y - screen.off_y,
2605 event->area.x, event->area.y,
2606 event->area.width, event->area.height);
2607 }
2608
2609 /*
2610 * Draw the whole thing onto screen
2611 */
2612 gdk_draw_pixmap(widget->window,
2613 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
2614 new_pixmap,
2615 event->area.x, event->area.y,
2616 event->area.x, event->area.y,
2617 event->area.width, event->area.height);
2618
2619 gdk_pixmap_unref(new_pixmap);
2620 gdk_gc_unref(gc);
2621
2622 /*
2623 * Draw Zooming outline if we are in that mode
2624 */
2625 if (screen.state == IN_ZOOM_OUTLINE) {
2626 render_draw_zoom_outline(screen.centered_outline_zoom);
2627 }
2628 else if (screen.state == IN_MEASURE) {
2629 render_draw_measure_distance();
2630 }
2631 if (screen.tool == MEASURE && screen.state != IN_MEASURE) {
2632 render_toggle_measure_line();
2633 }
2634
2635 return FALSE;
2636 }
2637
2638 cairo_t *cr;
2639 int width, height;
2640 int x_off=0, y_off=0;
2641 GdkDrawable *drawable = widget->window;
2642 GdkVisual *visual;
2643
2644 if (GDK_IS_WINDOW(widget->window)) {
2645 /* query the window's backbuffer if it has one */
2646 GdkWindow *window = GDK_WINDOW(widget->window);
2647 gdk_window_get_internal_paint_info (window,
2648 &drawable, &x_off, &y_off);
2649 }
2650 visual = gdk_drawable_get_visual (drawable);
2651 gdk_drawable_get_size (drawable, &width, &height);
2652
2653 #ifdef WIN32
2654 /* FIXME */
2655 cr = gdk_cairo_create (GDK_WINDOW(widget->window));
2656 #else
2657 cairo_surface_t *buffert;
2658
2659 buffert = (gpointer) cairo_xlib_surface_create (GDK_DRAWABLE_XDISPLAY (drawable),
2660 GDK_DRAWABLE_XID (drawable),
2661 GDK_VISUAL_XVISUAL (visual),
2662 event->area.width, event->area.height);
2663 cr = cairo_create (buffert);
2664 #endif
2665 cairo_translate (cr, -event->area.x + screen.off_x, -event->area.y + screen.off_y);
2666 render_project_to_cairo_target (cr);
2667 cairo_destroy (cr);
2668 #ifndef WIN32
2669 cairo_surface_destroy (buffert);
2670 #endif
2671
2672 if (screen.tool == MEASURE)
2673 render_toggle_measure_line();
2674 return FALSE;
2675 }
2676
2677 /* Transforms screen coordinates to board ones */
2678 static void
2679 callbacks_screen2board(gdouble *X, gdouble *Y, gint x, gint y) {
2680
2681 /* make sure we don't divide by zero (which is possible if the gui
2682 isn't displayed yet */
2683 if ((screenRenderInfo.scaleFactorX > 0.001)||(screenRenderInfo.scaleFactorY > 0.001)) {
2684 *X = screenRenderInfo.lowerLeftX + (x / screenRenderInfo.scaleFactorX);
2685 *Y = screenRenderInfo.lowerLeftY + ((screenRenderInfo.displayHeight - y)
2686 / screenRenderInfo.scaleFactorY);
2687 }
2688 else {
2689 *X = *Y = 0.0;
2690 }
2691 }
2692
2693 /* --------------------------------------------------------- */
2694 void
2695 callbacks_update_statusbar_coordinates (gint x, gint y) {
2696 gdouble X, Y;
2697
2698 callbacks_screen2board(&X, &Y, x, y);
2699 if (screen.unit == GERBV_MILS) {
2700 snprintf(screen.statusbar.coordstr, MAX_COORDLEN,
2701 "(%8.2f, %8.2f)",
2702 COORD2MILS(X), COORD2MILS(Y));
2703 } else if (screen.unit == GERBV_MMS) {
2704 snprintf(screen.statusbar.coordstr, MAX_COORDLEN,
2705 "(%8.3f, %8.3f)",
2706 COORD2MMS(X), COORD2MMS(Y));
2707 } else {
2708 snprintf(screen.statusbar.coordstr, MAX_COORDLEN,
2709 "(%4.5f, %4.5f)",
2710 COORD2MILS(X) / 1000.0, COORD2MILS(Y) / 1000.0);
2711 }
2712 callbacks_update_statusbar();
2713 }
2714
2715 void
2716 callbacks_update_selected_object_message (gboolean userTriedToSelect) {
2717 if (screen.tool != POINTER)
2718 return;
2719
2720 gint selectionLength = screen.selectionInfo.selectedNodeArray->len;
2721 if ((selectionLength == 0)&&(userTriedToSelect)) {
2722 /* update status bar message to make sure the user knows
2723 about needing to select the layer */
2724 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
2725 "<b>No object selected. Objects can only be selected in the active layer.</b>");
2726 }
2727 else if (selectionLength == 0) {
2728 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
2729 "Click to select objects in the current layer. Middle click and drag to pan.");
2730 }
2731 else if (selectionLength == 1) {
2732 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
2733 "1 object is currently selected");
2734 }
2735 else {
2736 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
2737 "%d objects are currently selected",selectionLength);
2738 }
2739 callbacks_update_statusbar();
2740 }
2741
2742 /* --------------------------------------------------------- */
2743 gboolean
2744 callbacks_drawingarea_motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
2745 {
2746 int x, y;
2747 GdkModifierType state;
2748
2749 if (event->is_hint)
2750 gdk_window_get_pointer (event->window, &x, &y, &state);
2751 else {
2752 x = event->x;
2753 y = event->y;
2754 state = event->state;
2755 }
2756
2757 switch (screen.state) {
2758 case IN_MOVE: {
2759 if (screen.last_x != 0 || screen.last_y != 0) {
2760 /* Move pixmap to get a snappier feel of movement */
2761 screen.off_x += x - screen.last_x;
2762 screen.off_y += y - screen.last_y;
2763 }
2764 screenRenderInfo.lowerLeftX -= ((x - screen.last_x) / screenRenderInfo.scaleFactorX);
2765 screenRenderInfo.lowerLeftY += ((y - screen.last_y) / screenRenderInfo.scaleFactorY);
2766 callbacks_force_expose_event_for_screen ();
2767 callbacks_update_scrollbar_positions ();
2768 screen.last_x = x;
2769 screen.last_y = y;
2770 break;
2771 }
2772 case IN_ZOOM_OUTLINE: {
2773 if (screen.last_x || screen.last_y)
2774 render_draw_zoom_outline(screen.centered_outline_zoom);
2775 screen.last_x = x;
2776 screen.last_y = y;
2777 render_draw_zoom_outline(screen.centered_outline_zoom);
2778 break;
2779 }
2780 case IN_MEASURE: {
2781 /* clear the previous drawn line by drawing over it */
2782 render_toggle_measure_line();
2783 callbacks_screen2board(&(screen.measure_last_x), &(screen.measure_last_y),
2784 x, y);
2785 /* screen.last_[xy] are updated to move the ruler pointers */
2786 screen.last_x = x;
2787 screen.last_y = y;
2788 /* draw the new line and write the new distance */
2789 render_draw_measure_distance();
2790 break;
2791 }
2792 case IN_SELECTION_DRAG: {
2793 if (screen.last_x || screen.last_y)
2794 render_draw_selection_box_outline();
2795 screen.last_x = x;
2796 screen.last_y = y;
2797 render_draw_selection_box_outline();
2798 break;
2799 }
2800 default:
2801 screen.last_x = x;
2802 screen.last_y = y;
2803 break;
2804 }
2805 callbacks_update_statusbar_coordinates (x, y);
2806 callbacks_update_ruler_pointers ();
2807 return TRUE;
2808 } /* motion_notify_event */
2809
2810 /* --------------------------------------------------------- */
2811 gboolean
2812 callbacks_drawingarea_button_press_event (GtkWidget *widget, GdkEventButton *event)
2813 {
2814 GdkCursor *cursor;
2815
2816 switch (event->button) {
2817 case 1 :
2818 if (screen.tool == POINTER) {
2819 /* select */
2820 /* selection will only work with cairo, so do nothing if it's
2821 not compiled */
2822 screen.state = IN_SELECTION_DRAG;
2823 screen.start_x = event->x;
2824 screen.start_y = event->y;
2825 }
2826 else if (screen.tool == PAN) {
2827 /* Plain panning */
2828 screen.state = IN_MOVE;
2829 screen.last_x = event->x;
2830 screen.last_y = event->y;
2831 }
2832 else if (screen.tool == ZOOM) {
2833 screen.state = IN_ZOOM_OUTLINE;
2834 /* Zoom outline mode initiated */
2835 screen.start_x = event->x;
2836 screen.start_y = event->y;
2837 screen.centered_outline_zoom = event->state;
2838 }
2839 else if (screen.tool == MEASURE) {
2840 screen.state = IN_MEASURE;
2841 callbacks_screen2board(&(screen.measure_start_x), &(screen.measure_start_y),
2842 event->x, event->y);
2843 screen.measure_last_x = screen.measure_start_x;
2844 screen.measure_last_y = screen.measure_start_y;
2845 /* force an expose event to clear any previous measure lines */
2846 callbacks_force_expose_event_for_screen ();
2847 }
2848 break;
2849 case 2 :
2850 screen.state = IN_MOVE;
2851 screen.last_x = event->x;
2852 screen.last_y = event->y;
2853 cursor = gdk_cursor_new(GDK_FLEUR);
2854 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
2855 cursor);
2856 gdk_cursor_destroy(cursor);
2857 break;
2858 case 3 :
2859 if (screen.tool == POINTER) {
2860 /* if no items are selected, try and find the item the user
2861 is pointing at */
2862 if (screen.selectionInfo.type == GERBV_SELECTION_EMPTY) {
2863 gint index=callbacks_get_selected_row_index();
2864 if ((index >= 0) &&
2865 (index <= mainProject->last_loaded) &&
2866 (mainProject->file[index]->isVisible)) {
2867 render_fill_selection_buffer_from_mouse_click(event->x,event->y,index,TRUE);
2868 } else {
2869 render_clear_selection_buffer ();
2870 render_refresh_rendered_image_on_screen ();
2871 }
2872 }
2873 /* only show the popup if we actually have something selected now */
2874 if (screen.selectionInfo.type != GERBV_SELECTION_EMPTY)
2875 gtk_menu_popup(GTK_MENU(screen.win.drawWindowPopupMenu), NULL, NULL, NULL, NULL,
2876 event->button, event->time);
2877 } else {
2878 /* Zoom outline mode initiated */
2879 screen.state = IN_ZOOM_OUTLINE;
2880 screen.start_x = event->x;
2881 screen.start_y = event->y;
2882 screen.centered_outline_zoom = event->state & GDK_SHIFT_MASK;
2883 cursor = gdk_cursor_new(GDK_SIZING);
2884 gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window),
2885 cursor);
2886 gdk_cursor_destroy(cursor);
2887 }
2888 break;
2889 case 4 : /* Scroll wheel */
2890 render_zoom_display (ZOOM_IN_CMOUSE, 0, event->x, event->y);
2891 break;
2892 case 5 : /* Scroll wheel */
2893 render_zoom_display (ZOOM_OUT_CMOUSE, 0, event->x, event->y);
2894 break;
2895 default:
2896 break;
2897 }
2898 callbacks_switch_to_correct_cursor ();
2899 return TRUE;
2900 }
2901
2902 /* --------------------------------------------------------- */
2903 gboolean
2904 callbacks_drawingarea_button_release_event (GtkWidget *widget, GdkEventButton *event)
2905 {
2906 if (event->type == GDK_BUTTON_RELEASE) {
2907 if (screen.state == IN_MOVE) {
2908 screen.off_x = 0;
2909 screen.off_y = 0;
2910 render_refresh_rendered_image_on_screen();
2911 callbacks_switch_to_normal_tool_cursor (screen.tool);
2912 }
2913 else if (screen.state == IN_ZOOM_OUTLINE) {
2914 if ((event->state & GDK_SHIFT_MASK) != 0) {
2915 render_zoom_display (ZOOM_OUT_CMOUSE, 0, event->x, event->y);
2916 }
2917 /* if the user just clicks without dragging, then simply
2918 zoom in a preset amount */
2919 else if ((abs(screen.start_x - event->x) < 4) &&
2920 (abs(screen.start_y - event->y) < 4)) {
2921 render_zoom_display (ZOOM_IN_CMOUSE, 0, event->x, event->y);
2922 }
2923 else
2924 render_calculate_zoom_from_outline (widget, event);
2925 callbacks_switch_to_normal_tool_cursor (screen.tool);
2926 }
2927 else if (screen.state == IN_SELECTION_DRAG) {
2928 /* selection will only work with cairo, so do nothing if it's
2929 not compiled */
2930 gint index=callbacks_get_selected_row_index();
2931 /* determine if this was just a click or a box drag */
2932 if ((index >= 0) &&
2933 (mainProject->file[index]->isVisible)) {
2934 gboolean eraseOldSelection = TRUE;
2935
2936 if ((event->state & GDK_SHIFT_MASK) ||
2937 (event->state & GDK_CONTROL_MASK)) {
2938 eraseOldSelection = FALSE;
2939 }
2940 if ((fabs((double)(screen.last_x - screen.start_x)) < 5) &&
2941 (fabs((double)(screen.last_y - screen.start_y)) < 5))
2942 render_fill_selection_buffer_from_mouse_click(event->x,event->y,index,eraseOldSelection);
2943 else
2944 render_fill_selection_buffer_from_mouse_drag(event->x,event->y,
2945 screen.start_x,screen.start_y,index,eraseOldSelection);
2946 /* check if anything was selected */
2947 callbacks_update_selected_object_message (TRUE);
2948 } else {
2949 render_clear_selection_buffer ();
2950 render_refresh_rendered_image_on_screen ();
2951 }
2952 }
2953 screen.last_x = screen.last_y = 0;
2954 screen.state = NORMAL;
2955 }
2956 return TRUE;
2957 } /* button_release_event */
2958
2959 /* --------------------------------------------------------- */
2960 gboolean
2961 callbacks_window_key_press_event (GtkWidget *widget, GdkEventKey *event)
2962 {
2963 switch(event->keyval) {
2964 case GDK_Escape:
2965 if (screen.tool == POINTER) {
2966 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
2967 "No objects are currently selected");
2968 callbacks_update_statusbar();
2969 render_clear_selection_buffer ();
2970 }
2971 break;
2972 default:
2973 break;
2974 }
2975
2976 /* Escape may be used to abort outline zoom and just plain repaint */
2977 if (event->keyval == GDK_Escape) {
2978 screen.state = NORMAL;
2979 render_refresh_rendered_image_on_screen();
2980 }
2981
2982 return TRUE;
2983 } /* key_press_event */
2984
2985 /* --------------------------------------------------------- */
2986 gboolean
2987 callbacks_window_key_release_event (GtkWidget *widget, GdkEventKey *event)
2988 {
2989 return TRUE;
2990 } /* key_release_event */
2991
2992 /* --------------------------------------------------------- */
2993 /* Scroll wheel */
2994 gboolean
2995 callbacks_window_scroll_event(GtkWidget *widget, GdkEventScroll *event)
2996 {
2997 switch (event->direction) {
2998 case GDK_SCROLL_UP:
2999 render_zoom_display (ZOOM_IN_CMOUSE, 0, event->x, event->y);
3000 break;
3001 case GDK_SCROLL_DOWN:
3002 render_zoom_display (ZOOM_OUT_CMOUSE, 0, event->x, event->y);
3003 break;
3004 case GDK_SCROLL_LEFT:
3005 /* Ignore */
3006 case GDK_SCROLL_RIGHT:
3007 /* Ignore */
3008 default:
3009 return TRUE;
3010 }
3011 return TRUE;
3012 } /* scroll_event */
3013
3014
3015 /* ------------------------------------------------------------------ */
3016 /** Displays additional information in the statusbar.
3017 The Statusbar is divided into three sections:\n
3018 statusbar.coordstr for coords\n
3019 statusbar.diststr for displaying measured distances or the designator
3020 (right click on a graphically marked and also actively selected part)\n
3021 statusbar.msg for e.g. showing progress of actions*/
3022 void
3023 callbacks_update_statusbar(void)
3024 {
3025 if ((screen.statusbar.coordstr != NULL)&&(GTK_IS_LABEL(screen.win.statusMessageLeft))) {
3026 gtk_label_set_text(GTK_LABEL(screen.win.statusMessageLeft), screen.statusbar.coordstr);
3027 }
3028 if ((screen.statusbar.diststr != NULL)&&(GTK_IS_LABEL(screen.win.statusMessageRight))) {
3029 gtk_label_set_markup(GTK_LABEL(screen.win.statusMessageRight), screen.statusbar.diststr);
3030 }
3031 }
3032
3033 /* --------------------------------------------------------- */
3034 void
3035 callbacks_update_statusbar_measured_distance (gdouble dx, gdouble dy){
3036 gdouble delta = sqrt(dx*dx + dy*dy);
3037
3038 if (screen.unit == GERBV_MILS) {
3039 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
3040 "Measured distance: %8.2f mils (%8.2f x, %8.2f y)",
3041 COORD2MILS(delta), COORD2MILS(dx), COORD2MILS(dy));
3042 }
3043 else if (screen.unit == GERBV_MMS) {
3044 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
3045 "Measured distance: %8.3f mms (%8.3f x, %8.3f y)",
3046 COORD2MMS(delta), COORD2MMS(dx), COORD2MMS(dy));
3047 }
3048 else {
3049 snprintf(screen.statusbar.diststr, MAX_DISTLEN,
3050 "Measured distance: %4.5f inches (%4.5f x, %4.5f y)",
3051 COORD2MILS(delta) / 1000.0, COORD2MILS(dx) / 1000.0,
3052 COORD2MILS(dy) / 1000.0);
3053 }
3054 callbacks_update_statusbar();
3055 }
3056
3057 /* --------------------------------------------------------- */
3058 void
3059 callbacks_sidepane_render_type_combo_box_changed (GtkComboBox *widget, gpointer user_data) {
3060 int activeRow = gtk_combo_box_get_active (widget);
3061
3062 dprintf ("%s(): activeRow = %d\n", __FUNCTION__, activeRow);
3063 screenRenderInfo.renderType = activeRow;
3064
3065 render_refresh_rendered_image_on_screen();
3066 }
3067
3068 /* --------------------------------------------------------- */
3069 void
3070 callbacks_statusbar_unit_combo_box_changed (GtkComboBox *widget, gpointer user_data) {
3071 int activeRow = gtk_combo_box_get_active (widget);
3072
3073 if (activeRow >= 0) {
3074 screen.unit = activeRow;
3075 }
3076 callbacks_update_ruler_scales();
3077 callbacks_update_statusbar_coordinates (screen.last_x, screen.last_y);
3078
3079 if (screen.tool == MEASURE)
3080 callbacks_update_statusbar_measured_distance (screen.win.lastMeasuredX,
3081 screen.win.lastMeasuredY);
3082 }
3083
3084 /* --------------------------------------------------------- */
3085 void
3086 callbacks_clear_messages_button_clicked (GtkButton *button, gpointer user_data) {
3087 GtkTextBuffer *textbuffer;
3088 GtkTextIter start, end;
3089
3090 textbuffer = gtk_text_view_get_buffer((GtkTextView*)screen.win.messageTextView);
3091 gtk_text_buffer_get_start_iter(textbuffer, &start);
3092 gtk_text_buffer_get_end_iter(textbuffer, &end);
3093 gtk_text_buffer_delete (textbuffer, &start, &end);
3094 }
3095
3096 /* --------------------------------------------------------- */
3097 void
3098 callbacks_handle_log_messages(const gchar *log_domain, GLogLevelFlags log_level,
3099 const gchar *message, gpointer user_data) {
3100 GtkTextBuffer *textbuffer = NULL;
3101 GtkTextIter iter;
3102 GtkTextTag *tag;
3103 GtkTextMark *StartMark = NULL, *StopMark = NULL;
3104 GtkTextIter StartIter, StopIter;
3105
3106 if (!screen.win.messageTextView)
3107 return;
3108
3109 textbuffer = gtk_text_view_get_buffer((GtkTextView*)screen.win.messageTextView);
3110
3111 /* create a mark for the end of the text. */
3112 gtk_text_buffer_get_end_iter(textbuffer, &iter);
3113
3114 /* get the current end position of the text (it will be the
3115 start of the new text. */
3116 StartMark = gtk_text_buffer_create_mark(textbuffer,
3117 "NewTextStart", &iter, TRUE);
3118
3119 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3120 "blue_foreground");
3121 /* the tag does not exist: create it and let them exist in the tag table.*/
3122 if (tag == NULL) {
3123 tag = gtk_text_buffer_create_tag(textbuffer, "black_foreground",
3124 "foreground", "black", NULL);
3125 tag = gtk_text_buffer_create_tag(textbuffer, "blue_foreground",
3126 "foreground", "blue", NULL);
3127 tag = gtk_text_buffer_create_tag(textbuffer, "red_foreground",
3128 "foreground", "red", NULL);
3129 tag = gtk_text_buffer_create_tag(textbuffer, "darkred_foreground",
3130 "foreground", "darkred", NULL);
3131 tag = gtk_text_buffer_create_tag(textbuffer, "darkblue_foreground",
3132 "foreground", "darkblue", NULL);
3133 tag = gtk_text_buffer_create_tag (textbuffer, "darkgreen_foreground",
3134 "foreground", "darkgreen", NULL);
3135 tag = gtk_text_buffer_create_tag (textbuffer,
3136 "saddlebrown_foreground",
3137 "foreground", "saddlebrown", NULL);
3138 }
3139
3140 /*
3141 * See rgb.txt for the color names definition
3142 * (on my PC it is on /usr/X11R6/lib/X11/rgb.txt)
3143 */
3144 switch (log_level & G_LOG_LEVEL_MASK) {
3145 case G_LOG_LEVEL_ERROR:
3146 /* a message of this kind aborts the application calling abort() */
3147 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3148 "red_foreground");
3149 gtk_notebook_set_current_page(GTK_NOTEBOOK(screen.win.sidepane_notebook), 1);
3150 gtk_widget_show(screen.win.sidepane_notebook);
3151 break;
3152 case G_LOG_LEVEL_CRITICAL:
3153 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3154 "red_foreground");
3155 gtk_notebook_set_current_page(GTK_NOTEBOOK(screen.win.sidepane_notebook), 1);
3156 gtk_widget_show(screen.win.sidepane_notebook);
3157 break;
3158 case G_LOG_LEVEL_WARNING:
3159 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3160 "darkred_foreground");
3161 gtk_notebook_set_current_page(GTK_NOTEBOOK(screen.win.sidepane_notebook), 1);
3162 gtk_widget_show(screen.win.sidepane_notebook);
3163 break;
3164 case G_LOG_LEVEL_MESSAGE:
3165 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3166 "darkblue_foreground");
3167 gtk_notebook_set_current_page(GTK_NOTEBOOK(screen.win.sidepane_notebook), 1);
3168 gtk_widget_show(screen.win.sidepane_notebook);
3169 break;
3170 case G_LOG_LEVEL_INFO:
3171 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3172 "darkgreen_foreground");
3173 break;
3174 case G_LOG_LEVEL_DEBUG:
3175 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textbuffer),
3176 "saddlebrown_foreground");
3177 break;
3178 default:
3179 tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table(textbuffer),
3180 "black_foreground");
3181 break;
3182 }
3183
3184 /*
3185 * Fatal aborts application. We will try to get the message out anyhow.
3186 */
3187 if (log_level & G_LOG_FLAG_FATAL)
3188 fprintf(stderr, "Fatal error : %s\n", message);
3189
3190 gtk_text_buffer_insert(textbuffer, &iter, message, -1);
3191
3192 gtk_text_buffer_get_end_iter(textbuffer, &iter);
3193
3194 StopMark = gtk_text_buffer_create_mark(textbuffer,
3195 "NewTextStop", &iter, TRUE);
3196
3197 gtk_text_buffer_get_iter_at_mark(textbuffer, &StartIter, StartMark);
3198 gtk_text_buffer_get_iter_at_mark(textbuffer, &StopIter, StopMark);
3199
3200 gtk_text_buffer_apply_tag(textbuffer, tag, &StartIter, &StopIter);
3201 }
3202
3203 /* --------------------------------------------------------- */
3204 void callbacks_force_expose_event_for_screen (void){
3205
3206 GdkRectangle update_rect;
3207
3208 update_rect.x = 0;
3209 update_rect.y = 0;
3210 update_rect.width = screenRenderInfo.displayWidth;
3211 update_rect.height = screenRenderInfo.displayHeight;
3212
3213 /* Calls expose_event */
3214 gdk_window_invalidate_rect (screen.drawing_area->window, &update_rect, FALSE);
3215
3216 /* update other gui things that could have changed */
3217 callbacks_update_ruler_scales();
3218 callbacks_update_scrollbar_limits();
3219 callbacks_update_scrollbar_positions();
3220 }
3221
Stefan Petersen unofficial branch