gerbv.h

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 * This file is a part of Gerbv.
 *
 *   Copyright (C) 2000-2003 Stefan Petersen (spe@stacken.kth.se)
 *
 * $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., 59 Temple Place, Suite 330, Boston, MA 02111 USA
 */
 
 
 
 
#ifndef __GERBV_H__
#define __GERBV_H__
 
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
 
#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>
 
#ifndef RENDER_USING_GDK
# include <cairo.h>
#endif
 
#ifndef M_PI
# define M_PI        3.14159265358979323846      /* pi */
#endif
#ifndef M_PI_2
# define M_PI_2             1.57079632679489661923      /* pi/2 */
#endif
#ifndef M_1_PI
# define M_1_PI             0.31830988618379067154      /* 1/pi */
#endif
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#define APERTURE_MIN 10
#define APERTURE_MAX 9999
 
/*
 * Maximum number of aperture parameters is set by the outline aperture macro.
 * There (p. 62) is defined up to 5000 points in outline. So 5000 points with x
 * and y plus outline shape code, exposure, # of vertices, and duplication of
 * start/end point gives
 */
#define APERTURE_PARAMETERS_MAX 10006
#define GERBV_SCALE_MIN 10
#define GERBV_SCALE_MAX 40000
#define MAX_ERRMSGLEN 25
#define MAX_COORDLEN 28
#define MAX_DISTLEN 180
#define MAX_STATUSMSGLEN (MAX_ERRMSGLEN+MAX_COORDLEN+MAX_DISTLEN)
 
/*
 * Files only have a limited precision in their data, so when interpreting
 * layer rotations or linear size that have been read from a project file, we
 * have to tolerate a certain amount of error.
 */
#define GERBV_PRECISION_ANGLE_RAD  1e-6
#define GERBV_PRECISION_LINEAR_INCH       1e-6
 
/* Macros to convert between unscaled gerber coordinates and other units */
/* XXX NOTE: Currently unscaled units are assumed as inch, this is not
   XXX necessarily true for all files */
#define COORD2INS(c) (c)
#define COORD2MILS(c) ((c)*1000.0)
#define COORD2MMS(c) ((c)*25.4)
 
#define DEG2RAD(d) ((d)*M_PI/180.0)
#define RAD2DEG(r) ((r)*180.0*M_1_PI)
 
#define GERB_FATAL_ERROR(...) g_log(NULL, G_LOG_LEVEL_ERROR, __VA_ARGS__)
#define GERB_COMPILE_ERROR(...)  g_log(NULL, G_LOG_LEVEL_CRITICAL, __VA_ARGS__)
#define GERB_COMPILE_WARNING(...)  g_log(NULL, G_LOG_LEVEL_WARNING, __VA_ARGS__)
#define GERB_MESSAGE(...)  g_log(NULL, G_LOG_LEVEL_MESSAGE, __VA_ARGS__)
#define GERB_NOTE(...)  g_log(NULL, G_LOG_LEVEL_INFO, __VA_ARGS__)
 
typedef enum {GERBV_OPCODE_NOP, 
             GERBV_OPCODE_PUSH, 
             GERBV_OPCODE_PPUSH, 
             GERBV_OPCODE_PPOP, 
             GERBV_OPCODE_ADD, 
             GERBV_OPCODE_SUB, 
             GERBV_OPCODE_MUL, 
             GERBV_OPCODE_DIV, 
             GERBV_OPCODE_PRIM 
} gerbv_opcodes_t;
 
typedef enum {GERBV_MESSAGE_FATAL, 
              GERBV_MESSAGE_ERROR, 
              GERBV_MESSAGE_WARNING, 
              GERBV_MESSAGE_NOTE 
} gerbv_message_type_t;
 
