render.c

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 *
 * render.c -- this file is a part of gerbv.
 *
 *   Copyright (C) 2007 Stuart Brorson (SDB@cloud9.net)
 *
 * $Id$
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
#include "gerbv.h"
 
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif
 
#ifdef HAVE_STRING_H
# include <string.h>
#endif
 
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
 
#ifdef HAVE_LIBGEN_H
# include <libgen.h> /* dirname */
#endif
 
#include <math.h>
 
#include "common.h"
#include "main.h"
#include "callbacks.h"
#include "interface.h"
#include "render.h"
#include "selection.h"
 
#ifdef WIN32
# include <cairo-win32.h>
#elif defined(QUARTZ)
# include <cairo-quartz.h>
#else
# include <cairo-xlib.h>
#endif
#include "draw.h"
 
#undef DPRINTF
#define DPRINTF(...) do { if (DEBUG) printf(__VA_ARGS__); } while (0)
 
gerbv_render_info_t screenRenderInfo;
 
/* ------------------------------------------------------ */
void
render_zoom_display (gint zoomType, gdouble scaleFactor, gdouble mouseX, gdouble mouseY)
{
       gdouble mouseCoordinateX = 0.0;
       gdouble mouseCoordinateY = 0.0;
       double oldWidth, oldHeight;
 
       oldWidth = screenRenderInfo.displayWidth / screenRenderInfo.scaleFactorX;
       oldHeight = screenRenderInfo.displayHeight / screenRenderInfo.scaleFactorY;
 
       if (zoomType == ZOOM_IN_CMOUSE || zoomType == ZOOM_OUT_CMOUSE) {
              /* calculate what user coordinate the mouse is pointing at */
              mouseCoordinateX = mouseX / screenRenderInfo.scaleFactorX + screenRenderInfo.lowerLeftX;
              mouseCoordinateY = (screenRenderInfo.displayHeight - mouseY) /
                     screenRenderInfo.scaleFactorY + screenRenderInfo.lowerLeftY;
       }
 
       switch(zoomType) {
              case ZOOM_IN : /* Zoom In */
              case ZOOM_IN_CMOUSE : /* Zoom In Around Mouse Pointer */
                     screenRenderInfo.scaleFactorX = MIN((gdouble)GERBV_SCALE_MAX,
                                   (1 + 1/3.0)*screenRenderInfo.scaleFactorX);
                     screenRenderInfo.scaleFactorY = screenRenderInfo.scaleFactorX;
                     screenRenderInfo.lowerLeftX += (oldWidth - (screenRenderInfo.displayWidth /
                                          screenRenderInfo.scaleFactorX)) / 2.0;
                     screenRenderInfo.lowerLeftY += (oldHeight - (screenRenderInfo.displayHeight /
                                          screenRenderInfo.scaleFactorY)) / 2.0;
                     break;
              case ZOOM_OUT :  /* Zoom Out */
              case ZOOM_OUT_CMOUSE : /* Zoom Out Around Mouse Pointer */
                     screenRenderInfo.scaleFactorX = MAX((gdouble)GERBV_SCALE_MIN,
                                   (1 - 1/3.0)*screenRenderInfo.scaleFactorX);
                     screenRenderInfo.scaleFactorY = screenRenderInfo.scaleFactorX;
                     screenRenderInfo.lowerLeftX += (oldWidth - (screenRenderInfo.displayWidth /
                                          screenRenderInfo.scaleFactorX)) / 2.0;
                     screenRenderInfo.lowerLeftY += (oldHeight - (screenRenderInfo.displayHeight /
                                          screenRenderInfo.scaleFactorY)) / 2.0;
                     break;
              case ZOOM_FIT : /* Zoom Fit */
                     gerbv_render_zoom_to_fit_display (mainProject, &screenRenderInfo);
                     break;
              case ZOOM_SET : /*explicit scale set by user */
                     screenRenderInfo.scaleFactorX =
                            MIN((gdouble)GERBV_SCALE_MAX, scaleFactor);
                     screenRenderInfo.scaleFactorY = screenRenderInfo.scaleFactorX;
                     screenRenderInfo.lowerLeftX += (oldWidth - (screenRenderInfo.displayWidth /
                                          screenRenderInfo.scaleFactorX)) / 2.0;
                     screenRenderInfo.lowerLeftY += (oldHeight - (screenRenderInfo.displayHeight /
                                          screenRenderInfo.scaleFactorY)) / 2.0;
                     break;
              default :
                     GERB_MESSAGE(_("Illegal zoom direction %d"), zoomType);
       }
 
       if (zoomType == ZOOM_IN_CMOUSE || zoomType == ZOOM_OUT_CMOUSE) {
              /* make sure the mouse is still pointing at the point calculated earlier */
              screenRenderInfo.lowerLeftX = mouseCoordinateX - mouseX / screenRenderInfo.scaleFactorX;
              screenRenderInfo.lowerLeftY = mouseCoordinateY - (screenRenderInfo.displayHeight - mouseY) /
                     screenRenderInfo.scaleFactorY;
       }
       render_refresh_rendered_image_on_screen();
       return;
}
 
 
/* --------------------------------------------------------- */
void
render_calculate_zoom_from_outline(GtkWidget *widget, GdkEventButton *event)
{
       int x1, y1, x2, y2, dx, dy; /* Zoom outline (UR and LL corners) */
       double centerPointX, centerPointY;
       int half_x, half_y;         /* cache for half window dimensions */
 
       x1 = MIN((gdouble)screen.start_x, event->x);
       y1 = MIN((gdouble)screen.start_y, event->y);
       x2 = MAX((gdouble)screen.start_x, event->x);
       y2 = MAX((gdouble)screen.start_y, event->y);
       dx = x2-x1;
       dy = y2-y1;
 
       if ((dx >= 4) && (dy >= 4)) {
              if (screen.centered_outline_zoom) {
                     /* Centered outline mode */
                     x1 = screen.start_x - dx;
                     y1 = screen.start_y - dy;
                     dx *= 2;
                     dy *= 2;
              }
              half_x = (x1+x2)/2;
              half_y = (y1+y2)/2;
              centerPointX = half_x/screenRenderInfo.scaleFactorX + screenRenderInfo.lowerLeftX;
              centerPointY = (screenRenderInfo.displayHeight - half_y)/screenRenderInfo.scaleFactorY +
                            screenRenderInfo.lowerLeftY;
 
              screenRenderInfo.scaleFactorX *=
                     MIN((double)screenRenderInfo.displayWidth / dx,
                            (double)screenRenderInfo.displayHeight / dy);
              screenRenderInfo.scaleFactorX = MIN((gdouble)GERBV_SCALE_MAX,
                            screenRenderInfo.scaleFactorX);
              screenRenderInfo.scaleFactorY = screenRenderInfo.scaleFactorX;
              screenRenderInfo.lowerLeftX = centerPointX - (screenRenderInfo.displayWidth /
                                   2.0 / screenRenderInfo.scaleFactorX);
              screenRenderInfo.lowerLeftY = centerPointY - (screenRenderInfo.displayHeight /
                                   2.0 / screenRenderInfo.scaleFactorY);
       }
       render_refresh_rendered_image_on_screen();
}
 
