home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / gfx / misc / imagefx_sdk / include / scan / mod.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-18  |  22.6 KB  |  552 lines
  1. /*
  2.  * ImageFX Development Header File
  3.  * Copyright © 1991-1995 Nova Design, Inc.
  4.  * Written by Thomas Krehbiel
  5.  *
  6.  * ScanBase and ModuleBase.
  7.  *
  8.  */
  9.  
  10. #ifndef SCAN_MOD_H
  11.  
  12.  
  13. #ifndef EXEC_TYPES_H
  14. #include <exec/types.h>
  15. #endif
  16.  
  17. #ifndef EXEC_LIBRARIES_H
  18. #include <exec/libraries.h>
  19. #endif
  20.  
  21. #ifndef EXEC_SEMAPHORES_H
  22. #include <exec/semaphores.h>
  23. #endif
  24.  
  25. #ifndef LIBRARIES_DOS_H
  26. #include <libraries/dos.h>
  27. #endif
  28.  
  29. #ifndef SCAN_GED_H
  30. #include <scan/ged.h>
  31. #endif
  32. #ifndef SCAN_PREFS_H
  33. #include <scan/prefs.h>
  34. #endif
  35. #ifndef SCAN_CMD_H
  36. #include <scan/cmd.h>
  37. #endif
  38. #ifndef SCAN_BUF_H
  39. #include <scan/buf.h>
  40. #endif
  41.  
  42. /*
  43.  * Module Types, to be found in the Node->ln_Type field.  I think NT_USER
  44.  * is defined in exec/nodes.h
  45.  */
  46. #define NT_PREVIEW            (NT_USER-1)
  47. #define NT_SCANNER            (NT_USER-2)
  48. #define NT_RENDER             (NT_USER-3)
  49. #define NT_PRINTER            (NT_USER-4)
  50. #define NT_QUANTIZE           (NT_USER-5)
  51. #define NT_DITHER             (NT_USER-6)
  52. #define NT_LOADER             (NT_USER-7)
  53. #define NT_SAVER              (NT_USER-8)
  54. #define NT_HOOK               (NT_USER-9)
  55. #define NT_DRAWMODE           (NT_USER-10)
  56. #define NT_XDRAWMODE          (NT_USER-11)      /* extended drawmode (2.0) */
  57. #define NT_XDRAWSTYLE         (NT_USER-12)      /* extended drawstyle (2.0) */
  58. #define NT_SYSTEM             (NT_USER-13)
  59. #define NT_FEATHER            (NT_USER-14)      /* feather module (2.0) */
  60.  
  61. /*
  62.  * ModuleBase:
  63.  *
  64.  * This is an extension of a standard Library structure created by
  65.  * ImageFX for external modules (eg. scanners, printers, previews).
  66.  *
  67.  */
  68. struct ModuleBase
  69. {
  70.    struct Library       Library;       /* Standard Exec library */
  71.    UBYTE                Flags;         /* Generic Flags - see below */
  72.    BYTE                 pad;           /* was NumGads - now a pad */
  73.    BPTR                 Segment;       /* AmigaDos module segment */
  74.    struct Library      *SysLib;        /* Exec.library pointer */
  75.    struct ScanBase     *ScanBase;      /* scan.library pointer */
  76.    struct NewGad       *NewGad;        /* Pointer to custom gadgets */
  77.    struct GedContext    GContext;      /* Gadget context maintained by Scan */
  78.    char                *Language;      /* Scan.text "tag" for finding text */
  79.    char               **Text;          /* Text array loaded by Scan */
  80.    long                 LangCount;     /* Count of entries in text array */
  81.    RXCMD               *CmdTable;      /* Table of commands recognized */
  82.    ULONG                PrefID;        /* Prefs file identifier */
  83.    ULONG                PrefLen;       /* Length of prefs data chunk */
  84.    struct NewWindow    *NewWin;        /* NewWindow for preview options */
  85.    ULONG                ExtFlags;      /* Extended flags - future expansion */
  86.    APTR                 NewGC;         /* private */
  87.    ULONG                Attr;          /* XDrawMode/XDrawStyle attributes */
  88.    BYTE                 BufXO, BufYO;  /* For XDrawMode */
  89.    BYTE                 Iterations;    /* For XDrawMode */
  90.    BYTE                 pad2;
  91.    ULONG                Reserved[9];   /* Reserved for expansion */
  92.    /*
  93.     * 64 bytes of space are reserved here
  94.     * for information specific to the
  95.     * module.  Image Scan ignores this
  96.     * data but guarantees its integrity.
  97.     */
  98. };
  99.  
  100. /*
  101.  * Flag bits:
  102.  */
  103. #define MF_VISIBLE      (0x01)         /* Scan sets this flag when your
  104.                                           module is visible onscreen (ie.
  105.                                           the gadgets may be updated
  106.                                           without fear of crashing). */
  107. #define MF_TEXTLOADED   (0x02)         /* Text has been loaded */
  108. #define MF_EGS          (0x80)         /* Called from EGS ImageFX */
  109.  
  110. /*
  111.  * Extended flag bits:
  112.  */
  113. #define XF_MOUSETRAP    (0x01)         /* Module should be notified of
  114.                                           mouse button and movement events.
  115.                                           Your module's *_HandleMMove() and
  116.                                           *_HandleMButton() will be called
  117.                                           upon seeing mouse button/movement
  118.                                           events; you should return non-zero
  119.                                           if you processed the event yourself.
  120.                                           You are passed a pointer to a COPY
  121.                                           of the event, do not reply to it.
  122.                                           Only for Scanner, Render, Printer
  123.                                           modules. */
  124. #define XF_24BITREND    (0x02)         /* Rendered images are really 24-bit */
  125. #define XF_MOVEMENU     (0x04)         /* Preview module wants to be notified
  126.                                           when the menu panel moves, gets
  127.                                           hidden, or whatever. */
  128. #define XF_EXTENDEDINIT (0x08)         /* Preview module can handle extended
  129.                                           initialization routine */
  130. #define XF_GHOST        (0x10)         /* Preview module can ghost unused
  131.                                           areas of the screen */
  132. #define XF_STICKY       (0x20)         /* "Sticky" modules remain in memory,
  133.                                           currently only used for savers
  134.                                           such as ANIM and FLC */
  135. #define XF_IDENTIFY     (0x40)         /* Loader can identify headers */
  136. #define XF_LOADNOTIFY   (0x80)         /* Module can handle load notification -
  137.                                           a module vector will be called when
  138.                                           a new image is loaded, created,
  139.                                           whatever by the user */
  140. #define XF_LOADMASK     (0x100)        /* Loader supports LM_LoadMask (2.0 only) */
  141. #define XF_SAVEMASK     (0x200)        /* Saver supports SM_SaveMask (2.0 only) */
  142. #define XF_NEWDMODE     (0x400)        /* Extended Drawing Mode (2.0 only) */
  143. #define XF_LOADMAPPED   (0x800)        /* Loader supports LM_LoadMapped (2.0 only) */
  144.  
  145. #define XF_EGSCOMPAT    (0x8000)       /* Set this ExtFlag if your module
  146.                                           is definitely EGS-ImageFX compatible.
  147.                                           Otherwise, the user will be given
  148.                                           a warning whenever he uses your
  149.                                           module with EGS-ImageFX. (1.6 only) */
  150.  
  151. #define NumGads         pad            /* Ancient compatibility, do not use */
  152.  
  153. /*
  154.  * ScanBase:
  155.  *
  156.  * Library created and maintained by ImageFX.  Hook programs will open
  157.  * this library to gain access to ImageFX, and Modules will be passed
  158.  * a pointer to this library directly for accessing these functions.
  159.  *
  160.  * Most of these fields should be considered READ ONLY, except where
  161.  * noted otherwise.
  162.  *
  163.  */
  164. struct ScanBase
  165. {
  166.    struct Library          Library;       /* Standard Exec library */
  167.  
  168.    /*
  169.     * pScreen and pWindow can be used to access the ImageFX toolbox
  170.     * screen and window.  It is generally not advised that you render
  171.     * graphics to this screen, though.
  172.     */
  173.    struct Screen          *pScreen;       /* Pointer to menu panel screen */
  174.    struct Window          *pWindow;       /* Pointer to menu panel window */
  175.    struct RastPort        *pRPort;        /* Pointer to menu panel rastport
  176.                                              (NOTE:  It would be wiser to
  177.                                              access the RastPort through
  178.                                              pWindow.) */
  179.  
  180.    /*
  181.     * Prefs contains information about the current user preferences
  182.     * settings.
  183.     */
  184.    struct UserPrefs        Prefs;         /* User preferences settings
  185.                                              (see scan/prefs.h) */
  186.  
  187.    /*
  188.     * Amiga Library bases.
  189.     */
  190.    struct IntuitionBase   *IntuitionBase; /* Intuition.library base */
  191.    struct GfxBase         *GfxBase;       /* Graphics.library base */
  192.  
  193.    /*
  194.     * Do not set LastError directly; use the functions SetError()
  195.     * and GetError() to set and retreive the value.
  196.     */
  197.    unsigned long           LastError;     /* Global error variable */
  198.  
  199.    /*
  200.     * MainBuffer is a pointer to the visible buffer.  A new buffer may
  201.     * be installed by deleting the old one (with KillBuffer()) and
  202.     * providing a new pointer.  NULL indicates no main buffer.
  203.     */
  204.    struct Buffer          *MainBuffer;    /* Main (visible) buffer */
  205.  
  206.    /*
  207.     * SwapBuffer is a pointer to the hidden buffer.  A new buffer may
  208.     * be installed by deleting the old one (with KillBuffer()) and
  209.     * providing a new pointer.  NULL indicates no swap buffer.
  210.     */
  211.    struct Buffer          *SwapBuffer;    /* Swap (hidden) buffer */
  212.  
  213.    /*
  214.     * Text is a pointer to the text strings used by ImageFX.
  215.     */
  216.    char                  **Text;          /* Language text array */
  217.  
  218.    struct SignalSemaphore  Lock;          /* Arbitrate access to library (UNUSED) */
  219.  
  220.    /*
  221.     * Alpha is a pointer to the alpha channel buffer.  A new buffer may
  222.     * be installed by deleting the old one (with KillBuffer()) and
  223.     * providing a new pointer.  NULL indicates no alpha channel.
  224.     */
  225.    struct Buffer          *Alpha;         /* Alpha channel buffer */
  226.  
  227.    /********************** Additions in 0.53 ************************/
  228.  
  229.    /*
  230.     * These values show the current state of various tools and settings
  231.     * within ImageFX.  They should be considered READ ONLY.
  232.     */
  233.    signed char             sb_AreaTool;   /* Current region selection */
  234.    signed char             sb_DrawTool;   /* Current drawing tool */
  235.    unsigned char           sb_Channel;    /* Current channel mask setting */
  236.    signed char             sb_GuiLocked;  /* Are graphics locked? */
  237.  
  238.    signed char             sb_ArexxCmd;   /* Currently execute Arexx cmd? */
  239.    signed char             sb_Iconified;  /* Are we currently iconified? */
  240.  
  241.    signed char             sb_FillType;   /* Current fill type */
  242.    signed char             sb_FillRange1; /* Gradient fill range #1 */
  243.    signed char             sb_FillRange2; /* Gradient fill range #2 */
  244.    signed char             sb_FillSmooth; /* Gradient fills are smoothed? */
  245.    signed char             sb_FillSkew;   /* Gradient fill "skew" */
  246.    signed char             sb_FillRough;  /* Area fill "roughness" */
  247.    short                   sb_FloodClose; /* Flood fill "closeness" */
  248.    signed char             sb_LightTab;   /* LightTable on? */
  249.    signed char             sb_AlphaMask;  /* Use alpha as stencil/frisket? */
  250.  
  251.    signed char             sb_EdgeMode;   /* Current edge mode */
  252.    unsigned char           sb_EdgeDir;    /* Edge direction mask */
  253.    short                   sb_EdgeRadius; /* Edge radius affected */
  254.  
  255.    signed char             sb_Hidden;     /* Menu panel hidden? */
  256.    signed char             sb_TranspRange;/* Transparent range (OBSOLETE) */
  257.    short                   sb_TranspClose;/* Transparent "closeness" (OBSOLETE) */
  258.  
  259.    signed char             sb_AirRadius;  /* Airbrush radius */
  260.    signed char             sb_DrawMode;   /* Current drawing mode */
  261.    signed char             sb_DrawBlend;  /* Current blend setting */
  262.    signed char             sb_Mode;       /* Which menu we're in */
  263.  
  264.    short                   sb_GridX,      /* Grid Width */
  265.                            sb_GridY,      /* Grid Height */
  266.                            sb_GOffsetX,   /* Grid X Origin */
  267.                            sb_GOffsetY;   /* Grid Y Origin */
  268.  
  269.    /*
  270.     * sb_Brush contains a pointer to the current brush, or NULL if none
  271.     * is defined.  To install a new brush, you should use the scan.library
  272.     * function NewBrush() instead of setting this field directly.  NewBrush()
  273.     * handles rendering and refreshing the brush for you.
  274.     *
  275.     */
  276.    struct Buffer          *sb_Brush;      /* Current Brush */
  277.  
  278.    /*
  279.     * Module pointers are READ ONLY!
  280.     */
  281.    struct ModuleBase      *sb_Scanner;    /* The current Scanner module */
  282.    struct ModuleBase      *sb_Render;     /* The current Render module */
  283.    struct ModuleBase      *sb_Printer;    /* The current Printer module */
  284.  
  285.    /*
  286.     * sb_PubName is the name of the public screen which ImageFX is open
  287.     * on.  For a custom screen, this is created by ImageFX (eg. "IMAGEFX.1").
  288.     * When using WBMode, this is the name of the screen we opened on
  289.     * (eg. "DEFAULT").  READ ONLY!
  290.     *
  291.     * When opening a window on the ImageFX screen, you should open onto
  292.     * this public screen.
  293.     *
  294.     */
  295.    char                   *sb_PubName;    /* Public screen name */
  296.  
  297.    /*
  298.     * sb_ArexxName is the name of ImageFX's Arexx port (eg. "IMAGEFX.1").
  299.     * READ ONLY!
  300.     */
  301.    char                   *sb_ArexxName;  /* Arexx port name */
  302.  
  303.    /*
  304.     * sb_CurrentDir is a lock on the ImageFX directory.  READ ONLY!
  305.     */
  306.    BPTR                    sb_CurrentDir; /* Lock on Mirage current dir */
  307.  
  308.    /*
  309.     * sb_ThisTask is a pointer to ImageFX's Task structure.  READ ONLY!
  310.     */
  311.    struct Task            *sb_ThisTask;   /* Pointer to Mirage task */
  312.  
  313.    /*
  314.     * More internal settings.  READ ONLY!
  315.     */
  316.    char                    sb_DrawAlpha;  /* Alpha channel status for drawing */
  317.    char                    sb_AirDensity; /* Airbrush center density */
  318.    char                    sb_AirSmear;   /* Airbrush smear mode */
  319.  
  320.    /*
  321.     * sb_BackPen is the pen number to use when rendering background pixels
  322.     * on the toolbox menu.  Under normal circumstances this will be pen 0,
  323.     * but with Opaque Panel on, it could be different.  Always use this
  324.     * pen number instead of assuming 0.  READ ONLY!
  325.     *
  326.     *    EG:   // erase background
  327.     *          SetAPen(ScanBase->sb_BackPen);
  328.     *          RectFill(pWindow->RPort, left, top, width, height);
  329.     */
  330.    char                    sb_BackPen;    /* Menu panel background pen # */
  331.  
  332.    struct Screen          *sb_Shanghai;   /* "Shanghai" screen */
  333.  
  334.    /*
  335.     * More internal settings.  READ ONLY!
  336.     */
  337.    char                    sb_PenType;    /* Type of default pen */
  338.    char                    sb_PenSize;    /* Size of default pen */
  339.    char                    sb_AlphaTab;   /* Light table to swap or alpha? */
  340.    char                    sb_AirRough;   /* Airbrush roughness */
  341.  
  342.    /*
  343.     * When a Hook program is launched via. an Arexx command, sb_HookMsg
  344.     * contains the RexxMsg that was used to do so.  This can be used
  345.     * to set the result string via. the scan.library SetResult() function.
  346.     * READ ONLY!
  347.     *
  348.     */
  349.    struct RexxMsg         *sb_HookMsg;    /* Message that invokes a hook */
  350.  
  351.    /*
  352.     * Pointer to Preview Screen.  In 2.0, do not use this pointer.  Use
  353.     * sb_vWindow instead.  READ ONLY!
  354.     */
  355.    struct Screen          *sb_vScreen;    /* Preview screen, or NULL */
  356.  
  357.    /*
  358.     * sb_HelpLock is a lock on the directory where the help text resides.
  359.     * READ ONLY!
  360.     */
  361.    BPTR                    sb_HelpLock;   /* Where the help directory is */
  362.  
  363.    /*
  364.     * sb_HostPort is a pointer to ImageFX's Arexx port.  READ ONLY!
  365.     */
  366.    struct MsgPort         *sb_HostPort;   /* Scan arexx port */
  367.  
  368.    ULONG                   sb_Magic;      /* Magic constant, just for fun */
  369.  
  370.    /*
  371.     * sb_TextLock is a lock on the directory where ImageFX localization
  372.     * text resides.  READ ONLY!
  373.     */
  374.    BPTR                    sb_TextLock;   /* Text directory lock */
  375.  
  376.    /*
  377.     * More internal settings.  READ ONLY!
  378.     */
  379.    short                   sb_PantoDX;    /* Pantograph offsets */
  380.    short                   sb_PantoDY;
  381.  
  382.    short                   sb_PantoCX;    /* Pantograph center coords */
  383.    short                   sb_PantoCY;
  384.  
  385.    UBYTE                  *sb_PenArray;   /* Pen definition (DO NOT TOUCH) */
  386.    short                   sb_PenWidth;   /* Pen width (DO NOT TOUCH) */
  387.    short                   sb_PenHeight;  /* Pen height (DO NOT TOUCH) */
  388.  
  389.    UBYTE                  *sb_AirArray;   /* Airbrush definition (DO NOT TOUCH) */
  390.    short                   sb_AirWidth;   /* Airbrush width (DO NOT TOUCH) */
  391.    short                   sb_AirHeight;  /* Airbrush height (DO NOT TOUCH) */
  392.  
  393.    UBYTE                   sb_Exclusive;  /* Disable GUI - exclusive access */
  394.    UBYTE                   sb_AirRT;      /* Realtime airbrush - 2.0 only */
  395.    /*
  396.     * If sb_NoAttach is non-zero, when opening a new screen under OS V39+,
  397.     * you should NOT attempt to attach it to any of the ImageFX screens.
  398.     * This is controlled by the NOATTACHEDSCREENS tool type.
  399.     */
  400.    UBYTE                   sb_NoAttach;   /* Do not attach screens under 3.x */
  401.    UBYTE                   sb_DrawStyle;  /* Current drawing style */
  402.  
  403.    /*
  404.     * sb_LearnOpts is read after executing a module; any text found here
  405.     * is output to the macro recording file as options for the module.
  406.     * This should not be used by Hook programs.
  407.     *
  408.     */
  409.    char                    sb_LearnOpts[64];
  410.                                           /* A rather kludgy way to get loader
  411.                                              and saver options back to ImageFX
  412.                                              while learning - modules should
  413.                                              place a string here describing
  414.                                              the options used, and ImageFX
  415.                                              will grab the string and spit
  416.                                              it out to the learn file. */
  417.  
  418.    /********************** Additions in 1.6 (EGS) ************************/
  419.  
  420.    /*
  421.     * sb_BufList is a list of BufNode structures describing all the
  422.     * buffers in memory.  It should be considered READ ONLY.
  423.     */
  424.    struct MinList          sb_BufList;    /* Multiple buffer support */
  425.  
  426.    ULONG                   sb_NewFlags;   /* 2.0 flags */
  427.    char                   *sb_EnvDir;     /* Name of IFX's ENV: dir */
  428.  
  429.    /*
  430.     * Obviously, these are only used in the EGS version:
  431.     */
  432.    APTR                    sb_EWindow;    /* EGS windows */
  433.    APTR                    sb_MWindow;    /* only valid in EGS version */
  434.    APTR                    sb_PWindow;
  435.  
  436.    struct Library         *EGSIntuiBase;
  437.    struct Library         *EGSGfxBase;
  438.  
  439.    APTR                    sb_EScreen;    /* custom EGS screen or NULL */
  440.  
  441.    /********************** Additions in 2.0 ************************/
  442.  
  443.    /*
  444.     * sb_BrushList is a list of BufNode structures describing all the
  445.     * brushes in memory.  It should be considered READ ONLY.
  446.     */
  447.    struct MinList          sb_BrushList;  /* Multiple brush support */
  448.  
  449.    /*
  450.     * More internal settings.  READ ONLY!
  451.     */
  452.    UBYTE                   sb_Include,    /* Include range */
  453.                            sb_Exclude,    /* Exclude range */
  454.                            sb_TClose,     /* Transparency closeness */
  455.                            pad8;
  456.  
  457.    /*
  458.     * sb_BarSigs may be set by the programmer.  It is normally 0.
  459.     */
  460.    ULONG                   sb_BarSigs;    /* Signals to wait on for
  461.                                              manually processing the
  462.                                              status bar signals (eg.
  463.                                              the cancel button).  If you
  464.                                              get one of these signals,
  465.                                              call HandleBar() and if
  466.                                              it returns TRUE, the user
  467.                                              has cancelled. */
  468.  
  469.    /*
  470.     * sb_vWindow should be used instead of sb_vScreen.  sb_vWindow could
  471.     * be non-NULL when sb_vScreen is NULL (eg. Workbench preview).  When
  472.     * rendering to the preview window, always use sb_vWindow.
  473.     */
  474.    struct Window          *sb_vWindow;    /* Preview window, or NULL */
  475.                                           /* USE THIS INSTEAD OF vScreen!!! */
  476.  
  477.    /*
  478.     * DO NOT TOUCH
  479.     */
  480.    struct ModuleBase      *sb_PreviewBase;
  481.    struct ModuleBase      *sb_ScannerBase;
  482.    struct ModuleBase      *sb_RenderBase;
  483.    struct ModuleBase      *sb_PrinterBase;
  484.    struct ModuleBase      *sb_QuantizeBase;
  485.    struct ModuleBase      *sb_DitherBase;
  486.  
  487.    struct RexxMsg         *sb_GuiOnlyMsg; /* (FUTURE EXPANSION) */
  488.  
  489.    /*
  490.     * A kludge to allow us to read and write colormapped images directly,
  491.     * without having to load as 24-bit and then render them.  This is
  492.     * virtually guaranteed to change in the future, so it will remain
  493.     * undocumented.
  494.     */
  495.    struct MappedImage     *sb_RenderedImage;
  496.  
  497.    char                   *sb_PubScrName; /* (2.0) public name of screen on which
  498.                                              menu is open (if WBMode, this
  499.                                              is another screen, otherwise,
  500.                                              it is the screen ImageFX is
  501.                                              open on (eg. "IMAGEFX.1")). */
  502.  
  503.    ULONG                   reserved[6];  /* reserved for future expansion */
  504.  
  505.    /*
  506.     * ScanBase size increased in ImageFX 2.0!
  507.     */
  508. };
  509.  
  510. /* values for sb_Channel: */
  511. #define CHAN_ALL           (0xFF)
  512. #define CHAN_RED           (0x01)
  513. #define CHAN_GRN           (0x02)
  514. #define CHAN_BLU           (0x04)
  515.  
  516.  
  517. /* values for sb_NewFlags: */
  518. #define SBF_DISABLED       0x0001         /* status bar operation should
  519.                                              check LMB via. nasty hardware
  520.                                              method, because we're currently
  521.                                              disabled */
  522. #define SBF_BUTTONDOWN     0x0002         /* set when the LMB is currently
  523.                                              down during a drawing operation.
  524.                                              xdrawmodes & xdrawstyles can
  525.                                              use this information. */
  526. #define SBF_NOHOOKLEARN    0x0004         /* set if a hook has already
  527.                                              created a Learn statement
  528.                                              for itself, which disables
  529.                                              ImageFX's automatic creation
  530.                                              of a Learn statement. */
  531. #define SBF_GRIDENABLED    0x0008         /* 2.0: drawing grid enabled? */
  532. #define SBF_BRUSHIO        0x0010         /* 2.0: imagefx sets this flag when
  533.                                              the user requests a brush
  534.                                              load or save, as opposed to
  535.                                              an image load or save.  Loaders
  536.                                              and savers can use this information
  537.                                              to do special handling for
  538.                                              brushes */
  539.  
  540. #define MIRAGE_MAGIC      'TEK!'          /* Magic constant */
  541.  
  542. /*
  543.  * These defines have remained since the dawn of time.  Don't ask me why.
  544.  */
  545. #define pScreen            ScanBase->pScreen
  546. #define pWindow            ScanBase->pWindow
  547. #define pRPort             ScanBase->pRPort
  548. #define Prefs              ScanBase->Prefs
  549.  
  550. #define SCAN_MOD_H
  551. #endif
  552.