typedef enum {
              GERBV_APTYPE_NONE, 
              GERBV_APTYPE_CIRCLE, 
              GERBV_APTYPE_RECTANGLE, 
              GERBV_APTYPE_OVAL, 
              GERBV_APTYPE_POLYGON, 
              GERBV_APTYPE_MACRO, 
                     GERBV_APTYPE_MACRO_CIRCLE, 
                     GERBV_APTYPE_MACRO_OUTLINE, 
                     GERBV_APTYPE_MACRO_POLYGON, 
                     GERBV_APTYPE_MACRO_MOIRE, 
                     GERBV_APTYPE_MACRO_THERMAL, 
                     GERBV_APTYPE_MACRO_LINE20, 
                     GERBV_APTYPE_MACRO_LINE21, 
                     GERBV_APTYPE_MACRO_LINE22 
} gerbv_aperture_type_t;
 
const char *gerbv_aperture_type_name(gerbv_aperture_type_t type);
 
typedef enum {GERBV_APERTURE_STATE_OFF, 
              GERBV_APERTURE_STATE_ON, 
              GERBV_APERTURE_STATE_FLASH 
} gerbv_aperture_state_t;
 
const char *gerbv_aperture_state_name(gerbv_aperture_state_t state);
 
typedef enum {
              CIRCLE_EXPOSURE,
              CIRCLE_DIAMETER,
              CIRCLE_CENTER_X,
              CIRCLE_CENTER_Y,
              CIRCLE_ROTATION,
} gerbv_aptype_macro_circle_index_t;
 
typedef enum {
              OUTLINE_EXPOSURE,
              OUTLINE_NUMBER_OF_POINTS,
              OUTLINE_FIRST_X, /* x0 */
              OUTLINE_FIRST_Y, /* y0 */
              /* x1, y1, x2, y2, ..., rotation */
              OUTLINE_ROTATION, /* Rotation index is correct if outline has
                                 no point except first */
} gerbv_aptype_macro_outline_index_t;
 
/* Point number is from 0 (first) to (including) OUTLINE_NUMBER_OF_POINTS */
#define OUTLINE_X_IDX_OF_POINT(number) (2*(number) + OUTLINE_FIRST_X)
#define OUTLINE_Y_IDX_OF_POINT(number) (2*(number) + OUTLINE_FIRST_Y)
#define       OUTLINE_ROTATION_IDX(param_array) \
                     ((int)param_array[OUTLINE_NUMBER_OF_POINTS]*2 + \
                     OUTLINE_ROTATION)
 
typedef enum {
              POLYGON_EXPOSURE,
              POLYGON_NUMBER_OF_POINTS,
              POLYGON_CENTER_X,
              POLYGON_CENTER_Y,
              POLYGON_DIAMETER,
              POLYGON_ROTATION,
} gerbv_aptype_macro_polygon_index_t;
 
typedef enum {
              MOIRE_CENTER_X,
              MOIRE_CENTER_Y,
              MOIRE_OUTSIDE_DIAMETER,
              MOIRE_CIRCLE_THICKNESS,
              MOIRE_GAP_WIDTH,
              MOIRE_NUMBER_OF_CIRCLES,
              MOIRE_CROSSHAIR_THICKNESS,
              MOIRE_CROSSHAIR_LENGTH,
              MOIRE_ROTATION,
} gerbv_aptype_macro_moire_index_t;
 
typedef enum {
              THERMAL_CENTER_X,
              THERMAL_CENTER_Y,
              THERMAL_OUTSIDE_DIAMETER,
              THERMAL_INSIDE_DIAMETER,
              THERMAL_CROSSHAIR_THICKNESS,
              THERMAL_ROTATION,
} gerbv_aptype_macro_thermal_index_t;
 
typedef enum {
              LINE20_EXPOSURE,
              LINE20_LINE_WIDTH,
              LINE20_WIDTH = LINE20_LINE_WIDTH,  /* Unification alias */
              LINE20_START_X,
              LINE20_START_Y,
              LINE20_END_X,
              LINE20_END_Y,
              LINE20_ROTATION,
} gerbv_aptype_macro_line20_index_t;
 
typedef enum {
              LINE21_EXPOSURE,
              LINE21_WIDTH,
              LINE21_HEIGHT,
              LINE21_CENTER_X,
              LINE21_CENTER_Y,
              LINE21_ROTATION,
} gerbv_aptype_macro_line21_index_t;
 