/* ------------------------------------------------------ */
void
render_draw_selection_box_outline(void) {
       GdkGC *gc;
       GdkGCValues values;
       GdkGCValuesMask values_mask;
       gint x1, y1, x2, y2, dx, dy;
 
       memset(&values, 0, sizeof(values));
       values.function = GDK_XOR;
       if (!screen.zoom_outline_color.pixel)
              gdk_colormap_alloc_color(gdk_colormap_get_system(), &screen.zoom_outline_color, FALSE, TRUE);
       values.foreground = screen.zoom_outline_color;
       values_mask = GDK_GC_FUNCTION | GDK_GC_FOREGROUND;
       gc = gdk_gc_new_with_values(screen.drawing_area->window, &values, values_mask);
       
       x1 = MIN(screen.start_x, screen.last_x);
       y1 = MIN(screen.start_y, screen.last_y);
       x2 = MAX(screen.start_x, screen.last_x);
       y2 = MAX(screen.start_y, screen.last_y);
       dx = x2-x1;
       dy = y2-y1;
 
       gdk_draw_rectangle(screen.drawing_area->window, gc, FALSE, x1, y1, dx, dy);
       gdk_gc_unref(gc);
}
 
/* --------------------------------------------------------- */
void
render_draw_zoom_outline(gboolean centered)
{
       GdkGC *gc;
       GdkGCValues values;
       GdkGCValuesMask values_mask;
       gint x1, y1, x2, y2, dx, dy;
 
       memset(&values, 0, sizeof(values));
       values.function = GDK_XOR;
       if (!screen.zoom_outline_color.pixel)
              gdk_colormap_alloc_color(gdk_colormap_get_system(), &screen.zoom_outline_color, FALSE, TRUE);
       values.foreground = screen.zoom_outline_color;
       values_mask = GDK_GC_FUNCTION | GDK_GC_FOREGROUND;
       gc = gdk_gc_new_with_values(screen.drawing_area->window, &values, values_mask);
       
       x1 = MIN(screen.start_x, screen.last_x);
       y1 = MIN(screen.start_y, screen.last_y);
       x2 = MAX(screen.start_x, screen.last_x);
       y2 = MAX(screen.start_y, screen.last_y);
       dx = x2-x1;
       dy = y2-y1;
 
       if (centered) {
              /* Centered outline mode */
              x1 = screen.start_x - dx;
              y1 = screen.start_y - dy;
              dx *= 2;
              dy *= 2;
              x2 = x1+dx;
              y2 = y1+dy;
       }
 
       gdk_draw_rectangle(screen.drawing_area->window, gc, FALSE, x1, y1, dx, dy);
       gdk_gc_unref(gc);
 
       /* Draw actual zoom area in dashed lines */
       memset(&values, 0, sizeof(values));
       values.function = GDK_XOR;
       values.foreground = screen.zoom_outline_color;
       values.line_style = GDK_LINE_ON_OFF_DASH;
       values_mask = GDK_GC_FUNCTION | GDK_GC_FOREGROUND | GDK_GC_LINE_STYLE;
       gc = gdk_gc_new_with_values(screen.drawing_area->window, &values,
                            values_mask);
       
       if ((dy == 0) || ((double)dx/dy > (double)screen.drawing_area->allocation.width/
                            screen.drawing_area->allocation.height)) {
              dy = dx * (double)screen.drawing_area->allocation.height/
                     screen.drawing_area->allocation.width;
       } 
       else {
              dx = dy * (double)screen.drawing_area->allocation.width/
                     screen.drawing_area->allocation.height;
       }
 
       gdk_draw_rectangle(screen.drawing_area->window, gc, FALSE, (x1+x2-dx)/2,
              (y1+y2-dy)/2, dx, dy);
 
       gdk_gc_unref(gc);
}
 
