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 <stdbool.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>
 
#ifndef RENDER_USING_GDK
#include <cairo.h>
#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__)
 
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;
 
typedef enum {
    CIRCLE_EXPOSURE,
    CIRCLE_DIAMETER,
    CIRCLE_CENTER_X,
    CIRCLE_CENTER_Y,
} 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;  // NOTE: memory here is released via `free()` (thus cannot be `const char*`)
    double real_value;
} gerbv_HID_Attr_Val;
 
typedef struct {
    const char* name;       // Allow 'const' variables (e.g., stored in read-only pages)
    const char* help_text;  // Allow 'const' variables (e.g., stored in read-only pages)
 
    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;                  
} 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, 
    const gchar*     filename      
);
 
void gerbv_open_layer_from_filename_with_color(
    gerbv_project_t* gerbvProject, 
    const gchar*     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, const gchar* filename, const gchar* baseName, int idx,
    int reload
);
int gerbv_open_image(
    gerbv_project_t* gerbvProject, const gchar* 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, 
    const gchar*     filename        
);
 
void gerbv_export_png_file_from_project(
    gerbv_project_t*     gerbvProject, 
    gerbv_render_info_t* renderInfo,   
    const gchar*         filename      
);
 
void gerbv_export_pdf_file_from_project_autoscaled(
    gerbv_project_t* gerbvProject, 
    const gchar*     filename      
);
 
void gerbv_export_pdf_file_from_project(
    gerbv_project_t*     gerbvProject, 
    gerbv_render_info_t* renderInfo,   
    const gchar*         filename      
);
 
void gerbv_export_postscript_file_from_project_autoscaled(
    gerbv_project_t* gerbvProject, 
    const gchar*     filename      
);
 
void gerbv_export_postscript_file_from_project(
    gerbv_project_t*     gerbvProject, 
    gerbv_render_info_t* renderInfo,   
    const gchar*         filename      
);
 
void gerbv_export_svg_file_from_project_autoscaled(
    gerbv_project_t* gerbvProject, 
    const gchar*     filename      
);
 
void gerbv_export_svg_file_from_project(
    gerbv_project_t*     gerbvProject, 
    gerbv_render_info_t* renderInfo,   
    const gchar*         filename      
);
 
gboolean gerbv_export_dxf_file_from_image(
    const gchar*                 filename, 
    gerbv_image_t*               image,    
    gerbv_user_transformation_t* transform 
);
 
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);
 
void gerbv_transform_coord(double* x, double* y, const gerbv_user_transformation_t* trans);
 
void gerbv_rotate_coord(double* x, double* y, double rad);
 
#if defined(__cplusplus)
 
#undef MIN
#undef MAX
#define MIN(x, y)           \
    ({                      \
        typeof(x) _x = (x); \
        typeof(y) _y = (y); \
        (void)(&_x == &_y); \
        _x < _y ? _x : _y;  \
    })
#define MAX(x, y)           \
    ({                      \
        typeof(x) _x = (x); \
        typeof(y) _y = (y); \
        (void)(&_x == &_y); \
        _x > _y ? _x : _y;  \
    })
}
#endif
 
#endif /* __GERBV_H__ */