global.h

Go to the documentation of this file.

#ifndef PCB_GLOBAL_H
#define PCB_GLOBAL_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "const.h"
#include "macro.h"

#include <locale.h>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdarg.h>
#include <math.h>
#include <ctype.h>
#include <sys/types.h>
#include <stdbool.h>
#include <glib.h>

/* Forward declarations for structures the HIDs need.  */
typedef struct BoxType BoxType;
typedef struct polygon_st PolygonType;
typedef struct pad_st PadType;
typedef struct pin_st PinType;
typedef struct drc_violation_st DrcViolationType;
typedef struct rtree rtree_t;
typedef struct AttributeListType AttributeListType;

typedef struct unit Unit;
typedef struct increments Increments;

typedef COORD_TYPE Coord;       
typedef double Angle;           
#include "hid.h"
#include "polyarea.h"

/* Internationalization support. */
#include "gettext.h"

#if defined (ENABLE_NLS)
/* When an empty string is used for msgid, the functions may return a nonempty
   string. */
# define _(S) (S[0] != '\0') ? gettext(S) : S
# define N_(S) gettext_noop(S)
# define C_(C, S) pgettext(C, S)
#else
# define _(S) S
# define N_(S) S
# define C_(C, S) S
#endif /* ENABLE_NLS */

typedef struct {
  int ival;
  Coord bval;
  double dval;
  char has_units;
} PLMeasure;

#ifndef XtSpecificationRelease
typedef unsigned int Cardinal;
/*typedef unsigned int  Pixel;*/
typedef char *String;
typedef short Position;
typedef short Dimension;
#endif
typedef unsigned char BYTE;

typedef struct
{
  unsigned long f;              /* generic flags */
  unsigned char t[(MAX_LAYER + 1) / 2];  /* thermals */
} FlagType;

#ifndef __GNUC__
#define __FUNCTION1(a,b) a ":" #b
#define __FUNCTION2(a,b) __FUNCTION1(a,b)
#define __FUNCTION__ __FUNCTION2(__FILE__,__LINE__)
#endif


/* ---------------------------------------------------------------------------
 * Macros to annotate branch-prediction information.
 * Taken from GLib 2.16.3 (LGPL 2).G_ / g_ prefixes have
 * been removed to avoid namespace clashes.
 */

/* The LIKELY and UNLIKELY macros let the programmer give hints to
 * the compiler about the expected result of an expression. Some compilers
 * can use this information for optimizations.
 *
 * The PCB_BOOLEAN_EXPR macro is intended to trigger a gcc warning when
 * putting assignments inside the test.
 */
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
#define PCB_BOOLEAN_EXPR(expr)                   \
 __extension__ ({                             \
   int _boolean_var_;                         \
   if (expr)                                  \
      _boolean_var_ = 1;                      \
   else                                       \
      _boolean_var_ = 0;                      \
   _boolean_var_;                             \
})
#define LIKELY(expr) (__builtin_expect (PCB_BOOLEAN_EXPR(expr), 1))
#define UNLIKELY(expr) (__builtin_expect (PCB_BOOLEAN_EXPR(expr), 0))
#else
#define LIKELY(expr) (expr)
#define UNLIKELY(expr) (expr)
#endif


/* ---------------------------------------------------------------------------
 * Do not change the following definitions even if they're not very
 * nice.  It allows us to have functions act on these "base types" and
 * not need to know what kind of actual object they're working on.
 */

/* Any object that uses the "object flags" defined in const.h, or
   exists as an object on the pcb, MUST be defined using this as the
   first fields, either directly or through ANYLINEFIELDS.  */
#define ANYOBJECTFIELDS                 \
        BoxType         BoundingBox;    \
        long int        ID;             \
        FlagType        Flags;          \
        //      struct LibraryEntryType *net

/* Lines, pads, and rats all use this so they can be cross-cast.  */
#define ANYLINEFIELDS                   \
        ANYOBJECTFIELDS;                \
        Coord           Thickness,      \
                        Clearance;      \
        PointType       Point1,         \
                        Point2

/* ---------------------------------------------------------------------------
 * some useful values of our widgets
 */

typedef struct
{
  hidGC bgGC, 
    fgGC, 
    pmGC; 
}
OutputType;