/* ------------------------------------------------------ */
/* Transforms board coordinates to screen ones */
static void
render_board2screen(gdouble *X, gdouble *Y, gdouble x, gdouble y) {
       *X = (x - screenRenderInfo.lowerLeftX) * screenRenderInfo.scaleFactorX;
       *Y = screenRenderInfo.displayHeight - (y - screenRenderInfo.lowerLeftY)
              * screenRenderInfo.scaleFactorY;
}
 
/* Trims the coordinates to avoid overflows in gdk_draw_line */
static void
render_trim_point(gdouble *start_x, gdouble *start_y, gdouble last_x, gdouble last_y)
{
       const gdouble max_coord = (1<<15) - 2;/* a value that causes no overflow
                                                                              and lies out of screen */
       gdouble dx, dy;
 
    if (fabs (*start_x) < max_coord && fabs (*start_y) < max_coord)
              return;       
 
       dx = last_x - *start_x;
       dy = last_y - *start_y;
 
       if (*start_x < -max_coord) {
              *start_x = -max_coord;
              if (last_x > -max_coord && fabs (dx) > 0.1)
                     *start_y = last_y - (last_x + max_coord) / dx * dy;
       }
       if (*start_x > max_coord) {
              *start_x = max_coord;
              if (last_x < max_coord && fabs (dx) > 0.1)
                     *start_y = last_y - (last_x - max_coord) / dx * dy;
       }
 
       dx = last_x - *start_x;
       dy = last_y - *start_y;
 
       if (*start_y < -max_coord) {
              *start_y = -max_coord;
              if (last_y > -max_coord && fabs (dy) > 0.1)
                     *start_x = last_x - (last_y + max_coord) / dy * dx;
       }
       if (*start_y > max_coord) {
              *start_y = max_coord;
              if (last_y < max_coord && fabs (dy) > 0.1)
                     *start_x = last_x - (last_y - max_coord) / dy * dx;
       }
}
 
