home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga Shareware Floppies / ma76.lha / MAShare76 / proged.lha / proged22 / installproged / sources / include / Ped.h
Encoding:
C/C++ Source or Header  |  1996-07-22  |  32.5 KB  |  1,250 lines
  1.  
  2. /******
  3.  * Includes
  4.  ******/
  5.  
  6. #include <exec/types.h>
  7. #include <exec/ports.h>
  8. #include <dos/dos.h>
  9. #include <intuition/screens.h>
  10.  
  11.  
  12.  
  13. /******
  14.  * Defines
  15.  ******/
  16.  
  17. #define ASM        __asm
  18. #define SAVEDS        __saveds
  19. #define RG(x)        register __ ## x
  20.  
  21. #define MAXCOLOR    256    /* Max # of colors. ProgED 2.0 can save up to 256 colours.
  22.                    1.0 & 1.1 releases could save only 32 colours. */
  23.  
  24. #define MAXDEPTH    8    /* Log2 of MAXCOLOR */
  25.  
  26. #define MAXREXXARGS    10    /* Max # of arguments for ARexx cmds */
  27.  
  28. #define MAXFILENAME    121    /* Max filename lenght */
  29.  
  30. #define    INSCHAR        1    /* UNDO: Insert char (INS) */
  31. #define REPCHAR        2    /* UNDO: Replace char (OVR) */
  32. #define    DELCHAR        3    /* UNDO: Delete char */
  33. #define    BACKCHAR    4    /* UNDO: Backspace char */
  34. #define    CUTLINE        5    /* UNDO: Cut line */
  35. #define    PASTELINE    6    /* UNDO: Paste line */
  36. #define    CLEARBLOCK    7    /* UNDO: Clear block */
  37. #define    CUTBLOCK    8    /* UNDO: Cut block */
  38. #define    PASTEBLOCK    9    /* UNDO: Paste block */
  39. #define REPLACE        10    /* UNDO: Replace */
  40. #define UPPERCASE    11    /* UNDO: Upper case char */
  41. #define LOWERCASE    12    /* UNDO: Lower case char */
  42. #define TOGGLECASE    13    /* UNDO: Toggle case char */
  43. #define SWAPLINE    14    /* UNDO: Swap lines */
  44. #define DOUBLELINE    15    /* UNDO: Double line */
  45. #define UPPERCASEBLOCK    16    /* UNDO: Upper case block */
  46. #define LOWERCASEBLOCK    17    /* UNDO: Lower case block */
  47. #define TOGGLECASEBLOCK    18    /* UNDO: Toggle case block */
  48. #define LAYOUTBLOCK    19    /* UNDO: Layout block */
  49. #define INDENTBLOCK    20    /* UNDO: Indent block */
  50. /* The followings are avaiable from ProgED 2.0 and above */
  51. #define DELEOL        21    /* UNDO: Delete EOL */
  52. #define    DELWORD        22    /* UNDO: Delete word */
  53. #define    BACKWORD    23    /* UNDO: Backspace word */
  54.  
  55. #define MAXMARKER    10    /* Max # of markers */
  56.  
  57. #define IND_MR        '0'    /* Words in Prefs.KeyWordInd[] MUST START with */
  58. #define IND_ML        '1'    /* one of this chars. They identify type of */
  59. #define IND_SR        '2'    /* indentation to assign at the word. */
  60. #define IND_SL        '3'    /* In ProgED 1.0 & 1.1 one of this chars */
  61. #define IND_MR_SR    '4'    /* should start the string. From 2.0 */
  62. #define IND_MR_SL    '5'    /* one of them must START the string. */
  63. #define IND_ML_SR    '6'
  64. #define IND_ML_SL    '7'
  65.  
  66. #define NO_SEL        0    /* If PEDWindow.Block=NO_SEL -> No block marked */
  67. #define BLOCK_SEL    1    /* If PEDWindow.Block=BLOCK_SEL -> Start of a block is marked */
  68. #define COLBLOCK_SEL    2    /* If PEDWindow.Block=COLBLOCK_SEL -> Start of a column block is marked */
  69.  
  70.  
  71.  
  72. /******
  73.  *
  74.  * Template structure
  75.  * ------------------
  76.  *
  77.  * It stores the activation string & the program to execute. This
  78.  * structure is linked via NextTemplate field in a list. The
  79.  * access pointer is stored in Template field of Prefs structure.
  80.  *
  81.  ******/
  82.  
  83. #define MAXTEMPLATE    21
  84.  
  85. struct MyTemplate
  86. {
  87.     char             Template[MAXTEMPLATE+1];
  88.     struct MyProgram    *Prg;
  89.     struct MyTemplate    *NextTemplate;
  90. };
  91.  
  92.  
  93.  
  94. /******
  95.  *
  96.  * Scanner structure
  97.  * -----------------
  98.  *
  99.  * It stores the scanners in a linked list accessible via Scan field
  100.  * of Prefs structure. In each structure you can find the BPTR to
  101.  * seglist of the scanner, the entry point to the scanner, the
  102.  * identification pattern for this scanner and the name of scanner.
  103.  *
  104.  ******/
  105.  
  106. #define MAXEXTSCAN    31
  107. #define MAXSCANNAME    121
  108.  
  109. struct MyScan
  110. {
  111.     BPTR         SegList;
  112.     ULONG        (* ASM ScanFunction)(RG(a0) char *,RG(a1) char *);
  113.     char         ScanExtension[MAXEXTSCAN+1],
  114.              Name[MAXSCANNAME+1];
  115.     struct MyScan    *NextScan;
  116. };
  117.  
  118.  
  119.  
  120. /******
  121.  *
  122.  * CommandData structure
  123.  * ---------------------
  124.  *
  125.  * An external cmd will receive this struct at each call.
  126.  *
  127.  ******/
  128.  
  129. struct CommandData
  130. {
  131.     char             *CommandLine;
  132.     void            **CommandArgs;
  133.     struct PEDWindow     *CurrentWindow,
  134.                  *FirstWindow;
  135.     struct Prefs         *CurrentPrefs;
  136.     LONG ASM (*ExecuteInternalCommand)(RG(a0) char *);
  137. };
  138.  
  139.  
  140.  
  141. /******
  142.  *
  143.  * MyProgram structure
  144.  * -------------------
  145.  *
  146.  * This structure stores a command (internal/external/shell or arexx).
  147.  * Each ProgED program is build up by a linked list of this structures
  148.  * linked via NextProgram field.
  149.  * The String field stores the command,Dir the current dir (used only
  150.  * if the cmd is of TYPE_SHELL or TYPE_AREXX). In Output field you can
  151.  * find the output file for TYPE_AREXX & TYPE_SHELL cmds (default CON:)
  152.  * Type specify type of cmd (see TYPE_xxx defines). Async field is
  153.  * TRUE if a TYPE_SHELL cmd have to be runned async.
  154.  * If Shanghai is TRUE then the command (SHELL/AREXX) must be runned
  155.  * in shanghai mode (ProgED screen became the default public screen).
  156.  * Secs specify the number of seconds of shanghai mode (if it's
  157.  * enabled).
  158.  * NOTE: From ProgED 1.0/1.1 this structure is changed due to
  159.  * introduction of Shanghai & Secs fields.
  160.  *
  161.  ******/
  162.  
  163. #define    TYPE_DUMMY    0
  164. #define    TYPE_INTERNAL    1
  165. #define    TYPE_SHELL    2
  166. #define    TYPE_AREXX    3
  167. #define    TYPE_TEXT    4
  168.  
  169. struct MyProgram
  170. {
  171.     char            *String,
  172.                 *Dir,
  173.                 *Output;
  174.     UBYTE             Type,
  175.                  Async,
  176.                  Shanghai,
  177.                  Secs;
  178.     struct MyProgram    *NextProgram;
  179. };
  180.  
  181.  
  182.  
  183. /******
  184.  *
  185.  * APIClient structure
  186.  * --------------
  187.  *
  188.  * APIClient stores API clients. In each structure you can find the
  189.  * MsgPort  (ac_ClientPort), notify flags (ac_Notify), name (ac_Name)
  190.  * of this client.
  191.  * The ac_Next field links up a list of clients. The access pointer
  192.  * to the list is the Clients field of Prefs structure.
  193.  *
  194.  * This structure have to be used when a new client want to 
  195.  * register itself at API ProgED port.
  196.  *
  197.  ******/
  198.  
  199. struct APIClient
  200. {
  201.     struct MsgPort        *ac_ClientPort;
  202.     ULONG             ac_Notify;    /* See NOTIFY_xxx defines */
  203.     char            *ac_name;
  204.     struct APIClient    *ac_Next;
  205. };
  206.  
  207. #define    NOTIFY_ON_SHOW_HIDE    0x00000001    /* Notify if ProgED closes & opens its screen */
  208. #define    NOTIFY_ON_KEY        0x00000002    /* Notify each key pressed */
  209.  
  210.  
  211.  
  212. /******
  213.  *
  214.  * APIMessage structure
  215.  * --------------------
  216.  *
  217.  * A client must use this structure to communicate with ProgED.
  218.  * Type of message is in am_MsgType field. The am_MsgArg[] array
  219.  * is used to communicate the message arguments'. am_RC specify
  220.  * the return code (see RC_xxx defines).
  221.  *
  222.  ******/
  223.  
  224. struct APIMessage
  225. {
  226.     struct Message         am_Message;
  227.     ULONG             am_MsgType,
  228.                  am_MsgArg[10],
  229.                  am_RC;
  230. };
  231.  
  232. /* This defines specify msg that ProgED can send to the clients.
  233.    Noone needs arguments */
  234.  
  235. #define PED_API_QUIT    0x80000000    /* PED is quitting -> quit yourself */
  236. #define PED_API_HIDE    0x80000001    /* PED is closing its screen -> close your windows */
  237. #define PED_API_SHOW    0x80000002    /* PED is opening its screen -> open your windows */
  238. #define PED_API_KEY    0x80000003    /* A key was pressed */
  239.  
  240. /* This defines specify msg that a client can send to ProgED */
  241.  
  242. #define    PED_API_REGISTER        0x90000000    /* Register me. Arg[0] = &struct APIClient */
  243. #define    PED_API_UNREGISTER        0x90000001    /* Unregister me. Arg[0] = &struct APIClient */
  244.  
  245. #define PED_API_ADD_INTERNAL_COMMAND    0x90000002    /* Add an external cmd: Arg[0] = &struct ArexxExtCmds */
  246. #define PED_API_REM_INTERNAL_COMMAND    0x90000003    /* Remove an ext cmd: Arg[0] =&struct ArexxExtCmds */
  247.  
  248. #define PED_API_GET_ACTIVE_WINDOW    0x90000004    /* Get active window */
  249. #define PED_API_GET_WINDOW_LIST        0x90000005    /* Get first window */
  250. #define PED_API_GET_SCREEN_ADDRESS    0x90000006    /* Get screen address */
  251. #define PED_API_GET_PREFS_ADDRESS    0x90000007    /* Get prefs address */
  252. #define PED_API_GET_PUBSCRNAME        0x90000008    /* Get screen name */
  253.  
  254.  
  255.  
  256. /******
  257.  *
  258.  * Menus structures
  259.  * ----------------
  260.  *
  261.  * ProgED stores its menus using this structures. They builds up a tree
  262.  * like Intuition menus tree.
  263.  *
  264.  * Description:
  265.  *
  266.  * MyMenu
  267.  * ------
  268.  *
  269.  * Name:    String to be used in rendering.
  270.  * Items:    Points to items of this menu.
  271.  * NextMenu:    Next menu :-)
  272.  *
  273.  *
  274.  * MyItem
  275.  * ------
  276.  *
  277.  * Name:    String to be used in rendering.
  278.  * Key:        String or char to render hotkey of this item.
  279.  * Subs:    Subitems of this item.
  280.  * Prgs:    ProgED Program to be executed at each activation of this item.
  281.  * CheckType:    See CHECK_xxx defines. If this field not is equal to
  282.  *        CHECK_NONE then this item is a check item. The value
  283.  *        defines the preference flag to be used in rendering.
  284.  * NextItem:    Next item ( Noooooo! Really? )
  285.  *
  286.  *
  287.  * MySub
  288.  * ------
  289.  *
  290.  * Name:    String to be used in rendering.
  291.  * Key:        String or char to render hotkey of this subitem.
  292.  * Prgs:    ProgED Program to be executed at each activation of this subitem.
  293.  * CheckType:    See CHECK_xxx defines. If this field not is equal to
  294.  *        CHECK_NONE then this item is a check item. The value
  295.  *        defines the preference flag to be used in rendering.
  296.  * NextSub:    Next subitem ( I waited for it... )
  297.  *
  298.  * The access pointer to the tree can be find in Menu field of Prefs structure.
  299.  *
  300.  ******/
  301.  
  302. #define MAXMENUNAME    30
  303.  
  304. struct MyMenu
  305. {
  306.     char             Name[MAXMENUNAME+1];
  307.     struct MyItem        *Items;
  308.     struct MyMenu        *NextMenu;
  309. };
  310.  
  311. struct MyItem
  312. {
  313.     char             Name[MAXMENUNAME+1];
  314.     char             Key[MAXMENUNAME+1];
  315.     struct MySub        *Subs;
  316.     struct MyProgram    *Prg;
  317.     UBYTE             CheckType;
  318.     struct MyItem        *NextItem;
  319. };
  320.  
  321. struct MySub
  322. {
  323.     char             Name[MAXMENUNAME+1];
  324.     char             Key[MAXMENUNAME+1];
  325.     struct MyProgram    *Prg;
  326.     UBYTE             CheckType;
  327.     struct MySub        *NextSub;
  328. };
  329.  
  330. #define CHECK_NONE        0
  331. #define CHECK_USEKEYWORDCOL    1
  332. #define CHECK_USECOMMENT1COL    2
  333. #define CHECK_USECOMMENT2COL    3    /* From ProgED 2.0 I changed CHECK_xxx */
  334. #define CHECK_ERASERIGHT    4    /* flags due to the "splitting" of */
  335. #define CHECK_SHOWCURPOS    5    /* CHECK_USECOMMENT flag into the */
  336. #define CHECK_SHOWPATHNAME    6    /* couple CHECK_USECOMMENT1 and */
  337. #define CHECK_AUTOARRANGEVER    7    /* CHECK_USECOMMENT2. */
  338. #define CHECK_AUTOARRANGEHOR    8
  339. #define CHECK_ARRANGEFAVOURITE    9
  340. #define CHECK_USEBACKUP        10
  341. #define CHECK_SAFESAVE        11
  342. #define CHECK_UNFOLDGOTOMARKER    12
  343. #define CHECK_UNFOLDGOTOLINE    13
  344. #define CHECK_UNFOLDGOTOBYTE    14
  345. #define CHECK_UNFOLDGOTOSCAN    15
  346. #define CHECK_UNFOLDSEARCH    16
  347. #define CHECK_AUTOFOLD        17
  348. #define CHECK_USEKWINDENTATION    18
  349. #define CHECK_FASTLOADING    19
  350. #define CHECK_USECLOCK        20
  351. #define CHECK_BLANKBORDERS    21
  352. #define CHECK_AUTORELOAD    22
  353. #define CHECK_AUTORELOADPRJ    23
  354. #define CHECK_USEMOUSEBLANKER    24
  355. #define CHECK_USEAPPICON    25
  356. #define CHECK_USEAPPITEM    26
  357. #define CHECK_SETDEFPUBSCR    27
  358. #define CHECK_USETEMPLATE    28
  359. #define CHECK_USEAUTOCASE    29
  360. #define CHECK_NUM        30
  361.  
  362.  
  363.  
  364. /******
  365.  *
  366.  * MyKey structure
  367.  * ---------------
  368.  *
  369.  * This structure stores the programs to be executed at each key pressed.
  370.  * In Qual & Code fields you can find the Intuition Qualifier & Code
  371.  * Activation values. Prg points to a MyProgram structure that ProgED
  372.  * will execute at the activation. NextKey points to the next structure
  373.  * of the list. The access pointer is the Key field of Prefs structure.
  374.  *
  375.  ******/
  376.  
  377. struct MyKey
  378. {
  379.     ULONG             Qual,
  380.                  Code;
  381.     struct MyProgram    *Prg;
  382.     struct MyKey        *NextKey;
  383. };
  384.  
  385.  
  386.  
  387. /******
  388.  *
  389.  * Event structure
  390.  * ---------------
  391.  *
  392.  * An array of this structures builds up the UNDO queue.
  393.  * I think that noone is interested in its contents, so I
  394.  * will not describe it. Perhaps I will do it later ... :-(
  395.  *
  396.  ******/
  397.  
  398. struct Event
  399. {
  400.     UBYTE         Type;
  401.     UBYTE         Arg1;
  402.     char        *Arg2;
  403.     ULONG         Arg3,
  404.              Arg4,
  405.              Arg5,
  406.              Arg6,
  407.              Arg7;
  408.     LONG         Col,
  409.              Line;
  410. };
  411.  
  412.  
  413.  
  414. /******
  415.  *
  416.  * Folder structure
  417.  * ---------------
  418.  *
  419.  * This structure stores each text fold's. Each text has a linker list
  420.  * of this structures in Folder field of PEDText structure. If a line
  421.  * is in a fold its Folder field points to a Folder structure, too.
  422.  *
  423.  * Description
  424.  * -----------
  425.  *
  426.  * Name:    Name of the fold. It will be used in rendering.
  427.  * Num:        # of lines folded.
  428.  * Line:    Pointer to the line of the cursor at fold time.
  429.  * Col:        # of column of the cursor at fold time.
  430.  * Start:    First line of the fold.
  431.  * Stop:    Last line of the fold.
  432.  * NextFolder:    This field links up a list of this structures.
  433.  *
  434.  ******/
  435.  
  436. #define MAXFOLDNAME    49
  437.  
  438. struct Folder
  439. {
  440.     char         Name[MAXFOLDNAME+1];
  441.     long         Num;
  442.     struct Line    *Line;
  443.     long         Col;
  444.     struct Line    *Start,
  445.             *End;
  446.  
  447.     struct Folder    *NextFolder;
  448. };
  449.  
  450.  
  451.  
  452. /******
  453.  *
  454.  * Marker structure
  455.  * ----------------
  456.  *
  457.  * The Marker structure stores a position of the text (yeah!)
  458.  * The Line field points to the line while the Col field contains
  459.  * the column number.
  460.  *
  461.  ******/
  462.  
  463. struct Marker
  464. {
  465.     struct Line    *Line;
  466.     long         Col;
  467. };
  468.  
  469. /* This structure contains the "static" markers. This new type of
  470.    markers are saved together the file. You can access to the list
  471.    list of the "static" markers using the field "LMarker" of the
  472.    PEDText structure. */
  473. struct LinkedMarker
  474. {
  475.     struct Line        *Line;    /* Pointer to the line */
  476.     long             Col;    /* Column */
  477.     struct LinkedMarker    *Next;    /* Pointer to next structure */
  478. };
  479.  
  480.  
  481.  
  482. /******
  483.  *
  484.  * ArexxExtCmds structure
  485.  * ----------------------
  486.  *
  487.  * This structures stores datas about the internal & external cmds.
  488.  * It have to be used when a client wants to add an external cmd.
  489.  *
  490.  * Description:
  491.  * ------------
  492.  *
  493.  * External:    Set up to TRUE,never FALSE.
  494.  * Name:    Name of the command.
  495.  * Template:    ReadArgs Template's of the command.
  496.  * Default:    Array of the default values.
  497.  * CommFunc:    Pointer to the external function. This, generally,
  498.  *        is in the code of the client (REMEMBER TO USE __saveds option!)
  499.  * NextCmd:    Don't use it ! ):-|
  500.  *
  501.  ******/
  502.  
  503. struct ArexxExtCmds
  504. {
  505.     UBYTE             External;
  506.     char            *Name;
  507.     char            *Template;
  508.     void            *Defaults[MAXREXXARGS];
  509.     LONG ASM        (*CommFunc)( RG(a0) struct CommandData *);
  510.     struct ArexxExtCmds    *NextCmd;
  511. };
  512.  
  513.  
  514.  
  515. /******
  516.  *
  517.  * Line structure
  518.  * --------------
  519.  *
  520.  * The Line structure stores a line of the text. The field Buffer
  521.  * points to a zero termined string (the line itself).
  522.  * The PrevLine & NextLine pointers points to the next & previous
  523.  * line (I'm a genious, isn't it ? ). If the line is folded the Folder
  524.  * field point to the relative Folder structure. If the line isn't
  525.  * folded it contains NULL.
  526.  *
  527.  ******/
  528.  
  529. struct Line
  530. {
  531.     char        *Buffer;
  532.     struct Line    *PrevLine,
  533.             *NextLine;
  534.     struct Folder    *Folder;
  535. };
  536.  
  537.  
  538.  
  539. /******
  540.  *
  541.  * PEDText structure
  542.  * -----------------
  543.  *
  544.  * This structure stores a text.
  545.  *
  546.  * Description:
  547.  * ------------
  548.  *
  549.  * Filename:    Name of the file loaded (with PATH!).
  550.  * MaxCol:    Number of columns.
  551.  * MaxLine:    Number of lines.
  552.  * Size:    Lenght of the text.
  553.  * Changes:    Changes from last save.
  554.  * FirstLine:    Pointer to the first line of text.
  555.  * LastLine:    I must write it?
  556.  * Events:    Pointer to the Events array to be used for undo.DON'T TOUCH!
  557.  * LastEvent:    DON'T TOUCH!
  558.  * NumEvent:    DON'T TOUCH!
  559.  * NumRedo:    DON'T TOUCH!
  560.  * UndoLevels:    Undo queue lenght.
  561.  * Folder:    Pointer to the first folder of this text.
  562.  * LinesFolded:    Lines not visible (because folds).
  563.  * NumFolds:    Number of folds (lenght of list accessible via Folder field).
  564.  * AutoSave:    This is a timer. When it reaches zero then an autosave occurs.
  565.  * DateStamp:    Date of last change.
  566.  * THE FOLLOWINGS FIELDS ARE PRESENT FROM 2.0 RELEASE
  567.  * MemoryPool:    MemoryPool used to allocate the memory for the text.
  568.  * StickyReply: DON'T TOUCH!
  569.  * FileType:    Pointer to the FileType structure of this text.
  570.  * LMarker:    Pointer to the first "static" marker of this text.
  571.  * UntitledFlag:TRUE if this is a "fresh" text (Untitled yet).
  572.  *
  573.  ******/
  574.  
  575. struct PEDText
  576. {
  577.     char         FileName[200];
  578.  
  579.     LONG         MaxCol,
  580.              MaxLine;
  581.  
  582.     ULONG         Size;
  583.  
  584.     ULONG         Changes;
  585.  
  586.     struct Line    *FirstLine,
  587.             *LastLine;
  588.  
  589.     struct Event     *Events;
  590.     LONG         LastEvent;
  591.     ULONG         NumEvent,
  592.              NumRedo,
  593.              UndoLevels;
  594.  
  595.     struct Folder    *Folder;
  596.     int         LinesFolded;
  597.     int         NumFolds;
  598.  
  599.     ULONG         AutoSave;
  600.  
  601.     struct DateStamp DateStamp;
  602.  
  603.     APTR         MemoryPool;
  604.  
  605.     APTR         StickyReply;
  606.  
  607.     struct FileType    *FileType;
  608.  
  609.     struct LinkedMarker *LMarker;
  610.  
  611.     UBYTE         UntitledFlag;
  612. };
  613.  
  614.  
  615.  
  616. /******
  617.  *
  618.  * PEDWindow structure
  619.  * -------------------
  620.  *
  621.  * This structure stores datas about ProgED windows'.
  622.  *
  623.  * Description:
  624.  * ------------
  625.  *
  626.  * Window:        Intuition window. It can be NULL, however. It happens
  627.  *            if the window is freezed.
  628.  * GadgetScrollX,
  629.  * GadgetScrollY,
  630.  * GadgetUpArrow,
  631.  * GadgetDownArrow,
  632.  * GadgetLeftArrow,
  633.  * GadgetRightArrow:    Pointers to the scrollers and arrows gadgets.
  634.  * ImageUpArrow,    
  635.  * ImageDownArrow,
  636.  * ImageLeftArrow,
  637.  * ImageRightArrow:    Pointer to arrows images'.
  638.  * OldSx,OldSy:        Stores position of the text in window at last refresh.
  639.  * Sx,Sy:        Position of text in window.
  640.  * Text:        Pointer to the text (structure PEDText).
  641.  * NumCol:        Number of visible columns.
  642.  * NumLine:        Number of visible lines.
  643.  * Left,
  644.  * Right,
  645.  * Width,
  646.  * Height:        Store windows info when ProgED needs close its screen.
  647.  * ZoomInfo:        Store intuition zoom data.
  648.  * Title:        Title of this window. ProgED refresh it when needed.
  649.  * CursorCol,
  650.  * CursorLine:        Position of the cursor in the text.
  651.  * LastCursorCol:    Column of the cursor at last insert.
  652.  * MLine:        TRUE=Lines block,FALSE=normal block.
  653.  * Block:        See COL_xxx defines.
  654.  * BlockLine:        Line number of start.
  655.  * BlockCol:        Column number of start.
  656.  * Line:        Pointer to the line of the cursor.
  657.  * RealNumCol:        Lenght of the line buffer.
  658.  * LogicNumCol:        Lenght of the line (it's greather than RealNumCol,
  659.  *             because TABs can use more space than 1 column!).
  660.  * FWidth:        Chars Width of text font.
  661.  * FHeight:        Chars Height of text font.
  662.  * FBase:        Chars Baseline of text font.
  663.  * WOffsetX:        Offset X from window left border.
  664.  * WOffsetY:        Offset Y from window top border.
  665.  * RP:            window rastport.
  666.  * Ins:            TRUE=insert mode, FALSE=overwrite mode.
  667.  * CuttedLine:        Pointer to line clipboard (NULL=empty).
  668.  * Marker:        Array of markers for this window.
  669.  * Frozen:        TRUE=window frozen,FALSE=window open.
  670.  * Locked:        If this field is >0 then the window is locked!
  671.  *            NOTE: If this window is "splitted" you MUST look
  672.  *            at split master window to read this field! Since
  673.  *            the SplitMaster field of a split master window
  674.  *            points to the master itself you should use ALWAYS:
  675.  *
  676.  *                [window pointer]->SplitMaster->Locked
  677.  *
  678.  *            to read this field. If you don't use it you
  679.  *            can manipulate a locked text!
  680.  * OldLine,
  681.  * LineBuffer,
  682.  * Pun,
  683.  * InsLine,
  684.  * Warn:        Fields used when a handler loads the file in this window.
  685.  * OldKeys:        Last keys pressed in this window. Useful for template checks.
  686.  * PunOldKeys:        Points to the last key in OldKeys array.
  687.  * NextSplit:        If this field isn't NULL then this window was splitted.
  688.  *            This field links up a list of twins windows.
  689.  *            The first window in this list owns the text, while
  690.  *            others can ONLY use it but not free it!
  691.  * SplitMaster:        This field points to the text owner of the twins windows.
  692.  *            Generally this field points to the structure itself
  693.  *            (generally the text owner is the window itself!).
  694.  *            if a window isn't the text owner then this field
  695.  *            points to the window that own it.
  696.  *            Yeah! I know, it's crazy... But it's the truth...
  697.  * NextWindow:        Points to the next window.
  698.  * UserData:        If you need to add data in a window use this array...
  699.  * CurBitMap:        DON'T TOUCH THIS! (From V2.0)
  700.  *
  701.  ******/
  702.  
  703. struct PEDWindow
  704. {
  705.     struct Window    *Window;
  706.  
  707.     struct Gadget    *GadgetScrollX,
  708.             *GadgetScrollY,
  709.             *GadgetUpArrow,
  710.             *GadgetDownArrow,
  711.             *GadgetLeftArrow,
  712.             *GadgetRightArrow;
  713.  
  714.     struct Image    *ImageUpArrow,
  715.             *ImageDownArrow,
  716.             *ImageLeftArrow,
  717.             *ImageRightArrow;
  718.  
  719.     int         OldSx,
  720.              OldSy,
  721.              Sx,
  722.              Sy;
  723.  
  724.     struct PEDText    *Text;
  725.  
  726.     LONG         NumCol,
  727.              NumLine;
  728.  
  729.     WORD         Left,
  730.              Top,
  731.              Width,
  732.              Height;
  733.  
  734.     WORD         ZoomInfo[4];
  735.  
  736.     char         Title[200];
  737.  
  738.     LONG         CursorCol;
  739.     LONG         CursorLine;
  740.     LONG         LastCursorCol;
  741.  
  742.     UBYTE         MLine,
  743.              Block;
  744.     LONG         BlockLine,
  745.              BlockCol;
  746.  
  747.     struct Line    *Line;
  748.     UWORD         RealNumCol;
  749.     UWORD         LogicNumCol;
  750.  
  751.     UWORD         FWidth,
  752.              FHeight,
  753.              FBase,
  754.              WOffsetX,
  755.              WOffsetY;
  756.     struct RastPort *RP;
  757.  
  758.     UBYTE         Ins;
  759.  
  760.     char        *CuttedLine;
  761.  
  762.     struct Marker     Marker[MAXMARKER];
  763.  
  764.     UBYTE         Frozen;
  765.  
  766.     ULONG         Locked;
  767.  
  768.     struct Line    *OldLine;
  769.     UBYTE        *LineBuffer,
  770.             *Pun,
  771.              InsLine,
  772.              Warn;
  773.  
  774.     UBYTE         OldKeys[MAXTEMPLATE];
  775.     UBYTE         PunOldKeys;
  776.  
  777.     struct PEDWindow *NextSplit,
  778.              *SplitMaster;
  779.  
  780.     struct PEDWindow *NextWindow;
  781.  
  782.     ULONG         UserData[16];
  783.  
  784.     struct BitMap    *CurBitMap;
  785. };
  786.  
  787.  
  788.  
  789. /******
  790.  *
  791.  * FileType structure
  792.  * ------------------
  793.  *
  794.  * This structure stores datas about ProgED filetypes. From 2.0.
  795.  *
  796.  * Description:
  797.  * ------------
  798.  *
  799.  * Node:        DON'T TOUCH THIS!
  800.  * Label:        Label used to name the filetype.
  801.  * Pattern:        AmigaDOS pattern of files.
  802.  * UseKeyWordColors:    TRUE=activate keywords colors.
  803.  * KeyAlpha:        DON'T TOUCH THIS!
  804.  * KeyWord:        Pointer to an array containing the keywords.
  805.  * NumKeyWord:        Number of keyword in KeyWord array.
  806.  * GestColorOff:    This is the charS that disable keywords colors.
  807.  * GestColorOn:        See GestColorOff... From 2.0 these fields are
  808.  *            arrays.
  809.  * UseComment1Colors:    TRUE=activate comments colors across lines.
  810.  * UseComment2Colors:    TRUE=activate comments colors on single line.
  811.  * ColorAllLine:    TRUE=color all line on "single line comments".
  812.  * CheckColorLines:    # of lines checked for a comment.
  813.  * Comment1Pen:        Pen to be used rendering the (*-*) comment.
  814.  * Comment2Pen:        Pen to be used rendering the // comment.
  815.  * Comment1On:        Comment initial string.
  816.  * Comment2Off:        Comment final string.
  817.  * Comment2On:        Comment initial string for // comment.
  818.  * DefBits:        Default bits of saved file.
  819.  * CreateIcons:        TRUE=Create icons at save.
  820.  * DefComment:        Comment of saved file.
  821.  * SearchFoldFileName:    Name of filename of the external folder.
  822.  * SearchFoldSeg:    Seglist of the folder.
  823.  * SearchFold:        Pointer to the function into the seglist.
  824.  * FoldStartStr:    Start string. Used (optionally) by the folder.
  825.  * FoldStopStr:        Stop string. Used (optionally) by the folder.
  826.  * UseKeyWordInd:    TRUE=Use keyword indentation.
  827.  * KeyWordInd:        Array of keywords needed for indentation.
  828.  * NumKeyWordInd:    Number of keywords in KeyWordInd array.
  829.  * Template:        Pointer to first Template structure.
  830.  * UseTemplate:        TRUE=Activate templates.
  831.  * Brackets:        Pointer to an array containing the brackets strings
  832.  *            for brackets match.
  833.  * NumBrackets:        Number of strings in Brackets array.
  834.  * DictWord:        Pointer to an array containing the dictionary words.
  835.  * NumDictWord:        Number of word in DictWord array.
  836.  * UseAutoCase:        TRUE=Activate autocase.
  837.  * GestCaseOff:        Case management off chars.
  838.  * GestCaseOn:        Case management on chars.
  839.  * UseAutoSave:        TRUE=Activate autosave.
  840.  * MinAutoSave:        Number of minutes for autosave.
  841.  *            it simply load file slowly.
  842.  * EraseRight:        TRUE=erase blanks & tabs on the right.
  843.  * Backup:        TRUE=create backup at save.
  844.  * BackupDir:        Dir to store backups. If it's empty ProgED
  845.  *            will use the dir used to save file.
  846.  * SaveRefs:        TRUE=Save related referements.
  847.  * RefsDir:        Dir to store refs. If it's empty ProgED
  848.  *            will use the dir used to save file.
  849.  * CheckPar:        TRUE=Activate () check on lines.
  850.  * Left,
  851.  * Right:        Column borders used in block layouting.
  852.  * Tab:            Size of tabs.
  853.  * IndJump:        # of chars per levels of indentation.
  854.  *            Better if you set it equal to Tab size.
  855.  * AutoFold:        TRUE=Auto fold all functions in text at load.
  856.  * InsStart:        Ins flag at window creation. TRUE=ins,FALSE=ovr.
  857.  * TabEqSpace:        TRUE=tab equal spaces.
  858.  * WordWrapping:    TRUE=Word wrapping active.
  859.  * RightWW:        Right margin for word wrapping.
  860.  * SaveMarkers:        TRUE=Save "static" markers together files.
  861.  * RefsDir:        Dir to store markers files. If it's empty ProgED
  862.  *            will use the dir used to save file.
  863.  * SeparatorsString:    Specify separators.
  864.  * SepChar[256]:    Table of separators.
  865.  * AutoReLoad:        TRUE=Reload files opened at last quit.
  866.  * NextFileType:    Pointer to the next filetype of the list.
  867.  *
  868.  ******/
  869.  
  870. #define MAXFILETYPELABEL    21
  871. #define MAXFILETYPEPATTERN    51
  872. #define MAXCOLONOFF        11
  873. #define MAXCOMMENT        19
  874. #define MAXCOMMENT2        79
  875. #define MAXFOLDFUNCNAME        49
  876. #define MAXCASEONOFF        11
  877. #define MAXSEPARATORSSTRING    149
  878. #define MAXFOLDSTR        19
  879.  
  880. struct FileType
  881. {
  882.     struct Node         Node;
  883.  
  884.     char             Label[MAXFILETYPELABEL+1],
  885.                  Pattern[MAXFILETYPEPATTERN+1];
  886.  
  887.     UBYTE             UseKeyWordColors;
  888.     UBYTE             KeyAlpha[256];
  889.     char             **KeyWord;
  890.     int             NumKeyWord;
  891.     char             GestColorOff[MAXCOLONOFF+1],
  892.                  GestColorOn[MAXCOLONOFF+1];
  893.  
  894.     UBYTE             UseComment1Colors;
  895.     UBYTE             UseComment2Colors;
  896.     UBYTE             ColorAllLine;
  897.     UWORD             CheckColorLines;
  898.  
  899.     UBYTE             Comment1Pen,
  900.                  Comment2Pen;
  901.     char             Comment1On[MAXCOMMENT+1],
  902.                  Comment1Off[MAXCOMMENT+1],
  903.                  Comment2On[MAXCOMMENT+1];
  904.  
  905.     LONG             DefBits;
  906.     UBYTE             CreateIcons;
  907.     char             DefComment[MAXCOMMENT2+1];
  908.  
  909.     char             SearchFoldFileName[MAXFOLDFUNCNAME+1];
  910.     BPTR             SearchFoldSeg;
  911.     ULONG            (* ASM SearchFold)(RG(a0) struct PEDWindow *,RG(d0) LONG,RG(d1) LONG,RG(a1) ULONG *,RG(a2) ULONG *,RG(a3) char *);
  912.     char             FoldStartStr[MAXFOLDSTR+1],
  913.                  FoldStopStr[MAXFOLDSTR+1];
  914.  
  915.     UBYTE             UseKeyWordInd;
  916.     char            **KeyWordInd;
  917.     int             NumKeyWordInd;
  918.  
  919.     struct MyTemplate    *Template;
  920.     UBYTE             UseTemplate;
  921.  
  922.     char            **Brackets;
  923.     int             NumBrackets;
  924.  
  925.     char            **DictWord;
  926.     int             NumDictWord;
  927.     UBYTE             UseAutoCase;
  928.     char             GestCaseOff[MAXCASEONOFF+1],
  929.                  GestCaseOn[MAXCASEONOFF+1];
  930.  
  931.     UBYTE             UseAutoSave;
  932.     UWORD             MinAutoSave;
  933.  
  934.     UBYTE             EraseRight;
  935.  
  936.     UBYTE             Backup;
  937.     char             BackupDir[MAXFILENAME+1];
  938.  
  939.     UBYTE             SaveRefs;
  940.     char             RefsDir[MAXFILENAME+1];
  941.  
  942.     UBYTE             CheckPar;
  943.  
  944.     UWORD             Left,
  945.                  Right;
  946.  
  947.     UBYTE             Tab;
  948.  
  949.     UWORD             IndJump;
  950.  
  951.     UBYTE             AutoFold;
  952.  
  953.     UBYTE             InsStart;
  954.  
  955.     UBYTE             TabEqSpace;
  956.  
  957.     UBYTE             WordWrapping;
  958.     UWORD             RightWW;
  959.  
  960.     UBYTE             SaveMarkers;
  961.     char             MarkerDir[MAXFILENAME+1];
  962.  
  963.     char             SeparatorsString[MAXSEPARATORSSTRING+1];
  964.     UBYTE             SepChar[256];
  965.  
  966.     UBYTE             AutoReLoad;
  967.  
  968.     struct FileType        *NextFileType;
  969. };
  970.  
  971.  
  972.  
  973. /******
  974.  *
  975.  * Prefs structure
  976.  * ---------------
  977.  *
  978.  * This structure stores datas about ProgED preferences.
  979.  *
  980.  * NOTE: From 2.0 this structure is changed. It will changes at
  981.  *       each release, if necessary. SO DON'T USE IT, PLEASE.
  982.  *       If it's necessary do it but, perharps, your job will
  983.  *       not work on future releases of ProgED.
  984.  *
  985.  * Description:
  986.  * ------------
  987.  *
  988.  * ScreenMode:        This is the DisplayID of the screen used. If you want
  989.  *            to copy WB screen use 0xFFFF0000, if you want to open
  990.  *            on a public screen use 0xFFFF0001 and put in
  991.  *            PublicScreenName field the screen name.
  992.  * ScreenWidth,
  993.  * ScreenHeight,
  994.  * ScreenOverscanType,
  995.  * ScreenDepth,
  996.  * ScreenAutoScroll:    Properties of the screen. They are used only if
  997.  *            ScreenMode doesn't is equal to 0xFFFF0000 (clone
  998.  *            WB screen) or 0xFFFF0001 (Open on WB screen).
  999.  * ScreenColors:    Colors of the the custom screen.
  1000.  * ScreenFontName,
  1001.  * ScreenFontSize:    Name & size of the screen font.
  1002.  * MenuFontName,
  1003.  * MenuFontSize:    Name & size of the menu font.
  1004.  * TextFontName,
  1005.  * TextFontSize:    Name & size of the text font.
  1006.  * GadgetFontName,
  1007.  * GadgetFontSize:    Name & size of the gadgets font.
  1008.  * APIClients:        Pointer to an array containing the filenames of
  1009.  *            ProgED clients.
  1010.  * NumAPIClients:    Number of ProgED clients in APIClients array.
  1011.  * Scan:        Pointer to first scanner.
  1012.  * Ref:            Pointer to an array containing the search strings
  1013.  *            for references creation.
  1014.  * NumRef:        Number of strings in Ref Array.
  1015.  * RAMReference:    TRUE=Keep reference file in RAM.
  1016.  * ReferenceCase:    TRUE=Activate case sensitivity for references.
  1017.  * ReferenceFile:    Filename of references file.
  1018.  * HuntPath:        Pointer to an array containing the search patterns
  1019.  *            for hunter.
  1020.  * NumHuntPath:        Number of patterns in HuntPath array.
  1021.  * ProjectFiles:    Pointer to an array containing the filenames
  1022.  *            of files in project.
  1023.  * NumProjectFiles:    Number of files in ProjectFiles array.
  1024.  * SeparateItems:    TRUE=Put a bar if the label of a menu is empty.
  1025.  * Menu:        Pointer to the menu tree's.
  1026.  * HelpFile:        Help file to use when user press HELP key.
  1027.  * Key:            Pointer to the list of hotkeys.
  1028.  * LeftBorder,
  1029.  * RightBorder,
  1030.  * TopBorder,
  1031.  * BottomBorder:    Scroller limits. Exceding them window will scroll.
  1032.  * BackPen:        Pen to be used in background rendering.
  1033.  * PaperPen:        Pen to be used in paper rendering.
  1034.  * DefTextPen:        Pen to be used in text rendering.
  1035.  * PaperBlockPen:    Pen to be used in block rendering.
  1036.  * CursorPen:        Pen to be used in cursor rendering (From 2.0!).
  1037.  * MarkCursorPen:    Pen to be used in cursor rendering if I'm marking (From 2.0!).
  1038.  * ScreenPens:        Screen pens to be used for SA_Pens. (12 pens+1 ~0).
  1039.  * ShowCursorPos:    TRUE=show cursor position in window title.
  1040.  * ShowPathName:    TRUE=show file path in window title.
  1041.  * AutoArrangeVer:    TRUE=arrange vertically automatically.
  1042.  * AutoArrangeHor:    TRUE=arrange horizontally automatically.
  1043.  * Favourite:        TRUE=give half screen to active window.
  1044.  * UnfoldOnGotoMarker:    TRUE=Unfold on goto marker.
  1045.  * UnfoldOnGotoLine:    TRUE=Unfold on goto line.
  1046.  * UnfoldOnGotoByte:    TRUE=Unfold on goto byte.
  1047.  * UnfoldOnGotoScan:    TRUE=Unfold on goto scan.
  1048.  * UnfoldOnSearch:    TRUE=Unfold on search & matching bracket.
  1049.  * UseRightGadget:    TRUE=Create right scroller gadget.
  1050.  * UseBottomGadget:    TRUE=Create bottom scroller gadget.
  1051.  * UseRTSysReq:        TRUE=Activate ReqTools system-requesters.
  1052.  * UseRTFileReq:    TRUE=Activate ReqTools file-requesters.
  1053.  * UseRTFontReq:    TRUE=Activate ReqTools font-requesters.
  1054.  * UseRTScreenReq:    TRUE=Activate ReqTools screenmode-requesters.
  1055.  * Clipboard:        Clipboard number used.
  1056.  * UseSetDefPubScr:    TRUE=use SetDefPubScreen to make ProgED screen
  1057.  *            the default public screen (very useful!).
  1058.  * UseClock:        TRUE=activate clock on the screen bar.
  1059.  * Save:        TRUE=Safe save.
  1060.  * BlankBorders:    TRUE=Make screen border blank.
  1061.  * UseAppIcon:        TRUE=Create an AppIcon on WB screen.
  1062.  * UseMenuItem:        TRUE=Create an AppItem on WB menu.
  1063.  * MouseBlanker:    TRUE=Activate mouse blanker.
  1064.  * FastLoad:        TRUE=Activate fast load. If ProgED haven't memory
  1065.  * MaxCol:        Max # of columns in texts. Set it at least at 300.
  1066.  *            Don't ask me why ProgED guru if you have 80 in
  1067.  *            this field!
  1068.  * AltStep:         Step of scroller with ALT key.
  1069.  * FastMode:        TRUE=Activate FAST mode (try it!)
  1070.  * StartUpMacro:    Filename of ARexx macro executed at startup.
  1071.  * PreIconifyMacro:    Filename of ARexx macro executed when ProgED closes
  1072.  *            its screen.
  1073.  * PostIconifyMacro:    Filename of ARexx macro executed when ProgED opens
  1074.  *            its screen.
  1075.  * LeftExtraSpace,
  1076.  * RightExtraSpace,
  1077.  * TopExtraSpace,
  1078.  * BottomExtraSpace:    Space (in pixels) leaved out when ProgED arrange
  1079.  *            its windows.
  1080.  * XpkLib[5]:        Name of XPK library used.
  1081.  * XpkMode:        XPK library mode used.
  1082.  * XpkPos:        DON'T TOUCH THIS!
  1083.  * XpkPassWord:        Password for XPK library.
  1084.  * UndoLevels:        Lenght of undo queues.
  1085.  * PublicScreenName:    Name of public screen on which you wish open ProgED
  1086.  *            screen.
  1087.  * FileTypes:        Pointer to the first filetype mounted.
  1088.  * LMouse[]:        ProgED programs executed at left mouse button
  1089.  *            pressure.
  1090.  * MMouse[]:        ProgED programs executed at middle mouse button
  1091.  *            pressure.
  1092.  * AskSetFileType:    Show requester to ask user if he/she wants
  1093.  *            change filetype at new/load operation.
  1094.  * AskChangeFileType:    Show requester to ask user if he/she wants
  1095.  *            change filetype at file-name change.
  1096.  * EOLChar:        Ascii code used to show CR chars. 0=none.
  1097.  * FavouritePerc:    Percentual of screen height used by active
  1098.  *            window (for window arranging).
  1099.  * AutoReloadPrj:    TRUE=Reload last project used.
  1100.  *
  1101.  ******/
  1102.  
  1103. #define MAXFONTNAM    49
  1104. #define MAXSTARTUPMACRO    99
  1105. #define MAXREFNAME    99
  1106.  
  1107. struct PEDColor
  1108. {
  1109.     ULONG    Red,
  1110.         Green,
  1111.         Blue;
  1112. };
  1113.  
  1114. struct Prefs
  1115. {
  1116.     ULONG             ScreenMode;
  1117.     UWORD             ScreenWidth;
  1118.     UWORD             ScreenHeight;
  1119.     UWORD             ScreenOverscanType;
  1120.     UBYTE             ScreenDepth;
  1121.     UBYTE             ScreenAutoScroll;
  1122.  
  1123.     struct PEDColor         ScreenColors[MAXCOLOR];
  1124.  
  1125.     char             ScreenFontName[MAXFONTNAM+1];
  1126.     UWORD             ScreenFontSize;
  1127.  
  1128.     char             MenuFontName[MAXFONTNAM+1];
  1129.     UWORD             MenuFontSize;
  1130.  
  1131.     char             TextFontName[MAXFONTNAM+1];
  1132.     UWORD             TextFontSize;
  1133.  
  1134.     char             GadgetFontName[MAXFONTNAM+1];
  1135.     UWORD             GadgetFontSize;
  1136.  
  1137.     char            **APIClients;
  1138.     int             NumAPIClients;
  1139.  
  1140.     struct MyScan        *Scan;
  1141.  
  1142.     char            **Ref;
  1143.     int             NumRef;
  1144.     UBYTE             RAMReference;
  1145.     UBYTE             ReferenceCase;
  1146.     char             ReferenceFile[MAXREFNAME+1];
  1147.  
  1148.     char            **HuntPath;
  1149.     int             NumHuntPath;
  1150.  
  1151.     char            **ProjectFiles;
  1152.     int             NumProjectFiles;
  1153.  
  1154.     UBYTE             SeparateItems;
  1155.     struct MyMenu        *Menu;
  1156.     char             HelpFile[MAXFILENAME+1];
  1157.  
  1158.     struct MyKey        *Key;
  1159.  
  1160.     UBYTE             LeftBorder;
  1161.     UBYTE             RightBorder;
  1162.     UBYTE             TopBorder;
  1163.     UBYTE             BottomBorder;
  1164.  
  1165.     UBYTE             BackPen;
  1166.     UBYTE             PaperPen;
  1167.     UBYTE             DefTextPen;
  1168.     UBYTE             PaperBlockPen;
  1169.     UBYTE             CursorPen;
  1170.     UBYTE             MarkCursorPen;
  1171.     UWORD             ScreenPens[13];
  1172.  
  1173.     UBYTE             ShowCursorPos;
  1174.     UBYTE             ShowPathName;
  1175.  
  1176.     UBYTE             AutoArrangeVer;
  1177.     UBYTE             AutoArrangeHor;
  1178.     UBYTE             Favourite;
  1179.  
  1180.     UBYTE             UnfoldOnGotoMarker;
  1181.     UBYTE             UnfoldOnGotoLine;
  1182.     UBYTE             UnfoldOnGotoByte;
  1183.     UBYTE             UnfoldOnGotoScan;
  1184.     UBYTE             UnfoldOnSearch;
  1185.  
  1186.     UBYTE             UseRightGadget;
  1187.     UBYTE             UseBottomGadget;
  1188.  
  1189.     UBYTE             UseRTSysReq;
  1190.     UBYTE             UseRTFileReq;
  1191.     UBYTE             UseRTFontReq;
  1192.     UBYTE             UseRTScreenReq;
  1193.  
  1194.     UBYTE             Clipboard;
  1195.  
  1196.     UBYTE             UseSetDefPubScr;
  1197.  
  1198.     UBYTE             UseClock;
  1199.  
  1200.     UBYTE             Save;
  1201.  
  1202.     UBYTE             BlankBorders;
  1203.  
  1204.     UBYTE             UseAppIcon;
  1205.  
  1206.     UBYTE             UseMenuItem;
  1207.  
  1208.     UBYTE             MouseBlanker;
  1209.  
  1210.     UBYTE             FastLoad;
  1211.  
  1212.     UWORD             MaxCol;
  1213.  
  1214.     UBYTE             AltStep;
  1215.  
  1216.     UBYTE             FastMode;
  1217.  
  1218.     char             StartUpMacro[MAXSTARTUPMACRO];
  1219.     char             PreIconifyMacro[MAXSTARTUPMACRO];
  1220.     char             PostIconifyMacro[MAXSTARTUPMACRO];
  1221.  
  1222.     LONG             LeftExtraSpace,
  1223.                  RightExtraSpace,
  1224.                  TopExtraSpace,
  1225.                  BottomExtraSpace;
  1226.  
  1227.     char             XpkLib[5];
  1228.     UBYTE             XpkMode;
  1229.     int             XpkPos;
  1230.     char             XpkPassWord[52];
  1231.  
  1232.         ULONG             UndoLevels;
  1233.  
  1234.     char             PublicScreenName[MAXPUBSCREENNAME+1];
  1235.  
  1236.     struct FileType        *FileTypes;
  1237.  
  1238.     struct MyProgram    *LMouse[8],
  1239.                 *MMouse[8];
  1240.  
  1241.     UBYTE             AskSetFileType,
  1242.                  AskChangeFileType;
  1243.  
  1244.     UBYTE             EOLChar;
  1245.  
  1246.     UBYTE             FavouritePerc;
  1247.  
  1248.     UBYTE             AutoReloadPrj;
  1249. };
  1250.