typedef enum {
              LINE22_EXPOSURE,
              LINE22_WIDTH,
              LINE22_HEIGHT,
              LINE22_LOWER_LEFT_X,
              LINE22_LOWER_LEFT_Y,
              LINE22_ROTATION,
} gerbv_aptype_macro_line22_index_t;
 
 
typedef enum {GERBV_UNIT_INCH, 
              GERBV_UNIT_MM, 
              GERBV_UNIT_UNSPECIFIED 
} gerbv_unit_t;
 
typedef enum {GERBV_POLARITY_POSITIVE, 
              GERBV_POLARITY_NEGATIVE, 
              GERBV_POLARITY_DARK, 
              GERBV_POLARITY_CLEAR 
} gerbv_polarity_t;
 
typedef enum {GERBV_OMIT_ZEROS_LEADING, 
              GERBV_OMIT_ZEROS_TRAILING, 
              GERBV_OMIT_ZEROS_EXPLICIT, 
              GERBV_OMIT_ZEROS_UNSPECIFIED 
} gerbv_omit_zeros_t;
 
typedef enum {GERBV_COORDINATE_ABSOLUTE, 
              GERBV_COORDINATE_INCREMENTAL 
} gerbv_coordinate_t;
 
typedef enum {GERBV_INTERPOLATION_LINEARx1, 
              GERBV_INTERPOLATION_LINEARx10, 
              GERBV_INTERPOLATION_LINEARx01, 
              GERBV_INTERPOLATION_LINEARx001, 
              GERBV_INTERPOLATION_CW_CIRCULAR, 
              GERBV_INTERPOLATION_CCW_CIRCULAR, 
              GERBV_INTERPOLATION_PAREA_START, 
              GERBV_INTERPOLATION_PAREA_END, 
              GERBV_INTERPOLATION_DELETED 
} gerbv_interpolation_t;
 
/* For backward compatibility */
enum {GERBV_INTERPOLATION_x10 = GERBV_INTERPOLATION_LINEARx10};
 
const char *gerbv_interpolation_name(gerbv_interpolation_t interp);
 
typedef enum {GERBV_ENCODING_NONE,
              GERBV_ENCODING_ASCII,
              GERBV_ENCODING_EBCDIC,
              GERBV_ENCODING_BCD,
              GERBV_ENCODING_ISO_ASCII,
              GERBV_ENCODING_EIA
} gerbv_encoding_t;
 
typedef enum {
              GERBV_LAYERTYPE_RS274X, 
              GERBV_LAYERTYPE_DRILL, 
              GERBV_LAYERTYPE_PICKANDPLACE_TOP, 
              GERBV_LAYERTYPE_PICKANDPLACE_BOT, 
} gerbv_layertype_t;
 
typedef enum {GERBV_KNOCKOUT_TYPE_NOKNOCKOUT,
              GERBV_KNOCKOUT_TYPE_FIXEDKNOCK,
              GERBV_KNOCKOUT_TYPE_BORDER
} gerbv_knockout_type_t;
 
typedef enum {GERBV_MIRROR_STATE_NOMIRROR,
              GERBV_MIRROR_STATE_FLIPA,
              GERBV_MIRROR_STATE_FLIPB,
              GERBV_MIRROR_STATE_FLIPAB
} gerbv_mirror_state_t;
 
typedef enum {GERBV_AXIS_SELECT_NOSELECT,
              GERBV_AXIS_SELECT_SWAPAB
} gerbv_axis_select_t;
 
typedef enum {GERBV_JUSTIFY_NOJUSTIFY,
              GERBV_JUSTIFY_LOWERLEFT,
              GERBV_JUSTIFY_CENTERJUSTIFY
} gerbv_image_justify_type_t;
 
typedef enum {       GERBV_SELECTION_POINT_CLICK = 1, 
              GERBV_SELECTION_DRAG_BOX 
} gerbv_selection_t;
 
enum draw_mode {
       DRAW_IMAGE = 0,
       DRAW_SELECTIONS,
       FIND_SELECTIONS,
       FIND_SELECTIONS_TOGGLE,
};
 