typedef struct
{
  Cardinal Number[MAX_GROUP], 
    Entries[MAX_GROUP][MAX_ALL_LAYER];
} LayerGroupType;

struct BoxType
{
  Coord X1, Y1; 
  Coord X2, Y2; 
};

typedef struct
{
  Coord x, y;
  Coord width, height;
} RectangleType;

typedef struct
{
  char *name;
  char *value;
} AttributeType;

struct AttributeListType
{
  int Number, Max;
  AttributeType *List;
};

/* ---------------------------------------------------------------------------
 * the basic object types supported by PCB
 */

typedef struct {
  ANYOBJECTFIELDS;
} AnyObjectType;

typedef struct
{
  Coord X, Y, X2, Y2; 
  long int ID;
} PointType;

typedef struct {
  ANYLINEFIELDS;
} AnyLineObjectType;

typedef struct
{
  ANYLINEFIELDS;
  char *Number;
} LineType;

typedef struct
{
  ANYOBJECTFIELDS;
  int Scale; 
  Coord X; 
  Coord Y; 
  BYTE Direction;
  char *TextString; 
  void *Element;
} TextType;

struct polygon_st
{
  ANYOBJECTFIELDS;
  Cardinal PointN; 
  Cardinal PointMax; 
  POLYAREA *Clipped; 
  PLINE *NoHoles; 
  int NoHolesValid; 
  PointType *Points; 
  Cardinal *HoleIndex; 
  Cardinal HoleIndexN; 
  Cardinal HoleIndexMax; 
};

typedef struct
{
  ANYOBJECTFIELDS;
  Coord Thickness, Clearance;
  PointType Point1;
  PointType Point2;
  Coord Width; 
  Coord Height; 
  Coord X; 
  Coord Y; 
  Angle StartAngle; 
  Angle Delta; 
} ArcType;

struct rtree
{
  struct rtree_node *root;
  int size; 
};

typedef struct
{
  LayertypeType Type; 
  char *Name; 
  Cardinal LineN; 
  Cardinal TextN; 
  Cardinal PolygonN; 
  Cardinal ArcN; 
  GList *Line;
  GList *Text;
  GList *Polygon;
  GList *Arc;
  rtree_t *line_tree, *text_tree, *polygon_tree, *arc_tree;
  bool On; 
  char *Color, 
   *SelectedColor;
  AttributeListType Attributes;
  int no_drc; 
}
LayerType;

typedef struct
{
  ANYLINEFIELDS;
  Cardinal group1; 
  Cardinal group2; 
} RatType;

struct pad_st
{
  ANYLINEFIELDS;
  Coord Mask;
  char *Name, *Number; 
  void *Element;
  void *Spare;
};

struct pin_st
{
  ANYOBJECTFIELDS;
  Coord Thickness;
  Coord Clearance;
  Coord Mask;
  Coord DrillingHole; 
  Coord X; 
  Coord Y; 
  char *Name;
  char *Number;
  void *Element;
  void *Spare;
  Cardinal BuriedFrom;
  Cardinal BuriedTo;
};

/* This is the extents of a Pin or Via, depending on whether it's a
   hole or not.  */
#define PIN_SIZE(pinptr) (TEST_FLAG(HOLEFLAG, (pinptr)) \
                          ? (pinptr)->DrillingHole \
                          : (pinptr)->Thickness)

typedef struct
{
  ANYOBJECTFIELDS;
  TextType Name[MAX_ELEMENTNAMES];
  Coord MarkX; 
  Coord MarkY; 
  Cardinal PinN; 
  Cardinal PadN; 
  Cardinal LineN; 
  Cardinal ArcN; 
  GList *Pin;
  GList *Pad;
  GList *Line;
  GList *Arc;
  BoxType VBox;
  AttributeListType Attributes;
} ElementType;

/* ---------------------------------------------------------------------------
 * symbol and font related stuff
 */
typedef struct
{
  LineType *Line;
  bool Valid;
  Cardinal LineN; 
  Cardinal LineMax;
  Coord Width; 
  Coord Height; 
  Coord Delta; 
} SymbolType;

