home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 1 / LSD Compendium Deluxe 1.iso / a / graphics / icontools / ficon11.lha / ForceIcon / Source / Interface.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-04  |  36.4 KB  |  1,479 lines
  1. /*
  2. Auto:        smake ForceIcon
  3. */
  4.  
  5.  
  6.  
  7. /* $Revision Header built automatically *************** (do not edit) ************
  8. **
  9. ** © Copyright by GuntherSoft
  10. **
  11. ** File             : SnakeSYS:CPrgs/Utils/ForceIcon/Interface.c
  12. ** Created on       : Friday, 22.10.93 16:28:10
  13. ** Created by       : Kai Iske
  14. ** Current revision : V1.0
  15. **
  16. **
  17. ** Purpose
  18. ** -------
  19. **   - User-Interface for ForceIcon
  20. **
  21. ** Revision V1.0
  22. ** --------------
  23. ** created on Friday, 22.10.93 16:28:10  by  Kai Iske.   LogMessage :
  24. **     --- Initial release ---
  25. **
  26. *********************************************************************************/
  27.  
  28.  
  29. #define    MainWinLeft    80
  30. #define    MainWinTop    25
  31. #define    MainWinWidth    457
  32. #define    MainWinHeight    126
  33. #define    EditWinLeft    102
  34. #define    EditWinTop    52
  35. #define    EditWinWidth    433
  36. #define    EditWinHeight    102
  37. #define    ManWinLeft    112
  38. #define    ManWinTop    60
  39. #define    ManWinWidth    438
  40. #define    ManWinHeight    41
  41.  
  42.  
  43.  
  44.  
  45. /**********************************************************************/
  46. /*                        External structures                         */
  47. /**********************************************************************/
  48. extern struct List        VolumeList;
  49. extern struct SignalSemaphore    MySemaphore;
  50.  
  51.  
  52.  
  53. /**********************************************************************/
  54. /*                        Module`s structures                         */
  55. /**********************************************************************/
  56. struct    Window        *MainWinHandle    = NULL;        // Window handles
  57. struct    Window        *EditWinHandle    = NULL;
  58. struct    Window        *PosWinHandle    = NULL;
  59. struct    Window        *ManWinHandle    = NULL;
  60.  
  61.  
  62. static struct VisualInfo    *MainVisInfo    = NULL;
  63. static struct VisualInfo    *EditVisInfo    = NULL;
  64. static struct VisualInfo    *ManVisInfo    = NULL;
  65. static struct Gadget        *MainWinGList    = NULL;
  66. static struct Gadget        *EditWinGList    = NULL;
  67. static struct Gadget        *ManWinGList    = NULL;
  68. static struct Gadget        *MainWinGadgets[MAINWIN_CNT];
  69. static struct Gadget        *EditWinGadgets[EDITWIN_CNT];
  70. static struct Gadget        *ManWinGadgets[MANWIN_CNT];
  71. static struct _Object        *EditWinGet    = NULL;
  72. static struct TextAttr        MainWinTxtAttr,
  73.                 EditWinTxtAttr,
  74.                 ManWinTxtAttr;
  75. static char            MainWinFontName[40],
  76.                 EditWinFontName[40],
  77.                 ManWinFontName[40];
  78.  
  79. static char            MainTypeStr[40];
  80.  
  81. static struct List        VolList;
  82. static struct VolEntry        OrigEntry;
  83. static WORD            SelVolume, SelEdVolume, PosMode, ManualType;
  84. static LONG            SecsLeft, MinsLeft, SecsRight, MinsRight;
  85. static WORD            LastLeft, LastRight;
  86. static struct Requester        MainReq;
  87.  
  88.  
  89.  
  90.  
  91.  
  92. /**********************************************************************/
  93. /*                         Window definitions                         */
  94. /**********************************************************************/
  95. static UBYTE *EditPos1Labels[] = {
  96.     (UBYTE *)"Open position window",
  97.     (UBYTE *)"Close position window",
  98.     NULL };
  99.  
  100. static UBYTE *ManType2Labels[] = {
  101.     (UBYTE *)"Device",
  102.     (UBYTE *)"Volume",
  103.     NULL };
  104.  
  105. static UWORD MainWinGTypes[] = {
  106.     LISTVIEW_KIND,
  107.     LISTVIEW_KIND,
  108.     BUTTON_KIND,
  109.     BUTTON_KIND,
  110.     BUTTON_KIND,
  111.     BUTTON_KIND,
  112.     BUTTON_KIND,
  113.     BUTTON_KIND,
  114.     BUTTON_KIND,
  115.     BUTTON_KIND,
  116.     BUTTON_KIND,
  117.     BUTTON_KIND,
  118.     TEXT_KIND
  119. };
  120.  
  121. static UWORD EditWinGTypes[] = {
  122.     CYCLE_KIND,
  123.     BUTTON_KIND,
  124.     BUTTON_KIND,
  125.     STRING_KIND,
  126.     STRING_KIND,
  127.     GENERIC_KIND,
  128.     CHECKBOX_KIND,
  129.     CYCLE_KIND,
  130.     CHECKBOX_KIND,
  131.     INTEGER_KIND,
  132.     INTEGER_KIND
  133. };
  134.  
  135. static UWORD ManWinGTypes[] = {
  136.     STRING_KIND,
  137.     BUTTON_KIND,
  138.     BUTTON_KIND,
  139.     CYCLE_KIND
  140. };
  141.  
  142. static struct NewGadget MainWinNGad[] = {
  143.     244, 17, 200, 56, (UBYTE *)"Ava_ilable Volumes/Devices", NULL, GD_MainVols, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  144.     13, 17, 200, 56, (UBYTE *)"Used _Volumes/Devices", NULL, GD_MainUseVols, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  145.     244, 69, 200, 12, (UBYTE *)"Add to _list", NULL, GD_MainAdd, PLACETEXT_IN, NULL, NULL,
  146.     13, 81, 200, 12, (UBYTE *)"_Edit entry...", NULL, GD_MainEdit, PLACETEXT_IN, NULL, NULL,
  147.     13, 93, 200, 12, (UBYTE *)"_Remove from list", NULL, GD_MainRemove, PLACETEXT_IN, NULL, NULL,
  148.     5, 112, 85, 12, (UBYTE *)"_Save", NULL, GD_MainSave, PLACETEXT_IN, NULL, NULL,
  149.     95, 112, 85, 12, (UBYTE *)"_Use", NULL, GD_MainUse, PLACETEXT_IN, NULL, NULL,
  150.     367, 112, 85, 12, (UBYTE *)"_Quit", NULL, GD_MainQuit, PLACETEXT_IN, NULL, NULL,
  151.     275, 112, 85, 12, (UBYTE *)"_Hide", NULL, GD_MainHide, PLACETEXT_IN, NULL, NULL,
  152.     244, 81, 200, 12, (UBYTE *)"Add _manually...", NULL, GD_MainManual, PLACETEXT_IN, NULL, NULL,
  153.     244, 93, 200, 12, (UBYTE *)"Resca_n list", NULL, GD_MainRescan, PLACETEXT_IN, NULL, NULL,
  154.     185, 112, 85, 12, (UBYTE *)"_About...", NULL, GD_MainAbout, PLACETEXT_IN, NULL, NULL,
  155.     13, 69, 200, 12, NULL, NULL, GD_MainType, 0, NULL, NULL
  156. };
  157.  
  158. static struct NewGadget EditWinNGad[] = {
  159.     108, 51, 202, 12, (UBYTE *)"_Position", NULL, GD_EditPos, PLACETEXT_LEFT, NULL, NULL,
  160.     5, 88, 85, 12, (UBYTE *)"_Ok", NULL, GD_EditOk, PLACETEXT_IN, NULL, NULL,
  161.     343, 88, 85, 12, (UBYTE *)"_Cancel", NULL, GD_EditCancel, PLACETEXT_IN, NULL, NULL,
  162.     108, 6, 297, 14, (UBYTE *)"_Volume", NULL, GD_EditVol, PLACETEXT_LEFT, NULL, NULL,
  163.     108, 69, 181, 14, (UBYTE *)"Ico_n", NULL, GD_EditIcon, PLACETEXT_LEFT, NULL, NULL,
  164.     290, 69, 20, 14, NULL, NULL, GD_EditGet, 0, NULL, NULL,
  165.     318, 69, 26, 11, (UBYTE *)"_Use Icon", NULL, GD_EditUseIcon, PLACETEXT_RIGHT, NULL, NULL,
  166.     108, 21, 297, 12, (UBYTE *)"_Type", NULL, GD_EditType, PLACETEXT_LEFT, NULL, NULL,
  167.     318, 51, 26, 11, (UBYTE *)"_IconPos", NULL, GD_EditIconPos, PLACETEXT_RIGHT, NULL, NULL,
  168.     108, 36, 67, 14, (UBYTE *)"Current _X", NULL, GD_EditX, PLACETEXT_LEFT, NULL, NULL,
  169.     338, 36, 67, 14, (UBYTE *)"Current _Y", NULL, GD_EditY, PLACETEXT_LEFT, NULL, NULL
  170. };
  171.  
  172. static struct NewGadget ManWinNGad[] = {
  173.     82, 7, 346, 14, (UBYTE *)"_Entry", NULL, GD_ManVol, PLACETEXT_LEFT, NULL, NULL,
  174.     5, 27, 85, 12, (UBYTE *)"_Ok", NULL, GD_ManOk, PLACETEXT_IN, NULL, NULL,
  175.     349, 27, 85, 12, (UBYTE *)"_Cancel", NULL, GD_ManCancel, PLACETEXT_IN, NULL, NULL,
  176.     175, 27, 121, 12, (UBYTE *)"_Type", NULL, GD_ManType, PLACETEXT_LEFT, NULL, NULL
  177. };
  178.  
  179. static ULONG MainWinGTags[] = {
  180.     (GTLV_ShowSelected), NULL, (GT_Underscore), '_', (TAG_DONE),
  181.     (GTLV_ShowSelected), NULL, (GT_Underscore), '_', (TAG_DONE),
  182.     (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  183.     (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  184.     (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  185.     (GT_Underscore), '_', (TAG_DONE),
  186.     (GT_Underscore), '_', (TAG_DONE),
  187.     (GT_Underscore), '_', (TAG_DONE),
  188.     (GT_Underscore), '_', (TAG_DONE),
  189.     (GT_Underscore), '_', (TAG_DONE),
  190.     (GT_Underscore), '_', (TAG_DONE),
  191.     (GT_Underscore), '_', (TAG_DONE),
  192.     (GTTX_Border), TRUE, (TAG_DONE)
  193. };
  194.  
  195. static ULONG EditWinGTags[] = {
  196.     (GTCY_Labels), (ULONG)&EditPos1Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE),
  197.     (GT_Underscore), '_', (TAG_DONE),
  198.     (GT_Underscore), '_', (TAG_DONE),
  199.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 128, (GT_Underscore), '_', (TAG_DONE),
  200.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 256, (GT_Underscore), '_', (TAG_DONE),
  201.     (TAG_DONE),
  202.     (GT_Underscore), '_', (GTCB_Scaled), TRUE, (TAG_DONE),
  203.     (GTCY_Labels), (ULONG)&ManType2Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE),
  204.     (GT_Underscore), '_', (GTCB_Scaled), TRUE, (TAG_DONE),
  205.     (STRINGA_ExitHelp), TRUE, (GTIN_Number), 0, (GTIN_MaxChars), 4, (GT_Underscore), '_', (TAG_DONE),
  206.     (STRINGA_ExitHelp), TRUE, (GTIN_Number), 0, (GTIN_MaxChars), 4, (GT_Underscore), '_', (TAG_DONE)
  207. };
  208.  
  209. static ULONG ManWinGTags[] = {
  210.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 128, (GT_Underscore), '_', (TAG_DONE),
  211.     (GT_Underscore), '_', (TAG_DONE),
  212.     (GT_Underscore), '_', (TAG_DONE),
  213.     (GTCY_Labels), (ULONG)&ManType2Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE)
  214. };
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227. /**********************************************************************/
  228. /*                       Handle the main window                       */
  229. /**********************************************************************/
  230. BOOL OpenMainWin(void)
  231. {
  232.         // Initialize volume list
  233.  
  234.     NewList(&VolList);
  235.  
  236.         // Get list of available volumes
  237.  
  238.     if(GetDevVolList(&VolList))
  239.     {
  240.             // Try to open main window
  241.  
  242.         if(OpenWin(MainWinLeft,
  243.             MainWinTop,
  244.             MainWinWidth,
  245.             MainWinHeight,
  246.             &MainWinGList,
  247.             MAINWIN_CNT,
  248.             NULL,
  249.             MainWinNGad,
  250.             MainWinGTypes,
  251.             MainWinGTags,
  252.             MainWinGadgets,
  253.             &MainWinHandle,
  254.             "ForceIcon v"REVISION" ("REVDATE") - GiftWare, Kai Iske",
  255.             LISTVIEWIDCMP|BUTTONIDCMP|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,
  256.             WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
  257.             5,
  258.             3,
  259.             447,
  260.             106,
  261.             &MainWinTxtAttr,
  262.             MainWinFontName,
  263.         &MainVisInfo))
  264.         {
  265.                 // Set right listview
  266.  
  267.             GT_SetGadgetAttrs(MainWinGadgets[GD_MainVols], MainWinHandle, NULL,
  268.                 GTLV_Labels,    &VolList,
  269.             TAG_DONE);
  270.  
  271.                 // Set left listview
  272.  
  273.             GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  274.                 GTLV_Labels,    &VolumeList,
  275.             TAG_DONE);
  276.  
  277.                 // Set variables for Window handling
  278.  
  279.             SelVolume    = SelEdVolume = -1;
  280.             LastLeft    = LastRight = -1;
  281.             SecsLeft    = MinsLeft = SecsRight = MinsRight = -1;
  282.         }
  283.         else
  284.             CloseMainWin();
  285.     }
  286.     else
  287.         FreeDevVolList(&VolList);
  288.  
  289.     if(!MainWinHandle)
  290.         DisplayError(ERR_NOMEM, NULL);
  291.  
  292.     return((BOOL)(MainWinHandle != NULL));
  293. }
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301. /**********************************************************************/
  302. /*                      Close main window again                       */
  303. /**********************************************************************/
  304. void CloseMainWin(void)
  305. {
  306.         // Unbusy window first
  307.  
  308.     UnBusyWindow(MainWinHandle, &MainReq);
  309.  
  310.         // Close window
  311.  
  312.     CloseWin(&MainWinHandle, &MainWinGList, &MainVisInfo, NULL);
  313.  
  314.         // Free volume list
  315.  
  316.     FreeDevVolList(&VolList);
  317. }
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324. /**********************************************************************/
  325. /*                          Open Edit window                          */
  326. /**********************************************************************/
  327. BOOL OpenEditWin(void)
  328. {
  329.         // Try to open editor window
  330.  
  331.     if(OpenWin(EditWinLeft,
  332.         EditWinTop,
  333.         EditWinWidth,
  334.         EditWinHeight,
  335.         &EditWinGList,
  336.         EDITWIN_CNT,
  337.         &EditWinGet,
  338.         EditWinNGad,
  339.         EditWinGTypes,
  340.         EditWinGTags,
  341.         EditWinGadgets,
  342.         &EditWinHandle,
  343.         "ForceIcon v"REVISION" ("REVDATE") - GiftWare, Kai Iske",
  344.         LISTVIEWIDCMP|BUTTONIDCMP|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,
  345.         WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
  346.         5,
  347.         3,
  348.         423,
  349.         83,
  350.         &EditWinTxtAttr,
  351.         EditWinFontName,
  352.     &EditVisInfo))
  353.     {
  354.             // Set gadgets
  355.  
  356.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditVol], EditWinHandle, NULL,
  357.             GTST_String,    OrigEntry.VolName,
  358.         TAG_DONE);
  359.  
  360.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditType], EditWinHandle, NULL,
  361.             GTCY_Active,    (ManualType = !(OrigEntry.Link.ln_Type == LDF_DEVICES)),
  362.         TAG_DONE);
  363.  
  364.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditX], EditWinHandle, NULL,
  365.             GTIN_Number,    OrigEntry.Left,
  366.         TAG_DONE);
  367.  
  368.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditY], EditWinHandle, NULL,
  369.             GTIN_Number,    OrigEntry.Top,
  370.         TAG_DONE);
  371.  
  372.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditIcon], EditWinHandle, NULL,
  373.             GTST_String,    OrigEntry.IconName,
  374.         TAG_DONE);
  375.  
  376.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditUseIcon], EditWinHandle, NULL,
  377.             GTCB_Checked,    OrigEntry.UseAlt,
  378.         TAG_DONE);
  379.  
  380.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditIcon], EditWinHandle, NULL,
  381.             GA_Disabled,    !OrigEntry.UseAlt,
  382.         TAG_DONE);
  383.  
  384.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditX], EditWinHandle, NULL,
  385.             GA_Disabled,    !OrigEntry.IconPos,
  386.         TAG_DONE);
  387.  
  388.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditY], EditWinHandle, NULL,
  389.             GA_Disabled,    !OrigEntry.IconPos,
  390.         TAG_DONE);
  391.  
  392.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditPos], EditWinHandle, NULL,
  393.             GA_Disabled,    !OrigEntry.IconPos,
  394.         TAG_DONE);
  395.  
  396.         GT_SetGadgetAttrs(EditWinGadgets[GD_EditIconPos], EditWinHandle, NULL,
  397.             GTCB_Checked,    OrigEntry.IconPos,
  398.         TAG_DONE);
  399.  
  400.         SetGetFileState(EditWinGadgets[GD_EditGet], EditWinHandle, !OrigEntry.UseAlt);
  401.  
  402.             // Set work mode variable
  403.  
  404.         PosMode = 0;
  405.     }
  406.     else
  407.         CloseEditWin();
  408.  
  409.     if(!EditWinHandle)
  410.         DisplayError(ERR_NOMEM, NULL);
  411.  
  412.     return((BOOL)(EditWinHandle != NULL));
  413. }
  414.  
  415.  
  416.  
  417.  
  418.  
  419.  
  420. /**********************************************************************/
  421. /*                        Close Editor window                         */
  422. /**********************************************************************/
  423. void CloseEditWin(void)
  424. {
  425.         // UnLock main window again
  426.  
  427.     UnBusyWindow(MainWinHandle, &MainReq);
  428.  
  429.         // Close position window
  430.  
  431.     ClosePosWin();
  432.  
  433.         // Close Editor window
  434.  
  435.     CloseWin(&EditWinHandle, &EditWinGList, &EditVisInfo, &EditWinGet);
  436. }
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445. /**********************************************************************/
  446. /*                         Open manual window                         */
  447. /**********************************************************************/
  448. BOOL OpenManWin(void)
  449. {
  450.         // Try to open manual input window
  451.  
  452.     if(OpenWin(ManWinLeft,
  453.         ManWinTop,
  454.         ManWinWidth,
  455.         ManWinHeight,
  456.         &ManWinGList,
  457.         MANWIN_CNT,
  458.         NULL,
  459.         ManWinNGad,
  460.         ManWinGTypes,
  461.         ManWinGTags,
  462.         ManWinGadgets,
  463.         &ManWinHandle,
  464.         "ForceIcon v"REVISION" ("REVDATE") - GiftWare, Kai Iske",
  465.         LISTVIEWIDCMP|BUTTONIDCMP|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,
  466.         WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
  467.         5,
  468.         3,
  469.         429,
  470.         22,
  471.         &ManWinTxtAttr,
  472.         ManWinFontName,
  473.     &ManVisInfo))
  474.     {
  475.         ManualType = 0;
  476.         ActivateGadget(ManWinGadgets[GD_ManVol], ManWinHandle, NULL);
  477.     }
  478.     else
  479.         CloseManWin();
  480.  
  481.     if(!ManWinHandle)
  482.         DisplayError(ERR_NOMEM, NULL);
  483.  
  484.     return((BOOL)(ManWinHandle != NULL));
  485. }
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493. /**********************************************************************/
  494. /*                        Close manual window                         */
  495. /**********************************************************************/
  496. void CloseManWin(void)
  497. {
  498.         // Unbusy main window first
  499.  
  500.     UnBusyWindow(MainWinHandle, &MainReq);
  501.  
  502.         // Close manual input window
  503.  
  504.     CloseWin(&ManWinHandle, &ManWinGList, &ManVisInfo, NULL);
  505. }
  506.  
  507.  
  508.  
  509.  
  510.  
  511.  
  512. /**********************************************************************/
  513. /*                        Open position window                        */
  514. /**********************************************************************/
  515. BOOL OpenPosWin(void)
  516. {
  517.     struct    Screen        *WBScreen;
  518.  
  519.         // Get info about WBScreen
  520.  
  521.     if((WBScreen = LockPubScreen("Workbench")))
  522.     {
  523.         PosWinHandle = OpenWindowTags(NULL,
  524.             WA_Left,    OrigEntry.Left,
  525.             WA_Top,        OrigEntry.Top,
  526.             WA_Width,    (EditWinHandle->IFont->tf_XSize * 8) + 30 + WBScreen->WBorLeft + WBScreen->WBorRight,
  527.             WA_Height,    WBScreen->WBorTop + WBScreen->Font->ta_YSize + 1,
  528.             WA_IDCMP,    IDCMP_CHANGEWINDOW,
  529.             WA_Flags,    WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_RMBTRAP,
  530.             WA_Title,    "IconPos",
  531.             WA_PubScreen,    WBScreen,
  532.         TAG_DONE);
  533.             // Unlock screen
  534.  
  535.         UnlockPubScreen(NULL, WBScreen);
  536.     }
  537.  
  538.  
  539.     if(!PosWinHandle)
  540.         DisplayError(ERR_NOMEM, NULL);
  541.  
  542.     return((BOOL)(PosWinHandle != NULL));
  543. }
  544.  
  545.  
  546.  
  547.  
  548. /**********************************************************************/
  549. /*                       Close Position window                        */
  550. /**********************************************************************/
  551. void ClosePosWin(void)
  552. {
  553.     if(PosWinHandle)
  554.         CloseWindow(PosWinHandle);
  555.     PosWinHandle = NULL;
  556. }
  557.  
  558.  
  559.  
  560. /**********************************************************************/
  561. /*                 Check for inputs from main window                  */
  562. /**********************************************************************/
  563. BOOL HandleMainWin(BOOL *QuitIT)
  564. {
  565.     struct    IntuiMessage    *MyMsg;
  566.     struct    Gadget        *MsgGad;
  567.     ULONG    MsgClass, CurrentSecs, CurrentMins;
  568.     UWORD    GadID, MsgQual, MsgCode;
  569.     BOOL    CloseIT = FALSE, KeyUse;
  570.  
  571.         // Loop for all messages
  572.  
  573.     while((MyMsg = (struct IntuiMessage *)GT_GetIMsg(MainWinHandle->UserPort)))
  574.     {
  575.         MsgClass    = MyMsg->Class;
  576.         MsgQual        = MyMsg->Qualifier;
  577.         MsgCode        = MyMsg->Code;
  578.         CurrentSecs    = MyMsg->Seconds;
  579.         CurrentMins    = MyMsg->Micros;
  580.  
  581.         if((MsgClass & (IDCMP_GADGETUP|IDCMP_GADGETDOWN)))
  582.         {
  583.             MsgGad    = (struct Gadget *)MyMsg->IAddress;
  584.             GadID    = MsgGad->GadgetID;
  585.         }
  586.  
  587.         CheckKeys(&MsgClass, &MsgCode, &GadID, &KeyUse, &MsgGad, &MainWinGadgets[0], MAINWIN_CNT);
  588.  
  589.         GT_ReplyIMsg(MyMsg);
  590.  
  591.         switch(MsgClass)
  592.         {
  593.             case IDCMP_CLOSEWINDOW :
  594.             {
  595.                 CloseIT    = TRUE;
  596.                 break;
  597.             }
  598.             case IDCMP_GADGETUP :
  599.             {
  600.                 switch(GadID)
  601.                 {
  602.                         // Save prefs to env:
  603.  
  604.                     case GD_MainUse :
  605.                     {
  606.                         SavePrefs(TRUE);
  607.                         CloseIT = TRUE;
  608.                         break;
  609.                     }
  610.                         // Save prefs to env: and envarc:
  611.  
  612.                     case GD_MainSave :
  613.                     {
  614.                         SavePrefs(FALSE);
  615.                         CloseIT = TRUE;
  616.                         break;
  617.                     }
  618.                         // Display about
  619.  
  620.                     case GD_MainAbout :
  621.                     {
  622.                         DisplayError(ERR_ABOUT, VERNUM, REVNUM, (ULONG)REVDATE, NULL);
  623.                         break;
  624.                     }
  625.  
  626.                         // Quit it
  627.  
  628.                     case GD_MainQuit :
  629.                     {
  630.                         *QuitIT    = TRUE;
  631.                         CloseIT    = TRUE;
  632.                         break;
  633.                     }
  634.                         // Hide all windows
  635.  
  636.                     case GD_MainHide :
  637.                     {
  638.                         CloseIT    = TRUE;
  639.                         break;
  640.                     }
  641.                         // Selected a new volume from the available ones ???
  642.  
  643.                     case GD_MainVols :
  644.                     {
  645.                         if((SelVolume = HandleListViewGad(MsgGad, MainWinHandle, KeyUse, MsgCode, MsgQual, SelVolume, 0, VolList.lh_Type - 1)) != -1)
  646.                         {
  647.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainAdd], MainWinHandle, NULL,
  648.                                 GA_Disabled,    FALSE,
  649.                             TAG_DONE);
  650.  
  651.                                 // Check for double-click
  652.  
  653.                             if(!KeyUse)
  654.                             {
  655.                                 if(LastRight == SelVolume)
  656.                                 {
  657.                                     if(DoubleClick(SecsRight, MinsRight, CurrentSecs, CurrentMins))
  658.                                     {
  659.                                         struct    VolEntry    *ThisEntry    = (struct VolEntry *)GetListEntry(&VolList, SelVolume);
  660.  
  661.                                         AddNewVolume(ThisEntry->VolName, ThisEntry->Link.ln_Type);
  662.                                     }
  663.                                 }
  664.                                 SecsRight    = CurrentSecs;
  665.                                 MinsRight    = CurrentMins;
  666.                                 LastRight    = SelVolume;
  667.                             }
  668.                         }
  669.                         break;
  670.                     }
  671.                     case GD_MainUseVols :
  672.                     {
  673.                             // Selected a new volume to edit ???
  674.  
  675.                         if((SelEdVolume = HandleListViewGad(MsgGad, MainWinHandle, KeyUse, MsgCode, MsgQual, SelEdVolume, 0, VolumeList.lh_Type - 1)) != -1)
  676.                         {
  677.                             strcpy(MainTypeStr, "Type: ");
  678.                             strcat(MainTypeStr, ManType2Labels[!(((struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume))->Link.ln_Type == LDF_DEVICES)]);
  679.  
  680.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  681.                                 GTTX_Text,    MainTypeStr,
  682.                             TAG_DONE);
  683.  
  684.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainEdit], MainWinHandle, NULL,
  685.                                 GA_Disabled,    FALSE,
  686.                             TAG_DONE);
  687.  
  688.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainRemove], MainWinHandle, NULL,
  689.                                 GA_Disabled,    FALSE,
  690.                             TAG_DONE);
  691.  
  692.                                 // Check for double-click
  693.  
  694.                             if(!KeyUse)
  695.                             {
  696.                                 if(LastLeft == SelEdVolume)
  697.                                 {
  698.                                     if(DoubleClick(SecsLeft, MinsLeft, CurrentSecs, CurrentMins))
  699.                                     {
  700.                                         struct    VolEntry    *EditEntry;
  701.  
  702.                                         if((EditEntry = (struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume)))
  703.                                         {
  704.                                             strcpy(OrigEntry.VolName, EditEntry->VolName);
  705.                                             strcpy(OrigEntry.IconName, EditEntry->IconName);
  706.                                             OrigEntry.Link.ln_Type    = EditEntry->Link.ln_Type;
  707.                                             OrigEntry.Left        = EditEntry->Left;
  708.                                             OrigEntry.Top        = EditEntry->Top;
  709.                                             OrigEntry.UseAlt    = EditEntry->UseAlt;
  710.                                             OrigEntry.IconPos    = EditEntry->IconPos;
  711.  
  712.                                             if(OpenEditWin())
  713.                                                 BusyWindow(MainWinHandle, &MainReq);
  714.                                         }
  715.                                     }
  716.                                 }
  717.                                 SecsLeft    = CurrentSecs;
  718.                                 MinsLeft    = CurrentMins;
  719.                                 LastLeft    = SelEdVolume;
  720.                             }
  721.                         }
  722.                         break;
  723.                     }
  724.                         // Add new entry to list
  725.  
  726.                     case GD_MainAdd :
  727.                     {
  728.                         struct    VolEntry    *VolEntry = (struct VolEntry *)GetListEntry(&VolList, SelVolume);
  729.  
  730.                         if(SelVolume != -1)
  731.                             AddNewVolume(VolEntry->VolName, VolEntry->Link.ln_Type);
  732.                         break;
  733.                     }
  734.                         // Remove active entry from list
  735.  
  736.                     case GD_MainRemove :
  737.                     {
  738.                         struct    VolEntry    *ThisEntry = (struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume);
  739.  
  740.                         if(ThisEntry)
  741.                         {
  742.                                 // Get semaphore
  743.  
  744.                             ObtainSemaphore(&MySemaphore);
  745.  
  746.                                 // Remove list from ListView
  747.  
  748.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  749.                                 GTLV_Labels,    ~0,
  750.                             TAG_DONE);
  751.  
  752.                                 // Remove entry and free memory
  753.  
  754.                             Remove((struct Node *)ThisEntry);
  755.                             FreeVec(ThisEntry);
  756.  
  757.                                 // One entry less
  758.  
  759.                             VolumeList.lh_Type--;
  760.  
  761.                                 // Set pointer to current entry
  762.  
  763.                             if(SelEdVolume >= VolumeList.lh_Type)
  764.                                 SelEdVolume--;
  765.  
  766.                                 // Still entries available ???
  767.  
  768.                             if(SelEdVolume > -1)
  769.                             {
  770.                                     // Reinstall list
  771.  
  772.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  773.                                     GTLV_Labels,    &VolumeList,
  774.                                     GTLV_Selected,    SelEdVolume,
  775.                                     GTLV_Top,    SelEdVolume,
  776.                                 TAG_DONE);
  777.  
  778.                                 strcpy(MainTypeStr, "Type: ");
  779.                                 strcat(MainTypeStr, ManType2Labels[!(((struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume))->Link.ln_Type == LDF_DEVICES)]);
  780.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  781.                                     GTTX_Text,    MainTypeStr,
  782.                                 TAG_DONE);
  783.                             }
  784.                             else
  785.                             {
  786.                                     // Disable gadgets
  787.  
  788.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  789.                                     GTLV_Labels,    NULL,
  790.                                 TAG_DONE);
  791.  
  792.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainEdit], MainWinHandle, NULL,
  793.                                     GA_Disabled,    TRUE,
  794.                                 TAG_DONE);
  795.  
  796.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainRemove], MainWinHandle, NULL,
  797.                                     GA_Disabled,    TRUE,
  798.                                 TAG_DONE);
  799.  
  800.                                 strcpy(MainTypeStr, "");
  801.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  802.                                     GTTX_Text,    MainTypeStr,
  803.                                 TAG_DONE);
  804.                             }
  805.  
  806.                             ReleaseSemaphore(&MySemaphore);
  807.                         }
  808.                         break;
  809.                     }
  810.                         // Edit current entry using the Editor window
  811.  
  812.                     case GD_MainEdit :
  813.                     {
  814.                         struct    VolEntry    *EditEntry;
  815.  
  816.                         if((EditEntry = (struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume)))
  817.                         {
  818.                                 // Copy data from current entry to spare
  819.  
  820.                             strcpy(OrigEntry.VolName, EditEntry->VolName);
  821.                             strcpy(OrigEntry.IconName, EditEntry->IconName);
  822.                             OrigEntry.Link.ln_Type    = EditEntry->Link.ln_Type;
  823.                             OrigEntry.Left        = EditEntry->Left;
  824.                             OrigEntry.Top        = EditEntry->Top;
  825.                             OrigEntry.UseAlt    = EditEntry->UseAlt;
  826.                             OrigEntry.IconPos    = EditEntry->IconPos;
  827.  
  828.                             if(OpenEditWin())
  829.                                 BusyWindow(MainWinHandle, &MainReq);
  830.                         }
  831.                         break;
  832.                     }
  833.                         // Enter manually
  834.  
  835.                     case GD_MainManual :
  836.                     {
  837.                         if(OpenManWin())
  838.                             BusyWindow(MainWinHandle, &MainReq);
  839.                         break;
  840.                     }
  841.                         // Recan volume list
  842.  
  843.                     case GD_MainRescan :
  844.                     {
  845.                             // Remove list
  846.  
  847.                         GT_SetGadgetAttrs(MainWinGadgets[GD_MainVols], MainWinHandle, NULL,
  848.                             GTLV_Labels,    ~0,
  849.                         TAG_DONE);
  850.  
  851.                             // Free old list and get new
  852.  
  853.                         FreeDevVolList(&VolList);
  854.                         GetDevVolList(&VolList);
  855.  
  856.                             // Set pointer to current entry
  857.  
  858.                         if(SelVolume >= VolList.lh_Type)
  859.                             SelVolume = VolList.lh_Type - 1;
  860.  
  861.                             // Reinstall gadget
  862.  
  863.                         GT_SetGadgetAttrs(MainWinGadgets[GD_MainVols], MainWinHandle, NULL,
  864.                             GTLV_Labels,    &VolList,
  865.                         TAG_DONE);
  866.  
  867.                             // Set gadget state
  868.  
  869.                         if(!VolList.lh_Type)
  870.                         {
  871.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainAdd], MainWinHandle, NULL,
  872.                                 GA_Disabled,    TRUE,
  873.                             TAG_DONE);
  874.                         }
  875.                         else
  876.                         {
  877.                             if(SelVolume != -1)
  878.                             {
  879.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainAdd], MainWinHandle, NULL,
  880.                                     GA_Disabled,    FALSE,
  881.                                 TAG_DONE);
  882.                             }
  883.                         }
  884.                         break;
  885.                     }
  886.                 }
  887.                 break;
  888.             }
  889.         }
  890.     }
  891.  
  892.     return(CloseIT);
  893. }
  894.  
  895.  
  896.  
  897.  
  898.  
  899. /**********************************************************************/
  900. /*                 Add a new entry to the volume list                 */
  901. /**********************************************************************/
  902. BOOL AddNewVolume(char *Name, ULONG Type)
  903. {
  904.     struct    VolEntry    *NewEntry;
  905.     BOOL    RetVal = TRUE;
  906.  
  907.         // Check for exitance
  908.  
  909.     if(CheckExists(Name))
  910.     {
  911.         DisplayError(ERR_EXISTS, (ULONG)Name, NULL);
  912.         return(FALSE);
  913.     }
  914.  
  915.         // Try to get our semaphore
  916.  
  917.     ObtainSemaphore(&MySemaphore);
  918.  
  919.         // Get memory for new entry
  920.  
  921.     if((NewEntry = AllocVec(sizeof(struct VolEntry), MEMF_CLEAR)))
  922.     {
  923.         GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  924.             GTLV_Labels,    ~0,
  925.         TAG_DONE);
  926.  
  927.         VolumeList.lh_Type++;
  928.         SelEdVolume = -1;
  929.  
  930.             // Add entry and fill out structure
  931.  
  932.         if(Type == LDF_VOLUMES)
  933.             AddHead(&VolumeList, (struct Node *)NewEntry);
  934.         else
  935.             AddTail(&VolumeList, (struct Node *)NewEntry);
  936.  
  937.         NewEntry->Link.ln_Name    = NewEntry->VolName;
  938.         NewEntry->Link.ln_Type    = Type;
  939.         strcpy(NewEntry->VolName, Name);
  940.  
  941.             // Sort the list again
  942.  
  943.         SortList(&VolumeList, TRUE);
  944.  
  945.             // reset listview
  946.  
  947.         GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  948.             GTLV_Labels,    &VolumeList,
  949.             GTLV_Selected,    ~0,
  950.             GTLV_Top,    0,
  951.         TAG_DONE);
  952.  
  953.             // Disable edit and remove gadgets
  954.  
  955.         GT_SetGadgetAttrs(MainWinGadgets[GD_MainEdit], MainWinHandle, NULL,
  956.             GA_Disabled,    TRUE,
  957.         TAG_DONE);
  958.  
  959.         GT_SetGadgetAttrs(MainWinGadgets[GD_MainRemove], MainWinHandle, NULL,
  960.             GA_Disabled,    TRUE,
  961.         TAG_DONE);
  962.  
  963.         strcpy(MainTypeStr, "");
  964.         GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  965.             GTTX_Text,    MainTypeStr,
  966.         TAG_DONE);
  967.     }
  968.     else
  969.     {
  970.         DisplayError(ERR_NOMEM, NULL);
  971.         RetVal = FALSE;
  972.     }
  973.  
  974.         // Free our semaphore
  975.  
  976.     ReleaseSemaphore(&MySemaphore);
  977.  
  978.     return(RetVal);
  979. }
  980.  
  981.  
  982.  
  983.  
  984. /**********************************************************************/
  985. /*                  Handle inputs from Editor window                  */
  986. /**********************************************************************/
  987. BOOL HandleEditWin(void)
  988. {
  989.     struct    IntuiMessage    *MyMsg;
  990.     struct    Gadget        *MsgGad;
  991.     ULONG    MsgClass;
  992.     UWORD    GadID, MsgQual, MsgCode;
  993.     BOOL    CloseIT = FALSE, KeyUse;
  994.  
  995.         // Loop for all messages
  996.  
  997.     while((MyMsg = (struct IntuiMessage *)GT_GetIMsg(EditWinHandle->UserPort)))
  998.     {
  999.         MsgClass    = MyMsg->Class;
  1000.         MsgQual        = MyMsg->Qualifier;
  1001.         MsgCode        = MyMsg->Code;
  1002.  
  1003.         if((MsgClass & (IDCMP_GADGETUP|IDCMP_GADGETDOWN)))
  1004.         {
  1005.             MsgGad    = (struct Gadget *)MyMsg->IAddress;
  1006.             GadID    = MsgGad->GadgetID;
  1007.         }
  1008.  
  1009.         CheckKeys(&MsgClass, &MsgCode, &GadID, &KeyUse, &MsgGad, &EditWinGadgets[0], EDITWIN_CNT);
  1010.  
  1011.         GT_ReplyIMsg(MyMsg);
  1012.  
  1013.         switch(MsgClass)
  1014.         {
  1015.             case IDCMP_CLOSEWINDOW :
  1016.             {
  1017.                 CloseIT    = TRUE;
  1018.                 break;
  1019.             }
  1020.             case IDCMP_GADGETUP :
  1021.             {
  1022.                 switch(GadID)
  1023.                 {
  1024.                         // Settings ok, copy to current entry
  1025.  
  1026.                     case GD_EditOk :
  1027.                     {
  1028.                         struct    VolEntry    *ToEntry = (struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume);
  1029.  
  1030.                         if(ToEntry)
  1031.                         {
  1032.                             LONG    NewSel = SelEdVolume;
  1033.  
  1034.                                 // Get semaphore
  1035.  
  1036.                             ObtainSemaphore(&MySemaphore);
  1037.  
  1038.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  1039.                                 GTLV_Labels,    ~0,
  1040.                             TAG_DONE);
  1041.  
  1042.                                 // Fill out structure
  1043.  
  1044.                             strcpy(ToEntry->VolName, ((struct StringInfo *)EditWinGadgets[GD_EditVol]->SpecialInfo)->Buffer);
  1045.                             strcpy(ToEntry->IconName, ((struct StringInfo *)EditWinGadgets[GD_EditIcon]->SpecialInfo)->Buffer);
  1046.                             if(!strstr(ToEntry->IconName, ".info") && strlen(ToEntry->IconName))
  1047.                                 strcat(ToEntry->IconName, ".info");
  1048.  
  1049.                                 // Rearrange Node`s position
  1050.  
  1051.                             if(ToEntry->Link.ln_Type != OrigEntry.Link.ln_Type)
  1052.                             {
  1053.                                 Remove((struct Node *)ToEntry);
  1054.  
  1055.                                 if(OrigEntry.Link.ln_Type == LDF_DEVICES)
  1056.                                     AddTail(&VolumeList, (struct Node *)ToEntry);
  1057.                                 else
  1058.                                     AddHead(&VolumeList, (struct Node *)ToEntry);
  1059.                                 SelEdVolume    = -1;
  1060.                                 NewSel        = ~0;
  1061.                             }
  1062.  
  1063.                             ToEntry->Link.ln_Type    = OrigEntry.Link.ln_Type;
  1064.                             ToEntry->Left        = OrigEntry.Left;
  1065.                             ToEntry->Top        = OrigEntry.Top;
  1066.                             ToEntry->UseAlt        = OrigEntry.UseAlt;
  1067.                             ToEntry->IconPos    = OrigEntry.IconPos;
  1068.  
  1069.                                 // Sort List again
  1070.  
  1071.                             if(NewSel == ~0)
  1072.                                 SortList(&VolumeList, TRUE);
  1073.  
  1074.                                 // Reset listview
  1075.  
  1076.                             GT_SetGadgetAttrs(MainWinGadgets[GD_MainUseVols], MainWinHandle, NULL,
  1077.                                 GTLV_Labels,    &VolumeList,
  1078.                                 GTLV_Selected,    NewSel,
  1079.                                 GTLV_Top,    0,
  1080.                             TAG_DONE);
  1081.  
  1082.                             if(NewSel == ~0)
  1083.                             {
  1084.                                     // Disable edit and remove gadgets
  1085.  
  1086.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainEdit], MainWinHandle, NULL,
  1087.                                     GA_Disabled,    TRUE,
  1088.                                 TAG_DONE);
  1089.  
  1090.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainRemove], MainWinHandle, NULL,
  1091.                                     GA_Disabled,    TRUE,
  1092.                                 TAG_DONE);
  1093.  
  1094.                                 strcpy(MainTypeStr, "");
  1095.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  1096.                                     GTTX_Text,    MainTypeStr,
  1097.                                 TAG_DONE);
  1098.                             }
  1099.                             else
  1100.                             {
  1101.                                 strcpy(MainTypeStr, "Type: ");
  1102.                                 strcat(MainTypeStr, ManType2Labels[!(((struct VolEntry *)GetListEntry(&VolumeList, SelEdVolume))->Link.ln_Type == LDF_DEVICES)]);
  1103.                                 GT_SetGadgetAttrs(MainWinGadgets[GD_MainType], MainWinHandle, NULL,
  1104.                                     GTTX_Text,    MainTypeStr,
  1105.                                 TAG_DONE);
  1106.                             }
  1107.  
  1108.                                 // Release our semaphore
  1109.  
  1110.                             ReleaseSemaphore(&MySemaphore);
  1111.                         }
  1112.  
  1113.                         CloseIT = TRUE;
  1114.                         break;
  1115.                     }
  1116.                         // Cancel Editor window
  1117.  
  1118.                     case GD_EditCancel :
  1119.                     {
  1120.                         CloseIT = TRUE;
  1121.                         break;
  1122.                     }
  1123.                         // Change Type of entry
  1124.  
  1125.                     case GD_EditType :
  1126.                     {
  1127.                         ManualType = HandleCycleGad(MsgGad, EditWinHandle, KeyUse, MsgCode, MsgQual, ManualType, 0, 1);
  1128.  
  1129.                         OrigEntry.Link.ln_Type = (!ManualType) ? LDF_DEVICES : LDF_VOLUMES;
  1130.                         break;
  1131.                     }
  1132.                         // Set X position manually
  1133.  
  1134.                     case GD_EditX :
  1135.                     {
  1136.                         if(OrigEntry.IconPos)
  1137.                         {
  1138.                             LONG    Val    = ((struct StringInfo *)MsgGad->SpecialInfo)->LongInt;
  1139.  
  1140.                             if(Val >= 0)
  1141.                             {
  1142.                                 OrigEntry.Left    = Val;
  1143.                                 if(PosWinHandle)
  1144.                                     MoveWindow(PosWinHandle, OrigEntry.Left - PosWinHandle->LeftEdge, 0);
  1145.                             }
  1146.                             else
  1147.                             {
  1148.                                 DisplayError(ERR_NONEG, NULL);
  1149.                                 GT_SetGadgetAttrs(MsgGad, EditWinHandle, NULL,
  1150.                                     GTIN_Number,    OrigEntry.Left,
  1151.                                 TAG_DONE);
  1152.                             }
  1153.                         }
  1154.                         break;
  1155.                     }
  1156.                         // Set Y position manually
  1157.  
  1158.                     case GD_EditY :
  1159.                     {
  1160.                         if(OrigEntry.IconPos)
  1161.                         {
  1162.                             LONG    Val    = ((struct StringInfo *)MsgGad->SpecialInfo)->LongInt;
  1163.  
  1164.                             if(Val >= 0)
  1165.                             {
  1166.                                 OrigEntry.Top    = Val;
  1167.                                 if(PosWinHandle)
  1168.                                     MoveWindow(PosWinHandle, 0, OrigEntry.Top - PosWinHandle->TopEdge);
  1169.                             }
  1170.                             else
  1171.                             {
  1172.                                 DisplayError(ERR_NONEG, NULL);
  1173.                                 GT_SetGadgetAttrs(MsgGad, EditWinHandle, NULL,
  1174.                                     GTIN_Number,    OrigEntry.Top,
  1175.                                 TAG_DONE);
  1176.                             }
  1177.                         }
  1178.                         break;
  1179.                     }
  1180.  
  1181.                         // Open/Close position window
  1182.  
  1183.                     case GD_EditPos :
  1184.                     {
  1185.                         if(OrigEntry.IconPos)
  1186.                         {
  1187.                             PosMode = HandleCycleGad(MsgGad, EditWinHandle, KeyUse, MsgCode, MsgQual, PosMode, 0, 1);
  1188.  
  1189.                             if(PosMode)
  1190.                             {
  1191.                                 if(!OpenPosWin())
  1192.                                 {
  1193.                                     PosMode = 0;
  1194.                                     GT_SetGadgetAttrs(EditWinGadgets[GD_EditPos], EditWinHandle, NULL,
  1195.                                         GTCY_Active, PosMode,
  1196.                                     TAG_DONE);
  1197.                                 }
  1198.                             }
  1199.                             else
  1200.                                 ClosePosWin();
  1201.                         }
  1202.                         break;
  1203.                     }
  1204.                         // Set mode for Icon position
  1205.  
  1206.                     case GD_EditIconPos :
  1207.                     {
  1208.                         if(KeyUse)
  1209.                             OrigEntry.IconPos    = !OrigEntry.IconPos;
  1210.                         else
  1211.                             OrigEntry.IconPos    = MsgCode;
  1212.  
  1213.                         GT_SetGadgetAttrs(EditWinGadgets[GD_EditIconPos], EditWinHandle, NULL,
  1214.                             GTCB_Checked,    OrigEntry.IconPos,
  1215.                         TAG_DONE);
  1216.  
  1217.                         GT_SetGadgetAttrs(EditWinGadgets[GD_EditX], EditWinHandle, NULL,
  1218.                             GA_Disabled,    !OrigEntry.IconPos,
  1219.                         TAG_DONE);
  1220.  
  1221.                         GT_SetGadgetAttrs(EditWinGadgets[GD_EditY], EditWinHandle, NULL,
  1222.                             GA_Disabled,    !OrigEntry.IconPos,
  1223.                         TAG_DONE);
  1224.  
  1225.                         GT_SetGadgetAttrs(EditWinGadgets[GD_EditPos], EditWinHandle, NULL,
  1226.                             GA_Disabled,    !OrigEntry.IconPos,
  1227.                         TAG_DONE);
  1228.                         break;
  1229.                     }
  1230.                     case GD_EditGet :
  1231.                     {
  1232.                         char    BackName[256];
  1233.  
  1234.                             // Allowed to use alternative icon ???
  1235.  
  1236.                         if(OrigEntry.UseAlt)
  1237.                         {
  1238.                                 // Get it using ListView
  1239.  
  1240.                             strcpy(BackName, OrigEntry.IconName);
  1241.                             if(!GetFileName(EditWinHandle, "Select an icon", OrigEntry.IconName))
  1242.                                 strcpy(OrigEntry.IconName, BackName);
  1243.                             else
  1244.                             {
  1245.                                 if(!strstr(OrigEntry.IconName, ".info"))
  1246.                                     strcat(OrigEntry.IconName, ".info");
  1247.                             }
  1248.  
  1249.                             GT_SetGadgetAttrs(EditWinGadgets[GD_EditIcon], EditWinHandle, NULL,
  1250.                                 GTST_String,    OrigEntry.IconName,
  1251.                             TAG_DONE);
  1252.                         }
  1253.                         break;
  1254.                     }
  1255.                     case GD_EditUseIcon :
  1256.                     {
  1257.                         if(KeyUse)
  1258.                             OrigEntry.UseAlt = !OrigEntry.UseAlt;
  1259.                         else
  1260.                             OrigEntry.UseAlt = MsgCode;
  1261.  
  1262.                         GT_SetGadgetAttrs(MsgGad, EditWinHandle, NULL,
  1263.                             GTCB_Checked,    OrigEntry.UseAlt,
  1264.                         TAG_DONE);
  1265.  
  1266.                         GT_SetGadgetAttrs(EditWinGadgets[GD_EditIcon], EditWinHandle, NULL,
  1267.                             GA_Disabled,    !OrigEntry.UseAlt,
  1268.                         TAG_DONE);
  1269.  
  1270.                         SetGetFileState(EditWinGadgets[GD_EditGet], EditWinHandle, !OrigEntry.UseAlt);
  1271.                         break;
  1272.                     }
  1273.                 }
  1274.                 break;
  1275.             }
  1276.             case IDCMP_GADGETDOWN :
  1277.             {
  1278.                 switch(GadID)
  1279.                 {
  1280.                     case GD_EditVol :
  1281.                     {
  1282.                         ActivateGadget(MsgGad, EditWinHandle, NULL);
  1283.                         break;
  1284.                     }
  1285.                     case GD_EditIcon :
  1286.                     {
  1287.                         if(OrigEntry.UseAlt)
  1288.                         {
  1289.                             if(KeyUse && (MsgQual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
  1290.                             {
  1291.                                 char    BackName[256];
  1292.  
  1293.                                 strcpy(BackName, OrigEntry.IconName);
  1294.                                 if(!GetFileName(EditWinHandle, "Select an icon", OrigEntry.IconName))
  1295.                                     strcpy(OrigEntry.IconName, BackName);
  1296.                                 else
  1297.                                 {
  1298.                                     if(!strstr(OrigEntry.IconName, ".info"))
  1299.                                         strcat(OrigEntry.IconName, ".info");
  1300.                                 }
  1301.  
  1302.                                 GT_SetGadgetAttrs(EditWinGadgets[GD_EditIcon], EditWinHandle, NULL,
  1303.                                     GTST_String,    OrigEntry.IconName,
  1304.                                 TAG_DONE);
  1305.                             }
  1306.                             else
  1307.                                 ActivateGadget(MsgGad, EditWinHandle, NULL);
  1308.                         }
  1309.                         break;
  1310.                     }
  1311.                     case GD_EditX :
  1312.                     case GD_EditY :
  1313.                     {
  1314.                         if(OrigEntry.IconPos)
  1315.                             ActivateGadget(MsgGad, EditWinHandle, NULL);
  1316.                         break;
  1317.                     }
  1318.                 }
  1319.                 break;
  1320.             }
  1321.             case IDCMP_ACTSTRGAD :
  1322.             {
  1323.                 ActivateGadget(MsgGad, EditWinHandle, NULL);
  1324.                 break;
  1325.             }
  1326.         }
  1327.     }
  1328.  
  1329.     return(CloseIT);
  1330. }
  1331.  
  1332.  
  1333.  
  1334.  
  1335. /**********************************************************************/
  1336. /*                  Handle input from manual window                   */
  1337. /**********************************************************************/
  1338. BOOL HandleManWin(void)
  1339. {
  1340.     struct    IntuiMessage    *MyMsg;
  1341.     struct    Gadget        *MsgGad;
  1342.     ULONG    MsgClass;
  1343.     UWORD    GadID, MsgCode, MsgQual;
  1344.     BOOL    CloseIT = FALSE, KeyUse;
  1345.  
  1346.         // Loop for all messages
  1347.  
  1348.     while((MyMsg = (struct IntuiMessage *)GT_GetIMsg(ManWinHandle->UserPort)))
  1349.     {
  1350.         MsgClass    = MyMsg->Class;
  1351.         MsgCode        = MyMsg->Code;
  1352.         MsgQual        = MyMsg->Qualifier;
  1353.  
  1354.         if((MsgClass & (IDCMP_GADGETUP|IDCMP_GADGETDOWN)))
  1355.         {
  1356.             MsgGad    = (struct Gadget *)MyMsg->IAddress;
  1357.             GadID    = MsgGad->GadgetID;
  1358.         }
  1359.  
  1360.         CheckKeys(&MsgClass, &MsgCode, &GadID, &KeyUse, &MsgGad, &ManWinGadgets[0], EDITWIN_CNT);
  1361.  
  1362.         GT_ReplyIMsg(MyMsg);
  1363.  
  1364.         switch(MsgClass)
  1365.         {
  1366.             case IDCMP_CLOSEWINDOW :
  1367.             {
  1368.                 CloseIT    = TRUE;
  1369.                 break;
  1370.             }
  1371.             case IDCMP_GADGETUP :
  1372.             {
  1373.                 switch(GadID)
  1374.                 {
  1375.                         // On Ok, add a new volume to the list
  1376.  
  1377.                     case GD_ManOk :
  1378.                     {
  1379.                         if(!CheckExists(((struct StringInfo *)ManWinGadgets[GD_ManVol]->SpecialInfo)->Buffer))
  1380.                         {
  1381.                             AddNewVolume(((struct StringInfo *)ManWinGadgets[GD_ManVol]->SpecialInfo)->Buffer, (!ManualType) ? LDF_DEVICES : LDF_VOLUMES);
  1382.                             CloseIT = TRUE;
  1383.                         }
  1384.                         else
  1385.                             DisplayError(ERR_EXISTS, (ULONG)((struct StringInfo *)ManWinGadgets[GD_ManVol]->SpecialInfo)->Buffer, NULL);
  1386.                         break;
  1387.                     }
  1388.                     case GD_ManCancel :
  1389.                     {
  1390.                         CloseIT = TRUE;
  1391.                         break;
  1392.                     }
  1393.                     case GD_ManType :
  1394.                     {
  1395.                          ManualType = HandleCycleGad(MsgGad, ManWinHandle, KeyUse, MsgCode, MsgQual, ManualType, 0, 1);
  1396.                          break;
  1397.                     }
  1398.                 }
  1399.                 break;
  1400.             }
  1401.             case IDCMP_GADGETDOWN :
  1402.             {
  1403.                 switch(GadID)
  1404.                 {
  1405.                     case GD_ManVol :
  1406.                     {
  1407.                         ActivateGadget(MsgGad, ManWinHandle, NULL);
  1408.                         break;
  1409.                     }
  1410.                 }
  1411.                 break;
  1412.             }
  1413.             case IDCMP_ACTSTRGAD :
  1414.             {
  1415.                 ActivateGadget(MsgGad, ManWinHandle, NULL);
  1416.                 break;
  1417.             }
  1418.         }
  1419.     }
  1420.     return(CloseIT);
  1421. }
  1422.  
  1423.  
  1424.  
  1425.  
  1426.  
  1427.  
  1428.  
  1429. /**********************************************************************/
  1430. /*                 Handle input from Position window                  */
  1431. /**********************************************************************/
  1432. void HandlePosWin(void)
  1433. {
  1434.     struct    IntuiMessage    *MyMsg;
  1435.     ULONG    MsgClass;
  1436.  
  1437.     while((MyMsg = (struct IntuiMessage *)GT_GetIMsg(PosWinHandle->UserPort)))
  1438.     {
  1439.         MsgClass    = MyMsg->Class;
  1440.  
  1441.         GT_ReplyIMsg(MyMsg);
  1442.  
  1443.             // Window was moved, so set the new values to the number gadgets
  1444.  
  1445.         if(MsgClass == IDCMP_CHANGEWINDOW)
  1446.         {
  1447.             OrigEntry.Left    = PosWinHandle->LeftEdge;
  1448.             OrigEntry.Top    = PosWinHandle->TopEdge;
  1449.  
  1450.             GT_SetGadgetAttrs(EditWinGadgets[GD_EditX], EditWinHandle, NULL,
  1451.                 GTIN_Number,    OrigEntry.Left,
  1452.             TAG_DONE);
  1453.  
  1454.             GT_SetGadgetAttrs(EditWinGadgets[GD_EditY], EditWinHandle, NULL,
  1455.                 GTIN_Number,    OrigEntry.Top,
  1456.             TAG_DONE);
  1457.         }
  1458.     }
  1459. }
  1460.  
  1461.  
  1462.  
  1463.  
  1464. /**********************************************************************/
  1465. /*              Sets the state of a generic_kind gadget               */
  1466. /**********************************************************************/
  1467. void SetGetFileState(struct Gadget *Gad, struct Window *Win, BOOL State)
  1468. {
  1469.     RemoveGList(Win, Gad, 1);
  1470.  
  1471.     if(!State)
  1472.         Gad->Flags &= ~GFLG_DISABLED;
  1473.     else
  1474.         Gad->Flags |= GFLG_DISABLED;
  1475.  
  1476.     AddGList(Win, Gad, -1, 1, NULL);
  1477.     RefreshGList(Gad, Win, NULL, 1);
  1478. }
  1479.