typedef enum {GERBV_RENDER_TYPE_GDK, 
              GERBV_RENDER_TYPE_GDK_XOR, 
              GERBV_RENDER_TYPE_CAIRO_NORMAL, 
              GERBV_RENDER_TYPE_CAIRO_HIGH_QUALITY, 
              GERBV_RENDER_TYPE_MAX 
} gerbv_render_types_t;
 
/* 
 * The following typedef's are taken directly from src/hid.h in the
 * pcb project.  The names are kept the same to make it easier to
 * compare to pcb's sources.
 */
    
/* Used for HID attributes (exporting and printing, mostly).
   HA_boolean uses int_value, HA_enum sets int_value to the index and
   str_value to the enumeration string.  HID_Label just shows the
   default str_value.  HID_Mixed is a real_value followed by an enum,
   like 0.5in or 100mm. 
*/
typedef struct {
    int int_value;
    char *str_value;
    double real_value;
} gerbv_HID_Attr_Val;
 
typedef struct {
    char *name;
    char *help_text;
    enum
       { HID_Label, HID_Integer, HID_Real, HID_String,
         HID_Boolean, HID_Enum, HID_Mixed, HID_Path
       } type;
    int min_val, max_val;   /* for integer and real */
    gerbv_HID_Attr_Val default_val;       /* Also actual value for global attributes.  */
    const char **enumerations;
    /* If set, this is used for global attributes (i.e. those set
       statically with REGISTER_ATTRIBUTES below) instead of changing
       the default_val.  Note that a HID_Mixed attribute must specify a
       pointer to gerbv_HID_Attr_Val here, and HID_Boolean assumes this is
       "char *" so the value should be initialized to zero, and may be
       set to non-zero (not always one).  */
    void *value;
    int hash; /* for detecting changes. */
} gerbv_HID_Attribute;
/* end of HID attributes from PCB */
 
typedef struct error_list {
    int layer;
    gchar *error_text;
    gerbv_message_type_t type;
    struct error_list *next;
} gerbv_error_list_t;
 
typedef struct instruction {
    gerbv_opcodes_t opcode;
    union {
       int ival;
       float fval;
    } data;
    struct instruction *next;
} gerbv_instruction_t;
 
typedef struct amacro {
    gchar *name;
    gerbv_instruction_t *program;
    unsigned int nuf_push;  /* Nuf pushes in program to estimate stack size */
    struct amacro *next;
} gerbv_amacro_t;
 
typedef struct gerbv_simplified_amacro {
    gerbv_aperture_type_t type;
    double parameter[APERTURE_PARAMETERS_MAX];
    struct gerbv_simplified_amacro *next;
} gerbv_simplified_amacro_t;
 
typedef struct gerbv_aperture {
    gerbv_aperture_type_t type;
    gerbv_amacro_t *amacro;
    gerbv_simplified_amacro_t *simplified;
    double parameter[APERTURE_PARAMETERS_MAX];
    int nuf_parameters;
    gerbv_unit_t unit;
} gerbv_aperture_t;
 
/* the gerb_aperture_list is used to keep track of 
 * apertures used in stats reporting */
typedef struct gerbv_aperture_list {
    int number;
    int layer;
    int count;
    gerbv_aperture_type_t type;
    double parameter[5];
    struct gerbv_aperture_list *next;
} gerbv_aperture_list_t;
 
typedef struct {
    gerbv_error_list_t *error_list;
    gerbv_aperture_list_t *aperture_list;
    gerbv_aperture_list_t *D_code_list;
 
    int layer_count;
    int G0;
    int G1;
    int G2;
    int G3;
    int G4;
    int G10;
    int G11;
    int G12;
    int G36;
    int G37;
    int G54;
    int G55;
    int G70;
    int G71;
    int G74;
    int G75;
    int G90;
    int G91;
    int G_unknown;
 
    int D1;
    int D2;
    int D3;
/*    GHashTable *D_user_defined; */
    int D_unknown;
    int D_error;
 
    int M0;
    int M1;
    int M2;
    int M_unknown;
 
    int X;
    int Y;
    int I;
    int J;
 
    /* Must include % RS-274 codes */
    int star;
    int unknown;
 
} gerbv_stats_t;
 