/* ------------------------------------------------------ */
void
render_toggle_measure_line(void)
{
 
       GdkGC *gc;
       GdkGCValues values;
       GdkGCValuesMask values_mask;
       gdouble start_x, start_y, last_x, last_y;
       memset(&values, 0, sizeof(values));
       values.function = GDK_XOR;
       values.line_width = 6;
       if (!screen.zoom_outline_color.pixel)
              gdk_colormap_alloc_color(gdk_colormap_get_system(), &screen.zoom_outline_color, FALSE, TRUE);
       values.foreground = screen.zoom_outline_color;
       values_mask = GDK_GC_FUNCTION | GDK_GC_LINE_WIDTH | GDK_GC_FOREGROUND;
       gc = gdk_gc_new_with_values(screen.drawing_area->window, &values,
                            values_mask);
       render_board2screen(&start_x, &start_y,
                            screen.measure_start_x, screen.measure_start_y);
       render_board2screen(&last_x, &last_y,
                            screen.measure_stop_x, screen.measure_stop_y);
       render_trim_point(&start_x, &start_y, last_x, last_y);
       render_trim_point(&last_x, &last_y, start_x, start_y);
       gdk_draw_line(screen.drawing_area->window, gc, start_x,
                start_y, last_x, last_y);
       gdk_gc_unref(gc);
} /* toggle_measure_line */
 
/* ------------------------------------------------------ */
void
render_draw_measure_distance(void)
{
       gdouble dx, dy;
 
       dx = fabs (screen.measure_start_x - screen.measure_stop_x);
       dy = fabs (screen.measure_start_y - screen.measure_stop_y);
 
       screen.measure_last_x = dx;
       screen.measure_last_y = dy;
       callbacks_update_statusbar_measured_distance (dx, dy);
       render_toggle_measure_line();
}
 
/* ------------------------------------------------------ */
static void render_selection (void)
{
       gerbv_selection_item_t sel_item;
       gerbv_fileinfo_t *file;
       gdouble pixel_width;
       cairo_t *cr;
       int i;
       guint j;
 
       if (selection_length (&screen.selectionInfo) == 0)
              return;
 
       if (screen.selectionRenderData)
              cairo_surface_destroy (
                            (cairo_surface_t *)screen.selectionRenderData);
 
       screen.selectionRenderData =
              (gpointer) cairo_surface_create_similar (
                     (cairo_surface_t *)screen.windowSurface,
                     CAIRO_CONTENT_COLOR_ALPHA,
                     screenRenderInfo.displayWidth,
                     screenRenderInfo.displayHeight);
 
       pixel_width = 1.0/MAX(screenRenderInfo.scaleFactorX,
                            screenRenderInfo.scaleFactorY);
 
       for (i = mainProject->last_loaded; i >= 0; i--) {
              file = mainProject->file[i]; 
 
              if (!file ||
              (!mainProject->show_invisible_selection && !file->isVisible))
                     continue;
 
              for (j = 0; j < selection_length (&screen.selectionInfo); j++) {
                     sel_item = selection_get_item_by_index (
                                   &screen.selectionInfo, j);
                     if (file->image != sel_item.image)
                            continue;
 
                     /* Have selected image(s) on this file, draw it */
 
                     cr = cairo_create(screen.selectionRenderData);
                     gerbv_render_cairo_set_scale_and_translation(cr,
                                   &screenRenderInfo);
                     cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.85);
                     draw_image_to_cairo_target (cr,
                            file->image, pixel_width,
                            DRAW_SELECTIONS, &screen.selectionInfo,
                            &screenRenderInfo, TRUE,
                            file->transform, TRUE);
                     cairo_destroy (cr);
 
                     break; /* All done, go to next file */
              }
       }
}
 