typedef struct
{
  Coord MaxHeight; 
  Coord MaxWidth; 
  BoxType DefaultSymbol; 
  SymbolType Symbol[MAX_FONTPOSITION + 1];
  bool Valid;
} FontType;

typedef struct
{
  Cardinal ViaN; 
  Cardinal ElementN; 
  Cardinal RatN; 
  int LayerN; 
  GList *Via;
  GList *Element;
  GList *Rat;
  rtree_t *via_tree, *element_tree, *pin_tree, *pad_tree, *name_tree[3],        /* for element names */
   *rat_tree;
  struct PCBType *pcb;
  LayerType Layer[MAX_ALL_LAYER];
  int polyClip;
} DataType;

typedef struct
{
  Coord DrillSize; 
  Cardinal ElementN; 
  Cardinal ElementMax; 
  Cardinal PinCount; 
  Cardinal ViaCount; 
  Cardinal UnplatedCount; 
  Cardinal PinN; 
  Cardinal PinMax; 
  PinType **Pin; 
  ElementType **Element; 
} DrillType;

typedef struct
{
  Cardinal DrillN; 
  Cardinal DrillMax; 
  DrillType *Drill; 
} DrillInfoType;

typedef struct
{
  Coord Thick; 
  Coord Diameter; 
  Coord Hole; 
  Coord Keepaway; 
  char *Name;
  int index;
} RouteStyleType;

typedef struct
{
  char *ListEntry; 
  char *AllocatedMemory; 
  char *Template; 
  char *Package; 
  char *Value; 
  char *Description; 
} LibraryEntryType;

typedef struct
{
  char *Name; 
  char *directory; 
  char *Style; 
  Cardinal EntryN; 
  Cardinal EntryMax; 
  LibraryEntryType *Entry; 
  char flag; 
  char internal; 
} LibraryMenuType;

typedef struct
{
  Cardinal MenuN; 
  Cardinal MenuMax; 
  LibraryMenuType *Menu; 
} LibraryType;


typedef struct PCBType
{
  long ID; 
  FlagType Flags;
  char *Name, 
   *Filename, 
   *PrintFilename, 
   *Netlistname, 
    ThermStyle; 
  bool Changed, 
    ViaOn, 
    ElementOn, 
    RatOn, 
    InvisibleObjectsOn,
    PinOn, 
    SilkActive, 
    RatDraw; 
  char *ViaColor, 
   *ViaSelectedColor, 
    *PinColor, 
    *PinSelectedColor, 
    *PinNameColor, 
    *ElementColor, 
    *RatColor, 
    *InvisibleObjectsColor, 
    *InvisibleMarkColor, 
    *ElementSelectedColor, 
    *RatSelectedColor, 
    *ConnectedColor, 
    *FoundColor, 
    *WarnColor, 
    *MaskColor; 
  long CursorX, 
    CursorY, 
    Clipping;
  Coord Bloat, 
    Shrink, 
    minWid, 
    minSlk, 
    minDrill, 
    minRing; 
  Coord GridOffsetX, 
    GridOffsetY, 
    MaxWidth, 
    MaxHeight; 
  Coord Grid; 
  double IsleArea, 
    ThermScale; 
  FontType Font;
  LayerGroupType LayerGroups;
  RouteStyleType RouteStyle[NUM_STYLES];
  LibraryType NetlistLib;
  AttributeListType Attributes;
  DataType *Data; 
  bool is_footprint; 
}
PCBType;

typedef struct
{
  Coord X; 
  Coord Y; 
  BoxType BoundingBox;
  DataType *Data; 
} BufferType;

/* ---------------------------------------------------------------------------
 * some types for cursor drawing, setting of block and lines
 * as well as for merging of elements
 */

typedef struct
{
  LayerType *Layer; 
  LineType *Line; 
  PointType *MovedPoint; 
} RubberbandType;

typedef struct
{
  PointType Point1; 
  PointType Point2; 
  long int State;
  bool draw;
} AttachedLineType;

typedef struct
{
  PointType Point1; 
  PointType Point2; 
  long int State;
  bool otherway;
} AttachedBoxType;