typedef struct drill_list {
    int drill_num;
    double drill_size;
    gchar *drill_unit;
    int drill_count;
    struct drill_list *next;
} gerbv_drill_list_t;
 
typedef struct {
    int layer_count;
    
    gerbv_error_list_t *error_list;
    gerbv_drill_list_t *drill_list;
    int comment;
    int F;
 
    int G00;
    int G01;
    int G02;
    int G03;
    int G04;
    int G05;
    int G85;
    int G90;
    int G91;
    int G93;
    int G_unknown;
 
    int M00;
    int M01;
    int M18;
    int M25;
    int M30;
    int M31;
    int M45;
    int M47;
    int M48;
    int M71;
    int M72;
    int M95;
    int M97;
    int M98;
    int M_unknown;
 
    int R;
 
    int unknown;
 
    /* used to total up the drill count across all layers/sizes */
    int total_count;
 
    char *detect;
 
} gerbv_drill_stats_t;
 
typedef struct {
       gpointer image;             /* gerbv_image_t* */
       gpointer net;        /* gerbv_net_t* */
} gerbv_selection_item_t;
 
typedef struct {
       gerbv_selection_t type;
       gdouble lowerLeftX;
       gdouble lowerLeftY;
       gdouble upperRightX;
       gdouble upperRightY;
       GArray *selectedNodeArray;
} gerbv_selection_info_t;
 
typedef struct {
    gdouble translateX; 
    gdouble translateY; 
    gdouble scaleX; 
    gdouble scaleY; 
    gdouble rotation; 
    gboolean mirrorAroundX;  
    gboolean mirrorAroundY;  
    gboolean inverted; 
} gerbv_user_transformation_t;
 
typedef struct {
    double left; 
    double right; 
    double bottom; 
    double top; 
} gerbv_render_size_t;
 
typedef struct gerbv_cirseg {
    double cp_x;   /* center point x */
    double cp_y;   /* center point y */
    double width;  /* used as diameter */
    double height; /* */
    double angle1; /* in degrees */
    double angle2; /* in degrees */
} gerbv_cirseg_t;
 
typedef struct gerbv_step_and_repeat { /* SR parameters */
    int X;
    int Y;
    double dist_X;
    double dist_Y;
} gerbv_step_and_repeat_t;
 
typedef struct {
    gboolean firstInstance;
    gerbv_knockout_type_t type;
    gerbv_polarity_t polarity;
    gdouble lowerLeftX;
    gdouble lowerLeftY;
    gdouble width;
    gdouble height;
    gdouble border;
} gerbv_knockout_t;
 
typedef struct {
    gerbv_step_and_repeat_t stepAndRepeat; 
    gerbv_knockout_t knockout; 
    gdouble rotation; 
    gerbv_polarity_t polarity; 
    gchar *name; 
    gpointer next; 
} gerbv_layer_t;
 
typedef struct {
    gerbv_axis_select_t axisSelect; 
    gerbv_mirror_state_t mirrorState; 
    gerbv_unit_t unit; 
    gdouble offsetA; 
    gdouble offsetB; 
    gdouble scaleA; 
    gdouble scaleB; 
    gpointer next; 
} gerbv_netstate_t;
 
typedef struct gerbv_net {
    double start_x; 
    double start_y; 
    double stop_x; 
    double stop_y; 
    gerbv_render_size_t boundingBox; 
    int aperture; 
    gerbv_aperture_state_t aperture_state; 
    gerbv_interpolation_t interpolation; 
    gerbv_cirseg_t *cirseg; 
    struct gerbv_net *next; 
    GString *label; 
    gerbv_layer_t *layer; 
    gerbv_netstate_t *state; 
} gerbv_net_t;
 