/* ------------------------------------------------------ */
void render_refresh_rendered_image_on_screen (void) {
       GdkCursor *cursor;
       
       DPRINTF("----> Entering redraw_pixmap...\n");
       cursor = gdk_cursor_new(GDK_WATCH);
       gdk_window_set_cursor(GDK_WINDOW(screen.drawing_area->window), cursor);
       gdk_cursor_destroy(cursor);
 
       if (screenRenderInfo.renderType <= GERBV_RENDER_TYPE_GDK_XOR){
           if (screen.pixmap) 
              gdk_pixmap_unref(screen.pixmap);
           screen.pixmap = gdk_pixmap_new(screen.drawing_area->window, screenRenderInfo.displayWidth,
           screenRenderInfo.displayHeight, -1);
           gerbv_render_to_pixmap_using_gdk (mainProject, screen.pixmap, &screenRenderInfo, &screen.selectionInfo,
                     &screen.selection_color);   
           DPRINTF("<---- leaving redraw_pixmap.\n");
       }
       else{
           int i;
           DPRINTF("    .... Now try rendering the drawing using cairo .... \n");
           /* 
            * This now allows drawing several layers on top of each other.
            * Higher layer numbers have higher priority in the Z-order.
            */
           for(i = mainProject->last_loaded; i >= 0; i--) {
              if (mainProject->file[i]) {
                  cairo_t *cr;
                  if (mainProject->file[i]->privateRenderData) 
                     cairo_surface_destroy ((cairo_surface_t *) mainProject->file[i]->privateRenderData);
                  mainProject->file[i]->privateRenderData = 
                     (gpointer) cairo_surface_create_similar ((cairo_surface_t *)screen.windowSurface,
                     CAIRO_CONTENT_COLOR_ALPHA, screenRenderInfo.displayWidth,
                     screenRenderInfo.displayHeight);
                  cr= cairo_create(mainProject->file[i]->privateRenderData );
                  gerbv_render_layer_to_cairo_target (cr, mainProject->file[i], &screenRenderInfo);
                  DPRINTF("    .... calling render_image_to_cairo_target on layer %d...\n", i);                 
                  cairo_destroy (cr);
              }
           }
           
           render_recreate_composite_surface ();
       }
       /* remove watch cursor and switch back to normal cursor */
       callbacks_switch_to_correct_cursor ();
       callbacks_force_expose_event_for_screen();
}
 
/* ------------------------------------------------------ */
void
render_remove_selected_objects_belonging_to_layer (
                     gerbv_selection_info_t *sel_info, gerbv_image_t *image)
{
       guint i;
 
       for (i = 0; i < selection_length (sel_info);) {
              gerbv_selection_item_t sItem =
                     selection_get_item_by_index (sel_info, i);
 
              if (image == (gerbv_image_t *) sItem.image)
                     selection_clear_item_by_index (sel_info, i);
              else
                     i++;
       }
}
 
