home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 19 / AACD19.BIN / AACD / System / SnoopDos / SnoopDos_Src / SnoopDos_Source / subwin.c < prev    next >
C/C++ Source or Header  |  2001-02-04  |  185KB  |  3,853 lines
  1. /*
  2.  *              SUBWIN.C                                                                                        vi:ts=4
  3.  *
  4.  *      Copyright (c) Eddy Carroll, September 1994.
  5.  *
  6.  *              This module handles all the windows other than the main window.
  7.  *              That is, the functions window, settings window and format
  8.  *              window.
  9.  */             
  10.  
  11. #include "system.h"
  12. #include "snoopdos.h"
  13. #include "gui.h"
  14.  
  15. #if 0
  16. #define DB(s)   KPrintF(s)
  17. #else
  18. #define DB(s)
  19. #endif
  20.  
  21. /*
  22.  *              These are used by all the requesters to decide what options to do
  23.  *              when leaving a requester (make current settings permanent or
  24.  *              restore the old settings)
  25.  */
  26. #define SEL_NONE                0               /* User didn't select an option yet             */
  27. #define SEL_USE                 1               /* User selected USE in a requester             */
  28. #define SEL_CANCEL              2               /* User selected CANCEL in a requester  */
  29.  
  30. /*
  31.  *              These control which items are displayed in the System and DOS
  32.  *              columns in the function window.
  33.  */
  34. #define COL_SELECTED    0               /* Column shows selected items                  */
  35. #define COL_ALL                 1               /* Column shows all items                               */
  36. #define COL_NONE                2               /* Column shows no items                                */
  37.  
  38. #define SETBUTTON_FILE  0               /* Little image of a file folder                */
  39. #define SETBUTTON_FONT  1               /* Little image of a font folder                */
  40. #define SETBUTTON_MAX   2               /* Anything above this is a string ID   */
  41.  
  42. /*
  43.  *              These two are imported from SNOOPDOS.C
  44.  */
  45. extern char     SnoopDosTitle[];
  46.  
  47. /*
  48.  *              Variables for the format editor
  49.  */
  50. int FBoxA_Left;                         /* X pos of left box in format window   */
  51. int FBoxA_Top;                          /* Y pos of left box in format window   */
  52. int FBoxA_Width;                        /* Width of left box in format window   */
  53. int FBoxA_Height;                       /* Height of left box in format window  */
  54. int FBoxA_NumChars;                     /* No. of characters across left box    */
  55. int FBoxA_CurLines;                     /* No. of lines currently in left box   */
  56.  
  57. int FBoxB_Left;                         /* X pos of right box in format window  */
  58. int FBoxB_Top;                          /* Y pos of right box in format window  */
  59. int FBoxB_Width;                        /* Hidth of right box in format window  */
  60. int FBoxB_Height;                       /* Weight of right box in format window */
  61. int FBoxB_NumChars;                     /* No. of characters across right box   */
  62. int FBoxB_CurLines;                     /* No. of lines currently in right box  */
  63.  
  64. int FBoxSpacing;                        /* Distance between box text baselines  */
  65. int FBoxSelected;                       /* Line number of right box selection   */
  66.                                                         /* (or FBOX_NOSELECT / FBOX_SELECTLEFT) */
  67.  
  68. int FBoxDeltaX;                         /* Offset from mouse to corner of drag  */
  69. int FBoxDeltaY;                         /* Offset from mouse to corner of drag  */
  70. int FBoxDragSelect;                     /* Currently selected drag drop area    */
  71. int FormatCurLMB;                       /* Current state of left mouse button   */
  72. int FormatMovingField;          /* If true, currently dragging field    */
  73. int FormatDragBox;                      /* Box we're dragging from                              */
  74. int FormatDragLine;                     /* Line we're dragging from                             */
  75.  
  76. char FBoxA_FormString[20];      /* sprintf format string for left box   */
  77. char FBoxB_FormString[20];      /* sprintf format string for right box  */
  78.  
  79. char FormatSaveFormat[MAX_FORM_LEN];    /* Save area for format ed      */
  80.  
  81. /*
  82.  *              These next two arrays are indices into the FieldTypes[] array
  83.  *              of format initialisers.
  84.  */
  85. typedef struct {
  86.         int     type;                                                   /* Type of this entry           */
  87.         int width;                                                      /* Width of this entry          */
  88. } EditEvent;
  89.         
  90. extern FieldInit FieldTypes[];                  /* Pulled in from BUFFER.C      */
  91.  
  92. EditEvent CurrentFields[EF_COUNT+1];    /* Fields in current format     */
  93. EditEvent AvailableFields[EF_COUNT+1];  /* Fields still available       */
  94.  
  95. Settings                        SavedFuncSets;          /* Saved function settings      */
  96. Settings                        SavedSetupSets;         /* Saved setup settings         */
  97.  
  98. struct Gadget           *SetGadList;            /* Settings window gadgets      */
  99. struct Gadget           *FuncGadList;           /* Function window gadgets      */
  100. struct Gadget           *FormGadList;           /* Format window gadgets        */
  101. struct Image            *FileButtonImage;       /* Image of a file button       */
  102. struct Image            *FontButtonImage;       /* Image of a font button       */
  103.  
  104. struct TextFont         *FormBufFont;           /* Format window listview       */
  105. struct TextFont         *FormGadFont;           /* Format window gadgets        */
  106.  
  107. /*
  108.  *              We don't usually free the Function window gadgets when we close
  109.  *              the window (since it takes a long time to generate them). However,
  110.  *              if we change window font, then we need a way to be able to change
  111.  *              them. This variable shows you how.
  112.  */
  113. int             FuncSystemCol;          /* Mode of system column (all/none/sel) */
  114. int             FuncDOSCol;                     /* Mode of DOS column (all/none/select) */
  115.  
  116. UBYTE   SavedCols[GID_NUMFUNCSETS];     /* Currently selected settings  */
  117. UBYTE   TempCols[GID_NUMFUNCSETS];      /* Currently selected settings  */
  118.  
  119. UBYTE   SetKeyboard[KB_SHORTCUT_SIZE];  /* For keyboard equivs          */
  120. UBYTE   FuncKeyboard[KB_SHORTCUT_SIZE]; /* For keyboard equivs          */
  121. UBYTE   FormKeyboard[KB_SHORTCUT_SIZE]; /* For keyboard equivs          */
  122.  
  123. /*
  124.  *              Now our font structures.
  125.  *
  126.  *              We do everything in terms of FontAttr structures, and whenever a
  127.  *              window needs a font, it OpenFont's it itself. This has several
  128.  *              advantages: it allows each window to dynamically select the
  129.  *              best-fitting font, and it also ensures no problems if we have a
  130.  *              window open with one font and the user than changes the font
  131.  *              to something else -- the first window will still have a valid
  132.  *              lock on the old font.
  133.  */
  134. extern struct TextAttr TopazFontAttr;
  135. extern struct TextAttr SystemFontAttr;
  136. extern struct TextAttr WindowFontAttr;
  137. extern struct TextAttr BufferFontAttr;
  138.  
  139. extern struct {
  140.         struct TextAttr *gadgetfa;
  141.         struct TextAttr *bufferfa;
  142. } MainWindowFontList[];                         /* Imported from MAINWIN.C */
  143.  
  144. struct TextAttr *SubWindowFontList[] = {
  145.         &WindowFontAttr,
  146.         &SystemFontAttr,
  147.         &TopazFontAttr,
  148.         NULL
  149. };
  150.  
  151. /*
  152.  *              Next, all our gadget structures -- these are used to build the
  153.  *              font-sensitive gadget windows at runtime.
  154.  */
  155. struct FuncGadgets {
  156.         ULONG   gadgid;                 /* Gadget ID                                    */
  157.         UWORD   stringid;               /* Name of checkmark gadget     */
  158.         UBYTE   col;                    /* Column (0, 1 or 2)                   */
  159.         UBYTE   row;                    /* Row (0 -- 13)                                */
  160. };
  161.  
  162. struct FuncGadgets FuncGadgs[] = {
  163.         /*
  164.          *              General controls
  165.          */
  166.         GID_ONLYFAILS,          MSG_SHOWFAILS_GAD,              0, 0,
  167.         GID_SHOWCLINUM,         MSG_SHOWCLI_GAD,                0, 1,
  168.         GID_SHOWPATHS,          MSG_SHOWFULLPATHS_GAD,  0, 2,
  169.         GID_USEDEVNAMES,        MSG_USEDEVNAMES_GAD,    0, 3,
  170.         GID_MONPACKETS,         MSG_MONPACKETS_GAD,             0, 4,
  171.         GID_MONALLPACKETS,      MSG_MONALLPACKETS_GAD,  0, 5,
  172.         GID_MONROMCALLS,        MSG_MONROMCALLS_GAD,    0, 6,
  173.         GID_IGNOREWB,           MSG_IGNOREWB_GAD,               0, 7,
  174.         /*
  175.          *              System functions
  176.          */
  177.         GID_FINDPORT,           MSG_FINDPORT_GAD,               1, 0,
  178.         GID_FINDRESIDENT,       MSG_FINDRESIDENT_GAD,   1, 1,
  179.         GID_FINDSEMAPHORE,      MSG_FINDSEMAPHORE_GAD,  1, 2,
  180.         GID_FINDTASK,           MSG_FINDTASK_GAD,               1, 3,
  181.         GID_LOCKSCREEN,         MSG_LOCKSCREEN_GAD,             1, 4,
  182.         GID_OPENDEVICE,         MSG_OPENDEVICE_GAD,             1, 5,
  183.         GID_OPENFONT,           MSG_OPENFONT_GAD,               1, 6,
  184.         GID_OPENLIBRARY,        MSG_OPENLIBRARY_GAD,    1, 7,
  185.         GID_OPENRESOURCE,       MSG_OPENRESOURCE_GAD,   1, 8,
  186.         GID_READTOOLTYPES,      MSG_READTOOLTYPES_GAD,  1, 9,
  187.         GID_SENDREXX,           MSG_SENDREXX_GAD,               1, 10,
  188.  
  189.         /*
  190.          *              AmigaDOS Functions
  191.          */
  192.         GID_CHANGEDIR,          MSG_CHANGEDIR_GAD,              2, 0,
  193.         GID_DELETE,                     MSG_DELETE_GAD,                 2, 1,
  194.         GID_EXECUTE,            MSG_EXECUTE_GAD,                2, 2,
  195.         GID_GETVAR,                     MSG_GETVAR_GAD,                 2, 3,
  196.         GID_LOADSEG,            MSG_LOADSEG_GAD,                2, 4,
  197.         GID_LOCKFILE,           MSG_LOCKFILE_GAD,               2, 5,
  198.         GID_MAKEDIR,            MSG_MAKEDIR_GAD,                2, 6,
  199.         GID_MAKELINK,           MSG_MAKELINK_GAD,               2, 7,
  200.         GID_OPENFILE,           MSG_OPENFILE_GAD,               2, 8,
  201.         GID_RENAME,                     MSG_RENAME_GAD,                 2, 9,
  202.         GID_RUNCOMMAND,         MSG_RUNCOMMAND_GAD,             2, 10,
  203.         GID_SETVAR,                     MSG_SETVAR_GAD,                 2, 11,
  204.         GID_SYSTEM,                     MSG_SYSTEM_GAD,                 2, 12,
  205.  
  206.         0,                                      0,                                              0, 0
  207. };
  208.  
  209. /*
  210.  *              This structure defines the gadgets in the settings window. There
  211.  *              are three basic types of gadgets supported: cycle, string and
  212.  *              display. For cycle gadgets, data1 is the index of the current
  213.  *              selection, data2 is a 0-terminated array of message IDs that
  214.  *              will hold the possible ListView choices, and data3 is a pointer
  215.  *              to an array of string pointers of the same size (including
  216.  *              terminating NULL) that will be filled in by the code with actual
  217.  *              pointers to those strings.
  218.  *              
  219.  *              For string and display gadgets, data2 is a pointer to the string
  220.  *              to be displayed inside the gadget and data1/data3 are unused.
  221.  *              However, if promptid is specified, then data1 is the message
  222.  *              number of the prompt to be used in the button instead of defaulting
  223.  *              to a question mark (the width is automatically adjusted).
  224.  */             
  225. struct SetGadgets {
  226.         UWORD   gadgid;                 /* Gadget ID                                                            */
  227.         UWORD   stringid;               /* ID of label name                                     */
  228.         ULONG   gtype;                  /* Gadget type (cycle, string, or display)      */
  229.         UWORD   promptid;               /* If non-zero, ID of optional "?" button       */
  230.         ULONG   data1;                  /* See above                                                            */
  231.         void    *data2;                 /* See above                                                            */
  232.         void    *data3;                 /* See above                                                            */
  233.         UBYTE   col;                    /* Start col (0 or 1)                                           */
  234.         UBYTE   cwidth;                 /* Column width (0, 1 or 2)                                     */
  235.         UBYTE   row;                    /* Row (0 to 6)                                                         */
  236. };
  237.  
  238. int SetCylHide[] = {
  239.         MSG_CYL_HIDE_GAD, MSG_CYL_ICONIFY_GAD, MSG_CYL_TOOLSMENU_GAD,
  240.         MSG_CYL_NONE_GAD, 0
  241. };
  242.  
  243. int SetCylOpenOn[] = {
  244.         MSG_CYL_DEFSCREEN_GAD, MSG_CYL_FRONTSCREEN_GAD, MSG_CYL_NAMEDSCREEN_GAD, 0
  245. };
  246.  
  247. int SetCylLogMode[] = {
  248.         MSG_CYL_PROMPT_USER_GAD, MSG_CYL_APPEND_GAD, MSG_CYL_OVERWRITE_GAD,
  249.         MSG_CYL_SERIALPORT_GAD, 0
  250. };
  251.  
  252. int SetCylFileIO[] = {
  253.         MSG_CYL_AUTOMATIC_GAD, MSG_CYL_IMMEDIATE_GAD, MSG_CYL_BUFFERED_GAD, 0
  254. };
  255.  
  256. char *SetCylHideText[HIDE_MAX+1];
  257. char *SetCylOpenOnText[SCREEN_MAX+1];
  258. char *SetCylLogModeText[LOGMODE_MAX+1];
  259. char *SetCylFileIOText[FILE_MAX+1];
  260.  
  261.  
  262. /*
  263.  *              If you re-arrange the order of these gadget definitions,
  264.  *              make sure you re-order the enum's that follow below as well.
  265.  */
  266. struct SetGadgets SetGadgs[] = {
  267.         GID_BUFFORMAT,  MSG_BUFFORMAT_GAD,      STRING_KIND,    GID_FORMATEDIT, 
  268.                                                                                                                 MSG_FORMATEDIT_GAD,
  269.                                         NULL,                           0,                                      0,      2,      5,
  270.  
  271.         GID_LOGFORMAT,  MSG_LOGFORMAT_GAD,      STRING_KIND,    GID_FORMATCOPY,
  272.                                                                                                                 MSG_FORMATCOPYF_GAD,
  273.                                         NULL,                           0,                                      0,      2,      6,
  274.         
  275.         GID_HIDEMETHOD, MSG_HIDEMETHOD_GAD,     CYCLE_KIND,             0,      0,
  276.                                         SetCylHide,                     SetCylHideText,         0,      0,      0,
  277.         
  278.         GID_OPENON,             MSG_OPENON_GAD,         CYCLE_KIND,             0,      0,
  279.                                         SetCylOpenOn,           SetCylOpenOnText,       0,      0,      1,
  280.  
  281.         GID_LOGMODE,    MSG_LOGMODE_GAD,        CYCLE_KIND,             0,      0,
  282.                                         SetCylLogMode,          SetCylLogModeText,      0,      0,      2,
  283.  
  284.         GID_FILEIO,             MSG_FILEIO_GAD,         CYCLE_KIND,             0,      0,
  285.                                         SetCylFileIO,           SetCylFileIOText,       0,      0,      3,
  286.         
  287.         GID_HOTKEY,             MSG_HOTKEY_GAD,         STRING_KIND,    0,      0,
  288.                                         NULL,                           0,                                      1,      1,      0,
  289.         
  290.         GID_SCREENNAME, MSG_SCREENNAME_GAD,     STRING_KIND,    0,      0,
  291.                                         NULL,                           0,                                      1,      1,      1,
  292.         
  293.         GID_LOGFILE,    MSG_LOGFILE_GAD,        STRING_KIND,    GID_FILEPROMPT,
  294.                                                                                                                 SETBUTTON_FILE,
  295.                                         NULL,                           0,                                      1,      1,      2,
  296.  
  297.         GID_WINDOWFONT, MSG_WINDOWFONT_GAD,     TEXT_KIND,              GID_WFONTPROMPT,
  298.                                                                                                                 SETBUTTON_FONT,
  299.                                         NULL,                           0,                                      1,      1,      3,
  300.         
  301.         GID_BUFFERFONT, MSG_BUFFERFONT_GAD,     TEXT_KIND,              GID_BFONTPROMPT,
  302.                                                                                                                 SETBUTTON_FONT,
  303.                                         NULL,                           0,                                      1,      1,      4,
  304.  
  305.         0
  306. };
  307.  
  308. /*
  309.  *              The following gadgets should match the _order_ that the above
  310.  *              gadgets are laid out in, since they are used as indices into the
  311.  *              above array.
  312.  */
  313. typedef enum {
  314.         SG_BufferFormat,
  315.         SG_LogfileFormat,
  316.         SG_HideMethod,
  317.         SG_ScreenType,
  318.         SG_LogMode,
  319.         SG_FileIOType,
  320.         SG_HotKey,
  321.         SG_ScreenName,
  322.         SG_LogFile,
  323.         SG_WindowFont,
  324.         SG_BufferFont,
  325. } SetGadgetEnums;
  326.  
  327. /*
  328.  *              Arrays of gadget names for calculating minimum width
  329.  */
  330.  
  331. /*
  332.  *              Miscellaneous gadgets in functions window
  333.  */
  334. int MiscColNames[] = {
  335.         MSG_SHOWFAILS_GAD,
  336.         MSG_SHOWCLI_GAD,
  337.         MSG_SHOWFULLPATHS_GAD,
  338.         MSG_USEDEVNAMES_GAD,
  339.         MSG_MONPACKETS_GAD,
  340.         MSG_MONALLPACKETS_GAD,
  341.         MSG_IGNOREWB_GAD,
  342.         0
  343. };
  344.  
  345. /*
  346.  *              System gadgets in functions window
  347.  */
  348. int SysColNames[] = {
  349.         MSG_FINDPORT_GAD,     
  350.         MSG_FINDRESIDENT_GAD, 
  351.         MSG_FINDSEMAPHORE_GAD,
  352.         MSG_FINDTASK_GAD,     
  353.         MSG_LOCKSCREEN_GAD,   
  354.         MSG_OPENDEVICE_GAD,   
  355.         MSG_OPENFONT_GAD,     
  356.         MSG_OPENLIBRARY_GAD,  
  357.         MSG_OPENRESOURCE_GAD, 
  358.         MSG_READTOOLTYPES_GAD,
  359.         MSG_SENDREXX_GAD, 
  360.         0
  361. };
  362.  
  363. /*
  364.  *              AmigaDOS gadgets in functions window
  365.  */
  366. int DOSColNames[] = {
  367.         MSG_CHANGEDIR_GAD, 
  368.         MSG_DELETE_GAD,    
  369.         MSG_EXECUTE_GAD,   
  370.         MSG_GETVAR_GAD,    
  371.         MSG_LOADSEG_GAD,   
  372.         MSG_LOCKFILE_GAD,  
  373.         MSG_MAKEDIR_GAD,   
  374.         MSG_MAKELINK_GAD,  
  375.         MSG_OPENFILE_GAD,  
  376.         MSG_RENAME_GAD,    
  377.         MSG_RUNCOMMAND_GAD,
  378.         MSG_SETVAR_GAD,    
  379.         MSG_SYSTEM_GAD,
  380.         0
  381. };
  382.  
  383. /*
  384.  *              Aditional gadgets in function window
  385.  */
  386. int FuncCycleText[]             = { MSG_ALL_GAD, MSG_NONE_GAD, MSG_SELECTED_GAD, 0 };
  387. int FuncCycleName[]             = { MSG_SELSYSTEM_GAD, MSG_SELDOS_GAD, 0 };
  388. int UseCancelUndoText[] = { MSG_USE_GAD, MSG_CANCEL_GAD, MSG_UNDO_GAD, 0 };
  389.  
  390. /*
  391.  *              Left column gadgets names in settings window
  392.  */
  393. int SettingsLeftNames[] = {
  394.         MSG_HIDEMETHOD_GAD,
  395.         MSG_OPENON_GAD,
  396.         MSG_LOGMODE_GAD,
  397.         MSG_FILEIO_GAD,
  398.         MSG_BUFFORMAT_GAD,
  399.         MSG_LOGFORMAT_GAD,
  400.         0
  401. };
  402.  
  403. /*
  404.  *              Right column gadget names in settings window
  405.  */
  406. int SettingsRightNames[] = {
  407.         MSG_HOTKEY_GAD,
  408.         MSG_SCREENNAME_GAD,
  409.         MSG_LOGFILE_GAD,
  410.         MSG_WINDOWFONT_GAD,
  411.         MSG_BUFFERFONT_GAD,
  412.         0
  413. };
  414.  
  415. /*
  416.  *              Two mini buttons attached to format gadgets in settings window
  417.  *              Note that we have two types of possibility: one for fixed point
  418.  *              fonts and one for proportional fonts. This is so that we can
  419.  *              arrange for the two strings "Edit..." and "Copy" to always
  420.  *              look properly aligned, regardless of font type. If we didn't do
  421.  *              this, then with fixed point fonts, "Copy" looks mis-aligned
  422.  *              with respect to "Edit..." because they are different lengths.
  423.  */
  424. int SetMiniButtonsP[] = {
  425.         MSG_FORMATCOPYP_GAD,
  426.         MSG_FORMATEDIT_GAD,
  427.         0
  428. };
  429.  
  430. int SetMiniButtonsF[] = {
  431.         MSG_FORMATCOPYF_GAD,
  432.         MSG_FORMATEDIT_GAD,
  433.         0
  434. };
  435.  
  436. /*
  437.  *              Left column gadget contents in settings
  438.  */
  439. int SettingsLeftContents[] = {
  440.         MSG_CYL_HIDE_GAD,
  441.         MSG_CYL_ICONIFY_GAD,
  442.         MSG_CYL_TOOLSMENU_GAD,
  443.         MSG_CYL_DEFSCREEN_GAD,
  444.         MSG_CYL_FRONTSCREEN_GAD,
  445.         MSG_CYL_NAMEDSCREEN_GAD,
  446.         MSG_CYL_PROMPT_USER_GAD,
  447.         MSG_CYL_APPEND_GAD,
  448.         MSG_CYL_OVERWRITE_GAD,
  449.         MSG_CYL_AUTOMATIC_GAD,
  450.         MSG_CYL_IMMEDIATE_GAD,
  451.         MSG_CYL_BUFFERED_GAD,
  452.         0
  453. };
  454.  
  455. /*
  456.  *              Mega struct that collects all the data needed to create useful BOBs.
  457.  */
  458. typedef struct MyGel {
  459.         struct GelsInfo  gelinfo;                       /* GelInfo for entire structure */
  460.         WORD                     nextline[8];           /* Nextline data                                */ 
  461.         WORD                     *lastcolor[8];         /* Last colour data                             */
  462.         struct RastPort  *mainrast;                     /* Rastport bob is displayed in */
  463.         struct collTable colltable;                     /* Collision table                              */
  464.         struct VSprite   vshead;                        /* Head sprite anchor                   */
  465.         struct VSprite   vstail;                        /* Tail sprite anchor                   */
  466.         struct VSprite   bobvsprite;            /* Vsprite used for bob                 */
  467.         struct Bob               bob;                           /* Data for a single bob                */
  468.         struct RastPort  rastport;                      /* Rastport for our BOB                 */
  469.         struct BitMap    bitmap;                        /* Bitmap for our BOB                   */
  470.         ULONG                    planesize;                     /* Size of one plane in bob             */
  471.         UBYTE                   *planedata;                     /* Pointer to first plane               */
  472.         UBYTE                   *chipdata;                      /* Pointer to all CHIP RAM data */
  473.         ULONG                    chipsize;                      /* Total size of allocated CHIP */
  474. } MyGel;
  475.  
  476. MyGel   *TextBob;                                               /* Info about GEL/BOBs                  */
  477.  
  478. /*
  479.  *              Some prototypes private to this file
  480.  */
  481. MyGel *CreateBob(struct RastPort *rport, int width, int height, int transp);
  482. void FreeBob(MyGel *mygel);
  483. void UpdateBob(int x, int y);
  484. int  PickupBob(int hit, int x, int y);
  485. void DropBob(void);
  486.  
  487. /*****************************************************************************
  488.  *
  489.  *              Start of functions!
  490.  *
  491.  *****************************************************************************/
  492.  
  493. /*
  494.  *              CleanupSubWindows()
  495.  *
  496.  *              Frees any resources associated with this module
  497.  */
  498. void CleanupSubWindows(void)
  499. {
  500.         PurgeFuncGadgets = 1;
  501.         CloseFunctionWindow();
  502.         CloseSettingsWindow();
  503.         CloseFormatWindow();
  504. }
  505.  
  506. /*
  507.  *              GetFuncName(gadgetid)
  508.  *
  509.  *              Returns a pointer to a string describing the function name which
  510.  *              matches the gadget ID passed in. This is used by PATCHES.C when
  511.  *              it is unpatching the patched functions at exit time to identify
  512.  *              which function can't be unpatched in the event of a problem.
  513.  */
  514. char *GetFuncName(int gadgetid)
  515. {
  516.         struct FuncGadgets *fg = FuncGadgs;
  517.  
  518.         if (gadgetid == GID_SENDREXX)   /* Special-case this multi-function one */
  519.                 return MSG(MSG_PACKET_NAME);
  520.  
  521.         for (fg = &FuncGadgs[0]; fg->gadgid; fg++) {
  522.                 if (fg->gadgid == gadgetid)
  523.                         return MSG(fg->stringid);
  524.         }
  525.         return ("<Unknown Function>");
  526. }
  527.  
  528. /*
  529.  *              CreateFunctionGadgets(fontattr, getsize, &width, &height)
  530.  *
  531.  *              Creates all the gadgets for the function window. If getsize
  532.  *              is true, then the width and height values are filled in with
  533.  *              the dimensions of the window needed to hold the gadgets. In
  534.  *              this case, NULL is returned if the window would be too big to
  535.  *              fit on the current screen, or non-NULL if width and height
  536.  *              were successfully initialised.
  537.  *
  538.  *              If getsize is zero, then the actual gadgets are created and
  539.  *              a pointer to the gadget list is returned, or NULL if an
  540.  *              error occurred (typically, out of memory).
  541.  */
  542. struct Gadget *CreateFunctionGadgets(struct TextAttr *fontattr,
  543.                                                                          int getsize, int *pwidth, int *pheight)
  544. {
  545.         static char *cyltext[4];
  546.         struct TextFont *font;
  547.         struct FuncGadgets *fg;
  548.         struct NewGadget ng;
  549.         struct Gadget *gadlist;
  550.         struct Gadget *gad;
  551.         UWORD spacing[3];
  552.         UWORD yoffset[3]; 
  553.         UWORD colpos[3];
  554.         int heightadjust = 0;
  555.         int width;
  556.         int height;
  557.         int gwidth;
  558.         int gheight;
  559.         int fonty;
  560.         int colspace = 30;
  561.         int topline;
  562.         int w1, w2;
  563.  
  564.         if (!FuncVI) {
  565.                 FuncVI = GetVisualInfoA(SnoopScreen, NULL);
  566.                 if (!FuncVI)
  567.                         return (NULL);
  568.         }
  569.         font = MyOpenFont(fontattr);
  570.         if (!font)
  571.                 return (NULL);
  572.  
  573.         fonty           = font->tf_YSize;
  574.         gheight         = fonty   + 3;
  575.         gwidth          = gheight + 15;
  576.         
  577.         spacing[0]  = fonty + 4;
  578.         spacing[1]  = fonty + 4;
  579.         spacing[2]  = fonty + 4;
  580.         yoffset[1]      = TitlebarHeight + fonty/2;
  581.         yoffset[2]      = yoffset[1];
  582.         yoffset[0]      = yoffset[1] + 10 * spacing[1] - 7 * spacing[0];
  583.  
  584.         colpos[0]       = BorderLeft + FUNC_MARGIN;
  585.         colpos[1]       = colpos[0]  + MaxTextLen(font, MiscColNames)
  586.                                   + gwidth + colspace;
  587.         w1                      = MaxTextLen(font, SysColNames) + gwidth;
  588.         w2                      = GetTextLen(font, MSG(MSG_SYSFUNCS_GAD));
  589.         colpos[2]       = colpos[1]  + MAX(w1, w2) + colspace;
  590.         w1                      = MaxTextLen(font, DOSColNames) + gwidth;
  591.         w2                      = GetTextLen(font, MSG(MSG_DOSFUNCS_GAD));
  592.         width           = colpos[2]  + MAX(w1, w2) + FUNC_MARGIN + BorderRight + 8;
  593.         height      = yoffset[2] + spacing[2] * 15 + BorderBottom;
  594.  
  595.         topline = yoffset[2];
  596.         if (ScreenHeight < 256 && height > ScreenHeight) {
  597.                 /*
  598.                  *              For medium and low resolution screens, shave another
  599.                  *              few pixels from the height. Our aim is to be able to
  600.                  *              open on a 640 x 200 screen with a 15 point screen font.
  601.                  */
  602.                 heightadjust = -2;
  603.                 height      += heightadjust * 2;
  604.         }
  605.         if ((height + spacing[2] * 2) <= ScreenHeight) {
  606.                 int disp = (spacing[2] * 3) / 2;
  607.  
  608.                 yoffset[0] += disp;
  609.                 yoffset[1] += disp;
  610.                 yoffset[2] += disp;
  611.                 height     += disp;
  612.         }
  613.  
  614.         if (width > ScreenWidth || height > ScreenHeight) {
  615.                 CloseFont(font);
  616.                 return (NULL);
  617.         }
  618.         if (getsize) {
  619.                 CloseFont(font);
  620.                 *pwidth  = width;
  621.                 *pheight = height;
  622.                 return (struct Gadget *)(-1);
  623.         }
  624.  
  625.         /*
  626.          *              Now create our new gadgets
  627.          */     
  628.         ng.ng_Height            = gheight; 
  629.         ng.ng_Width                     = gwidth;  
  630.         ng.ng_TextAttr          = fontattr;
  631.         ng.ng_VisualInfo        = FuncVI;
  632.         ng.ng_Flags         = PLACETEXT_RIGHT;
  633.  
  634.         gadlist = NULL;
  635.         gad = CreateContext(&gadlist);
  636.         if (!gad)
  637.                 goto fgad_failed;
  638.  
  639.         for (fg = &FuncGadgs[0]; fg->gadgid; fg++) {
  640.                 int col = fg->col;
  641.  
  642.                 ng.ng_LeftEdge          = colpos[col];
  643.                 ng.ng_TopEdge           = fg->row * spacing[col] + yoffset[col];
  644.                 ng.ng_GadgetText        = MSG(fg->stringid);
  645.                 ng.ng_GadgetID          = fg->gadgid;
  646.  
  647.                 gad = CreateGadget(CHECKBOX_KIND, gad, &ng,
  648.                                                    GT_Underscore,       '_',
  649.                                                    GTCB_Scaled,     TRUE,
  650.                                                    TAG_DONE);
  651.                 if (!gad)
  652.                         goto fgad_failed;
  653.                 Gadget[fg->gadgid] = gad;
  654.                 AddKeyShortcut(FuncKeyboard, fg->gadgid, fg->stringid);
  655.         }
  656.  
  657.         /*
  658.          *              Now create the remaining window gadgets
  659.          */
  660.         ng.ng_LeftEdge          = colpos[0]
  661.                                                   + GetTextLen(font, MSG(MSG_MATCHNAME_GAD)) + 10;
  662.         ng.ng_TopEdge           = yoffset[1] + (23 * spacing[1]) / 2;
  663.         ng.ng_GadgetText        = MSG(MSG_MATCHNAME_GAD);
  664.         ng.ng_GadgetID          = GID_MATCHNAME;
  665.         ng.ng_Width         = colpos[2] - ng.ng_LeftEdge - colspace + 8;
  666.         ng.ng_Height            = gheight + 3;
  667.         ng.ng_Flags         = PLACETEXT_LEFT;
  668.  
  669.         gad = CreateGadget(STRING_KIND,         gad, &ng,
  670.                                            GT_Underscore,       '_',
  671.                                            GTST_MaxChars,       MAX_STR_LEN,
  672.                                            GTST_String,         CurSettings.Func.Pattern,
  673.                                            TAG_DONE);
  674.         if (!gad)
  675.                 goto fgad_failed;
  676.         Gadget[GID_MATCHNAME] = gad;
  677.         AddKeyShortcut(FuncKeyboard, GID_MATCHNAME, MSG_MATCHNAME_GAD);
  678.  
  679.         ng.ng_GadgetText        = MSG(MSG_SELSYSTEM_GAD);
  680.         ng.ng_GadgetID          = GID_SELSYSTEM;
  681.         ng.ng_Height            = gheight + 3;
  682.         ng.ng_Width                     = MaxTextLen(font, FuncCycleText) + 40;
  683.         ng.ng_LeftEdge          = colpos[0] + MaxTextLen(font, FuncCycleName) + 10;
  684.         ng.ng_TopEdge           = yoffset[1];
  685.         cyltext[0]                      = MSG(MSG_SELECTED_GAD);
  686.         cyltext[1]                      = MSG(MSG_ALL_GAD);
  687.         cyltext[2]                      = MSG(MSG_NONE_GAD);
  688.         cyltext[3]                      = NULL;
  689.  
  690.         gad = CreateGadget(CYCLE_KIND,          gad, &ng,
  691.                                            GT_Underscore,       '_',
  692.                                            GTCY_Labels,         cyltext,
  693.                                            GTCY_Active,         COL_SELECTED,
  694.                                            TAG_DONE);
  695.         if (!gad)
  696.                 goto fgad_failed;
  697.         Gadget[GID_SELSYSTEM] = gad;
  698.         AddKeyShortcut(FuncKeyboard, GID_SELSYSTEM, MSG_SELSYSTEM_GAD);
  699.  
  700.         ng.ng_GadgetText        = MSG(MSG_SELDOS_GAD);
  701.         ng.ng_GadgetID          = GID_SELDOS;
  702.         ng.ng_TopEdge           = (yoffset[0] + yoffset[1]) / 2;
  703.  
  704.         gad = CreateGadget(CYCLE_KIND,          gad, &ng,
  705.                                            GT_Underscore,       '_',
  706.                                            GTCY_Labels,         cyltext,
  707.                                            GTCY_Active,         COL_SELECTED,
  708.                                            TAG_DONE);
  709.         if (!gad)
  710.                 goto fgad_failed;
  711.         Gadget[GID_SELDOS] = gad;
  712.         AddKeyShortcut(FuncKeyboard, GID_SELDOS, MSG_SELDOS_GAD);
  713.  
  714.         ng.ng_Width                     = MaxTextLen(font, UseCancelUndoText) + 32;
  715.         ng.ng_Height            = fonty + GadgetHeight;
  716.         ng.ng_GadgetText        = MSG(MSG_USE_GAD);
  717.         ng.ng_GadgetID          = GID_FUNCUSE;
  718.         ng.ng_LeftEdge          = colpos[0];
  719.         ng.ng_TopEdge           = yoffset[2] + heightadjust + (27 * spacing[2]) / 2;
  720.         ng.ng_Flags                     = PLACETEXT_IN;
  721.  
  722.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  723.                                            GT_Underscore,       '_',
  724.                                            TAG_DONE);
  725.         if (!gad)
  726.                 goto fgad_failed;
  727.         Gadget[GID_FUNCUSE] = gad;
  728.         AddKeyShortcut(FuncKeyboard, GID_FUNCUSE, MSG_USE_GAD);
  729.         
  730.         ng.ng_LeftEdge          = width - BorderRight - FUNC_MARGIN - ng.ng_Width;
  731.         ng.ng_GadgetText        = MSG(MSG_CANCEL_GAD);
  732.         ng.ng_GadgetID          = GID_FUNCCANCEL;
  733.  
  734.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  735.                                            GT_Underscore,       '_',
  736.                                            TAG_DONE);
  737.         if (!gad)
  738.                 goto fgad_failed;
  739.         Gadget[GID_FUNCCANCEL] = gad;
  740.         AddKeyShortcut(FuncKeyboard, GID_FUNCCANCEL, MSG_CANCEL_GAD);
  741.  
  742.         ng.ng_LeftEdge          = (ng.ng_LeftEdge + BorderLeft + FUNC_MARGIN) / 2;
  743.         ng.ng_GadgetText        = MSG(MSG_UNDO_GAD);
  744.         ng.ng_GadgetID          = GID_FUNCUNDO;
  745.  
  746.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  747.                                            GT_Underscore,       '_',
  748.                                            TAG_DONE);
  749.         if (!gad)
  750.                 goto fgad_failed;
  751.         Gadget[GID_FUNCUNDO] = gad;
  752.         AddKeyShortcut(FuncKeyboard, GID_FUNCUNDO, MSG_UNDO_GAD);
  753.         
  754.         if (topline != yoffset[2]) {
  755.                 /*
  756.                  *              If there's room at the top of the window, create two text
  757.                  *              gadgets with the column headings for the System and DOS cols.
  758.                  */
  759.                 ng.ng_TopEdge           = topline;
  760.                 ng.ng_LeftEdge          = colpos[1];
  761.                 ng.ng_GadgetText        = "";
  762.                 ng.ng_GadgetID          = 0;
  763.  
  764.                 gad = CreateGadget(TEXT_KIND,   gad, &ng,
  765.                                                    GTTX_Text,   MSG(MSG_SYSFUNCS_GAD),
  766.                                                    TAG_DONE);
  767.                 if (!gad)
  768.                         goto fgad_failed;
  769.  
  770.                 ng.ng_LeftEdge          = colpos[2];
  771.                 gad = CreateGadget(TEXT_KIND,   gad, &ng,
  772.                                                    GTTX_Text,   MSG(MSG_DOSFUNCS_GAD),
  773.                                                    TAG_DONE);
  774.                 if (!gad)
  775.                         goto fgad_failed;
  776.         }
  777.         PurgeFuncGadgets = 0;   /* No need to purge now */
  778.         CloseFont(font);
  779.         return (gadlist);
  780.  
  781. fgad_failed:
  782.         if (gadlist)
  783.                 FreeGadgets(gadlist);
  784.         CloseFont(font);
  785.         return (NULL);
  786. }
  787.  
  788. /*
  789.  *              OpenFunctionWindow()
  790.  *
  791.  *              Opens the functions window with all the functions gadgets.
  792.  *              Returns TRUE for success, FALSE for failure.
  793.  *              The window will contain all necessary gadgets.
  794.  *
  795.  *              As with the Settings window, we try a variety of fonts until we
  796.  *              find one that fits onto the screen.
  797.  */
  798. int OpenFunctionWindow(void)
  799. {
  800.         static struct TextAttr funcfontattr =
  801.                 { "empty-storage-for-func-fonts...", 0, FS_NORMAL, FPB_DISKFONT};
  802.  
  803.         static int width;               /* Maintained from call to call */
  804.         static int height;
  805.  
  806.         int left = CurSettings.FuncWinLeft;
  807.         int top  = CurSettings.FuncWinTop;
  808.         struct TextAttr *fontattr = NULL;
  809.         struct Window *win;
  810.         int i;
  811.  
  812.         CheckSegTracker();
  813.         if (FuncWindow) {
  814.                 WindowToFront(FuncWindow);
  815.                 ActivateWindow(FuncWindow);
  816.                 return (TRUE);
  817.         }
  818.         if (!CheckForScreen())
  819.                 return (FALSE);
  820.  
  821.         SavedFuncSets = CurSettings;            /* Save so we can restore later */
  822.  
  823.         if (!FuncGadList) {
  824.                 /*
  825.                  *              Find out what dimensions our new window should be; to do
  826.                  *              this, we calculate the size with a variety of fonts until
  827.                  *              we find one that works.
  828.                  */
  829.                 int i;
  830.  
  831.                 for (i = 0; fontattr = SubWindowFontList[i]; i++) {
  832.                         if (CreateFunctionGadgets(fontattr, TRUE, &width, &height))
  833.                                 break;
  834.                 }
  835.                 if (!fontattr) {
  836.                         ShowError(MSG(MSG_ERROR_OPENFUNC));
  837.                         return (FALSE);
  838.                 }
  839.                 /*
  840.                  *              We need to make a copy of the fontattr now so that if
  841.                  *              the user changes the font, all our gadgets don't suddenly
  842.                  *              inherit the new font (at least until the window has been
  843.                  *              closed and re-opened!)
  844.                  */
  845.                 strcpy(funcfontattr.ta_Name, fontattr->ta_Name);
  846.                 funcfontattr.ta_YSize = fontattr->ta_YSize;
  847.                 fontattr = &funcfontattr;
  848.         }
  849.         if (left == -1)  left = (ScreenWidth  - width)  / 2;
  850.         if (top  == -1)  top  = (ScreenHeight - height) / 2;
  851.  
  852.         win = OpenWindowTags(NULL,
  853.                                                  WA_Title,                      MSG(MSG_FUNCTION_TITLE),
  854.                                                  WA_IDCMP,                      IDCMP_CLOSEWINDOW        |
  855.                                                                                         IDCMP_REFRESHWINDOW      |
  856.                                                                                         IDCMP_NEWSIZE            |
  857.                                                                                         IDCMP_INACTIVEWINDOW |
  858.                                                                                         IDCMP_RAWKEY             |
  859.                                                                                         BUTTONIDCMP,
  860.                                                  WA_Left,                       left,
  861.                                                  WA_Top,                        top,
  862.                                                  WA_Width,                      width,
  863.                                                  WA_Height,                     height,
  864.                                                  WA_Flags,                      WFLG_DRAGBAR             |
  865.                                                                                         WFLG_DEPTHGADGET         |
  866.                                                                                         WFLG_ACTIVATE            |
  867.                                                                                         WFLG_RMBTRAP             |
  868.                                                                                         WFLG_NEWLOOKMENUS,
  869.                                                  RefreshTag,            TRUE,
  870.                                                  WA_NoCareRefresh,      NoCareRefreshBool,
  871.                                                  WA_PubScreen,          SnoopScreen,
  872.                                                  TAG_DONE);
  873.         if (!win) {
  874.                 ShowError(MSG(MSG_ERROR_OPENFUNC));
  875.                 return (FALSE);
  876.         }
  877.  
  878.         if (!FuncGadList) {
  879.                 FuncGadList = CreateFunctionGadgets(fontattr, 0, 0, 0);
  880.                 if (!FuncGadList) {
  881.                         CloseWindow(win);
  882.                         ShowError(MSG(MSG_ERROR_OPENFUNC));
  883.                         return (FALSE);
  884.                 }
  885.         }
  886.  
  887.         /*
  888.          *              Now update function gadgets to reflect current settings
  889.          *              for AmigaDOS functions. Under V39+, we can do this before
  890.          *              adding them to the window. Under V37, we have to do it
  891.          *              after adding them to the window.
  892.          */
  893.         if (GadToolsBase->lib_Version < 39) {
  894.                 AddGList(win, FuncGadList, -1, -1, NULL);
  895.                 RefreshGList(FuncGadList, win, NULL, -1);
  896.                 GT_RefreshWindow(win, NULL);
  897.                 for (i = FIRST_BOOL_GADGET; i <= LAST_BOOL_GADGET; i++) {
  898.                         if (Gadget[i]) {
  899.                                 GT_SetGadgetAttrs(Gadget[i], win, NULL,
  900.                                                                   GTCB_Checked, CurSettings.Func.Opts[i],
  901.                                                                   TAG_DONE);
  902.                         }
  903.                 }
  904.         } else { /* GadToolsBase->lib_Version >= 39 */
  905.                 for (i = FIRST_BOOL_GADGET; i <= LAST_BOOL_GADGET; i++) {
  906.                         if (Gadget[i]) {
  907.                                 GT_SetGadgetAttrs(Gadget[i], NULL, NULL,
  908.                                                                   GTCB_Checked, CurSettings.Func.Opts[i],
  909.                                                                   TAG_DONE);
  910.                         }
  911.                 }
  912.                 AddGList(win, FuncGadList, -1, -1, NULL);
  913.                 RefreshGList(FuncGadList, win, NULL, -1);
  914.                 GT_RefreshWindow(win, NULL);
  915.         }
  916.  
  917.         /*
  918.          *              All done, so initialise some globals and return
  919.          */
  920.         FuncWindow              = win;
  921.         FuncWindowPort  = win->UserPort;
  922.         FuncWindowMask  = 1 << FuncWindowPort->mp_SigBit;
  923.         FuncSystemCol   = COL_SELECTED;
  924.         FuncDOSCol              = COL_SELECTED;
  925.         if (DisableNestCount)
  926.                 DisableWindow(FuncWindow, &FuncRequester);
  927.         return (TRUE);
  928. }
  929.  
  930. /*
  931.  *              CreateSettingsGadgets(fontattr, getsize, &pwidth, &pheight)
  932.  *
  933.  *              Creates the gadgets list for the settings window using the specified
  934.  *              window font. If the window would be to big for the current screen
  935.  *              using this font, or if there is a problem creating the gadgets,
  936.  *              returns NULL.
  937.  *
  938.  *              The returned gadget list should be passed to FreeGadgets() when
  939.  *              it is no longer required.
  940.  *
  941.  *              If getsize is true, then pwidth and pheight are filled in with the
  942.  *              dimensions of the window size needed to hold the gadgets, but
  943.  *              no actual gadget creation is carried out. In this case, NULL is
  944.  *              returned for a failure (couldn't open font, or window size would
  945.  *              exceed current screen size) and non-NULL for success.
  946.  */
  947. struct Gadget *CreateSettingsGadgets(struct TextAttr *fontattr,
  948.                                                                          int getsize, int *pwidth, int *pheight)
  949. {
  950.         struct SetGadgets *sg;
  951.         struct NewGadget ng;
  952.         struct NewGadget ngbut;
  953.         struct TextFont *font;
  954.         struct Gadget *gadlist;
  955.         struct Gadget *gad;
  956.         UWORD spacing;
  957.         UWORD yoffset;
  958.         UWORD colpos[2];
  959.         UWORD colwidth[3];
  960.         int miniwidth;
  961.         int width;
  962.         int height;
  963.         int gheight;
  964.         int fonty;
  965.         int fontx;
  966.  
  967.         if (!SetVI) {
  968.                 SetVI = GetVisualInfoA(SnoopScreen, NULL);
  969.                 if (!SetVI)
  970.                         return (NULL);
  971.         }
  972.         font = MyOpenFont(fontattr);
  973.         if (!font)
  974.                 return (NULL);
  975.         
  976.         fonty           = font->tf_YSize;
  977.         fontx           = font->tf_XSize;
  978.  
  979.         gheight         = fonty + GadgetHeight;
  980.         spacing     = fonty + GadgetSpacing;
  981.         yoffset         = TitlebarHeight + fonty/2;
  982.         colpos[0]       = BorderLeft + SET_MARGIN
  983.                                   + MaxTextLen(font, SettingsLeftNames) + 7;
  984.         colwidth[0] = MaxTextLen(font, SettingsLeftContents) + 40;
  985.         colpos[1]       = colpos[0] + colwidth[0] + SET_MARGIN*2
  986.                                                           + MaxTextLen(font, SettingsRightNames);
  987.         colwidth[1] = fontx * 24; /* Room for about 24 chars in string gadgets */
  988.         colwidth[2] = colwidth[1] + colpos[1] - colpos[0];      /* Dual width */
  989.  
  990.         /*
  991.          *              See SetMiniButtons[] definitions for explanation of this bit
  992.          */
  993.         if (font->tf_Flags & FPF_PROPORTIONAL) {
  994.                 miniwidth = MaxTextLen(font, SetMiniButtonsP) + 20;
  995.                 SetGadgs[1].data1 = MSG_FORMATCOPYP_GAD;
  996.         } else {
  997.                 miniwidth = MaxTextLen(font, SetMiniButtonsF) + 20;
  998.                 SetGadgs[1].data1 = MSG_FORMATCOPYF_GAD;
  999.         }
  1000.  
  1001.         width           = colpos[1] + colwidth[1] + SET_MARGIN + BorderRight;
  1002.         height      = yoffset + spacing * 8 + BorderBottom;
  1003.  
  1004.         if (width > ScreenWidth || height >ScreenHeight) {
  1005.                 CloseFont(font);
  1006.                 return (NULL);
  1007.         }
  1008.         if (getsize) {
  1009.                 *pwidth  = width;
  1010.                 *pheight = height;
  1011.                 CloseFont(font);
  1012.                 return (struct Gadget *)(-1);
  1013.         }
  1014.  
  1015.         /*
  1016.          *              Okay, looks like our size is okay so now prime our gadget
  1017.          *              table with the current settings values to use when the
  1018.          *              gadget is created.
  1019.          *
  1020.          */
  1021. #define DEF_CYCLE(x)    SetGadgs[SG_##x].data1
  1022. #define DEF_STRING(x)   SetGadgs[SG_##x].data2
  1023.  
  1024.         DEF_CYCLE(HideMethod)     = CurSettings.Setup.HideMethod;
  1025.         DEF_CYCLE(ScreenType)     = CurSettings.Setup.ScreenType;
  1026.         DEF_CYCLE(LogMode)                = CurSettings.Setup.LogMode;
  1027.         DEF_CYCLE(FileIOType)     = CurSettings.Setup.FileIOType;
  1028.         DEF_STRING(HotKey)                = CurSettings.Setup.HotKey;
  1029.         DEF_STRING(ScreenName)    = CurSettings.Setup.ScreenName;
  1030.         DEF_STRING(LogFile)               = CurSettings.Setup.LogFile;
  1031.         DEF_STRING(WindowFont)    = GetFontDesc(WindowFontDesc,
  1032.                                                                                     WindowFontName, WindowFontSize);
  1033.         DEF_STRING(BufferFont)    = GetFontDesc(BufferFontDesc,
  1034.                                                                                 BufferFontName, BufferFontSize);
  1035.         DEF_STRING(BufferFormat)  = BufFormat;
  1036.         DEF_STRING(LogfileFormat) = LogFormat;
  1037.  
  1038.         /*
  1039.          *              Next, onto the gadget creation itself
  1040.          */
  1041.         ng.ng_Height            = gheight; 
  1042.         ng.ng_TextAttr          = fontattr;
  1043.         ng.ng_VisualInfo        = SetVI;
  1044.         ng.ng_Flags         = PLACETEXT_LEFT;
  1045.  
  1046.         ngbut.ng_Height         = gheight; 
  1047.         ngbut.ng_TextAttr       = fontattr;
  1048.         ngbut.ng_VisualInfo     = SetVI;
  1049.         ngbut.ng_Flags          = PLACETEXT_IN;
  1050.  
  1051.         FileButtonImage = CreateCustomImage(IMAGE_FILE, gheight+2-2*SquareAspect);
  1052.         FontButtonImage = CreateCustomImage(IMAGE_FONT, gheight);
  1053.         if (!FileButtonImage || !FontButtonImage) {
  1054.                 CloseFont(font);
  1055.                 return (NULL);
  1056.         }
  1057.         gadlist = NULL;
  1058.         gad = CreateContext(&gadlist);
  1059.         if (!gad) {
  1060.                 CloseFont(font);
  1061.                 return (NULL);
  1062.         }
  1063.  
  1064.         for (sg = &SetGadgs[0]; sg->gadgid; sg++) {
  1065.                 ng.ng_LeftEdge          = colpos[sg->col];
  1066.                 ng.ng_Width                     = colwidth[sg->cwidth];
  1067.                 ng.ng_TopEdge           = yoffset + sg->row * spacing;
  1068.                 ng.ng_GadgetText        = MSG(sg->stringid);
  1069.                 ng.ng_GadgetID          = sg->gadgid;
  1070.                 ng.ng_Height            = gheight;
  1071.  
  1072.                 if (sg->promptid) {
  1073.                         /*
  1074.                          *              Create optional mini gadget to right of main gadget.
  1075.                          *              If data1 == 0 or data1 == 1 then use a file or font
  1076.                          *              BOOPSI gadget image, else use a Gadtools text button
  1077.                          *              containing the label corresponding to MSG(data1) else
  1078.                          *              use string ID indicated by data1
  1079.                          */
  1080.                         ngbut.ng_GadgetID  = sg->promptid;
  1081.                         ngbut.ng_TopEdge   = ng.ng_TopEdge;
  1082.                         ngbut.ng_Height    = gheight;
  1083.                         if (sg->gtype == STRING_KIND && !SquareAspect) {
  1084.                                 ngbut.ng_Height  += 2;
  1085.                                 ngbut.ng_TopEdge -= 1;
  1086.                         }
  1087.                         if (sg->data1 > SETBUTTON_MAX) {
  1088.                                 /*
  1089.                                  *              Creating a text gadget
  1090.                                  */
  1091.                                 ngbut.ng_LeftEdge   = ng.ng_LeftEdge + ng.ng_Width - miniwidth;
  1092.                                 ngbut.ng_Width          = miniwidth;
  1093.                                 ngbut.ng_GadgetText = MSG(sg->data1);
  1094.                                 gad = CreateGadget(BUTTON_KIND, gad, &ngbut,
  1095.                                                                    GT_Underscore, '_',
  1096.                                                                    TAG_DONE);
  1097.                                 if (!gad)
  1098.                                         goto sgad_failed;
  1099.                                 AddKeyShortcut(SetKeyboard, sg->promptid, sg->data1);
  1100.                         } else {
  1101.                                 /*
  1102.                                  *              Creating an image gadget
  1103.                                  */
  1104.                                 struct Image *img = FileButtonImage;
  1105.  
  1106.                                 if (sg->data1 == SETBUTTON_FONT)
  1107.                                         img = FontButtonImage;
  1108.  
  1109.                                 ngbut.ng_Width          = img->Width;
  1110.                                 ngbut.ng_GadgetText = NULL;
  1111.                                 ngbut.ng_LeftEdge   = ng.ng_LeftEdge + ng.ng_Width -img->Width;
  1112.                                 gad = CreateGadget(GENERIC_KIND, gad, &ngbut, TAG_DONE);
  1113.                                 if (!gad)
  1114.                                         goto sgad_failed;
  1115.  
  1116.                                 /*
  1117.                                  *              Now fill in the details of our gadget
  1118.                                  */
  1119.                                 gad->Flags                      |= GFLG_GADGIMAGE | GFLG_GADGHIMAGE;
  1120.                                 gad->Activation         |= GACT_IMMEDIATE | GACT_RELVERIFY;
  1121.                                 gad->GadgetType         |= GTYP_BOOLGADGET;
  1122.                                 gad->GadgetRender       = img;
  1123.                                 gad->SelectRender       = img + 1;
  1124.                         }
  1125.                         Gadget[sg->promptid] = gad;
  1126.                         ng.ng_Width     -= ngbut.ng_Width + 2;
  1127.                 }
  1128.                 switch (sg->gtype) {
  1129.                         case STRING_KIND:
  1130.                                 if (!SquareAspect) {
  1131.                                         ng.ng_Height  += 2;
  1132.                                         ng.ng_TopEdge -= 1;
  1133.                                 }
  1134.                                 gad = CreateGadget(STRING_KIND, gad, &ng,
  1135.                                                                    GT_Underscore,       '_',
  1136.                                                                    GTST_String,         sg->data2,
  1137.                                                                    GTST_MaxChars,       MAX_STR_LEN,
  1138.                                                                    TAG_DONE);
  1139.                                 break;
  1140.  
  1141.                         case TEXT_KIND:
  1142.                                 ng.ng_Width-= 2;
  1143.                                 ng.ng_LeftEdge++;
  1144.                                 gad = CreateGadget(TEXT_KIND, gad, &ng,
  1145.                                                                    GT_Underscore,       '_',
  1146.                                                                    GTTX_Text,           sg->data2,
  1147.                                                                    GTTX_Border,         TRUE,
  1148.                                                                    TAG_DONE);
  1149.                                 break;
  1150.  
  1151.                         case CYCLE_KIND:
  1152.                         {
  1153.                                 int *msgid = sg->data2;
  1154.                                 char **msg = sg->data3;
  1155.                                 int i;
  1156.  
  1157.                                 for (i = 0; msgid[i]; i++)
  1158.                                         msg[i] = MSG(msgid[i]);
  1159.                                 msg[i] = NULL;
  1160.                                 gad = CreateGadget(CYCLE_KIND, gad, &ng,
  1161.                                                                    GT_Underscore,       '_',
  1162.                                                                    GTCY_Active,         sg->data1,
  1163.                                                                    GTCY_Labels,         msg,
  1164.                                                                    TAG_DONE);
  1165.                                 break;
  1166.                         }
  1167.                 }
  1168.                 if (!gad)
  1169.                         goto sgad_failed;
  1170.                 Gadget[sg->gadgid] = gad;
  1171.                 AddKeyShortcut(SetKeyboard, sg->gadgid, sg->stringid);
  1172.         }
  1173.  
  1174.         ng.ng_GadgetText        = MSG(MSG_BUFFERSIZE_GAD);
  1175.         ng.ng_GadgetID          = GID_BUFFERSIZE;
  1176.         ng.ng_TopEdge           = yoffset + spacing * 4 + (1 - SquareAspect);
  1177.         ng.ng_Height            = gheight + (2 - 2 * SquareAspect);
  1178.         ng.ng_Width                     = GetTextLen(font, "10000") + 14;
  1179.         ng.ng_LeftEdge          = colpos[0] + colwidth[0] - ng.ng_Width;
  1180.  
  1181.         gad = CreateGadget(INTEGER_KIND,        gad, &ng,
  1182.                                            GT_Underscore,       '_',
  1183.                                            GTIN_Number,         CurSettings.Setup.BufferSize,
  1184.                                            TAG_DONE);
  1185.         if (!gad)
  1186.                 goto sgad_failed;
  1187.         Gadget[GID_BUFFERSIZE] = gad;
  1188.         AddKeyShortcut(SetKeyboard, GID_BUFFERSIZE, MSG_BUFFERSIZE_GAD);
  1189.  
  1190.         ng.ng_Width                     = MaxTextLen(font, UseCancelUndoText) + 32;
  1191.         ng.ng_Height            = fonty + GadgetHeight;
  1192.         ng.ng_GadgetText        = MSG(MSG_USE_GAD);
  1193.         ng.ng_GadgetID          = GID_SETUSE;
  1194.         ng.ng_LeftEdge          = BorderLeft + SET_MARGIN;
  1195.         ng.ng_TopEdge           = yoffset + 7 * spacing;
  1196.         ng.ng_Flags                     = PLACETEXT_IN;
  1197.  
  1198.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  1199.                                            GT_Underscore,       '_',
  1200.                                            TAG_DONE);
  1201.         if (!gad)
  1202.                 goto sgad_failed;
  1203.         Gadget[GID_SETUSE] = gad;
  1204.         AddKeyShortcut(SetKeyboard, GID_SETUSE, MSG_USE_GAD);
  1205.         
  1206.         ng.ng_LeftEdge          = width - BorderRight - SET_MARGIN - ng.ng_Width;
  1207.         ng.ng_GadgetText        = MSG(MSG_CANCEL_GAD);
  1208.         ng.ng_GadgetID          = GID_SETCANCEL;
  1209.  
  1210.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  1211.                                            GT_Underscore,       '_',
  1212.                                            TAG_DONE);
  1213.         if (!gad)
  1214.                 goto sgad_failed;
  1215.         Gadget[GID_SETCANCEL] = gad;
  1216.         AddKeyShortcut(SetKeyboard, GID_SETCANCEL, MSG_CANCEL_GAD);
  1217.         
  1218.         ng.ng_LeftEdge          = (ng.ng_LeftEdge + BorderLeft + SET_MARGIN) / 2;
  1219.         ng.ng_GadgetText        = MSG(MSG_UNDO_GAD);
  1220.         ng.ng_GadgetID          = GID_SETUNDO;
  1221.  
  1222.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  1223.                                            GT_Underscore,       '_',
  1224.                                            TAG_DONE);
  1225.         if (!gad)
  1226.                 goto sgad_failed;
  1227.         Gadget[GID_SETUNDO] = gad;
  1228.         AddKeyShortcut(SetKeyboard, GID_SETUNDO, MSG_UNDO_GAD);
  1229.  
  1230.         CloseFont(font);
  1231.         return (gadlist);
  1232.  
  1233. sgad_failed:
  1234.         if (gadlist)
  1235.                 FreeGadgets(gadlist);
  1236.         CloseFont(font);
  1237.         return (FALSE);
  1238. }
  1239.  
  1240. /*
  1241.  *              OpenSettingsWindow()
  1242.  *
  1243.  *              Opens the settings window with all the settings gadgets.
  1244.  *              The window will contain all necessary gadgets. Note that
  1245.  *              since gadgets can take some time to create on 68000 systems,
  1246.  *              we cache the gadget list so that on subsequent re-opens of
  1247.  *              the window, we don't need to recreate them all.
  1248.  *
  1249.  *              Returns TRUE for success, false for failure.
  1250.  */
  1251. int OpenSettingsWindow(void)
  1252. {
  1253.         static struct TextAttr setfontattr =
  1254.                 { "empty-storage-for-setup-fonts..", 0, FS_NORMAL, FPB_DISKFONT};
  1255.  
  1256.         static int width;               /* Maintained from call to call */
  1257.         static int height;
  1258.  
  1259.         int left = CurSettings.SetupWinLeft;
  1260.         int top  = CurSettings.SetupWinTop;
  1261.         struct TextAttr *fontattr = NULL;
  1262.         struct Window *win;
  1263.  
  1264.         CheckSegTracker();
  1265.         if (SetWindow) {
  1266.                 WindowToFront(SetWindow);
  1267.                 ActivateWindow(SetWindow);
  1268.                 return (TRUE);
  1269.         }
  1270.         if (!CheckForScreen())
  1271.                 return (FALSE);
  1272.  
  1273.         SavedSetupSets = CurSettings;           /* Save so we can restore later */
  1274.  
  1275.         if (!SetGadList) {
  1276.                 /*
  1277.                  *              Find out what dimensions our new window should be; to do
  1278.                  *              this, we calculate the size with a variety of fonts until
  1279.                  *              we find one that works.
  1280.                  */
  1281.                 int i;
  1282.  
  1283.                 for (i = 0; fontattr = SubWindowFontList[i]; i++) {
  1284.                         if (CreateSettingsGadgets(fontattr, TRUE, &width, &height))
  1285.                                 break;
  1286.                 }
  1287.                 if (!fontattr) {
  1288.                         ShowError(MSG(MSG_ERROR_OPENSET));
  1289.                         return (FALSE);
  1290.                 }
  1291.                 /*
  1292.                  *              We need to make a copy of the fontattr now so that if
  1293.                  *              the user changes the font, all our gadgets don't suddenly
  1294.                  *              inherit the new font (at least until the window has been
  1295.                  *              closed and re-opened!)
  1296.                  */
  1297.                 strcpy(setfontattr.ta_Name, fontattr->ta_Name);
  1298.                 setfontattr.ta_YSize = fontattr->ta_YSize;
  1299.                 fontattr = &setfontattr;
  1300.         }
  1301.         if (left == -1)  left = (ScreenWidth  - width)  / 2;
  1302.         if (top  == -1)  top  = (ScreenHeight - height) / 2;
  1303.  
  1304.         win = OpenWindowTags(NULL,
  1305.                                                  WA_Title,                      MSG(MSG_SETTINGS_TITLE),
  1306.                                                  WA_IDCMP,                      IDCMP_CLOSEWINDOW        |
  1307.                                                                                         IDCMP_REFRESHWINDOW      |
  1308.                                                                                         IDCMP_NEWSIZE            |
  1309.                                                                                         IDCMP_RAWKEY             |
  1310.                                                                                         IDCMP_INACTIVEWINDOW |
  1311.                                                                                         BUTTONIDCMP,
  1312.                                                  WA_Left,                       left,
  1313.                                                  WA_Top,                        top,
  1314.                                                  WA_Width,                      width,
  1315.                                                  WA_Height,                     height,
  1316.                                                  WA_Flags,                      WFLG_DRAGBAR             |
  1317.                                                                                         WFLG_DEPTHGADGET         |
  1318.                                                                                         WFLG_ACTIVATE            |
  1319.                                                                                         WFLG_RMBTRAP             |
  1320.                                                                                         WFLG_NEWLOOKMENUS,
  1321.                                                  RefreshTag,            TRUE,
  1322.                                                  WA_NoCareRefresh,      NoCareRefreshBool,
  1323.                                                  WA_PubScreen,          SnoopScreen,
  1324.                                                  TAG_DONE);
  1325.         if (!win) {
  1326.                 ShowError(MSG(MSG_ERROR_OPENSET));
  1327.                 return (FALSE);
  1328.         }
  1329.         if (!SetGadList) {
  1330.                 SetGadList = CreateSettingsGadgets(fontattr, 0, 0, 0);
  1331.                 if (!SetGadList) {
  1332.                         CloseWindow(win);
  1333.                         ShowError(MSG(MSG_ERROR_OPENSET));
  1334.                         return (FALSE);
  1335.                 }
  1336.         }
  1337.         AddGList(win, SetGadList, -1, -1, NULL);
  1338.         RefreshGList(SetGadList, win, NULL, -1);
  1339.         GT_RefreshWindow(win, NULL);
  1340.  
  1341.         SetWindow               = win;
  1342.         SetWindowPort   = win->UserPort;
  1343.         SetWindowMask   = 1 << SetWindowPort->mp_SigBit;
  1344.         if (DisableNestCount)
  1345.                 DisableWindow(SetWindow, &SetRequester);
  1346.         return (TRUE);
  1347. }
  1348.  
  1349. /*
  1350.  *              CloseFunctionWindow(void)
  1351.  *
  1352.  *              Closes the functions window. Note that we do NOT free the gadget
  1353.  *              list in this case; since it takes so long to build, we leave it
  1354.  *              alone for the benefit of future opens.
  1355.  */
  1356. void CloseFunctionWindow(void)
  1357. {
  1358.         if (FuncWindow) {
  1359.                 RecordWindowSizes();
  1360.                 CloseWindow(FuncWindow);
  1361.                 FuncWindow     = NULL;
  1362.                 FuncWindowMask = 0;
  1363.         }
  1364.         if (PurgeFuncGadgets && FuncGadList) {
  1365.                 FreeGadgets(FuncGadList);
  1366.                 FuncGadList        = NULL;
  1367.         }
  1368.         if (PurgeFuncGadgets && FuncVI) {
  1369.                 FreeVisualInfo(FuncVI);
  1370.                 FuncVI = NULL;
  1371.         }
  1372.         PurgeFuncGadgets = 0;
  1373. }
  1374.  
  1375. /*
  1376.  *              CloseSettingsWindow(void)
  1377.  *
  1378.  *              Closes the settings window, and free gadgets associated with window.
  1379.  */
  1380. void CloseSettingsWindow(void)
  1381. {
  1382.         if (SetWindow) {
  1383.                 RecordWindowSizes();
  1384.                 CloseWindow(SetWindow);
  1385.                 SetWindow     = NULL;
  1386.                 SetWindowMask = 0;
  1387.         }
  1388.         if (SetGadList) {
  1389.                 FreeGadgets(SetGadList);
  1390.                 SetGadList = NULL;
  1391.         }
  1392.         if (FileButtonImage) {
  1393.                 FreeCustomImage(FileButtonImage);
  1394.                 FileButtonImage = NULL;
  1395.         }
  1396.         if (FontButtonImage) {
  1397.                 FreeCustomImage(FontButtonImage);
  1398.                 FontButtonImage = NULL;
  1399.         }
  1400.         if (SetVI) {
  1401.                 FreeVisualInfo(SetVI);
  1402.                 SetVI = NULL;
  1403.         }
  1404. }
  1405.  
  1406. /*
  1407.  *              HandleSettingsMsgs()
  1408.  *
  1409.  *              Processes all outstanding messages associated with the Settings
  1410.  *              gadget window. To be called whenever we get a settings event.
  1411.  */
  1412.  
  1413. #define STRVAL(gid)     (((struct StringInfo *)(Gadget[gid]->SpecialInfo))->Buffer)
  1414.  
  1415. void HandleSettingsMsgs(void)
  1416. {
  1417.         static int activegad;                   /* Non-zero if gadget is depressed   */
  1418.         static int activekey;                   /* Keycode shortcut of activegad     */
  1419.  
  1420.         struct IntuiMessage *imsg;
  1421.         int doneset = SEL_NONE;
  1422.         char *str;
  1423.         int val;
  1424.  
  1425.         if (!SetWindow)
  1426.                 return;
  1427.  
  1428.         while ((imsg = GT_GetIMsg(SetWindowPort)) != NULL) {
  1429.                 struct Gadget *gad;
  1430.                 int gadid;
  1431.                 int shift  = (imsg->Qualifier & IE_SHIFT);
  1432.                 int newval;
  1433.  
  1434.                 switch (imsg->Class) {
  1435.                         
  1436.                         case IDCMP_CLOSEWINDOW:
  1437.                                 doneset = SEL_USE;
  1438.                                 break;
  1439.  
  1440.                         case IDCMP_REFRESHWINDOW:
  1441.                                 GT_BeginRefresh(SetWindow);
  1442.                                 GT_EndRefresh(SetWindow, TRUE);
  1443.                                 break;
  1444.  
  1445.                         case IDCMP_MOUSEMOVE: 
  1446.                         case IDCMP_GADGETDOWN:
  1447.                         case IDCMP_GADGETUP:
  1448.                                 gad    = (struct Gadget *)imsg->IAddress;
  1449.                                 gadid  = gad->GadgetID;
  1450.                                 newval = imsg->Code;
  1451.  
  1452. handle_set_gads:
  1453.                                 switch (gadid) {
  1454.  
  1455.                                         case GID_FILEPROMPT:
  1456.                                         {
  1457.                                                 char *defname = "";
  1458.  
  1459.                                                 /*
  1460.                                                  *              Choose a default name for the logfile
  1461.                                                  */
  1462.                                                 if (IsFileSystem(DefaultLogName))
  1463.                                                         defname = DefaultLogName;
  1464.  
  1465.                                                 if (SelectFile(DefaultLogName, defname, SetWindow,
  1466.                                                                            FILESEL_DEFLOGNAME))
  1467.                                                 {
  1468.                                                         /*
  1469.                                                          *              Got a new default filename, so update
  1470.                                                          *              the logfile gadget accordingly
  1471.                                                          */
  1472.                                                         GT_SetGadgetAttrs(Gadget[GID_LOGFILE],
  1473.                                                                                           SetWindow, NULL,
  1474.                                                                                           GTST_String, DefaultLogName,
  1475.                                                                                           TAG_DONE);
  1476.                                                 }
  1477.                                                 break;
  1478.                                         }
  1479.  
  1480.                                         case GID_WFONTPROMPT:
  1481.                                                 /*
  1482.                                                  *              Choose a new gadget (window) font
  1483.                                                  */
  1484.                                                 if (SelectFont(SetWindow, FONTSEL_WINDOW)) {
  1485.                                                         strcpy(WindowFontName, WindowFR->fo_Attr.ta_Name);
  1486.                                                         WindowFontSize = WindowFR->fo_Attr.ta_YSize;
  1487.                                                         WindowFontAttr.ta_YSize = WindowFontSize;
  1488.  
  1489.                                                         GT_SetGadgetAttrs(
  1490.                                                                 Gadget[GID_WINDOWFONT], SetWindow, NULL,
  1491.                                                                 GTTX_Text, GetFontDesc(WindowFontDesc,
  1492.                                                                                                            WindowFontName,
  1493.                                                                                                            WindowFontSize),
  1494.                                                                 TAG_DONE);
  1495.                                                         ReOpenMainWindow();
  1496.                                                         WindowToFront(SetWindow);
  1497.                                                         /*
  1498.                                                          *              Since we allow the function gadgets
  1499.                                                          *              to hang around even when the function
  1500.                                                          *              window closes, we need to free the
  1501.                                                          *              gadgets when we change fonts to force
  1502.                                                          *              them to be regenerated in the new
  1503.                                                          *              font.
  1504.                                                          */             
  1505.                                                         if (!FuncWindow) {
  1506.                                                                 FreeGadgets(FuncGadList);
  1507.                                                                 FuncGadList              = NULL;
  1508.                                                         } else {
  1509.                                                                 PurgeFuncGadgets = TRUE;
  1510.                                                         }
  1511.                                                 }
  1512.                                                 break;
  1513.  
  1514.                                         case GID_BFONTPROMPT:
  1515.                                                 /*
  1516.                                                  *              Choose a new buffer font
  1517.                                                  */
  1518.                                                 if (SelectFont(SetWindow, FONTSEL_BUFFER)) {
  1519.                                                         strcpy(BufferFontName, BufferFR->fo_Attr.ta_Name);
  1520.                                                         BufferFontSize = BufferFR->fo_Attr.ta_YSize;
  1521.                                                         BufferFontAttr.ta_YSize = BufferFontSize;
  1522.  
  1523.                                                         GT_SetGadgetAttrs(
  1524.                                                                 Gadget[GID_BUFFERFONT],
  1525.                                                                 SetWindow, NULL,
  1526.                                                                 GTTX_Text, GetFontDesc(BufferFontDesc,
  1527.                                                                                                            BufferFontName,
  1528.                                                                                                            BufferFontSize),
  1529.                                                                 TAG_DONE);
  1530.                                                         ReOpenMainWindow();
  1531.                                                         WindowToFront(SetWindow);
  1532.                                                 }
  1533.                                                 break;
  1534.  
  1535.                                         case GID_FORMATEDIT:
  1536.                                                 OpenFormatWindow();
  1537.                                                 break;
  1538.  
  1539.                                         case GID_FORMATCOPY:
  1540.                                                 if (shift)
  1541.                                                         *LogFormat = '\0';
  1542.                                                 else
  1543.                                                         strcpy(LogFormat, BufFormat);
  1544.                                                 GT_SetGadgetAttrs(Gadget[GID_LOGFORMAT],
  1545.                                                                                   SetWindow, NULL,
  1546.                                                                                   GTST_String, LogFormat,
  1547.                                                                                   TAG_DONE);
  1548.                                                 break;
  1549.  
  1550.                                         case GID_FILEIO:
  1551.                                                 CurSettings.Setup.FileIOType = newval;
  1552.                                                 break;
  1553.  
  1554.                                         case GID_OPENON:
  1555.                                                 CurSettings.Setup.ScreenType = newval;
  1556.                                                 break;
  1557.  
  1558.                                         case GID_LOGMODE:
  1559.                                                 CurSettings.Setup.LogMode        = newval;
  1560.                                                 SetLogGadget(newval, LG_REFRESH);
  1561.                                                 break;
  1562.  
  1563.                                         case GID_HIDEMETHOD:
  1564.                                                 if (!CxBase)
  1565.                                                         newval = 0;
  1566.  
  1567.                                                 if (newval != CurSettings.Setup.HideMethod) {
  1568.                                                         int oldval = CurSettings.Setup.HideMethod;
  1569.  
  1570.                                                         CurSettings.Setup.HideMethod = newval;
  1571.                                                         if (newval == HIDE_NONE)
  1572.                                                                 CleanupHotKey();
  1573.                                                         else if (oldval == HIDE_NONE) {
  1574.                                                                 /*
  1575.                                                                  *              Switching out of hide state so
  1576.                                                                  *              re-activate hotkey
  1577.                                                                  */
  1578.                                                                 InstallHotKey(CurSettings.Setup.HotKey);
  1579.                                                         }
  1580.                                                         SetMainHideState(newval);
  1581.                                                 }
  1582.                                                 break;
  1583.  
  1584.                                         case GID_HOTKEY:
  1585.                                         {
  1586.                                                 char *msg = CurSettings.Setup.HotKey;
  1587.  
  1588.                                                 strcpy(msg, STRVAL(GID_HOTKEY));
  1589.                                                 InstallHotKey(msg);
  1590.                                                 SetMainHideState(CurSettings.Setup.HideMethod);
  1591.                                                 break;
  1592.                                         }
  1593.  
  1594.                                         case GID_SCREENNAME:
  1595.                                                 strcpy(CurSettings.Setup.ScreenName,
  1596.                                                            STRVAL(GID_SCREENNAME));
  1597.                                                 break;
  1598.  
  1599.                                         case GID_LOGFILE:
  1600.                                                 strcpy(CurSettings.Setup.LogFile, STRVAL(GID_LOGFILE));
  1601.                                                 break;
  1602.  
  1603.                                         case GID_LOGFORMAT:
  1604.                                                 strcpy(CurSettings.Setup.LogfileFormat,
  1605.                                                            STRVAL(GID_LOGFORMAT));
  1606.                                                 break;
  1607.  
  1608.                                         case GID_BUFFORMAT:
  1609.                                                 str = STRVAL(GID_BUFFORMAT);
  1610.                                                 if (strcmp(BufFormat, str) != 0) {
  1611.                                                         strcpy(BufFormat, str);
  1612.                                                         InstallNewFormat(NEW_STRING);
  1613.                                                 }
  1614.                                                 break;
  1615.  
  1616.                                         case GID_BUFFERSIZE:
  1617.                                                 /*
  1618.                                                  *              We don't do anything here at all ... instead,
  1619.                                                  *              the update is handled when the user clicks
  1620.                                                  *              on USE.
  1621.                                                  */
  1622.                                                 break;
  1623.  
  1624.                                         case GID_SETUSE:
  1625.                                                 doneset = SEL_USE;
  1626.                                                 break;
  1627.  
  1628.                                         case GID_SETCANCEL:
  1629.                                                 doneset = SEL_CANCEL;
  1630.                                                 break;
  1631.  
  1632.                                         case GID_SETUNDO:
  1633.                                                 /*
  1634.                                                  *              Major bummer -- we need to manually update
  1635.                                                  *              ALL the string gadgets, since if the user
  1636.                                                  *              modified one of them and didn't press RETURN
  1637.                                                  *              we won't have picked it up and so we won't
  1638.                                                  *              know to undo it :-(
  1639.                                                  */
  1640.                                                 InstallSettings(&SavedSetupSets, SET_SETUP);
  1641.  
  1642. #define UndoSet SavedSetupSets.Setup
  1643.  
  1644.                                                 GT_SetGadgetAttrs(Gadget[GID_HOTKEY],
  1645.                                                                                   SetWindow, NULL,
  1646.                                                                                   GTST_String, UndoSet.HotKey,
  1647.                                                                                   TAG_DONE);
  1648.                                                 GT_SetGadgetAttrs(Gadget[GID_SCREENNAME],
  1649.                                                                                   SetWindow, NULL,
  1650.                                                                                   GTST_String, UndoSet.ScreenName,
  1651.                                                                                   TAG_DONE);
  1652.                                                 GT_SetGadgetAttrs(Gadget[GID_LOGFILE],
  1653.                                                                                   SetWindow, NULL,
  1654.                                                                                   GTST_String, UndoSet.LogFile,
  1655.                                                                                   TAG_DONE);
  1656.                                                 GT_SetGadgetAttrs(Gadget[GID_BUFFORMAT],
  1657.                                                                                   SetWindow, NULL,
  1658.                                                                                   GTST_String, UndoSet.BufferFormat,
  1659.                                                                                   TAG_DONE);
  1660.                                                 GT_SetGadgetAttrs(Gadget[GID_LOGFORMAT],
  1661.                                                                                   SetWindow, NULL,
  1662.                                                                                   GTST_String, UndoSet.LogfileFormat,
  1663.                                                                                   TAG_DONE);
  1664.                                                 GT_SetGadgetAttrs(Gadget[GID_BUFFERSIZE],
  1665.                                                                                   SetWindow, NULL,
  1666.                                                                                   GTIN_Number, UndoSet.BufferSize,
  1667.                                                                                   TAG_DONE);
  1668.                                                 break;
  1669.                                 }
  1670.                                 break;
  1671.  
  1672.                         case IDCMP_INACTIVEWINDOW:
  1673.                                 if (activegad) {
  1674.                                         ShowGadget(SetWindow, Gadget[activegad], GADGET_UP);
  1675.                                         activegad = 0;
  1676.                                 }
  1677.                                 break;
  1678.  
  1679.                         case IDCMP_RAWKEY:
  1680.                         {
  1681.                                 int upstroke = imsg->Code & 0x80;
  1682.                                 int keypress = ConvertIMsgToChar(imsg);
  1683.  
  1684.                                 gadid  = SetKeyboard[keypress];
  1685.                                 if (activegad) {
  1686.                                         /*
  1687.                                          *              We're releasing a gadget that was pressed
  1688.                                          *              earlier, so handle it now
  1689.                                          */
  1690.                                         int samekey = (imsg->Code & 0x7f) == activekey;
  1691.  
  1692.                                         if (samekey && !upstroke)       /* Ignore repeated keys */
  1693.                                                 break;
  1694.  
  1695.                                         ShowGadget(SetWindow, Gadget[activegad], GADGET_UP);
  1696.                                         if (samekey) {
  1697.                                                 /*
  1698.                                                  *              Just released the key that was originally
  1699.                                                  *              pressed for this gadget, so now go and
  1700.                                                  *              handle the gadget action.
  1701.                                                  */
  1702.                                                 gadid     = activegad;
  1703.                                                 gad       = Gadget[gadid];
  1704.                                                 activegad = 0;
  1705.                                                 goto handle_set_gads;
  1706.                                         }
  1707.  
  1708.                                         /*
  1709.                                          *              If the above check didn't kick in, it means
  1710.                                          *              we got a downpress of a different key, so
  1711.                                          *              disable the gadget for this key and continue
  1712.                                          *              to press the other key.
  1713.                                          */
  1714.                                         activegad = 0;
  1715.                                 }
  1716.  
  1717.                                 if (imsg->Code == HELPKEY) {
  1718.                                         ShowAGuide(MSG(MSG_LINK_SETUPWIN));
  1719.                                         break;
  1720.                                 }
  1721.  
  1722.                                 /*
  1723.                                  *              Handle keyboard equivalent keypresses for gadgets
  1724.                                  */
  1725.                                 if (gadid) {
  1726.                                         int numopts;
  1727.  
  1728.                                         gad = Gadget[gadid];
  1729.  
  1730.                                         switch (gadid) {
  1731.                                                 case GID_HIDEMETHOD:
  1732.                                                         newval  = CurSettings.Setup.HideMethod;
  1733.                                                         numopts = HIDE_MAX;
  1734.                                                         goto handle_set_cycle;
  1735.  
  1736.                                                 case GID_OPENON:
  1737.                                                         newval  = CurSettings.Setup.ScreenType;
  1738.                                                         numopts = SCREEN_MAX;
  1739.                                                         goto handle_set_cycle;
  1740.  
  1741.                                                 case GID_LOGMODE:
  1742.                                                         newval  = CurSettings.Setup.LogMode;
  1743.                                                         numopts = LOGMODE_MAX;
  1744.                                                         goto handle_set_cycle;
  1745.  
  1746.                                                 case GID_FILEIO:
  1747.                                                         newval  = CurSettings.Setup.FileIOType;
  1748.                                                         numopts = FILE_MAX;
  1749. handle_set_cycle:
  1750.                                                         newval++;
  1751.                                                         if (shift)
  1752.                                                                 newval -= 2;
  1753.                                                         if (newval < 0)                 newval += numopts;
  1754.                                                         if (newval >= numopts)  newval -= numopts;
  1755.                                                         GT_SetGadgetAttrs(gad, SetWindow, NULL,
  1756.                                                                                           GTCY_Active, newval,
  1757.                                                                                           TAG_DONE);
  1758.                                                         goto handle_set_gads;
  1759.  
  1760.                                                 case GID_BUFFERSIZE:
  1761.                                                 case GID_BUFFORMAT:
  1762.                                                 case GID_LOGFORMAT:
  1763.                                                 case GID_HOTKEY:
  1764.                                                 case GID_SCREENNAME:
  1765.                                                 case GID_LOGFILE:
  1766.                                                         if (gadid != GID_LOGFILE || !shift) {
  1767.                                                                 ActivateGadget(gad, SetWindow, NULL);
  1768.                                                                 break;
  1769.                                                         }
  1770.                                                         /*
  1771.                                                          *              User pressed GID_LOGFILE with SHIFT
  1772.                                                          *              pressed, so change gadget type to
  1773.                                                          *              GID_FILEPROMPT and fall through to
  1774.                                                          *              button code.
  1775.                                                          */
  1776.                                                         gadid = GID_FILEPROMPT;
  1777.                                                         /* Fall through */
  1778.  
  1779.                                                 case GID_SETUSE:
  1780.                                                 case GID_SETUNDO:
  1781.                                                 case GID_SETCANCEL:
  1782.                                                 case GID_FORMATCOPY:
  1783.                                                 case GID_FORMATEDIT:
  1784.                                                 case GID_WINDOWFONT:
  1785.                                                 case GID_BUFFERFONT:
  1786.                                                 case GID_WFONTPROMPT:
  1787.                                                 case GID_BFONTPROMPT:
  1788.                                                         if (gadid == GID_WINDOWFONT)
  1789.                                                                 gadid = GID_WFONTPROMPT;
  1790.                                                         if (gadid == GID_BUFFERFONT)
  1791.                                                                 gadid = GID_BFONTPROMPT;
  1792.                                                         gad = Gadget[gadid];
  1793.                                                         ShowGadget(SetWindow, gad, GADGET_DOWN);
  1794.                                                         activegad = gadid;
  1795.                                                         activekey = imsg->Code;
  1796.                                                         break;
  1797.                                         }
  1798.                                 }
  1799.                                 break;
  1800.                         }
  1801.                 }
  1802.                 GT_ReplyIMsg(imsg);
  1803.         }
  1804.         /*
  1805.          *              Handled all messages. Now check for possible USE/CANCEL
  1806.          */
  1807.         if (doneset == SEL_USE) {
  1808.                 /*
  1809.                  *              Use the current settings. To be safe, we update all
  1810.                  *              our string gadgets in case they were modified but
  1811.                  *              we didn't catch the modification (i.e. user didn't press
  1812.                  *              Return).
  1813.                  */
  1814.                 str = STRVAL(GID_BUFFORMAT);
  1815.                 if (strcmp(BufFormat, str) != 0) {
  1816.                         strcpy(BufFormat, str);
  1817.                         InstallNewFormat(NEW_STRING);
  1818.                 }
  1819.                 strcpy(CurSettings.Setup.LogFile,                STRVAL(GID_LOGFILE));
  1820.                 strcpy(CurSettings.Setup.ScreenName,     STRVAL(GID_SCREENNAME));
  1821.                 strcpy(CurSettings.Setup.HotKey,                 STRVAL(GID_HOTKEY));
  1822.                 strcpy(CurSettings.Setup.LogfileFormat,  STRVAL(GID_LOGFORMAT));
  1823.                 strcpy(CurSettings.Setup.LogfileFormat,  STRVAL(GID_LOGFORMAT));
  1824.                 val = atoi(STRVAL(GID_BUFFERSIZE));
  1825.                 CloseSettingsWindow();
  1826.                 /*
  1827.                  *              Now check if we've got a new buffer size --
  1828.                  *              if so, install it.
  1829.                  */
  1830.                 if (val < 1)
  1831.                         val = 1;
  1832.  
  1833.                 if (val != SavedSetupSets.Setup.BufferSize) {
  1834.                         CurSettings.Setup.BufferSize = val;
  1835.                         ClearWindowBuffer();
  1836.                         if (!SetTotalBufferSize(val * 1024, SETBUF_FORCENEW)) {
  1837.                                 ShowError(MSG(MSG_ERROR_NOBUFMEM), val);
  1838.                                 Cleanup(20);
  1839.                         }
  1840.                 }
  1841.         } else if (doneset == SEL_CANCEL) {
  1842.                 /*
  1843.                  *              Cancel the current settings, and restore those that
  1844.                  *              were in effect before we started this. We close
  1845.                  *              the settings window first in case the main window
  1846.                  *              needs to close and re-open (change of font) since
  1847.                  *              this looks cleaner.
  1848.                  *
  1849.                  *              Note that even though we saved the entire set of settings,
  1850.                  *              we only restore the SETUP settings, not all of them.
  1851.                  */
  1852.                 CloseSettingsWindow();
  1853.                 InstallSettings(&SavedSetupSets, SET_SETUP);
  1854.         }
  1855. }
  1856.  
  1857. /*
  1858.  *              ShowFuncOpts(options, firstid, lastid)
  1859.  *
  1860.  *              Updates the function window gadgets to reflect the new values
  1861.  *              in the specified options array.
  1862.  *
  1863.  *              The new options are compared with the existing options to see
  1864.  *              if they've changed, so you should make sure to call this function
  1865.  *              _before_ copying the new options onto the current settings.
  1866.  *
  1867.  *              Only gadgets from the first to the last ID given are affected.
  1868.  */
  1869. void ShowFuncOpts(UBYTE newopts[], int firstid, int lastid)
  1870. {
  1871.         int i;
  1872.  
  1873.         for (i = firstid; i <= lastid; i++) {
  1874.                 if (Gadget[i] != NULL && newopts[i] != CurSettings.Func.Opts[i]) {
  1875.                         GT_SetGadgetAttrs(Gadget[i], FuncWindow, NULL,
  1876.                                                           GTCB_Checked, newopts[i],
  1877.                                                           TAG_DONE);
  1878.                 }
  1879.         }
  1880. }
  1881.  
  1882. /*
  1883.  *              ResetFuncToSelected()
  1884.  *
  1885.  *              Changes the two cycle gadgets in the function window back to the
  1886.  *              SELECTED state, and updates the variables accordingly. Note
  1887.  *              that doesn't change the actual boolean settings themselves; in
  1888.  *              effect, it makes the current settings permanent by stopping you
  1889.  *              switching back to the SELECTED state to restore an older set
  1890.  *              by clicking on the cycle gadget yourself.
  1891.  */
  1892. void ResetFuncToSelected(void)
  1893. {
  1894.         if (FuncSystemCol != COL_SELECTED) {
  1895.                 GT_SetGadgetAttrs(Gadget[GID_SELSYSTEM],
  1896.                                                   FuncWindow, NULL,
  1897.                                                   GTCY_Active, COL_SELECTED,
  1898.                                                   TAG_DONE);
  1899.         }
  1900.         if (FuncDOSCol != COL_SELECTED) {
  1901.                 GT_SetGadgetAttrs(Gadget[GID_SELDOS],
  1902.                                                   FuncWindow, NULL,
  1903.                                                   GTCY_Active, COL_SELECTED,
  1904.                                                   TAG_DONE);
  1905.         }
  1906.         FuncSystemCol = COL_SELECTED;
  1907.         FuncDOSCol    = COL_SELECTED;
  1908. }
  1909.  
  1910. /*
  1911.  *              HandleFuncMsgs()
  1912.  *
  1913.  *              Processes all outstanding messages associated with the Functions
  1914.  *              gadget window. To be called whenever we get a functions event.
  1915.  *
  1916.  *              The only slightly complicated bit here concerns the two cycle
  1917.  *              gadgets which can be used to select all or none of either of
  1918.  *              the DOS and System columns, or to restore a previous setting
  1919.  *              installed before.
  1920.  */
  1921. void HandleFuncMsgs(void)
  1922. {
  1923.         static int activegad;                   /* Non-zero if gadget is depressed   */
  1924.         static int activekey;                   /* Keycode shortcut of activegad     */
  1925.  
  1926.         struct IntuiMessage *imsg;
  1927.         int donefunc = SEL_NONE;
  1928.  
  1929.         if (!FuncWindow)
  1930.                 return;
  1931.  
  1932.         while ((imsg = GT_GetIMsg(FuncWindowPort)) != NULL) {
  1933.                 struct Gadget *gad;
  1934.                 int shift = (imsg->Qualifier & IE_SHIFT);
  1935.                 LONG gadid;
  1936.                 int newval;
  1937.  
  1938.                 switch (imsg->Class) {
  1939.                         
  1940.                         case IDCMP_REFRESHWINDOW:
  1941.                                 GT_BeginRefresh(FuncWindow);
  1942.                                 GT_EndRefresh(FuncWindow, TRUE);
  1943.                                 break;
  1944.  
  1945.                         case IDCMP_CLOSEWINDOW:
  1946.                                 donefunc = SEL_USE;
  1947.                                 break;
  1948.  
  1949.                         case IDCMP_MOUSEMOVE: 
  1950.                         case IDCMP_GADGETDOWN:
  1951.                         case IDCMP_GADGETUP:
  1952.                                 gad    = (struct Gadget *)imsg->IAddress;
  1953.                                 gadid  = gad->GadgetID;
  1954.                                 newval = imsg->Code;
  1955.  
  1956. handle_func_gads:
  1957.  
  1958.                                 switch (gadid) {
  1959.  
  1960.                                         case GID_MATCHNAME:
  1961.                                                 strcpy(MatchName, STRVAL(GID_MATCHNAME));
  1962.                                                 SetPattern(MatchName, IgnoreWBShell);
  1963.                                                 break;
  1964.  
  1965.                                         case GID_SELSYSTEM:
  1966.                                         case GID_SELDOS:
  1967.                                                 /*
  1968.                                                  *              Changing system column cycle gadget.
  1969.                                                  *              Update to show ALL, NONE or SELECTED
  1970.                                                  *              system gadgets.
  1971.                                                  */
  1972.                                         {
  1973.                                                 int first    = FIRST_SYS_GADGET;
  1974.                                                 int last     = LAST_SYS_GADGET;
  1975.                                                 int numgads  = NUM_SYS_GADGETS;
  1976.                                                 int *pcurval = &FuncSystemCol;
  1977.  
  1978.                                                 if (gadid == GID_SELDOS) {
  1979.                                                         /*
  1980.                                                          *              Override above defaults with new
  1981.                                                          *              defaults for DOS cycle gadget
  1982.                                                          */
  1983.                                                         first    = FIRST_DOS_GADGET;
  1984.                                                         last     = LAST_DOS_GADGET;
  1985.                                                         numgads  = NUM_DOS_GADGETS;
  1986.                                                         pcurval  = &FuncDOSCol;
  1987.                                                 }
  1988.                                                 if (newval == *pcurval)
  1989.                                                         break;          /* Ignore no-op events */
  1990.  
  1991.                                                 if (newval == COL_SELECTED) {
  1992.                                                         /*
  1993.                                                          *              Restore previously saved system col values
  1994.                                                          */
  1995.                                                         ShowFuncOpts(SavedCols, first, last);
  1996.                                                         memcpy(&CurSettings.Func.Opts[first],
  1997.                                                                    &SavedCols[first], numgads);
  1998.                                                 } else {
  1999.                                                         /*
  2000.                                                          *              Select either ALL or NONE of the settings
  2001.                                                          *              in the system column.
  2002.                                                          */
  2003.                                                         int fillval = (newval == COL_ALL);
  2004.  
  2005.                                                         memset(&TempCols[first], fillval, numgads);
  2006.                                                         ShowFuncOpts(TempCols, first, last);
  2007.                                                                         
  2008.                                                         if (*pcurval == COL_SELECTED) {
  2009.                                                            /*
  2010.                                                             *           If we are moving out of the
  2011.                                                                 *               selected state, then save the
  2012.                                                                 *               existing settings for later.
  2013.                                                                 */
  2014.                                                            memcpy(&SavedCols[first],
  2015.                                                                           &CurSettings.Func.Opts[first], numgads);
  2016.                                                         }
  2017.                                                         memset(&CurSettings.Func.Opts[first],
  2018.                                                                    fillval, numgads);
  2019.                                                 }
  2020.                                                 LoadFuncSettings(&CurSettings.Func);
  2021.                                                 *pcurval = newval;
  2022.                                                 break;
  2023.                                         }
  2024.  
  2025.                                         case GID_FUNCUSE:
  2026.                                                 /*
  2027.                                                  *              Retain existing settings, and exit
  2028.                                                  */
  2029.                                                 donefunc = SEL_USE;
  2030.                                                 break;
  2031.  
  2032.                                         case GID_FUNCCANCEL:
  2033.                                                 /*
  2034.                                                  *              Restore original settings and exit
  2035.                                                  */
  2036.                                                 donefunc = SEL_CANCEL;
  2037.                                                 break;
  2038.  
  2039.                                         case GID_FUNCUNDO:
  2040.                                                 /*
  2041.                                                  *              Restore original settings but don't exit
  2042.                                                  */
  2043.                                                 InstallSettings(&SavedFuncSets, SET_FUNC);
  2044.                                                 break;
  2045.  
  2046.                                         default:
  2047.                                                 if (gadid >= FIRST_BOOL_GADGET &&
  2048.                                                                                                 gadid <= LAST_BOOL_GADGET) {
  2049.                                                         /*
  2050.                                                          *              Getting a new boolean gadget so update
  2051.                                                          *              CurSettings to reflect this.
  2052.                                                          */
  2053.                                                         CurSettings.Func.Opts[gadid] =
  2054.                                                                                 (gad->Flags & GFLG_SELECTED) != 0;
  2055.                                                         LoadFuncSettings(&CurSettings.Func);
  2056.                                                         /*
  2057.                                                          *              Now check to see if we need to put
  2058.                                                          *              either column back into the selected
  2059.                                                          *              state again.
  2060.                                                          */
  2061.                                                         if (FuncSystemCol != COL_SELECTED &&
  2062.                                                                 gadid >= FIRST_SYS_GADGET         &&
  2063.                                                             gadid <= LAST_SYS_GADGET)
  2064.                                                         {
  2065.                                                                 FuncSystemCol = COL_SELECTED;
  2066.                                                                 GT_SetGadgetAttrs(Gadget[GID_SELSYSTEM],
  2067.                                                                                                   FuncWindow, NULL,
  2068.                                                                                                   GTCY_Active, COL_SELECTED,
  2069.                                                                                                   TAG_DONE);
  2070.                                                         }
  2071.                                                         if (FuncDOSCol != COL_SELECTED  &&
  2072.                                                                 gadid >= FIRST_DOS_GADGET       &&
  2073.                                                             gadid <= LAST_DOS_GADGET)
  2074.                                                         {
  2075.                                                                 FuncDOSCol = COL_SELECTED;
  2076.                                                                 GT_SetGadgetAttrs(Gadget[GID_SELDOS],
  2077.                                                                                                   FuncWindow, NULL,
  2078.                                                                                                   GTCY_Active, COL_SELECTED,
  2079.                                                                                                   TAG_DONE);
  2080.                                                         }
  2081.                                                 }
  2082.                                                 break;
  2083.                                 }
  2084.                                 break;
  2085.  
  2086.                         case IDCMP_INACTIVEWINDOW:
  2087.                                 if (activegad) {
  2088.                                         ShowGadget(FuncWindow, Gadget[activegad], GADGET_UP);
  2089.                                         activegad = 0;
  2090.                                 }
  2091.                                 break;
  2092.  
  2093.                         case IDCMP_RAWKEY:
  2094.                         {
  2095.                                 int upstroke = imsg->Code & 0x80;
  2096.                                 int keypress = ConvertIMsgToChar(imsg);
  2097.  
  2098.                                 gadid  = FuncKeyboard[keypress];
  2099.                                 if (activegad) {
  2100.                                         /*
  2101.                                          *              We're releasing a gadget that was pressed
  2102.                                          *              earlier, so handle it now
  2103.                                          */
  2104.                                         int samekey = (imsg->Code & 0x7f) == activekey;
  2105.  
  2106.                                         if (samekey && !upstroke)       /* Ignore repeated keys */
  2107.                                                 break;
  2108.  
  2109.                                         ShowGadget(FuncWindow, Gadget[activegad], GADGET_UP);
  2110.                                         if (samekey) {
  2111.                                                 /*
  2112.                                                  *              Just released the key that was originally
  2113.                                                  *              pressed for this gadget, so now go and
  2114.                                                  *              handle the gadget action.
  2115.                                                  */
  2116.                                                 gadid     = activegad;
  2117.                                                 gad       = Gadget[gadid];
  2118.                                                 activegad = 0;
  2119.                                                 goto handle_func_gads;
  2120.                                         }
  2121.                                         /*
  2122.                                          *              If the above check didn't kick in, it means
  2123.                                          *              we got a downpress of a different key, so
  2124.                                          *              disable the gadget for this key and continue
  2125.                                          *              to press the other key.
  2126.                                          */
  2127.                                         activegad = 0;
  2128.                                 }
  2129.  
  2130.                                 if (imsg->Code == HELPKEY) {
  2131.                                         ShowAGuide(MSG(MSG_LINK_FUNCWIN));
  2132.                                         break;
  2133.                                 }
  2134.  
  2135.                                 /*
  2136.                                  *              Handle keyboard equivalents for gadgets
  2137.                                  */
  2138.                                 gadid = FuncKeyboard[keypress];
  2139.                                 if (gadid) {
  2140.                                         gad = Gadget[gadid];
  2141.  
  2142.                                         if (gadid >= FIRST_BOOL_GADGET &&
  2143.                                                                                 gadid <= LAST_BOOL_GADGET) {
  2144.                                                 /*
  2145.                                                  *              It's a boolean gadget so just invert its
  2146.                                                  *              current setting
  2147.                                                  */
  2148.                                                 newval = !CurSettings.Func.Opts[gadid];
  2149.                                                 GT_SetGadgetAttrs(Gadget[gadid], FuncWindow, NULL,
  2150.                                                                                   GTCB_Checked, newval, TAG_DONE);
  2151.                                                 goto handle_func_gads;
  2152.                                         } else if (gadid == GID_SELSYSTEM || gadid == GID_SELDOS) {
  2153.                                                 /*
  2154.                                                  *              One of the two cycle gadgets. Cycle forward
  2155.                                                  *              if the unshifted key was pressed or back
  2156.                                                  *              if the shifted version was pressed
  2157.                                                  */
  2158.                                                 newval = FuncSystemCol;
  2159.                                                 if (gadid == GID_SELDOS)
  2160.                                                         newval = FuncDOSCol;
  2161.                                                 newval++;
  2162.                                                 if (shift)
  2163.                                                         newval -= 2;
  2164.                                                 if (newval < 0) newval = 2;
  2165.                                                 if (newval > 2) newval = 0;
  2166.                                                 GT_SetGadgetAttrs(gad, FuncWindow, NULL,
  2167.                                                                                   GTCY_Active, newval, TAG_DONE);
  2168.                                                 goto handle_func_gads;
  2169.                                         } else if (gadid == GID_MATCHNAME) {
  2170.                                                 /* 
  2171.                                                  *              The string gadget, so simply activate it
  2172.                                                  */
  2173.                                                 ActivateGadget(gad, FuncWindow, NULL);
  2174.                                         } else {
  2175.                                                 /*
  2176.                                                  *              It must be a button gadget so show it
  2177.                                                  *              selected first before processing it
  2178.                                                  */
  2179.                                                 ShowGadget(FuncWindow, gad, GADGET_DOWN);
  2180.                                                 activegad = gadid;
  2181.                                                 activekey = imsg->Code;
  2182.                                         }
  2183.                                 }
  2184.                                 break;
  2185.                         }
  2186.                 }
  2187.                 GT_ReplyIMsg(imsg);
  2188.         }
  2189.         if (donefunc != SEL_NONE) {
  2190.                 /*
  2191.                  *              Since we cache the function gadgets between window opens,
  2192.                  *              we need to ensure the two cycle gadgets are reset to
  2193.                  *              SELECTED mode ready for the next time we open the window.
  2194.                  *              (Ideally, we would remember the cycle state and use the
  2195.                  *              same state next time, but that's too much work!)
  2196.                  */
  2197.                 ResetFuncToSelected();
  2198.         }
  2199.         if (donefunc == SEL_USE) {
  2200.                 strcpy(MatchName, STRVAL(GID_MATCHNAME));
  2201.                 SetPattern(MatchName, IgnoreWBShell);
  2202.                 CloseFunctionWindow();
  2203.         } else if (donefunc == SEL_CANCEL) {
  2204.                 CloseFunctionWindow();
  2205.                 /*
  2206.                  *              Note that though we saved all the settings, we only
  2207.                  *              re-install the original function settings, not all
  2208.                  *              of them.
  2209.                  */
  2210.                 InstallSettings(&SavedFuncSets, SET_FUNC);
  2211.         }
  2212. }
  2213.  
  2214. /*
  2215.  *              CreateFormatGadgets(gadgetfa, bufferfa, getsize, &width, &height)
  2216.  *
  2217.  *              Creates all the gadgets for the format window. If getsize
  2218.  *              is true, then the width and height values are filled in with
  2219.  *              the dimensions of the window needed to hold the gadgets. In
  2220.  *              this case, NULL is returned if the window would be too big to
  2221.  *              fit on the current screen, or non-NULL if width and height
  2222.  *              were successfully initialised.
  2223.  *
  2224.  *              gadgetfa gives the gadget font to use, bufferfa gives the buffer
  2225.  *              font (for the format listings).
  2226.  *
  2227.  *              If getsize is zero, then the actual gadgets are created and
  2228.  *              a pointer to the gadget list is returned, or NULL if an
  2229.  *              error occurred (typically, out of memory).
  2230.  */
  2231. struct Gadget *CreateFormatGadgets(struct TextAttr *gadgetfa,
  2232.                                                                    struct TextAttr *bufferfa,
  2233.                                                                    int getsize, int *pwidth, int *pheight)
  2234. {
  2235.         struct TextFont *gfont;
  2236.         struct TextFont *bfont;
  2237.         struct NewGadget ng;
  2238.         struct Gadget *gadlist;
  2239.         struct Gadget *gad;
  2240.         FieldInit *fi;
  2241.         int width;
  2242.         int height;
  2243.         int gwidth;
  2244.         int gheight;
  2245.         int gfonty;
  2246.         int bfontx;
  2247.         int bfonty;
  2248.         int topline;
  2249.         int maxtitlelen;
  2250.         int buttonwidth;
  2251.         int buttonspace;
  2252.         int headingspace;
  2253.         int outmargin;
  2254.  
  2255.         if (!FormVI) {
  2256.                 FormVI = GetVisualInfoA(SnoopScreen, NULL);
  2257.                 if (!FormVI)
  2258.                         return (NULL);
  2259.         }
  2260.         gfont = MyOpenFont(gadgetfa);
  2261.         if (!gfont)
  2262.                 return (NULL);
  2263.  
  2264.         bfont = MyOpenFont(bufferfa);
  2265.         if (!bfont) {
  2266.                 CloseFont(gfont);
  2267.                 return (NULL);
  2268.         }
  2269.         if (bfont->tf_Flags & FPF_PROPORTIONAL) {
  2270.                 CloseFont(bfont);
  2271.                 CloseFont(gfont);
  2272.                 return (NULL);
  2273.         }
  2274.         bfontx          = bfont->tf_XSize;
  2275.         bfonty          = bfont->tf_YSize;
  2276.         gfonty          = gfont->tf_YSize;
  2277.         gheight         = gfonty  + 3;
  2278.         gwidth          = gheight + 15;
  2279.         topline     = TitlebarHeight + gfonty/2;
  2280.  
  2281.         /*
  2282.          *              Now calculate the width of the window boxes which will contain
  2283.          *              the format sequences being displayed. The defaults box must be
  2284.          *              wide enough to hold "titlemsg..  %x" whereas the current format
  2285.          *              box must be wide enough to hold "titlemsg..  %20x".
  2286.          *
  2287.          *              Since the message titles may be localised, we calculate the
  2288.          *              longest string and work from that.
  2289.          */
  2290.         maxtitlelen = 0;
  2291.         for (fi = FieldTypes; fi->type != EF_END; fi++) {
  2292.                 int len = strlen(MSG(fi->titlemsgid));
  2293.  
  2294.                 if (len > maxtitlelen)
  2295.                         maxtitlelen = len;
  2296.         }
  2297.         /*
  2298.          *              The next two vars give the number of characters that will fit
  2299.          *              across each box. These is used when producing output.
  2300.          *
  2301.          *              For the left box, this is the length of the longest heading title,
  2302.          *              plus 2 for spacing after the heading name, another 2 for the
  2303.          *              format ID (%x) and a final 2 for the spacing on either side.
  2304.          *
  2305.          *              The right box is similar, but uses an additional 2 characters to
  2306.          *              display the field width of the selected item.
  2307.          */
  2308.         FBoxA_NumChars  = maxtitlelen   + 6;
  2309.         FBoxB_NumChars  = FBoxA_NumChars + 2;
  2310.         FBoxA_Width     = FBoxA_NumChars * bfontx + 4;
  2311.         FBoxB_Width     = FBoxB_NumChars * bfontx + 4;
  2312.  
  2313.         /*
  2314.          *              Create format strings for sprintf formatting later on. These
  2315.          *              look like this:
  2316.          *
  2317.          *                      FBoxA_FormString:       " %-??s  %%%lc "                (2 parameters)
  2318.          *                      FBoxB_FormString:       " %-??s  %%%02ld%lc "   (3 parameters)
  2319.          *
  2320.          *              and when strings are output using these templates, they look like:
  2321.          *
  2322.          *                      FBoxA_FormString:       " PaddedTitleName....  %x "
  2323.          *                      FBoxB_FormString:   " PaddedTitleName....  %12x "
  2324.          */
  2325.         mysprintf(FBoxA_FormString, " %%-%lds  %%%%%%lc ",               maxtitlelen);
  2326.         mysprintf(FBoxB_FormString, " %%-%lds  %%%%%%02ld%%lc ", maxtitlelen);
  2327.  
  2328.         /*
  2329.          *              Make sure we never have overlapping button gadgets (this might
  2330.          *              happen if we had a big gadget font and small buffer font).
  2331.          */
  2332.         buttonwidth = MaxTextLen(gfont, UseCancelUndoText) + 32;
  2333.         buttonspace = buttonwidth * 3 + FORM_MARGIN * 4 + BorderLeft + BorderRight;
  2334.  
  2335.         width = FBoxA_Width + FBoxB_Width + FORM_MARGIN * 4 +
  2336.                                                   BorderLeft  + BorderRight;
  2337.  
  2338.         outmargin = FORM_MARGIN;
  2339.         if (buttonspace > width)
  2340.                 width = buttonspace;
  2341.  
  2342.         headingspace =  GetTextLen(gfont, MSG(MSG_AVAILABLE_GAD)) +
  2343.                                         GetTextLen(gfont, MSG(MSG_CURFORMAT_GAD)) +
  2344.                                         BorderLeft + BorderRight + FORM_MARGIN*3;
  2345.  
  2346.         if (headingspace > width)
  2347.                 width = headingspace;
  2348.  
  2349.         /*
  2350.          *              Now calculate the dimensions of our two windows boxes. The left
  2351.          *              box displays the available format headings, and the right box
  2352.          *              displays the currently selected format headings.
  2353.          */
  2354.         FBoxSpacing             = bfonty + 2;
  2355.         FBoxA_Top               = topline + gfonty + 4;
  2356.         FBoxA_Height    = EF_COUNT * FBoxSpacing + 4;
  2357.         FBoxA_Left      = BorderLeft + outmargin;
  2358.  
  2359.         FBoxB_Top               = FBoxA_Top;
  2360.         FBoxB_Height    = FBoxA_Height;
  2361.         FBoxB_Left      = width - BorderRight - outmargin - FBoxB_Width;
  2362.          
  2363.         height = FBoxA_Top + FBoxA_Height + BorderBottom +
  2364.                          (gfonty + GadgetHeight) * 3;
  2365.  
  2366.         if (width > ScreenWidth || height > ScreenHeight) {
  2367.                 CloseFont(gfont);
  2368.                 CloseFont(bfont);
  2369.                 return (NULL);
  2370.         }
  2371.         if (getsize) {
  2372.                 CloseFont(gfont);
  2373.                 CloseFont(bfont);
  2374.                 *pwidth  = width;
  2375.                 *pheight = height;
  2376.                 return (struct Gadget *)(-1);
  2377.         }
  2378.  
  2379.         /*
  2380.          *              Now create our window gadgets. We have a total of 4 -- the
  2381.          *              Use, Undo, Cancel buttons, and the field width slider.
  2382.          */     
  2383.         gadlist = NULL;
  2384.         gad = CreateContext(&gadlist);
  2385.         if (!gad)
  2386.                 goto fogad_failed;
  2387.  
  2388.         ng.ng_TextAttr          = gadgetfa;
  2389.         ng.ng_VisualInfo        = FormVI;
  2390.         ng.ng_Flags                     = PLACETEXT_IN;
  2391.         ng.ng_TopEdge           = height - BorderBottom - (gfonty+GadgetHeight) * 3/2;
  2392.         ng.ng_Height            = gfonty + GadgetHeight;
  2393.         ng.ng_Width                     = buttonwidth;
  2394.  
  2395.         ng.ng_LeftEdge          = FORM_MARGIN + BorderLeft;
  2396.         ng.ng_GadgetText        = MSG(MSG_USE_GAD);
  2397.         ng.ng_GadgetID          = GID_FORMUSE;
  2398.  
  2399.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  2400.                                            GT_Underscore,       '_',
  2401.                                            TAG_DONE);
  2402.         if (!gad)
  2403.                 goto fogad_failed;
  2404.         Gadget[GID_FORMUSE] = gad;
  2405.         AddKeyShortcut(FormKeyboard, GID_FORMUSE, MSG_USE_GAD);
  2406.         
  2407.         ng.ng_LeftEdge          = width - BorderRight - FORM_MARGIN - ng.ng_Width;
  2408.         ng.ng_GadgetText        = MSG(MSG_CANCEL_GAD);
  2409.         ng.ng_GadgetID          = GID_FORMCANCEL;
  2410.  
  2411.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  2412.                                            GT_Underscore,       '_',
  2413.                                            TAG_DONE);
  2414.         if (!gad)
  2415.                 goto fogad_failed;
  2416.         Gadget[GID_FORMCANCEL] = gad;
  2417.         AddKeyShortcut(FormKeyboard, GID_FORMCANCEL, MSG_CANCEL_GAD);
  2418.         
  2419.         ng.ng_LeftEdge          = (ng.ng_LeftEdge + BorderLeft + FORM_MARGIN) / 2;
  2420.         ng.ng_GadgetText        = MSG(MSG_UNDO_GAD);
  2421.         ng.ng_GadgetID          = GID_FORMUNDO;
  2422.  
  2423.         gad = CreateGadget(BUTTON_KIND,         gad, &ng,
  2424.                                            GT_Underscore,       '_',
  2425.                                            TAG_DONE);
  2426.         if (!gad)
  2427.                 goto fogad_failed;
  2428.         Gadget[GID_FORMUNDO] = gad;
  2429.         AddKeyShortcut(FormKeyboard, GID_FORMUNDO, MSG_UNDO_GAD);
  2430.  
  2431.         /*
  2432.          *              Create the slider gadget. We need to leave room on the left for
  2433.          *              the title, and on the right for the current value.
  2434.          */
  2435.         ng.ng_LeftEdge          = FORM_MARGIN + BorderLeft + 8 +
  2436.                                                   GetTextLen(gfont, MSG(MSG_FIELDWIDTH_GAD));
  2437.         ng.ng_Width                     = width - FORM_MARGIN - ng.ng_LeftEdge -
  2438.                                                   BorderLeft - BorderRight - GetTextLen(gfont, "99 ");
  2439.         ng.ng_Height            = gfonty + 3;
  2440.         ng.ng_TopEdge           = (ng.ng_TopEdge + FBoxA_Top + FBoxA_Height -
  2441.                                                    ng.ng_Height) / 2;
  2442.         ng.ng_GadgetText        = MSG(MSG_FIELDWIDTH_GAD);
  2443.         ng.ng_GadgetID          = GID_FORMWIDTH;
  2444.         ng.ng_Flags                     = PLACETEXT_LEFT;
  2445.  
  2446.         gad = CreateGadget(SLIDER_KIND,                 gad, &ng,
  2447.                                            GTSL_LevelFormat,    "%2ld ",
  2448.                                            GTSL_LevelPlace,             PLACETEXT_RIGHT,
  2449.                                            GTSL_Level,                  1,
  2450.                                            GTSL_Min,                    1,
  2451.                                            GTSL_Max,                    MAX_FIELD_LEN,
  2452.                                            GTSL_MaxLevelLen,    2,
  2453.                                            GT_Underscore,               '_',
  2454.                                            GA_Disabled,                 TRUE,
  2455.                                            GA_RelVerify,                TRUE,
  2456.                                            TAG_DONE);
  2457.         if (!gad)
  2458.                 goto fogad_failed;
  2459.         Gadget[GID_FORMWIDTH] = gad;
  2460.         AddKeyShortcut(FormKeyboard, GID_FORMWIDTH, MSG_FIELDWIDTH_GAD);
  2461.  
  2462.         FormGadFont = gfont;
  2463.         FormBufFont = bfont;
  2464.         return (gadlist);
  2465.  
  2466. fogad_failed:
  2467.         if (gadlist)
  2468.                 FreeGadgets(gadlist);
  2469.         CloseFont(gfont);
  2470.         CloseFont(bfont);
  2471.         return (NULL);
  2472. }
  2473.  
  2474. /*
  2475.  *              ShowFormatLine(line, select)
  2476.  *
  2477.  *              Outputs the numbered line of text in the right-hand box. If the
  2478.  *              number given is too high, then a blank line is output instead.
  2479.  *              The text will be of the form "HeadingName.... %02x" according
  2480.  *              to the current contents of the line.
  2481.  *
  2482.  *              If select is FORMAT_SELECTED, the line will be highlighted, else
  2483.  *              it will be output normally.
  2484.  */
  2485. void ShowFormatLine(int line, int select)
  2486. {
  2487.         int bfontbaseline          = FormBufFont->tf_Baseline;
  2488.         int boxwidth               = FormBufFont->tf_XSize * FBoxB_NumChars;
  2489.         struct RastPort *rport = FormWindow->RPort;
  2490.         char viewbuf[60];
  2491.         int fillpen = 0;
  2492.         int textpen = 1;
  2493.         int textrow;
  2494.         
  2495.         if (select == FORMAT_SELECTED) {
  2496.                 fillpen = ScreenDI->dri_Pens[FILLPEN];
  2497.                 textpen = ScreenDI->dri_Pens[FILLTEXTPEN];
  2498.         }
  2499.         SetFont(rport, FormBufFont);
  2500.         SetAPen(rport, textpen);
  2501.         SetBPen(rport, fillpen);
  2502.         SetDrMd(rport, JAM2);
  2503.  
  2504.         if (line < 0 || line >= EF_COUNT)
  2505.                 return;
  2506.  
  2507.         if (line < FBoxB_CurLines) {
  2508.                 FieldInit *fi = &FieldTypes[CurrentFields[line].type];
  2509.  
  2510.                 mysprintf(viewbuf, FBoxB_FormString, MSG(fi->titlemsgid),
  2511.                                                    CurrentFields[line].width, fi->idchar);
  2512.         } else {
  2513.                 memset(viewbuf, ' ', FBoxB_NumChars);
  2514.         }
  2515.         textrow = FBoxB_Top + line*FBoxSpacing + 3;
  2516.         Move(rport, FBoxB_Left + 2, textrow + bfontbaseline);
  2517.         Text(rport, viewbuf, FBoxB_NumChars);
  2518.  
  2519.         /*
  2520.          *              Now draw highlight on top and bottom of selected line
  2521.          *              (or erase, as the case may be). This fills out the
  2522.          *              selection area and makes it look much better.
  2523.          */
  2524.         SetAPen(rport, fillpen);
  2525.         Move(rport, FBoxB_Left + 2, textrow - 1);
  2526.         Draw(rport, FBoxB_Left + 1 + boxwidth, textrow - 1);
  2527.         Move(rport, FBoxB_Left + 2, textrow + FormBufFont->tf_YSize);
  2528.         Draw(rport, FBoxB_Left + 1 + boxwidth, textrow + FormBufFont->tf_YSize);
  2529. }
  2530.  
  2531. /*
  2532.  *              ShowDragSelect(pos, select)
  2533.  *
  2534.  *              Highlights the specified region to indicate where the currently
  2535.  *              dragged field will end up if it is released here.
  2536.  *
  2537.  *              If pos is FBOX_NOSELECT, no drop area is active and no output is
  2538.  *              produced. If pos is FBOX_SELECTLEFT, then the left box is active
  2539.  *              and it is given an inverse highlight around the interior of the
  2540.  *              box giving a bezel effect.
  2541.  *
  2542.  *              If pos is in the range 0 ... EF_COUNT, then it corresponds to an
  2543.  *              insertion point between two lines in the right-most box. This is
  2544.  *              show by a two-pixel high highlight line drawn between those two
  2545.  *              lines.
  2546.  *
  2547.  *              If select is FORMAT_SELECTED, the feature is drawn; if select is
  2548.  *              FORMAT_UNSELECTED, the feature is instead erased. Note that after
  2549.  *              calling this function, it may be necessary to redisplay any
  2550.  *              current highlight bar in the right box (see ShowFormatLine) since
  2551.  *              there is a one-pixel overlap between the highlight bar and the
  2552.  *              rendering done here.
  2553.  */
  2554. void ShowDragSelect(int pos, int select)
  2555. {
  2556.         struct RastPort *rport = FormWindow->RPort;
  2557.         int black = 1;
  2558.         int white = 2; 
  2559.  
  2560.         if (pos == FBOX_NOSELECT)
  2561.                 return;
  2562.         
  2563.         if (select == FORMAT_UNSELECTED) {
  2564.                 black = 0;
  2565.                 white = 0;
  2566.         }
  2567.         SetDrMd(rport, JAM2);
  2568.         if (pos == FBOX_SELECTLEFT) {
  2569.                 /*
  2570.                  *              Draw bezel inside left box
  2571.                  */
  2572.                 int boxleft  = FBoxA_Left + 2;
  2573.                 int boxtop       = FBoxA_Top  + 1;
  2574.                 int boxright = FBoxA_Left + FBoxA_Width  - 3;
  2575.                 int boxbot   = FBoxA_Top  + FBoxA_Height - 2;
  2576.  
  2577.                 SetAPen(rport, black);
  2578.                 Move(rport, boxleft,    boxbot);
  2579.                 Draw(rport, boxleft,    boxtop);
  2580.                 Move(rport, boxleft+1,  boxbot-1);
  2581.                 Draw(rport, boxleft+1,  boxtop);
  2582.                 Draw(rport, boxright-1, boxtop);
  2583.  
  2584.                 SetAPen(rport, white);
  2585.                 Move(rport, boxright,   boxtop);
  2586.                 Draw(rport, boxright,   boxbot);
  2587.                 Move(rport, boxright-1, boxtop);
  2588.                 Draw(rport, boxright-1, boxbot);
  2589.                 Draw(rport, boxleft-1,  boxbot);
  2590.         } else if (pos >= 0 && pos <= EF_COUNT) {
  2591.                 /*
  2592.                  *              Draw thin selection line in right box
  2593.                  */
  2594.                 int line = FBoxB_Top + 1 + pos * FBoxSpacing;
  2595.  
  2596.                 SetAPen(rport, white);
  2597.                 Move(rport, FBoxB_Left+2,                               line);
  2598.                 Draw(rport, FBoxB_Left+FBoxB_Width-3,   line);
  2599.                 SetAPen(rport, black);
  2600.                 Move(rport, FBoxB_Left+2,                               line+1);
  2601.                 Draw(rport, FBoxB_Left+FBoxB_Width-3,   line+1);
  2602.         }
  2603. }
  2604.  
  2605. /*
  2606.  *              RedrawFormatWindow()
  2607.  *
  2608.  *              Redraws all the parts of the format window that are generated by
  2609.  *              hand: this includes the two bevelled boxes containing the available
  2610.  *              format fields, the headings for those boxes, and the current contens
  2611.  *              of those boxes, including highlighting where appropriate.
  2612.  */
  2613. void RedrawFormatWindow(void)
  2614. {
  2615.         char viewbuf[60];
  2616.         struct RastPort *rport = FormWindow->RPort;
  2617.         int gfonty                = FormGadFont->tf_YSize;
  2618.         int gfontbaseline = FormGadFont->tf_Baseline;
  2619.         int bfontbaseline = FormBufFont->tf_Baseline;
  2620.         int line;
  2621.         int headpos;
  2622.         EditEvent *ee;
  2623.  
  2624.         DrawBevelBox(rport, FBoxA_Left, FBoxA_Top, FBoxA_Width, FBoxA_Height,
  2625.                                                 GT_VisualInfo, FormVI,
  2626.                                                 TAG_DONE);
  2627.  
  2628.         DrawBevelBox(rport, FBoxB_Left, FBoxB_Top, FBoxB_Width, FBoxB_Height,
  2629.                                                 GT_VisualInfo, FormVI,
  2630.                                                 TAG_DONE);
  2631.  
  2632.         SetAPen(rport, 1);
  2633.         SetBPen(rport, 0);
  2634.         SetDrMd(rport, JAM2);
  2635.         SetFont(rport, FormGadFont);
  2636.  
  2637.         /*
  2638.          *              When outputting the box headings, we adjust the centering
  2639.          *              to ensure that headings wider than the boxes don't get
  2640.          *              pushed into the window borders.
  2641.          */
  2642. #define CENTRE(left,width,msgid)        \
  2643.                 ((width - GetTextLen(FormGadFont, MSG(msgid)))/2 + left)
  2644.  
  2645.         headpos = CENTRE(FBoxA_Left, FBoxA_Width, MSG_AVAILABLE_GAD);
  2646.         if (headpos < (BorderLeft + 4))
  2647.                 headpos = FBoxA_Left; /* was: BorderLeft + 4; */
  2648.  
  2649.         Move(rport, headpos, FBoxA_Top - gfonty + gfontbaseline - 4);
  2650.         Text(rport, MSG(MSG_AVAILABLE_GAD), strlen(MSG(MSG_AVAILABLE_GAD)));
  2651.  
  2652.         headpos = CENTRE(FBoxB_Left, FBoxB_Width, MSG_CURFORMAT_GAD);
  2653.         if (headpos < (FBoxB_Left - 4))
  2654.                 headpos = FBoxB_Left + FBoxB_Width -
  2655.                                                            GetTextLen(FormGadFont, MSG(MSG_CURFORMAT_GAD));
  2656.  
  2657.         Move(rport, headpos, FBoxB_Top - gfonty + gfontbaseline - 4);
  2658.         Text(rport, MSG(MSG_CURFORMAT_GAD), strlen(MSG(MSG_CURFORMAT_GAD)));
  2659.  
  2660.         /*
  2661.          *              Now redraw the text inside the left box (available headings)
  2662.          */
  2663.         SetFont(rport, FormBufFont);
  2664.         ee = &AvailableFields[0];
  2665.         for (line = 0; line < (FBoxB_Height - 4); line += FBoxSpacing) {
  2666.                 if (ee->type != END_EDITLIST) {
  2667.                         FieldInit *fi = &FieldTypes[ee->type];
  2668.                         mysprintf(viewbuf, FBoxA_FormString, MSG(fi->titlemsgid),
  2669.                                                                                                  fi->idchar);
  2670.                         ee++;
  2671.                 } else {
  2672.                         memset(viewbuf, ' ', FBoxA_NumChars);
  2673.                 }
  2674.                 Move(rport, FBoxA_Left + 2, FBoxA_Top + line + bfontbaseline + 3);
  2675.                 Text(rport, viewbuf, FBoxA_NumChars);
  2676.         }
  2677.  
  2678.         /*
  2679.          *              Redraw the text inside the right box (currently selected headings)
  2680.          */
  2681.         ee = &CurrentFields[0];
  2682.         for (line = 0; line < EF_COUNT; line++) {
  2683.                 if (line == FBoxSelected)
  2684.                         ShowFormatLine(line, FORMAT_SELECTED);
  2685.                 else
  2686.                         ShowFormatLine(line, FORMAT_UNSELECTED);
  2687.         }
  2688. }
  2689.  
  2690. /*
  2691.  *              ConvertListToFormat(list, format)
  2692.  *
  2693.  *              Converts the passed in EditList to a format list which can be
  2694.  *              used for updating the main SnoopDos display. Returns the
  2695.  *              total width (in characters) occupied by the format.
  2696.  */
  2697. int ConvertListToFormat(EditEvent *ee, EventFormat *evformat)
  2698. {
  2699.         int width = 0;
  2700.  
  2701.         while (ee->type != END_EDITLIST) {
  2702.                 width               += ee->width + 1; /* Include space between cols */
  2703.                 evformat->type           = FieldTypes[ee->type].type;
  2704.                 evformat->width          = ee->width;
  2705.                 evformat->titlemsgid = FieldTypes[ee->type].titlemsgid;
  2706.                 evformat++;
  2707.                 ee++;
  2708.         }
  2709.         evformat->type = EF_END;
  2710.         if (width)
  2711.                 width--;                /* Don't count extra space at end */
  2712.         return (width);
  2713. }
  2714.  
  2715. /*
  2716.  *              CreateFormatLists(format)
  2717.  *
  2718.  *              Parses the passed-in format string and creates the two lists
  2719.  *              used by the format editor window to allow the user to re-arrange
  2720.  *              the format.
  2721.  *
  2722.  *              Should be called before RedrawFormatWindow() is called for the
  2723.  *              first time.
  2724.  *
  2725.  *              Also initialises some format globals related to the list boxes.
  2726.  */
  2727. void CreateFormatLists(EventFormat *evformat)
  2728. {
  2729.         EditEvent *ee;
  2730.         FieldInit *fi;
  2731.         EventFormat *ef;
  2732.  
  2733.         /*
  2734.          *              Now build the lists for the two boxes. The right box contains
  2735.          *              all items in the format string (and in the same order that they
  2736.          *              appear in the format string). The left box contains all the
  2737.          *              items that are NOT in the format string, in the presorted
  2738.          *              order that they appear in the FieldTypes[] initialiser array.
  2739.          *
  2740.          *              Note that the two edit lists contain indexes directly into
  2741.          *              the FieldTypes array, rather than specific event types.
  2742.          *              Thus, we store the offset into the array when we find a match
  2743.          *              rather than fi->type.
  2744.          */
  2745.         ee = &CurrentFields[0];
  2746.         for (ef = evformat; ef->type != EF_END; ef++) {
  2747.                 for (fi = FieldTypes; fi->type != ef->type && fi->type != EF_END; fi++)
  2748.                         ;
  2749.                 ee->type  = fi - FieldTypes;
  2750.                 ee->width = ef->width;
  2751.                 ee++;
  2752.         }
  2753.         ee->type = END_EDITLIST;
  2754.         FBoxB_CurLines = ee - &CurrentFields[0];
  2755.  
  2756.         ee = &AvailableFields[0];
  2757.         for (fi = FieldTypes; fi->type != EF_END; fi++) {
  2758.                 for (ef = BufferEFormat; ef->type != fi->type && ef->type != EF_END;
  2759.                                                                 ef++)
  2760.                         ;
  2761.                 if (ef->type != fi->type) {     /* Not in current format so add it here */
  2762.                         ee->type = fi - &FieldTypes[0];
  2763.                         ee++;
  2764.                 }
  2765.         }
  2766.         ee->type = END_EDITLIST;
  2767.  
  2768.         FBoxA_CurLines          = ee - &AvailableFields[0];
  2769.         FBoxSelected            = FBOX_NOSELECT;
  2770.         FBoxDragSelect          = FBOX_NOSELECT;
  2771.         FormatCurLMB            = 0;    /* Left mouse button not selected at start */
  2772.         FormatMovingField       = 0;
  2773.         /*
  2774.          *              Ensure slider gadget is disabled (it might have been left
  2775.          *              enabled from an earlier time, which can be confusing).
  2776.          */
  2777.         if (FormWindow) {
  2778.                 GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH], FormWindow,  NULL,
  2779.                                                   GA_Disabled, TRUE,
  2780.                                                   TAG_DONE);
  2781.         }
  2782. }
  2783.  
  2784. /*
  2785.  *              OpenFormatWindow()
  2786.  *
  2787.  *              Opens the format editor window with all the format gadgets.
  2788.  *              Returns TRUE for success, FALSE for failure.
  2789.  *              The window will contain all necessary gadgets.
  2790.  *
  2791.  *              As with the Settings window, we try a variety of fonts until we
  2792.  *              find one that fits onto the screen.
  2793.  */
  2794. int OpenFormatWindow(void)
  2795. {
  2796.         static struct TextAttr formgfontattr =
  2797.                 { "empty-storage-for-format1-fonts", 0, FS_NORMAL, FPB_DISKFONT};
  2798.         static struct TextAttr formbfontattr =
  2799.                 { "empty-storage-for-format2-fonts", 0, FS_NORMAL, FPB_DISKFONT};
  2800.  
  2801.         static int width;               /* Maintained from call to call */
  2802.         static int height;
  2803.  
  2804.         int left = CurSettings.FormWinLeft;
  2805.         int top  = CurSettings.FormWinTop;
  2806.         struct TextAttr *gadgetfa;
  2807.         struct TextAttr *bufferfa;
  2808.         struct Window *win;
  2809.         int i;
  2810.  
  2811.         CheckSegTracker();
  2812.         if (FormWindow) {
  2813.                 WindowToFront(FormWindow);
  2814.                 ActivateWindow(FormWindow);
  2815.                 return (TRUE);
  2816.         }
  2817.         if (!CheckForScreen())
  2818.                 return (FALSE);
  2819.  
  2820.         strcpy(FormatSaveFormat, BufFormat);    /* Save for possible Undo */
  2821.  
  2822.         /*
  2823.          *              Now try all combinations of gadget and buffer font until we
  2824.          *              find a font combination that fits on our screen
  2825.          */
  2826.         for (i = 0; gadgetfa = MainWindowFontList[i].gadgetfa; i++) {
  2827.                 bufferfa = MainWindowFontList[i].bufferfa;
  2828.                 if (CreateFormatGadgets(gadgetfa, bufferfa, TRUE, &width, &height))
  2829.                         break;
  2830.         }
  2831.         if (!gadgetfa) {
  2832.                 ShowError(MSG(MSG_ERROR_OPENFORMAT));
  2833.                 return (FALSE);
  2834.         }
  2835.         /*
  2836.          *              Now copy our font attributes so that our gadgets won't strangely
  2837.          *              get changed behind the scenes if we update our fonts
  2838.          */
  2839.         strcpy(formgfontattr.ta_Name, gadgetfa->ta_Name);
  2840.         formgfontattr.ta_YSize = gadgetfa->ta_YSize;
  2841.         gadgetfa = &formgfontattr;
  2842.  
  2843.         strcpy(formbfontattr.ta_Name, bufferfa->ta_Name);
  2844.         formbfontattr.ta_YSize = bufferfa->ta_YSize;
  2845.         bufferfa = &formbfontattr;
  2846.  
  2847.         if (left == -1)  left = (ScreenWidth  - width)  / 2;
  2848.         if (top  == -1)  top  = (ScreenHeight - height) / 2;
  2849.  
  2850.         win = OpenWindowTags(NULL,
  2851.                                                  WA_Title,                      MSG(MSG_FORMAT_TITLE),
  2852.                                                  WA_IDCMP,                      IDCMP_CLOSEWINDOW        |
  2853.                                                                                         IDCMP_REFRESHWINDOW      |
  2854.                                                                                         IDCMP_NEWSIZE            |
  2855.                                                                                         IDCMP_RAWKEY             |
  2856.                                                                                         IDCMP_MOUSEBUTTONS       |
  2857.                                                                                         IDCMP_INACTIVEWINDOW |
  2858.                                                                                         BUTTONIDCMP                      |
  2859.                                                                                         SLIDERIDCMP,
  2860.                                                  WA_Left,                       left,
  2861.                                                  WA_Top,                        top,
  2862.                                                  WA_Width,                      width,
  2863.                                                  WA_Height,                     height,
  2864.                                                  WA_Flags,                      WFLG_DRAGBAR             |
  2865.                                                                                         WFLG_DEPTHGADGET         |
  2866.                                                                                         WFLG_ACTIVATE            |
  2867.                                                                                         WFLG_RMBTRAP             |
  2868.                                                                                         WFLG_NEWLOOKMENUS,
  2869.                                                  RefreshTag,            TRUE,
  2870.                                                  WA_NoCareRefresh,      NoCareRefreshBool,
  2871.                                                  WA_PubScreen,          SnoopScreen,
  2872.                                                  TAG_DONE);
  2873.         if (!win) {
  2874.                 ShowError(MSG(MSG_ERROR_OPENFORMAT));
  2875.                 return (FALSE);
  2876.         }
  2877.  
  2878.         if (!FormGadList) {
  2879.                 FormGadList = CreateFormatGadgets(gadgetfa, bufferfa, 0, 0, 0);
  2880.                 if (!FormGadList) {
  2881.                         CloseWindow(win);
  2882.                         ShowError(MSG(MSG_ERROR_OPENFORMAT));
  2883.                         return (FALSE);
  2884.                 }
  2885.         }
  2886.  
  2887.         /*
  2888.          *              Now try and create our BOBs for the window
  2889.          */
  2890.         TextBob = CreateBob(win->RPort, FBoxB_Width + 8,
  2891.                                                                     FormBufFont->tf_YSize + 4, 1);
  2892.         if (!TextBob) {
  2893.                 ShowError(MSG(MSG_ERROR_OPENFORMAT));
  2894.                 FreeGadgets(FormGadList);
  2895.                 FormGadList     = NULL;
  2896.                 CloseWindow(win);
  2897.                 return (FALSE);
  2898.         }
  2899.         AddBob(&TextBob->bob, win->RPort);
  2900.  
  2901.         /*
  2902.          *              Now add gadgets to screen window, and then setup the current
  2903.          *              format string for editing.
  2904.          */
  2905.         AddGList(win, FormGadList, -1, -1, NULL);
  2906.         RefreshGList(FormGadList, win, NULL, -1);
  2907.         GT_RefreshWindow(win, NULL);
  2908.  
  2909.         /*
  2910.          *              All done, so initialise some globals and return
  2911.          */
  2912.         FormWindow              = win;
  2913.         FormWindowPort  = win->UserPort;
  2914.         FormWindowMask  = 1 << FormWindowPort->mp_SigBit;
  2915.  
  2916.         CreateFormatLists(BufferEFormat);
  2917.         /*
  2918.          *              Finally, draw our window to reflect this
  2919.          */
  2920.         RedrawFormatWindow();
  2921.         if (DisableNestCount)
  2922.                 DisableWindow(FormWindow, &FormRequester);
  2923.         return (TRUE);
  2924. }
  2925.  
  2926. /*
  2927.  *              CloseFormatWindow(void)
  2928.  *
  2929.  *              Close the format window and free gadgets associated with the window.
  2930.  */
  2931. void CloseFormatWindow(void)
  2932. {
  2933.         if (FormWindow) {
  2934.                 if (TextBob) {
  2935.                         FreeBob(TextBob);
  2936.                         TextBob = NULL;
  2937.                 }
  2938.                 RecordWindowSizes();
  2939.                 CloseWindow(FormWindow);
  2940.                 CloseFont(FormGadFont);
  2941.                 CloseFont(FormBufFont);
  2942.                 FormWindow     = NULL;
  2943.                 FormWindowMask = 0;
  2944.                 FormGadFont        = NULL;
  2945.                 FormBufFont        = NULL;
  2946.         }
  2947.         if (FormGadList) {
  2948.                 FreeGadgets(FormGadList);
  2949.                 FormGadList = NULL;
  2950.         }
  2951.         if (FormVI) {
  2952.                 FreeVisualInfo(FormVI);
  2953.                 FormVI = NULL;
  2954.         }
  2955. }
  2956.  
  2957. /*
  2958.  *              FormatHitDetect(x, y)
  2959.  *
  2960.  *              Does a bounds check for the specified X/Y co-ordinates against the
  2961.  *              format editor window. A return value in the range 0..EF_COUNT-1
  2962.  *              indicates that line number in the right hand window was hit.
  2963.  *
  2964.  *              A return of FBOX_SELECTLEFT indicates that the left box was selected
  2965.  *              (not sure which line; doesn't really matter).
  2966.  *
  2967.  *              A return of FBOX_NOSELECT indicates neither box was selected.
  2968.  */
  2969. int FormatHitDetect(int x, int y)
  2970. {
  2971.         if (x >= FBoxA_Left && x <= (FBoxA_Left + FBoxA_Width  - 1) &&
  2972.                 y >= FBoxA_Top  && y <= (FBoxA_Top  + FBoxA_Height - 1))
  2973.         {
  2974.                 return (FBOX_SELECTLEFT);
  2975.         }
  2976.         
  2977.         if (x >= FBoxB_Left && x <= (FBoxB_Left + FBoxB_Width  - 1) &&
  2978.                 y >= FBoxB_Top  && y <= (FBoxB_Top  + FBoxB_Height - 1))
  2979.         {
  2980.                 if (y <= FBoxB_Top + FBoxSpacing + 2)
  2981.                         return (0);
  2982.                 else
  2983.                         return (y - FBoxB_Top - 2) / FBoxSpacing;
  2984.         }
  2985.         return (FBOX_NOSELECT);
  2986. }
  2987.  
  2988. /*
  2989.  *              InstallNewFormat(type)
  2990.  *
  2991.  *              Installs the currently defined format into the main window for
  2992.  *              the user to see immediately.
  2993.  *
  2994.  *              If type is NEW_LISTVIEW, then the new format is assumed to be
  2995.  *              from the format editor window's CurrentFields list. The
  2996.  *              setup window, if open, will have its own format string updated
  2997.  *              accordingly.
  2998.  *
  2999.  *              If type is NEW_STRING, then the new format is assumed to be
  3000.  *              stored in the BufFormat string. The format window, if open,
  3001.  *              will have its own format listview updated accordingly.
  3002.  *
  3003.  *              If the buffer string is completely invalid (i.e. evaluates to
  3004.  *              an empty format) then it will be replaced with an empty string.
  3005.  */
  3006. void InstallNewFormat(int type)
  3007. {
  3008.         if (type == NEW_LISTVIEW) {
  3009.                 BufferWidth = ConvertListToFormat(CurrentFields, BufferEFormat);
  3010.         } else /* type == NEW_STRING */ {
  3011.                 BufferWidth = ParseFormatString(BufFormat, BufferEFormat,
  3012.                                                                                                    MAX_FORM_LEN);
  3013.                 if (BufferWidth == 0) {
  3014.                         BufferWidth = ParseFormatString(DefaultSettings.Setup.BufferFormat,
  3015.                                                                                         BufferEFormat, MAX_FORM_LEN);
  3016.                 }
  3017.                 if (FormWindow) {
  3018.                         CreateFormatLists(BufferEFormat);
  3019.                         RedrawFormatWindow();
  3020.                 }
  3021.         }
  3022.         BuildFormatString(BufferEFormat, BufFormat, MAX_FORM_LEN);
  3023.         if (SetWindow) {
  3024.                 GT_SetGadgetAttrs(Gadget[GID_BUFFORMAT], SetWindow, NULL,
  3025.                                                   GTST_String,  BufFormat,
  3026.                                                   TAG_DONE);
  3027.         }
  3028.         ClearMainRHS = 1;
  3029.         InitMainMargins();
  3030.         UpdateMainHScroll();
  3031.         RedrawMainWindow();
  3032. }
  3033.  
  3034. /*
  3035.  *              HandleFormatMsgs()
  3036.  *
  3037.  *              Processes all outstanding messages associated with the Format
  3038.  *              editor gadget window. To be called whenever we get a format event.
  3039.  */
  3040. void HandleFormatMsgs(void)
  3041. {
  3042.         static int activegad;                   /* Non-zero if gadget is depressed   */
  3043.         static int activekey;                   /* Keycode shortcut of activegad     */
  3044.  
  3045.         struct IntuiMessage *imsg;
  3046.         int doneform = SEL_NONE;
  3047.         int hit;
  3048.         int lmb;
  3049.         int rmb;
  3050.  
  3051.         if (!FormWindow)
  3052.                 return;
  3053.  
  3054.         while ((imsg = GT_GetIMsg(FormWindowPort)) != NULL) {
  3055.                 struct Gadget *gad;
  3056.                 int dxwidth = 0;                                /* Amount to adjust width by */
  3057.                 int newrow  = FBoxSelected;             /* Currently selected row        */
  3058.                 int gadid;
  3059.  
  3060.                 switch (imsg->Class) {
  3061.                         
  3062.                         case IDCMP_CLOSEWINDOW:
  3063.                                 doneform = SEL_USE;
  3064.                                 break;
  3065.  
  3066.                         case IDCMP_REFRESHWINDOW:
  3067.                                 GT_BeginRefresh(FormWindow);
  3068.                                 RedrawFormatWindow();
  3069.                                 GT_EndRefresh(FormWindow, TRUE);
  3070.                                 break;
  3071.  
  3072.                         case IDCMP_MOUSEBUTTONS:
  3073.                                 lmb = imsg->Qualifier & IEQUALIFIER_LEFTBUTTON;
  3074.                                 rmb = imsg->Qualifier & IEQUALIFIER_RBUTTON;
  3075.                                 /*
  3076.                                  *              If we're already dragging something, then the
  3077.                                  *              right mouse button allows it to be cancelled.
  3078.                                  */
  3079.                                 if (FormatMovingField && rmb)
  3080.                                         goto cancel_moving_field;
  3081.  
  3082.                                 if (lmb == FormatCurLMB)        /* Ignore spurious events */
  3083.                                         break;
  3084.  
  3085.                                 hit = FormatHitDetect(imsg->MouseX, imsg->MouseY);
  3086.                                 if (lmb) {
  3087.                                         /*
  3088.                                          *              User is trying to select or pick-up a new
  3089.                                          *              event.
  3090.                                          */
  3091.                                         if (hit >= 0 && hit < FBoxB_CurLines &&
  3092.                                                                                                 hit != FBoxSelected) {
  3093.                                                 if (FBoxSelected >= 0 && FBoxSelected < FBoxB_CurLines)
  3094.                                                         ShowFormatLine(FBoxSelected, FORMAT_UNSELECTED);
  3095.                                                 FBoxSelected = hit;
  3096.                                                 ShowFormatLine(hit, FORMAT_SELECTED);
  3097.                                                 GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH],
  3098.                                                                                   FormWindow,  NULL,
  3099.                                                                                   GA_Disabled, FALSE,
  3100.                                                                                   GTSL_Level, CurrentFields[hit].width,
  3101.                                                                                   TAG_DONE);
  3102.                                         }
  3103.                                         if (hit != FBOX_NOSELECT) {
  3104.                                                 /*
  3105.                                                  *              Pick-up the icon under mouse
  3106.                                                  */
  3107.                                                 if (PickupBob(hit, imsg->MouseX, imsg->MouseY)) {
  3108.                                                         FormatMovingField = 1;
  3109.                                                         ReportMouse(1, FormWindow);     /* Enable mouse moves */
  3110.                                                 }
  3111.                                         }
  3112.                                 } else {
  3113.                                         /*
  3114.                                          *              We might be finished doing a drag of a field
  3115.                                          *              from one position to another -- if so, drop the
  3116.                                          *              field in it's new place.
  3117.                                          */
  3118.                                         if (FormatMovingField) {
  3119.                                                 int curdragselect = FBoxDragSelect;
  3120.  
  3121.                                                 FormatMovingField = 0;
  3122.                                                 ReportMouse(0, FormWindow);     /* Disable mouse moves  */
  3123.                                                 DropBob();
  3124.                                                 if (curdragselect != FBOX_NOSELECT)
  3125.                                                         InstallNewFormat(NEW_LISTVIEW);
  3126.                                         }
  3127.                                 }
  3128.                                 FormatCurLMB = lmb;
  3129.                                 break;
  3130.                                                 
  3131.                         case IDCMP_MOUSEMOVE: 
  3132.                                 if (FormatMovingField) {
  3133.                                         UpdateBob(imsg->MouseX, imsg->MouseY);
  3134.                                         break;
  3135.                                 }
  3136.  
  3137.                                 /*
  3138.                                  *              Fall through to handle MOUSEMOVE for slider gadget
  3139.                                  */
  3140.  
  3141.                         case IDCMP_GADGETDOWN:
  3142.                         case IDCMP_GADGETUP:
  3143.                                 gad   = (struct Gadget *)imsg->IAddress;
  3144.                                 gadid = gad->GadgetID;
  3145.  
  3146. handle_form_gads:
  3147.                                 switch (gadid) {
  3148.  
  3149.                                         case GID_FORMUSE:
  3150.                                                 doneform = SEL_USE;
  3151.                                                 break;
  3152.  
  3153.                                         case GID_FORMCANCEL:
  3154.                                                 doneform = SEL_CANCEL;
  3155.                                                 break;
  3156.  
  3157.                                         case GID_FORMUNDO:
  3158.                                                 strcpy(BufFormat, FormatSaveFormat);
  3159.                                                 InstallNewFormat(NEW_STRING);
  3160.                                                 break;
  3161.  
  3162.                                         case GID_FORMWIDTH:
  3163.                                                 /*
  3164.                                                  *              The slider has been moved, so update the
  3165.                                                  *              currently selected item accordingly.
  3166.                                                  */
  3167.                                                 if (FBoxSelected >= 0 &&
  3168.                                                                                         FBoxSelected < FBoxB_CurLines) {
  3169.                                                         CurrentFields[FBoxSelected].width = imsg->Code;
  3170.                                                         ShowFormatLine(FBoxSelected, FORMAT_SELECTED);
  3171.                                                         if (imsg->Class == IDCMP_GADGETUP)
  3172.                                                                 InstallNewFormat(NEW_LISTVIEW);
  3173.                                                 }
  3174.                                                 break;
  3175.                                 }
  3176.                                 break;
  3177.  
  3178.                         case IDCMP_INACTIVEWINDOW:
  3179.                                 /*
  3180.                                  *              Cancel any currently pressed button
  3181.                                  */
  3182.                                 if (activegad) {
  3183.                                         ShowGadget(FormWindow, Gadget[activegad], GADGET_UP);
  3184.                                         activegad = 0;
  3185.                                 }
  3186.                                 /*
  3187.                                  *              If we're dragging something and the window
  3188.                                  *              goes inactive, drop it. Otherwise, when the
  3189.                                  *              window is reactivated, it will still be attached
  3190.                                  *              to the mouse pointer!
  3191.                                  */
  3192.                                 if (FormatMovingField) {
  3193.                                         FormatCurLMB      = 0;
  3194. cancel_moving_field:
  3195.                                         ReportMouse(0, FormWindow);
  3196.                                         UpdateBob(0, -9999);            /* Make position invalid */
  3197.                                         DropBob();
  3198.                                         FormatMovingField = 0;
  3199.                                         if (imsg->Class == IDCMP_INACTIVEWINDOW) {
  3200.                                                 /*
  3201.                                                  *              If we went inactive, then the act of
  3202.                                                  *              erasing the BOB has probably resulted
  3203.                                                  *              in a portion of the window frame being
  3204.                                                  *              restored in its active colours, even
  3205.                                                  *              though the window is now inactive -- so
  3206.                                                  *              we refresh it to get around this.
  3207.                                                  */
  3208.                                                 RefreshWindowFrame(FormWindow);
  3209.                                         }
  3210.                                 }
  3211.                                 break;
  3212.                                         
  3213.                         case IDCMP_RAWKEY:
  3214.                         {
  3215.                                 int shift    = imsg->Qualifier & IE_SHIFT;
  3216.                                 int altctrl  = imsg->Qualifier & (IE_ALT | IE_CTRL);
  3217.                                 int upstroke = imsg->Code & 0x80;
  3218.                                 int keypress = ConvertIMsgToChar(imsg);
  3219.  
  3220.                                 /*
  3221.                                  *              Handle keyboard shortcuts
  3222.                                  */
  3223.                                 if (FormatMovingField && keypress == '\033') {
  3224.                                         /*
  3225.                                          *              ESC cancels any drag currently in operation
  3226.                                          */
  3227.                                         goto cancel_moving_field;
  3228.                                 }
  3229.  
  3230.                                 gadid  = FormKeyboard[keypress];
  3231.                                 if (activegad) {
  3232.                                         /*
  3233.                                          *              We're releasing a gadget that was pressed
  3234.                                          *              earlier, so handle it now
  3235.                                          */
  3236.                                         int samekey = (imsg->Code & 0x7f) == activekey;
  3237.  
  3238.                                         if (samekey && !upstroke)       /* Ignore repeated keys */
  3239.                                                 break;
  3240.  
  3241.                                         ShowGadget(FormWindow, Gadget[activegad], GADGET_UP);
  3242.                                         if (samekey) {
  3243.                                                 /*
  3244.                                                  *              Just released the key that was originally
  3245.                                                  *              pressed for this gadget, so now go and
  3246.                                                  *              handle the gadget action.
  3247.                                                  */
  3248.                                                 gadid     = activegad;
  3249.                                                 gad       = Gadget[gadid];
  3250.                                                 activegad = 0;
  3251.                                                 goto handle_form_gads;
  3252.                                         }
  3253.  
  3254.                                         /*
  3255.                                          *              If the above check didn't kick in, it means
  3256.                                          *              we got a downpress of a different key, so
  3257.                                          *              disable the gadget for this key and continue
  3258.                                          *              to press the other key.
  3259.                                          */
  3260.                                         activegad = 0;
  3261.                                 }
  3262.  
  3263.                                 /*
  3264.                                  *              Check for normal gadget keyboard shortcuts
  3265.                                  */
  3266.                                 if (gadid) {
  3267.                                         gad = Gadget[gadid];
  3268.                                         if (gadid == GID_FORMWIDTH) {
  3269.                                                 /*
  3270.                                                  *              Got a slider adjustment request
  3271.                                                  */
  3272.                                                 if (imsg->Qualifier & IE_SHIFT)
  3273.                                                         dxwidth = -1;
  3274.                                                 else
  3275.                                                         dxwidth = 1;
  3276.  
  3277.                                                 if (newrow == FBOX_NOSELECT)
  3278.                                                         newrow = 0;     /* If no row active, pick first row */
  3279.  
  3280.                                                 if (FBoxB_CurLines == 0)  /* Ignore if box is empty */
  3281.                                                         break;
  3282.  
  3283.                                                 goto format_move_slider;
  3284.                                         }
  3285.                                         /*
  3286.                                          *              Must be a simple button press so highlight
  3287.                                          *              the button and handle accordingly
  3288.                                          */
  3289.                                         ShowGadget(FormWindow, gad, GADGET_DOWN);
  3290.                                         activegad = gadid;
  3291.                                         activekey = imsg->Code;
  3292.                                         break;
  3293.                                 }
  3294.  
  3295.                                 /*
  3296.                                  *              Handle cursor movement. This lets us choose a
  3297.                                  *              new item in the format box, or adjust the width
  3298.                                  *              of an existing item.
  3299.                                  */
  3300.                                 if (!FBoxB_CurLines)    /* A format must exist */
  3301.                                         break;
  3302.                                 
  3303.                                 if (newrow == FBOX_NOSELECT)
  3304.                                         newrow = -1;    /* Ensure cursor down selects item 0 */
  3305.  
  3306.                                 switch (imsg->Code) {
  3307.                                         case CURSORUP:
  3308.                                                 if (newrow > 0 && !(shift | altctrl))
  3309.                                                         newrow--;
  3310.                                                 else
  3311.                                                         newrow = 0;
  3312.                                                 break;
  3313.  
  3314.                                         case CURSORDOWN:
  3315.                                                 if (shift | altctrl)
  3316.                                                         newrow = FBoxB_CurLines - 1;
  3317.                                                 else if (newrow < (FBoxB_CurLines-1))
  3318.                                                         newrow++;
  3319.                                                 break;
  3320.  
  3321.                                         case CURSORLEFT:
  3322.                                                 dxwidth = -1;
  3323.                                                 if (shift)   dxwidth  = -5;
  3324.                                                 if (altctrl) dxwidth  = -MAX_FIELD_LEN;
  3325.                                                 break;
  3326.  
  3327.                                         case CURSORRIGHT:
  3328.                                                 dxwidth = 1;
  3329.                                                 if (shift)   dxwidth = 5;
  3330.                                                 if (altctrl) dxwidth = MAX_FIELD_LEN;
  3331.                                                 break;
  3332.  
  3333.                                         case HELPKEY:
  3334.                                                 ShowAGuide(MSG(MSG_LINK_FORMATWIN));
  3335.                                                 goto done_keys;
  3336.  
  3337.                                         default:
  3338.                                                 goto done_keys;         /* Ignore all other keys */
  3339.                                 }
  3340.  
  3341. format_move_slider:
  3342.                                 /*
  3343.                                  *              First check if the row has changed. (As well as
  3344.                                  *              changing via cursor up/down, this can also happen
  3345.                                  *              with left/right if there was no item selected to
  3346.                                  *              begin with
  3347.                                  */
  3348.                                 if (newrow < 0)
  3349.                                         newrow = 0;
  3350.  
  3351.                                 if (newrow != FBoxSelected && FBoxB_CurLines > 0) {
  3352.                                         /*
  3353.                                          *              Unactivate old row, activate a new row
  3354.                                          */
  3355.                                         if (FBoxSelected >= 0 && FBoxSelected < FBoxB_CurLines)
  3356.                                                 ShowFormatLine(FBoxSelected, FORMAT_UNSELECTED);
  3357.                                         FBoxSelected = newrow;
  3358.                                         ShowFormatLine(newrow, FORMAT_SELECTED);
  3359.                                         GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH],
  3360.                                                                           FormWindow,  NULL,
  3361.                                                                           GA_Disabled, FALSE,
  3362.                                                                           GTSL_Level, CurrentFields[newrow].width,
  3363.                                                                           TAG_DONE);
  3364.                                 }
  3365.  
  3366.                                 /*
  3367.                                  *              Now check if the horizontal position of the
  3368.                                  *              slider has changed.
  3369.                                  */
  3370.                                 if (dxwidth) {
  3371.                                         int newwidth = CurrentFields[FBoxSelected].width + dxwidth;
  3372.  
  3373.                                         if (newwidth < 1)                               newwidth = 1;
  3374.                                         if (newwidth > MAX_FIELD_LEN)   newwidth = MAX_FIELD_LEN;
  3375.                                         if (FBoxSelected != FBOX_NOSELECT) {
  3376.                                                 if (newwidth != CurrentFields[FBoxSelected].width) {
  3377.                                                         GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH],
  3378.                                                                                           FormWindow,  NULL,
  3379.                                                                                           GTSL_Level,  newwidth,
  3380.                                                                                           TAG_DONE);
  3381.                                                         CurrentFields[FBoxSelected].width = newwidth;
  3382.                                                         ShowFormatLine(FBoxSelected, FORMAT_SELECTED);
  3383.                                                         InstallNewFormat(NEW_LISTVIEW);
  3384.                                                 }
  3385.                                         }
  3386.                                 }
  3387. done_keys:
  3388.                                 break;
  3389.                         }
  3390.                 }
  3391.                 GT_ReplyIMsg(imsg);
  3392.         }
  3393.         if (doneform != SEL_NONE) {
  3394.                 CloseFormatWindow();
  3395.                 if (doneform == SEL_CANCEL) {
  3396.                         strcpy(BufFormat, FormatSaveFormat);
  3397.                         InstallNewFormat(NEW_STRING);
  3398.                 }
  3399.         }
  3400. }
  3401.  
  3402. /*
  3403.  *              -----------------------------------------------------------------------
  3404.  *              Now our BOB/GEL routines for the drag-and-drop format editor.
  3405.  *              These should really be in their own module, but they're being
  3406.  *              put here for now for convenience.
  3407.  *              -----------------------------------------------------------------------
  3408.  */
  3409.  
  3410. /*
  3411.  *              InitGel(rastport, width, height, transp)
  3412.  *
  3413.  *              This function does all the initialisation necessary to allow us
  3414.  *              to use a single BOB in the given rastport. A new bitmap is allocated
  3415.  *              of dimensions width x height into which data can be rendered.
  3416.  *
  3417.  *              If successful, this function returns a pointer to a MyGel structure
  3418.  *              which contains, among other things, the rastport and bob structure
  3419.  *              you will use when calling system routines to manipulate the bob.
  3420.  *
  3421.  *              Note that the bob must be removed from the Gel list before rendering
  3422.  *              into it.
  3423.  *
  3424.  *              If transp is true, then the BOB will be transparent on colour zero.
  3425.  *              In this case, you must call InitMasks(mygel->vsprite) whenever
  3426.  *              you make a change to the image, to recalculate the mask.
  3427.  */
  3428. MyGel *CreateBob(struct RastPort *rport, int width, int height, int transp)
  3429. {
  3430.         struct GelsInfo *gInfo;
  3431.         struct Bob              *bob;
  3432.         struct VSprite  *vsprite;
  3433.         MyGel                   *mygel;
  3434.         ULONG                   linesize;
  3435.         ULONG                   planesize;
  3436.         ULONG                   imagesize;
  3437.         ULONG                   chipsize;
  3438.         UBYTE                   *chipdata;
  3439.         int                             wordwidth;
  3440.         int                             depth;
  3441.         int                             i;
  3442.  
  3443.         wordwidth       = (width + 15) >> 4;
  3444.         depth           = rport->BitMap->Depth;
  3445.  
  3446.         mygel = (MyGel *)AllocMem(sizeof(MyGel), MEMF_CLEAR);
  3447.         if (!mygel)
  3448.                 return (NULL);
  3449.                 
  3450.         mygel->mainrast         = rport;
  3451.         gInfo                           = &mygel->gelinfo;
  3452.         gInfo->nextLine         = mygel->nextline;
  3453.         gInfo->lastColor        = mygel->lastcolor;
  3454.         gInfo->collHandler      = &mygel->colltable;
  3455.         gInfo->sprRsrvd         = 0x03;
  3456.  
  3457.         /*
  3458.          *              Set left-most and top-most to 1 to better keep items
  3459.          *              inside the display boundaries.
  3460.          */
  3461.         gInfo->leftmost   = 1;
  3462.         gInfo->topmost    = 1;
  3463.         gInfo->rightmost  = (rport->BitMap->BytesPerRow << 3) - 1;
  3464.         gInfo->bottommost = rport->BitMap->Rows - 1;
  3465.         rport->GelsInfo   = gInfo;
  3466.         InitGels(&mygel->vshead, &mygel->vstail, gInfo);
  3467.  
  3468.         /*
  3469.          *              Now allocate a new BOB to be linked into this structure.
  3470.          *              We also allocate a bitmap associated with the bob, and
  3471.          *              give it its own RastPort so that we can render into it.
  3472.          */
  3473.         linesize        = sizeof(WORD)  * wordwidth;
  3474.         planesize       = linesize      * height;
  3475.         imagesize       = planesize             * depth;
  3476.         chipsize        = imagesize*2 + linesize + planesize;
  3477.         bob                     = &mygel->bob;
  3478.         vsprite         = &mygel->bobvsprite;
  3479.  
  3480.         if (!(chipdata = AllocMem(chipsize, MEMF_CHIP | MEMF_CLEAR))) {
  3481.                 rport->GelsInfo = NULL;
  3482.                 FreeMem(mygel, sizeof(MyGel));
  3483.                 return (NULL);
  3484.         }
  3485.         mygel->chipdata         = (void *)(chipdata);
  3486.         mygel->chipsize         = chipsize;
  3487.  
  3488.         mygel->planedata        = (void *)(chipdata);
  3489.         bob->SaveBuffer         = (void *)(chipdata + imagesize);
  3490.         vsprite->BorderLine = (void *)(chipdata + imagesize*2);
  3491.         vsprite->CollMask       = (void *)(chipdata + imagesize*2 + linesize);
  3492.  
  3493.         vsprite->Y                      = -9999;
  3494.         vsprite->X                      = -9999;
  3495.         vsprite->Flags      = SAVEBACK | (transp ? OVERLAY : 0);
  3496.         vsprite->Width      = wordwidth;
  3497.         vsprite->Depth      = depth;
  3498.         vsprite->Height     = height;
  3499.         vsprite->MeMask     = 0;
  3500.         vsprite->HitMask    = 0;
  3501.         vsprite->ImageData  = (void *)mygel->planedata;
  3502.         vsprite->SprColors  = NULL;
  3503.         vsprite->PlanePick  = -1;
  3504.         vsprite->PlaneOnOff = 0x00;
  3505.         InitMasks(vsprite);
  3506.  
  3507.         vsprite->VSBob      = bob;
  3508.         bob->BobVSprite     = vsprite;
  3509.         bob->ImageShadow    = vsprite->CollMask;
  3510.         bob->Flags          = 0;
  3511.         bob->Before         = NULL;
  3512.         bob->After          = NULL;
  3513.         bob->BobComp        = NULL;
  3514.         bob->DBuffer            = NULL;
  3515.  
  3516.         /*
  3517.          *              Now setup the Rastport and Bitmap so we can render into the BOB
  3518.          */
  3519.         InitRastPort(&mygel->rastport);
  3520.         InitBitMap(&mygel->bitmap, depth, width, height);
  3521.         mygel->rastport.BitMap = &mygel->bitmap;
  3522.  
  3523.         for (i = 0; i < depth; i++)
  3524.                 mygel->bitmap.Planes[i] = mygel->planedata + i * planesize;
  3525.  
  3526.         return (mygel);
  3527. }
  3528.  
  3529. /*
  3530.  *              FreeBob(mygel)
  3531.  *
  3532.  *              Frees the bob allocated earlier, along with all other associated info 
  3533.  *              Also removes all GELs from the system rastport.
  3534.  */
  3535. void FreeBob(MyGel *mygel)
  3536. {
  3537.         mygel->mainrast->GelsInfo = NULL;
  3538.         FreeMem(mygel->chipdata, mygel->chipsize);
  3539.         FreeMem(mygel, sizeof(MyGel));
  3540. }
  3541.  
  3542. /*
  3543.  *              PickupBob(hit, x, y)
  3544.  *
  3545.  *              Picks up the line and copies it into our bob's bitmap, then adds
  3546.  *              the bob to the screen at the current mouse location so the
  3547.  *              user can drag it around.
  3548.  *
  3549.  *              If the hit is correct, we can ignore Y since the field being
  3550.  *              dragged is in the right box and we already know which line.
  3551.  *              Otherwise, Y is a pixel co-ordinate that we use to calculate
  3552.  *              the line of the box that's being chosen.
  3553.  *
  3554.  *              If hit is FBOX_SELECTLEFT, then we need to calculate which line
  3555.  *              we are dealing with.
  3556.  *
  3557.  *              We also record the start line we use.
  3558.  *
  3559.  *              Returns true for success, false if we didn't have a hit after all.
  3560.  */
  3561. int PickupBob(int hit, int x, int y)
  3562. {
  3563.         struct RastPort *rport    = FormWindow->RPort;
  3564.         struct RastPort *bobrport = &TextBob->rastport;
  3565.         char viewbuf[50];
  3566.         int line;
  3567.         int box;
  3568.         int xpos;
  3569.         int ypos;
  3570.         int len;
  3571.  
  3572.         if (hit == FBOX_NOSELECT) {
  3573.                 return (FALSE);
  3574.         } else if (hit == FBOX_SELECTLEFT) {
  3575.                 box  = FORMAT_LEFTBOX;
  3576.                 line = (y - FBoxA_Top - 2);
  3577.                 if (line < FBoxSpacing)
  3578.                         line = 0;
  3579.                 else
  3580.                         line /= FBoxSpacing;
  3581.                 if (line >= FBoxA_CurLines)
  3582.                         return (FALSE);
  3583.         } else {
  3584.                 /* Right box */
  3585.                 box  = FORMAT_RIGHTBOX;
  3586.                 line = hit;
  3587.                 if (line >= FBoxB_CurLines)
  3588.                         return (FALSE);
  3589.         }
  3590.  
  3591.         /*
  3592.          *              Okay, got a definite hit so go ahead and start the drag
  3593.          */
  3594.         FormatDragBox   = box;
  3595.         FormatDragLine  = line;
  3596.         
  3597.         SetRast(bobrport, 0);                           /* Erase rast bitmap    */
  3598.         SetAPen(bobrport, 2);                           /* White foreground             */
  3599.         SetBPen(bobrport, 1);                           /* Black background             */
  3600.         SetDrMd(bobrport, JAM2);                        /* Solid text                   */
  3601.         SetFont(bobrport, FormBufFont);
  3602.  
  3603.         if (box == FORMAT_LEFTBOX) {
  3604.                 FieldInit *fi = &FieldTypes[AvailableFields[line].type];
  3605.  
  3606.                 mysprintf(viewbuf, FBoxA_FormString, MSG(fi->titlemsgid), fi->idchar);
  3607.                 len  = FBoxA_NumChars;
  3608.                 xpos = FBoxA_Left + 2;
  3609.                 ypos = FBoxA_Top  + 2 + line * FBoxSpacing;
  3610.         } else {
  3611.                 FieldInit *fi = &FieldTypes[CurrentFields[line].type];
  3612.  
  3613.                 mysprintf(viewbuf, FBoxB_FormString, MSG(fi->titlemsgid),
  3614.                                                    CurrentFields[line].width, fi->idchar);
  3615.                 len  = FBoxB_NumChars;
  3616.                 xpos = FBoxB_Left + 2;
  3617.                 ypos = FBoxB_Top  + 2 + line * FBoxSpacing;
  3618.         }
  3619.         TextBob->bob.BobVSprite->X = xpos;
  3620.         TextBob->bob.BobVSprite->Y = ypos;
  3621.         FBoxDeltaX = xpos - x;
  3622.         FBoxDeltaY = ypos - y;
  3623.  
  3624.         Move(bobrport, 0, FormBufFont->tf_Baseline+1);
  3625.         Text(bobrport, viewbuf, len);
  3626.  
  3627.         /*
  3628.          *              Now draw highlight above and below the text
  3629.          */
  3630.         SetAPen(bobrport, 1);
  3631.         Move(bobrport, 0, 0);
  3632.         Draw(bobrport, len * FormBufFont->tf_XSize - 1, 0);
  3633.         Move(bobrport, 0, FormBufFont->tf_YSize + 1);
  3634.         Draw(bobrport, len * FormBufFont->tf_XSize - 1, FormBufFont->tf_YSize + 1);
  3635.  
  3636.         InitMasks(TextBob->bob.BobVSprite);
  3637.         SortGList(rport);
  3638.         DrawGList(rport, ViewPortAddress(FormWindow));
  3639.         return (1);
  3640. }
  3641.  
  3642. /*
  3643.  *              DropBob()
  3644.  *
  3645.  *              Releases the current bob at the target, and updates the two
  3646.  *              lists/displays accordingly.
  3647.  */
  3648. void DropBob(void)
  3649. {
  3650.         EditEvent savedev;
  3651.         EditEvent *ee;
  3652.         int destpos;
  3653.         int seltype;
  3654.  
  3655.         destpos = FBoxDragSelect;                       /* Save destination drop selection      */
  3656.         UpdateBob(0, -9999);                            /* Kill any highlighted region          */
  3657.  
  3658.         /*
  3659.          *              Now re-arrange the edit lists to reflect the new position of
  3660.          *              the dragged field. There are three cases to consider:
  3661.          *
  3662.          *                      Left box        -> Right box
  3663.          *                      Right box       -> Right box
  3664.          *                      Right box       -> Left box
  3665.          */
  3666.         if (destpos == FBOX_NOSELECT)
  3667.                 return;
  3668.         
  3669.         ShowFormatLine(FBoxSelected, FORMAT_UNSELECTED);
  3670.         if (FBoxSelected >= 0 && FBoxSelected < EF_COUNT)
  3671.                 seltype = CurrentFields[FBoxSelected].type;
  3672.         else
  3673.                 seltype = -1;
  3674.  
  3675.         /*
  3676.          *              First, delete item from its current list
  3677.          */
  3678.         if (FormatDragBox == FORMAT_LEFTBOX) {
  3679.                 /*
  3680.                  *              Deleting from left box
  3681.                  */
  3682.                 ee              = &AvailableFields[FormatDragLine];
  3683.                 savedev.type  = ee->type;
  3684.                 savedev.width = FieldTypes[ee->type].defwidth;
  3685.  
  3686.                 while (ee->type != END_EDITLIST) {
  3687.                         ee[0] = ee[1];
  3688.                         ee++;
  3689.                 }
  3690.                 FBoxA_CurLines--;
  3691.                 seltype = savedev.type; /* New selection is item we just dragged */
  3692.         } else {
  3693.                 /*
  3694.                  *              Deleting from right box. If the drop position is after
  3695.                  *              the point where we're deleting, we adjust it to reflect
  3696.                  *              the deleted line.
  3697.                  */
  3698.  
  3699.                 if (destpos > FormatDragLine && destpos <= EF_COUNT)
  3700.                         destpos--;
  3701.  
  3702.                 ee              = &CurrentFields[FormatDragLine];
  3703.                 savedev = *ee;
  3704.                 while (ee->type != END_EDITLIST) {
  3705.                         ee[0] = ee[1];
  3706.                         ee++;
  3707.                 }
  3708.                 FBoxB_CurLines--;
  3709.         }
  3710.         /*
  3711.          *              Now add the item (savedev) to the new list in the appropriate
  3712.          *              place
  3713.          */
  3714.         if (destpos == FBOX_SELECTLEFT) {
  3715.                 /*
  3716.                  *              Search the existing left box list looking for the best place
  3717.                  *              to insert the item -- we do this in strict alphabetical
  3718.                  *              order (based on the % identifer)
  3719.                  */
  3720.                 int newid = FieldTypes[savedev.type].idchar;
  3721.                 EditEvent tempev;
  3722.  
  3723.                 for (ee = &AvailableFields[0]; ee->type != END_EDITLIST; ee++)
  3724.                         if (FieldTypes[ee->type].idchar > newid)
  3725.                                 break;
  3726.  
  3727.                 do {
  3728.                         tempev  = *ee;
  3729.                         *ee     = savedev;
  3730.                         savedev = tempev;
  3731.                         ee++;
  3732.                 } while (ee[-1].type != END_EDITLIST);
  3733.                 FBoxA_CurLines++;
  3734.         } else {
  3735.                 /* 
  3736.                  *              Adding line to the right box. Simply insert it at the
  3737.                  *              specified location.
  3738.                  */
  3739.                 EditEvent tempev;
  3740.  
  3741.                 ee = &CurrentFields[destpos];
  3742.                 do {
  3743.                         tempev  = *ee;
  3744.                         *ee     = savedev;
  3745.                         savedev = tempev;
  3746.                         ee++;
  3747.                 } while (ee[-1].type != END_EDITLIST);
  3748.                 FBoxB_CurLines++;
  3749.         }
  3750.         /*
  3751.          *              Now search our right box list to see can we match the item
  3752.          *              that was currently highlighted when we entered this routine.
  3753.          */
  3754.         FBoxSelected = 0;
  3755.         for (ee = &CurrentFields[0]; ee->type != END_EDITLIST; ee++) {
  3756.                 if (ee->type == seltype)
  3757.                         break;
  3758.                 FBoxSelected++;
  3759.         }
  3760.         if (ee->type == END_EDITLIST) {
  3761.                 FBoxSelected = FBOX_NOSELECT;
  3762.                 GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH], FormWindow,  NULL,
  3763.                                                   GA_Disabled, TRUE,
  3764.                                                   TAG_DONE);
  3765.         } else {
  3766.                 GT_SetGadgetAttrs(Gadget[GID_FORMWIDTH], FormWindow,  NULL,
  3767.                                                   GA_Disabled, FALSE,
  3768.                                                   GTSL_Level,  ee->width,
  3769.                                                   TAG_DONE);
  3770.         }
  3771.  
  3772.         /*
  3773.          *              Now, finally, update our window to show the new arrangement.
  3774.          */
  3775.         RedrawFormatWindow();
  3776. }
  3777.  
  3778. /*
  3779.  *              UpdateBob(x, y)
  3780.  *
  3781.  *              Updates the current position of the bob on the screen, and
  3782.  *              draws any highlights etc. that are deemed necessary.
  3783.  */
  3784. void UpdateBob(int x, int y)
  3785. {
  3786.         int bfonty = FormBufFont->tf_YSize;
  3787.         int pos;
  3788.  
  3789.         /*
  3790.          *              Now see if we are overlapping any of the drop regions, and if
  3791.          *              so, highlight the region appropriately.
  3792.          *
  3793.          *              When dragging into the left box, we highlight the entire box
  3794.          *              since the order of items is pre-determined and it doesn't
  3795.          *              make any sense to drop a field into one particular place.
  3796.          *
  3797.          *              When dragging into the right box, we highlight a line in
  3798.          *              between two other lines, which shows where the item will
  3799.          *              be inserted.
  3800.          *
  3801.          *              For neatness, we don't show highlighting which would have
  3802.          *              no effect on the current settings (i.e. moving a field to
  3803.          *              the same position it's already in).
  3804.          */
  3805.         pos = FBOX_NOSELECT;
  3806.         if (x >= FBoxA_Left && x <= (FBoxA_Left + FBoxA_Width  - 1) &&
  3807.             y >= FBoxA_Top  && y <= (FBoxA_Top  + FBoxA_Height - 1) &&
  3808.                 FormatDragBox != FORMAT_LEFTBOX) {
  3809.                 /*
  3810.                  *              Got a hit in left-hand box
  3811.                  */
  3812.                 pos = FBOX_SELECTLEFT;
  3813.         } else if (x >= FBoxB_Left && x <= (FBoxB_Left + FBoxB_Width - 1) &&
  3814.                            y >= (FBoxB_Top - 10) && y <= (FBoxB_Top + FBoxB_Height + 10)) {
  3815.                 /*
  3816.                  *              Got a hit in the right-hand box, so now calculate which line
  3817.                  */
  3818.                 pos = (y - FBoxB_Top - 2 + bfonty/2) / FBoxSpacing;
  3819.  
  3820.                 if (pos < 0)                            pos = 0;
  3821.                 if (pos > FBoxB_CurLines)       pos = FBoxB_CurLines;
  3822.                 if (FormatDragBox == FORMAT_RIGHTBOX &&
  3823.                                                 (pos == FormatDragLine || pos == (FormatDragLine+1))) {
  3824.                         pos = FBOX_NOSELECT;    /* Don't highlight line we dragged from */
  3825.                 }
  3826.         }
  3827.  
  3828.         if (pos != FBoxDragSelect) {
  3829.                 /*
  3830.                  *              Currently selected item has changed, so erase current one,
  3831.                  *              then draw new one. We also refresh the currently selected
  3832.                  *              line, in case it got trashed by the highlighting.
  3833.                  *
  3834.                  *              Note that we must first move the bob off-screen while we
  3835.                  *              render the changes, otherwise it gets confused and tends
  3836.                  *              to obscure the output.
  3837.                  */
  3838.                 TextBob->bob.BobVSprite->X = 0;
  3839.                 TextBob->bob.BobVSprite->Y = -9999;
  3840.                 SortGList(FormWindow->RPort);
  3841.                 DrawGList(FormWindow->RPort, ViewPortAddress(FormWindow));
  3842.                 ShowDragSelect(FBoxDragSelect, FORMAT_UNSELECTED);
  3843.                 ShowFormatLine(FBoxSelected, FORMAT_SELECTED);
  3844.                 ShowDragSelect(pos, FORMAT_SELECTED);
  3845.                 FBoxDragSelect = pos;
  3846.         }
  3847.  
  3848.         TextBob->bob.BobVSprite->X = x + FBoxDeltaX;
  3849.         TextBob->bob.BobVSprite->Y = y + FBoxDeltaY;
  3850.         SortGList(FormWindow->RPort);
  3851.         DrawGList(FormWindow->RPort, ViewPortAddress(FormWindow));
  3852. }
  3853.