typedef struct gerbv_format {
    gerbv_omit_zeros_t omit_zeros;
    gerbv_coordinate_t coordinate;
    int x_int;
    int x_dec;
    int y_int;
    int y_dec;
    int lim_seqno; /* Length limit for codes of sequence number */
    int lim_gf;    /* Length limit for codes of general function */
    int lim_pf;    /* Length limit for codes of plot function */
    int lim_mf;    /* Length limit for codes of miscellaneous function */
} gerbv_format_t;
       
 
typedef struct gerbv_image_info {
    char *name;
    gerbv_polarity_t polarity;
    double min_x; /* Always in inches */
    double min_y;
    double max_x;
    double max_y;
    double offsetA;
    double offsetB;
    gerbv_encoding_t encoding;
    double imageRotation;
    gerbv_image_justify_type_t imageJustifyTypeA;
    gerbv_image_justify_type_t imageJustifyTypeB;
    gdouble imageJustifyOffsetA;
    gdouble imageJustifyOffsetB;
    gdouble imageJustifyOffsetActualA;
    gdouble imageJustifyOffsetActualB;
    gchar *plotterFilm;
 
    /* Descriptive string for the type of file (rs274-x, drill, etc)
     * that this is
     */
    gchar *type;
 
    /* Attribute list that is used to hold all sorts of information
     * about how the layer is to be parsed.
    */ 
    gerbv_HID_Attribute *attr_list;
    int n_attr;
} gerbv_image_info_t;
 
typedef struct {
  gerbv_layertype_t layertype; 
  gerbv_aperture_t *aperture[APERTURE_MAX]; 
  gerbv_layer_t *layers; 
  gerbv_netstate_t *states; 
  gerbv_amacro_t *amacro; 
  gerbv_format_t *format; 
  gerbv_image_info_t *info; 
  gerbv_net_t *netlist; 
  gerbv_stats_t *gerbv_stats; 
  gerbv_drill_stats_t *drill_stats;  
} gerbv_image_t;
 
typedef struct {
  gerbv_image_t *image; 
  GdkColor color; 
  guint16 alpha; 
  gboolean isVisible; 
  gpointer privateRenderData; 
  gchar *fullPathname; 
  gchar *name; 
  gerbv_user_transformation_t transform; 
  gboolean layer_dirty;  
} gerbv_fileinfo_t;
 
typedef struct {
  GdkColor  background; 
  int max_files; 
  gerbv_fileinfo_t **file; 
  int curr_index; 
  int last_loaded; 
  int renderType; 
  gboolean check_before_delete;  
  gboolean show_invisible_selection; 
  gchar *path; 
  gchar *execpath;    
  gchar *execname;    
  gchar *project;     
  gboolean use_cairo_svg; 
} gerbv_project_t;
 
typedef struct{
    unsigned char red;
    unsigned char green;
    unsigned char blue;
    unsigned char alpha;
}gerbv_layer_color;
 
typedef struct {
       gdouble scaleFactorX; 
       gdouble scaleFactorY; 
       gdouble lowerLeftX; 
       gdouble lowerLeftY; 
       gerbv_render_types_t renderType; 
       gint displayWidth; 
       gint displayHeight; 
       gboolean show_cross_on_drill_holes; 
} gerbv_render_info_t;
 
gerbv_image_t *gerbv_create_image(gerbv_image_t *image, 
              const gchar *type 
);
 
void gerbv_destroy_image(gerbv_image_t *image 
);
 
void
gerbv_image_copy_image (gerbv_image_t *sourceImage, 
       gerbv_user_transformation_t *transform, 
       gerbv_image_t *destinationImage 
);
 
gerbv_image_t *
gerbv_image_duplicate_image (gerbv_image_t *sourceImage, 
       gerbv_user_transformation_t *transform 
);
 
void
gerbv_image_delete_net (gerbv_net_t *currentNet 
);
 
gboolean
gerbv_image_reduce_area_of_selected_objects (GArray *selectionArray, gdouble areaReduction, gint paneRows,
              gint paneColumns, gdouble paneSeparation);
 
gboolean
gerbv_image_move_selected_objects (GArray *selectionArray, gdouble translationX,
              gdouble translationY);
 
gerbv_net_t *
gerbv_image_return_next_renderable_object (gerbv_net_t *oldNet);
 
gerbv_project_t *
gerbv_create_project (void);
 