/* ------------------------------------------------------ */
gint
render_create_cairo_buffer_surface () {
       if (screen.bufferSurface) {
              cairo_surface_destroy (screen.bufferSurface);
              screen.bufferSurface = NULL;
       }
       if (!screen.windowSurface)
              return 0;
 
       screen.bufferSurface= cairo_surface_create_similar ((cairo_surface_t *)screen.windowSurface,
                                           CAIRO_CONTENT_COLOR, screenRenderInfo.displayWidth,
                                           screenRenderInfo.displayHeight);
       return 1;
}
 
/* ------------------------------------------------------ */
static void
render_find_selected_objects_and_refresh_display (gint activeFileIndex,
              enum selection_action action)
{
       enum draw_mode mode = FIND_SELECTIONS;
 
       /* clear the old selection array if desired */
       if ((action == SELECTION_REPLACE)
        && (selection_length (&screen.selectionInfo) != 0))
              selection_clear (&screen.selectionInfo);
 
       if (action == SELECTION_TOGGLE)
              mode = FIND_SELECTIONS_TOGGLE;
 
       /* make sure we have a bufferSurface...if we start up in FAST mode, we may not
          have one yet, but we need it for selections */
       if (!render_create_cairo_buffer_surface ())
              return;
 
       /* call draw_image... passing the FILL_SELECTION mode to just search for
          nets which match the selection, and fill the selection buffer with them */
       cairo_t *cr = cairo_create (screen.bufferSurface);      
       gerbv_render_cairo_set_scale_and_translation (cr, &screenRenderInfo);
       draw_image_to_cairo_target (cr,
                     mainProject->file[activeFileIndex]->image,
                     1.0/MAX (screenRenderInfo.scaleFactorX,
                            screenRenderInfo.scaleFactorY),
                     mode, &screen.selectionInfo, &screenRenderInfo, TRUE,
                     mainProject->file[activeFileIndex]->transform, TRUE);
       cairo_destroy (cr);
 
       /* re-render the selection buffer layer */
       if (screenRenderInfo.renderType <= GERBV_RENDER_TYPE_GDK_XOR) {
              render_refresh_rendered_image_on_screen ();
       } else {
              render_recreate_composite_surface ();
              callbacks_force_expose_event_for_screen ();
       }
}
 
/* ------------------------------------------------------ */
void
render_fill_selection_buffer_from_mouse_click (gint mouseX, gint mouseY,
              gint activeFileIndex, enum selection_action action)
{
       screen.selectionInfo.lowerLeftX = mouseX;
       screen.selectionInfo.lowerLeftY = mouseY;
       /* no need to populate the upperright coordinates for a point_click */
       screen.selectionInfo.type = GERBV_SELECTION_POINT_CLICK;
       render_find_selected_objects_and_refresh_display (
                     activeFileIndex, action);
}
 
/* ------------------------------------------------------ */
void
render_fill_selection_buffer_from_mouse_drag (gint corner1X, gint corner1Y,
              gint corner2X, gint corner2Y,
              gint activeFileIndex, enum selection_action action)
{
       /* figure out the lower left corner of the box */
       screen.selectionInfo.lowerLeftX = MIN(corner1X, corner2X);
       screen.selectionInfo.lowerLeftY = MIN(corner1Y, corner2Y);
       /* figure out the upper right corner of the box */
       screen.selectionInfo.upperRightX = MAX(corner1X, corner2X);
       screen.selectionInfo.upperRightY = MAX(corner1Y, corner2Y);
       
       screen.selectionInfo.type = GERBV_SELECTION_DRAG_BOX;
       render_find_selected_objects_and_refresh_display (
                     activeFileIndex, action);
}
 