typedef struct
{
  Coord X; 
  Coord Y; 
  BoxType BoundingBox;
  long int Type, 
    State;
  void *Ptr1; 
  void *Ptr2; 
  void *Ptr3; 
  Cardinal RubberbandN, 
    RubberbandMax;
  RubberbandType *Rubberband;
} AttachedObjectType;

enum crosshair_shape
{
  Basic_Crosshair_Shape = 0,  
  Union_Jack_Crosshair_Shape, 
  Dozen_Crosshair_Shape,      
  Crosshair_Shapes_Number
};

typedef struct
{
  hidGC GC; 
  hidGC AttachGC; 
  Coord X; 
  Coord Y; 
  Coord MinX; 
  Coord MinY; 
  Coord MaxX; 
  Coord MaxY; 
  AttachedLineType AttachedLine; 
  AttachedBoxType AttachedBox;
  PolygonType AttachedPolygon;
  AttachedObjectType AttachedObject; 
  enum crosshair_shape shape; 
} CrosshairType;

typedef struct
{
  bool status;
  Coord X, Y;
} MarkType;

typedef struct
{
  const Unit *grid_unit;
  Increments *increments;

  int verbose;

  char *BlackColor,
    *WhiteColor,
    *BackgroundColor, 
    *CrosshairColor, 
    *CrossColor, 
    *ViaColor, 
    *ViaSelectedColor, 
    *PinColor, 
    *PinSelectedColor, 
    *PinNameColor, 
    *ElementColor, 
    *RatColor, 
    *InvisibleObjectsColor, 
    *InvisibleMarkColor, 
    *ElementSelectedColor, 
    *RatSelectedColor, 
    *ConnectedColor, 
    *FoundColor, 
    *OffLimitColor,
    *GridColor, 
    *LayerColor[MAX_LAYER],
    *LayerSelectedColor[MAX_LAYER],
    *WarnColor, 
    *MaskColor; 
  Coord ViaThickness, 
    ViaDrillingHole, 
    LineThickness, 
    RatThickness, 
    Keepaway, 
    MaxWidth, 
    MaxHeight, 
    AlignmentDistance,
    Bloat, 
    Shrink, 
    minWid, 
    minSlk, 
    minDrill, 
    minRing; 
  int TextScale; 
  Coord Grid; 
  double IsleArea; 
  Coord PasteAdjust; 
  int PinoutNameLength, 
    Volume, 
    CharPerLine, 
    Mode, 
    BufferNumber; 
  int BackupInterval; 
  char *DefaultLayerName[MAX_LAYER],
   *FontCommand, 
   *FileCommand, 
   *ElementCommand, 
   *PrintFile,
   *LibraryCommandDir,
   *LibraryCommand,
   *LibraryContentsCommand,
   *LibraryTree, 
   *SaveCommand,
   *LibraryFilename,
   *FontFile, 
   *Groups, 
   *Routes, 
   *FilePath,
   *RatPath,
   *RatCommand,
   *FontPath,
   *PinoutFont,
   *ElementPath,
   *LibraryPath,
   *Size, 
   *BackgroundImage, 
   *ScriptFilename, 
   *ActionString, 
   *FabAuthor, 
   *GnetlistProgram, 
   *MakeProgram, 
   *InitialLayerStack; 
  Coord PinoutOffsetX; 
  Coord PinoutOffsetY; 
  Coord PinoutTextOffsetX; 
  Coord PinoutTextOffsetY; 
  RouteStyleType RouteStyle[NUM_STYLES]; 
  LayerGroupType LayerGroups; 
  bool ClearLine,
    FullPoly,
    UniqueNames, 
    SnapPin, 
    ShowBottomSide, 
    SaveLastCommand, 
    SaveInTMP, 
    SaveMetricOnly, 
    DrawGrid, 
    RatWarn, 
    StipplePolygons, 
    AllDirectionLines, 
    RubberBandMode, 
    SwapStartDirection,
    ShowDRC, 
    AutoDRC, 
    ShowNumber, 
    OrthogonalMoves, 
    ResetAfterElement, 
    liveRouting, 
    AutoBuriedVias,
    RingBellWhenFinished,
    AutoPlace;
}
SettingType;