void
gerbv_destroy_project (gerbv_project_t *gerbvProject 
);
 
void 
gerbv_open_layer_from_filename (
       gerbv_project_t *gerbvProject, 
       gchar const* filename 
);
 
void 
gerbv_open_layer_from_filename_with_color(gerbv_project_t *gerbvProject, 
       gchar const* filename, 
       guint16 red, 
       guint16 green, 
       guint16 blue, 
       guint16 alpha 
);
 
void
gerbv_destroy_fileinfo (gerbv_fileinfo_t *fileInfo 
);
 
gboolean 
gerbv_save_layer_from_index(gerbv_project_t *gerbvProject, gint index, gchar *filename);
 
int
gerbv_revert_file(gerbv_project_t *gerbvProject, int idx);
 
void 
gerbv_revert_all_files(gerbv_project_t *gerbvProject);
 
void 
gerbv_unload_layer(gerbv_project_t *gerbvProject, int index);
 
void 
gerbv_unload_all_layers (gerbv_project_t *gerbvProject);
 
void 
gerbv_change_layer_order(gerbv_project_t *gerbvProject, gint oldPosition, gint newPosition);
 
gint
gerbv_add_parsed_image_to_project (gerbv_project_t *gerbvProject, gerbv_image_t *parsed_image,
                     gchar const* filename, gchar const* baseName, int idx, int reload);
int
gerbv_open_image(gerbv_project_t *gerbvProject, gchar const* filename, int idx, int reload,
              gerbv_HID_Attribute *fattr, int n_fattr, gboolean forceLoadFile);
              
void
gerbv_render_get_boundingbox(gerbv_project_t *gerbvProject, gerbv_render_size_t *boundingbox);
 
void
gerbv_render_zoom_to_fit_display (gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo 
);
 
void
gerbv_render_translate_to_fit_display (gerbv_project_t *gerbvProject, gerbv_render_info_t *renderInfo);
 
void
gerbv_render_to_pixmap_using_gdk (gerbv_project_t *gerbvProject, GdkPixmap *pixmap,
              gerbv_render_info_t *renderInfo, gerbv_selection_info_t *selectionInfo,
              GdkColor *selectionColor);
 
#ifndef RENDER_USING_GDK
void
gerbv_render_all_layers_to_cairo_target_for_vector_output (gerbv_project_t *gerbvProject,
              cairo_t *cr, gerbv_render_info_t *renderInfo);
 
void
gerbv_render_all_layers_to_cairo_target (gerbv_project_t *gerbvProject, cairo_t *cr,
                     gerbv_render_info_t *renderInfo);
 
void
gerbv_render_layer_to_cairo_target (cairo_t *cr, 
              gerbv_fileinfo_t *fileInfo, 
              gerbv_render_info_t *renderInfo 
);
                                          
void
gerbv_render_cairo_set_scale_and_translation(cairo_t *cr, gerbv_render_info_t *renderInfo);
 
void
gerbv_render_layer_to_cairo_target_without_transforming(cairo_t *cr, gerbv_fileinfo_t *fileInfo, gerbv_render_info_t *renderInfo, gboolean pixelOutput );
#endif
 
double
gerbv_get_tool_diameter(int toolNumber
);
 
int
gerbv_process_tools_file(const char *toolFileName
);
 
void
gerbv_export_png_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              int widthInPixels, 
              int heightInPixels, 
              gchar const* filename  
);
 
void
gerbv_export_png_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);
 
void
gerbv_export_pdf_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);
 
void
gerbv_export_pdf_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);
 
void
gerbv_export_postscript_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);
 
void
gerbv_export_postscript_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);
 
void
gerbv_export_svg_file_from_project_autoscaled (
              gerbv_project_t *gerbvProject, 
              gchar const* filename  
);
 
void
gerbv_export_svg_file_from_project_autoscaled_with_options (
              gerbv_project_t *gerbvProject, 
              gchar const* filename, 
              gboolean exportLayersAsSvgLayers 
);
 
void
gerbv_export_svg_file_from_project (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename 
);
 
