src/hid.h

   1 #ifndef _HID_H_
   2 #define _HID_H_
   3
   4 #include <stdarg.h>
   5
   6 /* Human Interface Device */
   7
   8 /*
   9
  10 The way the HID layer works is that you instantiate a HID device
  11 structure, and invoke functions through its members.  Code in the
  12 common part of PCB may *not* rely on *anything* other than what's
  13 defined in this file.  Code in the HID layers *may* rely on data and
  14 functions in the common code (like, board size and such) but it's
  15 considered bad form to do so when not needed.
  16
  17 Coordinates are ALWAYS in pcb's default resolution (1/100 mil at the
  18 moment).  Positive X is right, positive Y is down.  Angles are
  19 degrees, with 0 being right (positive X) and 90 being up (negative Y).
  20 All zoom, scaling, panning, and conversions are hidden inside the HID
  21 layers.
  22
  23 The main structure is at the end of this file.
  24
  25 Data structures passed to the HIDs will be copied if the HID needs to
  26 save them.  Data structures retured from the HIDs must not be freed,
  27 and may be changed by the HID in response to new information.
  28
  29 */
  30
  31 #if defined(__cplusplus) && __cplusplus
  32 extern "C"
  33 {
  34 #endif
  35
  36 /* Like end cap styles.  The cap *always* extends beyond the
  37    coordinates given, by half the width of the line.  Beveled ends can
  38    used to make octagonal pads by giving the same x,y coordinate
  39    twice.  */
  40   typedef enum
  41   {
  42     Trace_Cap,                  /* This means we're drawing a trace, which has round caps.  */
  43     Square_Cap,                 /* Square pins or pads. */
  44     Round_Cap,                  /* Round pins or round-ended pads, thermals.  */
  45     Beveled_Cap                 /* Octagon pins or bevel-cornered pads.  */
  46   } EndCapStyle;
  47
  48 /* The HID may need something more than an "int" for colors, timers,
  49    etc.  So it passes/returns one of these, which is castable to a
  50    variety of things.  */
  51   typedef union
  52   {
  53     long lval;
  54     void *ptr;
  55   } hidval;
  56
  57 /* This graphics context is an opaque pointer defined by the HID.  GCs
  58    are HID-specific; attempts to use one HID's GC for a different HID
  59    will result in a fatal error.  */
  60   typedef struct hid_gc_struct *hidGC;
  61
  62 #define HIDCONCAT(a,b) a##b
  63
  64 /* This is used to register the action callbacks (for menus and
  65    whatnot).  HID assumes the following actions are available for its
  66    use:
  67         SaveAs(filename);
  68         Quit();
  69 */
  70   typedef struct
  71   {
  72     /* This is matched against action names in the GUI configuration */
  73     char *name;
  74     /* If this string is non-NULL, the action needs to know the X,Y
  75        coordinates to act on, and this string may be used to prompt
  76        the user to select a coordinate.  If NULL, the coordinates may
  77        be 0,0 if none are known.  */
  78     const char *need_coord_msg;
  79     /* Called when the action is triggered.  If this function returns
  80        non-zero, no further actions will be invoked for this key/mouse
  81        event.  */
  82     int (*trigger_cb) (int argc, char **argv, int x, int y);
  83     /* Short description that sometimes accompanies the name.  */
  84     const char *description;
  85     /* Full allowed syntax; use \n to separate lines.  */
  86     const char *syntax;
  87   } HID_Action;
  88
  89   extern void hid_register_actions (HID_Action *, int);
  90 #define REGISTER_ACTIONS(a) HIDCONCAT(void register_,a) ()\
  91 { hid_register_actions(a, sizeof(a)/sizeof(a[0])); }
  92
  93   /* Note that PCB expects the gui to provide the following actions:
  94
  95      PCBChanged();
  96      RouteStylesChanged()
  97      NetlistChanged()
  98      LayersChanged()
  99      LibraryChanged()
 100      Busy()
 101    */
 102
 103   extern const char pcbchanged_help[];
 104   extern const char pcbchanged_syntax[];
 105   extern const char routestyleschanged_help[];
 106   extern const char routestyleschanged_syntax[];
 107   extern const char netlistchanged_help[];
 108   extern const char netlistchanged_syntax[];
 109   extern const char layerschanged_help[];
 110   extern const char layerschanged_syntax[];
 111   extern const char librarychanged_help[];
 112   extern const char librarychanged_syntax[];
 113
 114   int hid_action (const char *action_);
 115   int hid_actionl (const char *action_, ...);   /* NULL terminated */
 116   int hid_actionv (const char *action_, int argc_, char **argv_);
 117   void hid_save_settings (int);
 118   void hid_load_settings (void);
 119
 120 /* Parse the given string into action calls, and call `f' for each
 121    action found.  Returns nonzero if the action handler(s) return
 122    nonzero.  If f is NULL, hid_actionv is called.  */
 123   int hid_parse_actions (const char *str_,
 124                          int (*_f) (const char *, int, char **));
 125
 126   typedef struct
 127   {
 128     /* Name of the flag */
 129     char *name;
 130     /* Function to call to get the value of the flag.  */
 131     int (*function) (int);
 132     /* Additional parameter to pass to that function.  */
 133     int parm;
 134   } HID_Flag;
 135
 136   extern void hid_register_flags (HID_Flag *, int);
 137 #define REGISTER_FLAGS(a) HIDCONCAT(void register_,a) ()\
 138 { hid_register_flags(a, sizeof(a)/sizeof(a[0])); }
 139
 140 /* Looks up one of the flags registered above.  If the flag is
 141    unknown, returns zero.  */
 142   int hid_get_flag (const char *name_);
 143
 144 /* Used for HID attributes (exporting and printing, mostly).
 145    HA_boolean uses int_value, HA_enum sets int_value to the index and
 146    str_value to the enumeration string.  HID_Label just shows the
 147    default str_value.  HID_Mixed is a real_value followed by an enum,
 148    like 0.5in or 100mm. */
 149   typedef struct
 150   {
 151     int int_value;
 152     char *str_value;
 153     double real_value;
 154   } HID_Attr_Val;
 155
 156   typedef struct
 157   {
 158     char *name;
 159     /* If the help_text is this, usage() won't show this option */
 160 #define ATTR_UNDOCUMENTED ((char *)(1))
 161     char *help_text;
 162     enum
 163     { HID_Label, HID_Integer, HID_Real, HID_String,
 164       HID_Boolean, HID_Enum, HID_Mixed, HID_Path
 165     } type;
 166     int min_val, max_val;       /* for integer and real */
 167     HID_Attr_Val default_val;   /* Also actual value for global attributes.  */
 168     const char **enumerations;
 169     /* If set, this is used for global attributes (i.e. those set
 170        statically with REGISTER_ATTRIBUTES below) instead of changing
 171        the default_val.  Note that a HID_Mixed attribute must specify a
 172        pointer to HID_Attr_Val here, and HID_Boolean assumes this is
 173        "char *" so the value should be initialized to zero, and may be
 174        set to non-zero (not always one).  */
 175     void *value;
 176     int hash; /* for detecting changes. */
 177   } HID_Attribute;
 178
 179   extern void hid_register_attributes (HID_Attribute *, int);
 180 #define REGISTER_ATTRIBUTES(a) HIDCONCAT(void register_,a) ()\
 181 { hid_register_attributes(a, sizeof(a)/sizeof(a[0])); }
 182
 183 /* These three are set by hid_parse_command_line().  */
 184   extern char *program_name;
 185   extern char *program_directory;
 186   extern char *program_basename;
 187
 188 #define SL_0_SIDE       0x0000
 189 #define SL_TOP_SIDE     0x0001
 190 #define SL_BOTTOM_SIDE  0x0002
 191 #define SL_SILK         0x0010
 192 #define SL_MASK         0x0020
 193 #define SL_PDRILL       0x0030
 194 #define SL_UDRILL       0x0040
 195 #define SL_PASTE        0x0050
 196 #define SL_INVISIBLE    0x0060
 197 #define SL_FAB          0x0070
 198 #define SL_ASSY         0x0080
 199 /* Callers should use this.  */
 200 #define SL(type,side) (~0xfff | SL_##type | SL_##side##_SIDE)
 201
 202 /* File Watch flags */
 203 /* Based upon those in dbus/dbus-connection.h */
 204 typedef enum
 205 {
 206   PCB_WATCH_READABLE = 1 << 0, /**< As in POLLIN */
 207   PCB_WATCH_WRITABLE = 1 << 1, /**< As in POLLOUT */
 208   PCB_WATCH_ERROR    = 1 << 2, /**< As in POLLERR */
 209   PCB_WATCH_HANGUP   = 1 << 3  /**< As in POLLHUP */
 210 } PCBWatchFlags;
 211
 212
 213 /* This is the main HID structure.  */
 214   typedef struct
 215   {
 216     /* The size of this structure.  We use this as a compatibility
 217        check; a HID built with a different hid.h than we're expecting
 218        should have a different size here.  */
 219     int struct_size;
 220
 221     /* The name of this HID.  This should be suitable for
 222        command line options, multi-selection menus, file names,
 223        etc. */
 224     const char *name;
 225
 226     /* Likewise, but allowed to be longer and more descriptive.  */
 227     const char *description;
 228
 229     /* If set, this is the GUI HID.  Exactly one of these three flags
 230        must be set; setting "gui" lets the expose callback optimize and
 231        coordinate itself.  */
 232     char gui:1;
 233
 234     /* If set, this is the printer-class HID.  The common part of PCB
 235        may use this to do command-line printing, without having
 236        instantiated any GUI HIDs.  Only one printer HID is normally
 237        defined at a time.  */
 238     char printer:1;
 239
 240     /* If set, this HID provides an export option, and should be used as
 241        part of the File->Export menu option.  Examples are PNG, Gerber,
 242        and EPS exporters.  */
 243     char exporter:1;
 244
 245     /* If set, the redraw code will draw polygons before erasing the
 246        clearances.  */
 247     char poly_before:1;
 248
 249     /* If set, the redraw code will draw polygons after erasing the
 250        clearances.  Note that HIDs may set both of these, in which case
 251        polygons will be drawn twice.  */
 252     char poly_after:1;
 253
 254     /* If set, the redraw code will dice the polygons, so that there
 255        are no clearances in any polygons.  */
 256     char poly_dicer:1;
 257
 258     /* Returns a set of resources describing options the export or print
 259        HID supports.  In GUI mode, the print/export dialogs use this to
 260        set up the selectable options.  In command line mode, these are
 261        used to interpret command line options.  If n_ret is non-NULL,
 262        the number of attributes is stored there.  */
 263     HID_Attribute *(*get_export_options) (int *n_ret_);
 264
 265     /* Export (or print) the current PCB.  The options given represent
 266        the choices made from the options returned from
 267        get_export_options.  Call with options == NULL to start the
 268        primary GUI (create a main window, print, export, etc)  */
 269     void (*do_export) (HID_Attr_Val * options_);
 270
 271     /* Parse the command line.  Call this early for whatever HID will be
 272        the primary HID, as it will set all the registered attributes.
 273        The HID should remove all arguments, leaving any possible file
 274        names behind.  */
 275     void (*parse_arguments) (int *argc_, char ***argv_);
 276
 277     /* This may be called outside of redraw to force a redraw.  Pass
 278        zero for "last" for all but the last call before control returns
 279        to the user (pass nonzero the last time).  If determining the
 280        last call is difficult, call *_wh at the end with width and
 281        height zero.  */
 282     void (*invalidate_wh) (int x_, int y_, int width_, int height_, int last_);
 283     void (*invalidate_lr) (int left_, int right_, int top_, int bottom_,
 284                            int last_);
 285     void (*invalidate_all) (void);
 286
 287     /* During redraw or print/export cycles, this is called once per
 288        layer (or layer group, for copper layers).  If it returns false
 289        (zero), the HID does not want that layer, and none of the drawing
 290        functions should be called.  If it returns true (nonzero), the
 291        items in that layer [group] should be drawn using the various
 292        drawing functions.  In addition to the MAX_LAYERS copper layer
 293        groups, you may select layers indicated by the macros SL_*
 294        defined above, or any others with an index of -1.  For copper
 295        layer groups, you may pass NULL for name to have a name fetched
 296        from the PCB struct.  The EMPTY argument is a hint - if set, the
 297        layer is empty, if zero it may be non-empty.  */
 298     int (*set_layer) (const char *name_, int group_, int _empty);
 299
 300     /* Drawing Functions.  Coordinates and distances are ALWAYS in PCB's
 301        default coordinates (1/100 mil at the time this comment was
 302        written).  Angles are always in degrees, with 0 being "right"
 303        (positive X) and 90 being "up" (positive Y).  */
 304
 305     /* Make an empty graphics context.  */
 306       hidGC (*make_gc) (void);
 307     void (*destroy_gc) (hidGC gc_);
 308
 309     /* Special note about the "erase" color: To use this color, you must
 310        use this function to tell the HID when you're using it.  At the
 311        beginning of a layer redraw cycle (i.e. after set_layer), call
 312        use_mask() to redirect output to a buffer.  Draw to the buffer
 313        (using regular HID calls) using regular and "erase" colors.  Then
 314        call use_mask(HID_MASK_OFF) to flush the buffer to the HID.  If
 315        you use the "erase" color when use_mask is disabled, it simply
 316        draws in the background color.  */
 317     void (*use_mask) (int use_it_);
 318     /* Flush the buffer and return to non-mask operation.  */
 319 #define HID_MASK_OFF 0
 320     /* Polygons being drawn before clears.  */
 321 #define HID_MASK_BEFORE 1
 322     /* Clearances being drawn.  */
 323 #define HID_MASK_CLEAR 2
 324     /* Polygons being drawn after clears.  */
 325 #define HID_MASK_AFTER 3
 326
 327     /* Set a color.  Names can be like "red" or "#rrggbb" or special
 328        names like "erase".  *Always* use the "erase" color for removing
 329        ink (like polygon reliefs or thermals), as you cannot rely on
 330        knowing the background color or special needs of the HID.  Always
 331        use the "drill" color to draw holes.  You may assume this is
 332        cheap enough to call inside the redraw callback, but not cheap
 333        enough to call for each item drawn. */
 334     void (*set_color) (hidGC gc_, const char *name_);
 335
 336     /* Set the line style.  While calling this is cheap, calling it with
 337        different values each time may be expensive, so grouping items by
 338        line style is helpful.  */
 339     void (*set_line_cap) (hidGC gc_, EndCapStyle style_);
 340     void (*set_line_width) (hidGC gc_, int width_);
 341     void (*set_draw_xor) (hidGC gc_, int xor_);
 342     /* Blends 20% or so color with 80% background.  Only used for
 343        assembly drawings so far. */
 344     void (*set_draw_faded) (hidGC gc_, int faded_);
 345
 346     /* When you pass the same x,y twice to draw_line, the end caps are
 347        drawn as if the "line" were parallel to the line defined by these
 348        coordinates.  Use this for rotating non-round pads.  */
 349     void (*set_line_cap_angle) (hidGC gc_, int x1_, int y1_, int x2_, int y2_);
 350
 351     /* The usual drawing functions.  "draw" means to use segments of the
 352        given width, whereas "fill" means to fill to a zero-width
 353        outline.  */
 354     void (*draw_line) (hidGC gc_, int x1_, int y1_, int x2_, int y2_);
 355     void (*draw_arc) (hidGC gc_, int cx_, int cy_, int xradius_, int yradius_,
 356                       int start_angle_, int delta_angle_);
 357     void (*draw_rect) (hidGC gc_, int x1_, int y1_, int x2_, int y2_);
 358     void (*fill_circle) (hidGC gc_, int cx_, int cy_, int radius_);
 359     void (*fill_polygon) (hidGC gc_, int n_coords_, int *x_, int *y_);
 360     void (*fill_pcb_polygon) (hidGC gc_, PolygonType *poly,
 361                               const BoxType *clip_box);
 362     void (*thindraw_pcb_polygon) (hidGC gc_, PolygonType *poly,
 363                                   const BoxType *clip_box);
 364     void (*fill_rect) (hidGC gc_, int x1_, int y1_, int x2_, int y2_);
 365
 366
 367     /* This is for the printer.  If you call this for the GUI, xval and
 368        yval are ignored, and a dialog pops up to lead you through the
 369        calibration procedure.  For the printer, if xval and yval are
 370        zero, a calibration page is printed with instructions for
 371        calibrating your printer.  After calibrating, nonzero xval and
 372        yval are passed according to the instructions.  Metric is nonzero
 373        if the user prefers metric units, else inches are used. */
 374     void (*calibrate) (double xval_, double yval_);
 375
 376
 377     /* GUI layout functions.  Not used or defined for print/export
 378        HIDs.  */
 379
 380     /* Temporary */
 381     int (*shift_is_pressed) (void);
 382     int (*control_is_pressed) (void);
 383     void (*get_coords) (const char *msg_, int *x_, int *y_);
 384
 385     /* Sets the crosshair, which may differ from the pointer depending
 386        on grid and pad snap.  Note that the HID is responsible for
 387        hiding, showing, redrawing, etc.  The core just tells it what
 388        coordinates it's actually using.  Note that this routine may
 389        need to know what "pcb units" are so it can display them in mm
 390        or mils accordingly.  If cursor_action is set, the cursor or
 391        screen may be adjusted so that the cursor and the crosshair are
 392        at the same point on the screen.  */
 393     void (*set_crosshair) (int x_, int y_, int cursor_action_);
 394 #define HID_SC_DO_NOTHING       0
 395 #define HID_SC_WARP_POINTER     1
 396 #define HID_SC_PAN_VIEWPORT     2
 397
 398     /* Causes func to be called at some point in the future.  Timers are
 399        only good for *one* call; if you want it to repeat, add another
 400        timer during the callback for the first.  user_data can be
 401        anything, it's just passed to func.  Times are not guaranteed to
 402        be accurate.  */
 403       hidval (*add_timer) (void (*func) (hidval user_data_),
 404                            unsigned long milliseconds_, hidval user_data_);
 405     /* Use this to stop a timer that hasn't triggered yet.  */
 406     void (*stop_timer) (hidval timer_);
 407
 408     /* Causes func to be called when some condition occurs on the file
 409        descriptor passed. Conditions include data for reading, writing,
 410        hangup, and errors. user_data can be anything, it's just passed
 411        to func. */
 412       hidval (*watch_file) (int fd_, unsigned int condition_, void (*func_) (hidval watch_, int fd_, unsigned int condition_, hidval user_data_),
 413         hidval user_data);
 414     /* Use this to stop a file watch. */
 415     void (*unwatch_file) (hidval watch_);
 416
 417     /* Causes func to be called in the mainloop prior to blocking */
 418       hidval (*add_block_hook) (void (*func_) (hidval data_), hidval data_);
 419     /* Use this to stop a mainloop block hook. */
 420     void (*stop_block_hook) (hidval block_hook_);
 421
 422     /* Various dialogs */
 423
 424     /* Log a message to the log window.  */
 425     void (*log) (const char *fmt_, ...);
 426     void (*logv) (const char *fmt_, va_list args_);
 427
 428     /* A generic yes/no dialog.  Returns zero if the cancel button is
 429        pressed, one for the ok button.  If you specify alternate labels
 430        for ..., they are used instead of the default OK/Cancel ones, and
 431        the return value is the index of the label chosen.  You MUST pass
 432        NULL as the last parameter to this.  */
 433     int (*confirm_dialog) (char *msg_, ...);
 434
 435     /* A close confirmation dialog for unsaved pages, for example, with
 436        options "Close without saving", "Cancel" and "Save". Returns zero
 437        if the close is cancelled, or one if it should proceed. The HID
 438        is responsible for any "Save" action the user may wish before
 439        confirming the close.
 440        */
 441     int (*close_confirm_dialog) ();
 442 #define HID_CLOSE_CONFIRM_CANCEL 0
 443 #define HID_CLOSE_CONFIRM_OK     1
 444
 445     /* Just prints text.  */
 446     void (*report_dialog) (char *title_, char *msg_);
 447
 448     /* Prompts the user to enter a string, returns the string.  If
 449        default_string isn't NULL, the form is pre-filled with this
 450        value.  "msg" is like "Enter value:".  */
 451     char *(*prompt_for) (char *msg_, char *default_string_);
 452
 453     /* Prompts the user for a filename or directory name.  For GUI
 454        HID's this would mean a file select dialog box.  The 'flags'
 455        argument is the bitwise OR of the following values.  */
 456 #define HID_FILESELECT_READ  0x01
 457
 458     /* The function calling hid->fileselect will deal with the case
 459        where the selected file already exists.  If not given, then the
 460        gui will prompt with an "overwrite?" prompt.  Only used when
 461        writing.
 462     */
 463 #define HID_FILESELECT_MAY_NOT_EXIST 0x02
 464
 465     /* The call is supposed to return a file template (for gerber
 466        output for example) instead of an actual file.  Only used when
 467        writing.
 468     */
 469 #define HID_FILESELECT_IS_TEMPLATE 0x04
 470
 471     /* title may be used as a dialog box title.  Ignored if NULL.
 472      *
 473      * descr is a longer help string.  Ignored if NULL.
 474      *
 475      * default_file is the default file name.  Ignored if NULL.
 476      *
 477      * default_ext is the default file extension, like ".pdf".
 478      * Ignored if NULL.
 479      *
 480      * history_tag may be used by the GUI to keep track of file
 481      * history.  Examples would be "board", "vendor", "renumber",
 482      * etc.  If NULL, no specific history is kept.
 483      *
 484      * flags are the bitwise or of the HID_FILESELECT defines above
 485      */
 486
 487     char *(*fileselect) (const char *title_, const char *descr_,
 488                          char *default_file_, char *default_ext_,
 489                          const char *history_tag_, int flags_);
 490
 491     /* A generic dialog to ask for a set of attributes.  If n_attrs is
 492        zero, attrs(.name) must be NULL terminated.  Returns non-zero if
 493        an error occurred (usually, this means the user cancelled the
 494        dialog or something). title is the title of the dialog box
 495        descr (if not NULL) can be a longer description of what the
 496        attributes are used for.  The HID may choose to ignore it or it
 497        may use it for a tooltip or text in a dialog box, or a help
 498        string.
 499     */
 500     int (*attribute_dialog) (HID_Attribute * attrs_,
 501                              int n_attrs_, HID_Attr_Val * results_,
 502                              const char * title_, const char * descr_);
 503
 504     /* This causes a second window to display, which only shows the
 505        selected item. The expose callback is called twice; once to size
 506        the extents of the item, and once to draw it.  To pass magic
 507        values, pass the address of a variable created for this
 508        purpose.  */
 509     void (*show_item) (void *item_);
 510
 511     /* Something to alert the user.  */
 512     void (*beep) (void);
 513
 514     /* Used by optimizers and autorouter to show progress to the user.
 515        Pass all zeros to flush display and remove any dialogs.
 516        Returns nonzero if the user wishes to cancel the operation.  */
 517     int (*progress) (int so_far_, int total_, const char *message_);
 518
 519   } HID;
 520
 521 /* Call this as soon as possible from main().  No other HID calls are
 522    valid until this is called.  */
 523   void hid_init (void);
 524
 525 /* When PCB runs in interactive mode, this is called to instantiate
 526    one GUI HID which happens to be the GUI.  This HID is the one that
 527    interacts with the mouse and keyboard.  */
 528   HID *hid_find_gui ();
 529
 530 /* Finds the one printer HID and instantiates it.  */
 531   HID *hid_find_printer (void);
 532
 533 /* Finds the indicated exporter HID and instantiates it.  */
 534   HID *hid_find_exporter (const char *);
 535
 536 /* This returns a NULL-terminated array of available HIDs.  The only
 537    real reason to use this is to locate all the export-style HIDs. */
 538   HID **hid_enumerate (void);
 539
 540 /* This function (in the common code) will be called whenever the GUI
 541    needs to redraw the screen, print the board, or export a layer.  If
 542    item is not NULL, only draw the given item.  Item is only non-NULL
 543    if the HID was created via show_item.
 544
 545    Each time func is called, it should do the following:
 546
 547    * allocate any colors needed, via get_color.
 548
 549    * cycle through the layers, calling set_layer for each layer to be
 550      drawn, and only drawing elements (all or specified) of desired
 551      layers.
 552
 553    Do *not* assume that the hid that is passed is the GUI hid.  This
 554    callback is also used for printing and exporting. */
 555   struct BoxType;
 556   void hid_expose_callback (HID * hid_, struct BoxType *region_, void *item_);
 557
 558 /* This is initially set to a "no-gui" gui, and later reset by
 559    hid_start_gui.  */
 560   extern HID *gui;
 561
 562 /* This is either NULL or points to the current HID that is being called to
 563         do the exporting. The gui HIDs set and unset this var.*/
 564   extern HID *exporter;
 565
 566 /* The GUI may set this to be approximately the PCB size of a pixel,
 567    to allow for near-misses in selection and changes in drawing items
 568    smaller than a screen pixel.  */
 569   extern int pixel_slop;
 570
 571 #if defined(__cplusplus) && __cplusplus
 572 }
 573 #endif
 574
 575 #endif