typedef struct
{
  void *(*Line) (LayerType *, LineType *);
  void *(*Text) (LayerType *, TextType *);
  void *(*Polygon) (LayerType *, PolygonType *);
  void *(*Via) (PinType *);
  void *(*Element) (ElementType *);
  void *(*ElementName) (ElementType *);
  void *(*Pin) (ElementType *, PinType *);
  void *(*Pad) (ElementType *, PadType *);
  void *(*LinePoint) (LayerType *, LineType *, PointType *);
  void *(*Point) (LayerType *, PolygonType *, PointType *);
  void *(*Arc) (LayerType *, ArcType *);
  void *(*Rat) (RatType *);
} ObjectFunctionType;

/* ---------------------------------------------------------------------------
 * structure used by device drivers
 */


typedef struct
{
  Coord X; 
  Coord Y; 
  long int type; 
  void *ptr1; 
  void *ptr2; 
  Cardinal group; 
  LibraryMenuType *menu; 
} ConnectionType;

typedef struct
{
  Cardinal ConnectionN; 
  Cardinal ConnectionMax; 
  ConnectionType *Connection;
  RouteStyleType *Style;
} NetType;

typedef struct
{
  Cardinal NetN; 
  Cardinal NetMax; 
  NetType *Net;
} NetListType;

typedef struct
{
  Cardinal NetListN; 
  Cardinal NetListMax; 
  NetListType *NetList;
} NetListListType;

typedef struct
{
  Cardinal PtrN; 
  Cardinal PtrMax; 
  void **Ptr;
} PointerListType;

typedef struct
{
  Cardinal BoxN; 
  Cardinal BoxMax; 
  BoxType *Box;
} BoxListType;

struct drc_violation_st
{
  char *title;
  char *explanation;
  Coord x, y;
  Angle angle;
  int have_measured;
  Coord measured_value;
  Coord required_value;
  int object_count;
  long int *object_id_list;
  int *object_type_list;
};

/* ---------------------------------------------------------------------------
 * define supported types of undo operations
 * note these must be separate bits now
 */
#define UNDO_CHANGENAME                 0x0001  
#define UNDO_MOVE                       0x0002  
#define UNDO_REMOVE                     0x0004  
#define UNDO_REMOVE_POINT               0x0008  
#define UNDO_INSERT_POINT               0x0010  
#define UNDO_REMOVE_CONTOUR             0x0020  
#define UNDO_INSERT_CONTOUR             0x0040  
#define UNDO_ROTATE                     0x0080  
#define UNDO_CREATE                     0x0100  
#define UNDO_MOVETOLAYER                0x0200  
#define UNDO_FLAG                       0x0400  
#define UNDO_CHANGESIZE                 0x0800  
#define UNDO_CHANGE2NDSIZE              0x1000  
#define UNDO_MIRROR                     0x2000  
#define UNDO_CHANGECLEARSIZE            0x4000  
#define UNDO_CHANGEMASKSIZE             0x8000  
#define UNDO_CHANGEANGLES              0x10000  
#define UNDO_LAYERCHANGE               0x20000  
#define UNDO_CLEAR                     0x40000  
#define UNDO_NETLISTCHANGE             0x80000  
#define UNDO_CHANGESETVIALAYERS        0x100000  
/* ---------------------------------------------------------------------------
 */
#if (__GNUC__ * 1000 + __GNUC_MINOR__) > 2007
#define ATTRIBUTE_UNUSED __attribute__((unused))
#else
#define ATTRIBUTE_UNUSED
#endif

/* ---------------------------------------------------------------------------
 * Macros called by various action routines to show usage or to report
 * a syntax error and fail
 */
#define AUSAGE(x) Message (_("Usage:\n%s\n"), _(x##_syntax))
#define AFAIL(x) { Message (_("Syntax error.  Usage:\n%s\n"), _(x##_syntax)); return 1; }

/* ---------------------------------------------------------------------------
 * Variables with absolute paths to various directories.  These are deduced
 * at runtime to allow pcb to be relocatable
 */
extern char *bindir;       
extern char *pcblibdir;    
extern char *pcblibpath;   
extern char *pcbtreedir;   
extern char *pcbtreepath;  
extern char *exec_prefix;
extern char *homedir;

#endif /* PCB_GLOBAL_H  */