void
gerbv_export_svg_file_from_project_with_options (
              gerbv_project_t *gerbvProject, 
              gerbv_render_info_t *renderInfo, 
              gchar const* filename, 
              gboolean exportLayersAsSvgLayers 
);
 
gboolean
gerbv_export_dxf_file_from_image (const gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);
 
gerbv_image_t *
gerbv_create_excellon_image_from_filename (const gchar *filename 
);
 
gerbv_image_t *
gerbv_create_rs274x_image_from_filename (const gchar *filename 
);
 
gboolean
gerbv_export_rs274x_file_from_image (const gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);
 
gboolean
gerbv_export_drill_file_from_image (const gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);
 
gboolean
gerbv_export_isel_drill_file_from_image (const gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);
 
gboolean
gerbv_export_geda_pcb_file_from_image (const gchar *filename, 
              gerbv_image_t *image, 
              gerbv_user_transformation_t *transform 
);
 
void
gerbv_image_create_line_object (gerbv_image_t *image, 
              gdouble startX, 
              gdouble startY, 
              gdouble endX, 
              gdouble endY, 
              gdouble lineWidth, 
              gerbv_aperture_type_t apertureType  
);
 
void
gerbv_image_create_arc_object (gerbv_image_t *image, 
              gdouble centerX, 
              gdouble centerY, 
              gdouble radius, 
              gdouble startAngle, 
              gdouble endAngle, 
              gdouble lineWidth, 
              gerbv_aperture_type_t apertureType  
);
              
void
gerbv_image_create_rectangle_object (gerbv_image_t *image, 
              gdouble coordinateX, 
              gdouble coordinateY, 
              gdouble width, 
              gdouble height 
);
 
void
gerbv_image_create_dummy_apertures (gerbv_image_t *parsed_image 
);
              
gerbv_drill_stats_t *
gerbv_drill_stats_new(void);
 
void
gerbv_drill_stats_destroy(gerbv_drill_stats_t *);
 
void
gerbv_drill_stats_add_layer(gerbv_drill_stats_t *accum_stats,
              gerbv_drill_stats_t *input_stats,
              int this_layer
);
 
gerbv_stats_t *
gerbv_stats_new(void);
 
void
gerbv_stats_destroy(gerbv_stats_t *);
 
void
gerbv_stats_add_layer(gerbv_stats_t *accum_stats, 
              gerbv_stats_t *input_stats,
              int this_layer
);
 
void
gerbv_attribute_destroy_HID_attribute (gerbv_HID_Attribute *attributeList, int n_attr);
 
gerbv_HID_Attribute *
gerbv_attribute_dup (gerbv_HID_Attribute *, int);
 
gerbv_fileinfo_t *
gerbv_get_fileinfo_for_image(const gerbv_image_t *image,
                            const gerbv_project_t *project);
 
int
gerbv_transform_coord_for_image(double *x, double *y,
              const gerbv_image_t *image, const gerbv_project_t *project);
 
gboolean
gerbv_endswith(const char *path, const char *ext);
 
gboolean
gerbv_is_loadable_file(const char *filename);
 
void
gerbv_transform_coord(double *x, double *y,
              const gerbv_user_transformation_t *trans);
 
void
gerbv_rotate_coord(double *x, double *y, double rad);
 
/* Standard C inline functions for MIN/MAX - works with any C99+ compiler */
#undef MIN
#undef MAX
 
static inline int min_int(int x, int y) { return x < y ? x : y; }
static inline int max_int(int x, int y) { return x > y ? x : y; }
static inline double min_double(double x, double y) { return x < y ? x : y; }
static inline double max_double(double x, double y) { return x > y ? x : y; }
 
/* Generic macros using C11 _Generic for type-safe selection */
#define MIN(x, y) _Generic((x), \
    int: min_int, \
    double: min_double, \
    default: min_double \
)((x), (y))
 
#define MAX(x, y) _Generic((x), \
    int: max_int, \
    double: max_double, \
    default: max_double \
)((x), (y))
 
#if defined(__cplusplus)
}
#endif
 
#endif /* __GERBV_H__ */