/* ------------------------------------------------------ */
void render_recreate_composite_surface ()
{
       gint i;
       
       if (!render_create_cairo_buffer_surface())
              return;
 
       cairo_t *cr= cairo_create(screen.bufferSurface);
       /* fill the background with the appropriate color */
       cairo_set_source_rgba (cr, (double) mainProject->background.red/G_MAXUINT16,
              (double) mainProject->background.green/G_MAXUINT16,
              (double) mainProject->background.blue/G_MAXUINT16, 1);
       cairo_paint (cr);
       
       for(i = mainProject->last_loaded; i >= 0; i--) {
              if (mainProject->file[i] && mainProject->file[i]->isVisible) {
                     cairo_set_source_surface (cr, (cairo_surface_t *) mainProject->file[i]->privateRenderData,
                                                   0, 0);
                     /* ignore alpha if we are in high-speed render mode */
                     if (((double) mainProject->file[i]->alpha < 65535)&&(screenRenderInfo.renderType != GERBV_RENDER_TYPE_GDK_XOR)) {
                            cairo_paint_with_alpha(cr,(double) mainProject->file[i]->alpha/G_MAXUINT16);
                     }
                     else {
                            cairo_paint (cr);
                     }
              }
       }
 
       /* render the selection layer at the end */
       if (selection_length (&screen.selectionInfo) != 0) {
              render_selection ();
              cairo_set_source_surface (cr, (cairo_surface_t *) screen.selectionRenderData,
                                                   0, 0);
              cairo_paint_with_alpha (cr,1.0);
       }
       cairo_destroy (cr);
}
 
/* ------------------------------------------------------ */
void render_project_to_cairo_target (cairo_t *cr) {
       /* fill the background with the appropriate color */
       cairo_set_source_rgba (cr, (double) mainProject->background.red/G_MAXUINT16,
              (double) mainProject->background.green/G_MAXUINT16,
              (double) mainProject->background.blue/G_MAXUINT16, 1);
       cairo_paint (cr);
 
       cairo_set_source_surface (cr, (cairo_surface_t *) screen.bufferSurface, 0 , 0);
                                                   
       cairo_paint (cr);
}
 
void
render_free_screen_resources (void) {
       if (screen.selectionRenderData) 
              cairo_surface_destroy ((cairo_surface_t *)
                     screen.selectionRenderData);
       if (screen.bufferSurface)
              cairo_surface_destroy ((cairo_surface_t *)
                     screen.bufferSurface);
       if (screen.windowSurface)
              cairo_surface_destroy ((cairo_surface_t *)
                     screen.windowSurface);
       if (screen.pixmap) 
              gdk_pixmap_unref(screen.pixmap);
}
 
 
/* ------------------------------------------------------------------ */
gerbv_stats_t *
generate_gerber_analysis(void)
{
       int i;
       gerbv_stats_t *stats;
       gerbv_stats_t *instats;
 
       /* Create new stats structure to hold report for whole project 
       * (i.e. all layers together) */
       stats = gerbv_stats_new();
 
       /* Loop through open layers and compile statistics by accumulating reports from each layer */
       for (i = 0; i <= mainProject->last_loaded; i++) {
              if (mainProject->file[i] && mainProject->file[i]->isVisible &&
                            (mainProject->file[i]->image->layertype == GERBV_LAYERTYPE_RS274X) ) {
                     instats = mainProject->file[i]->image->gerbv_stats;
                     gerbv_stats_add_layer(stats, instats, i+1);
              }
       }
       return stats;
}
 
 
/* ------------------------------------------------------------------ */
gerbv_drill_stats_t *
generate_drill_analysis(void)
{
       int i;
       gerbv_drill_stats_t *stats;
       gerbv_drill_stats_t *instats;
 
       stats = gerbv_drill_stats_new();
 
       /* Loop through open layers and compile statistics by accumulating reports from each layer */
       for(i = mainProject->last_loaded; i >= 0; i--) {
              if (mainProject->file[i] && 
                            mainProject->file[i]->isVisible &&
                            (mainProject->file[i]->image->layertype == GERBV_LAYERTYPE_DRILL) ) {
                     instats = mainProject->file[i]->image->drill_stats;
                     /* add this batch of stats.  Send the layer 
                     * index for error reporting */
                     gerbv_drill_stats_add_layer(stats, instats, i+1);
              }
       }
       return stats;
}