home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / amigalib / d984 / forceicon.lha / ForceIcon / Source / FIconPrefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-05  |  58.1 KB  |  2,375 lines
  1. /*
  2. Auto:        smake FIconPrefs
  3. */
  4.  
  5.  
  6. /* $Revision Header built automatically *************** (do not edit) ************
  7. **
  8. ** © Copyright by GuntherSoft
  9. **
  10. ** File             : SnakeSYS:CPrgs/ForceIcon2/FIconPrefs.c
  11. ** Created on       : Wednesday, 16.03.94 16:19:51
  12. ** Created by       : Kai Iske
  13. ** Current revision : V1.0
  14. **
  15. **
  16. ** Purpose
  17. ** -------
  18. **   - Prefs Editor for ForceIcon
  19. **
  20. ** Revision V1.0
  21. ** --------------
  22. ** created on Wednesday, 16.03.94 16:19:51  by  Kai Iske.   LogMessage :
  23. **     --- Initial release ---
  24. **
  25. *********************************************************************************/
  26.  
  27.  
  28.  
  29.  
  30. /**********************************************************************/
  31. /*                     Define for DisplayError()                      */
  32. /**********************************************************************/
  33. #define    PREFSRUN
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40. /**********************************************************************/
  41. /*                      Routines for this module                      */
  42. /**********************************************************************/
  43. static BOOL            OpenAll(void);
  44. static void            CloseAll(void);
  45. static struct    FIconSema    *FindFIconSema(void);
  46. static void            RemoveFIconSema(struct FIconSema *FIconSema);
  47. static BOOL            InitApp(void);
  48. static void            RemoveApp(void);
  49. static ULONG    __saveds __asm    DispViewFunc(register __a0 struct Hook *MyHook, register __a2 char **array, register __a1 struct VolEntry *Data);
  50. static ULONG    __saveds __asm    DisableFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data);
  51. static ULONG    __saveds __asm    PageChangeFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data);
  52. static struct    VolEntry    *AddNewVolume(char *Name, ULONG Type, struct VolEntry *CopyPtr);
  53. static BOOL            CheckExists(char *Name);
  54. static BOOL            SavePrefs(BOOL EnvMode);
  55. static void            DskChange(struct VolEntry *ListEntry);
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62. /**********************************************************************/
  63. /*                    Functions of files included                     */
  64. /**********************************************************************/
  65.     // LoadPrefs.h
  66.  
  67. static void            LoadPrefs(struct FIconSema *FIconSema);
  68.  
  69.     // VolList.h
  70.  
  71. static BOOL            GetDevVolList(struct List *VolList);
  72. static BOOL            GetDosEntries(struct List *VolList, ULONG Mode);
  73. static void            FreeDevVolList(struct List *VolList);
  74. static void            SortList(struct List *VolList, BOOL DisplayType);
  75. static void            SortPartialList(struct List *VolList, UWORD Left, UWORD Right);
  76. static APTR            GetListEntry(struct List *List, WORD EntryNum);
  77. static BOOL            MyStrCmp(char *FromName, char *ToName);
  78.  
  79.     // Error.h
  80.  
  81. static void    __stdargs    DisplayError(LONG ErrCode, ULONG Arg1, ...);
  82.  
  83.     // CheckToolTypes.h
  84.  
  85. static void            CheckToolTypes(struct WBStartup *WBenchMsg);
  86.  
  87.     // PoolVec.h
  88.  
  89. static APTR            AllocVecPool(struct FIconSema *FIconSema, ULONG Size);
  90. static void            FreeVecPool(struct FIconSema *FIconSema, APTR Addr);
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97. /**********************************************************************/
  98. /*                           Library bases                            */
  99. /**********************************************************************/
  100. struct    ExecBase        *SysBase;
  101. struct    IntuitionBase        *IntuitionBase    = NULL;
  102. struct    DosLibrary        *DOSBase    = NULL;
  103. struct    Library            *IconBase    = NULL;
  104. struct    Library            *UtilityBase    = NULL;
  105. struct    Library            *IFFParseBase    = NULL;
  106. struct    Library            *MUIMasterBase    = NULL;
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113. /**********************************************************************/
  114. /*                         "No-StartUp vars"                          */
  115. /**********************************************************************/
  116. #define    MUIVERS                    "$VER:ForceIcon_Prefs "REVISION" ("REVDATE")"
  117. char                _ProgramName[]    = "ForceIconPrefs";
  118. LONG                _OSERR        = 0;
  119.  
  120.  
  121.  
  122.  
  123. /**********************************************************************/
  124. /*                           Our variables                            */
  125. /**********************************************************************/
  126. static    struct    FIconSema    *FIconSema    = NULL;        // Pointer to our rendezvous semaphore
  127. static    struct    List        AvailableList;
  128. static    UWORD            FlushMemory    = FALSE;
  129.  
  130.  
  131.  
  132.  
  133. /**********************************************************************/
  134. /*                 Application and window definitions                 */
  135. /**********************************************************************/
  136. static    struct    DiskObject    *DObj        = NULL;
  137. static    APTR            AppObject    = NULL;
  138. static    APTR            MainWindow    = NULL;
  139. static    APTR            UsedList;
  140. static    APTR            EditEntry;
  141. static    APTR            CopyEntry;
  142. static    APTR            RemoveEntry;
  143. static    APTR            AvailList;
  144. static    APTR            AddEntry;
  145. static    APTR            AddEntryMan;
  146. static    APTR            RescanList;
  147. static    APTR            SaveObj;
  148. static    APTR            UseObj;
  149. static    APTR            AboutObj;
  150. static    APTR            HideObj;
  151. static    APTR            QuitObj;
  152.  
  153. static    APTR            EditWindow;
  154. static    APTR            VolumeName;
  155. static    APTR            VolumeType;
  156. static    APTR            IconPosGroup;
  157. static    APTR            IconPos[2];
  158. static    APTR            IconX;
  159. static    APTR            IconY;
  160. static    APTR            Position;
  161. static    APTR            UseIconGroup;
  162. static    APTR            UseIcon[2];
  163. static    APTR            IconName;
  164. static    APTR            UseWindowGroup;
  165. static    APTR            UseWindow[2];
  166. static    APTR            WinX;
  167. static    APTR            WinY;
  168. static    APTR            WinWidth;
  169. static    APTR            WinHeight;
  170. static    APTR            LookWin;
  171. static    APTR            UseFlagsGroup;
  172. static    APTR            UseFlags[2];
  173. static    APTR            FlagModes;
  174. static    APTR            EditOkObj;
  175. static    APTR            EditCancelObj;
  176.  
  177. static    APTR            ManWindow;
  178. static    APTR            ManVolName;
  179. static    APTR            ManVolType;
  180. static    APTR            ManOkObj;
  181. static    APTR            ManCancelObj;
  182.  
  183.  
  184.  
  185.  
  186.  
  187. /**********************************************************************/
  188. /*                     Strings for Cycle gadgets                      */
  189. /**********************************************************************/
  190. static const char *TypeEntries[] =
  191. {
  192.     "Volume",
  193.     "Device",
  194.     NULL
  195. };
  196.  
  197.  
  198. static const char *ModeEntriesVol[] =
  199. {
  200.     "Ignore",
  201.     "Use",
  202.     "Inherit",
  203.     NULL
  204. };
  205.  
  206.  
  207. static const char *ModeEntriesDev[] =
  208. {
  209.     "Ignore",
  210.     "Use",
  211.     NULL
  212. };
  213.  
  214.  
  215. static const char *PositionEntries[] =
  216. {
  217.     "Open position window",
  218.     "Close position window",
  219.     NULL
  220. };
  221.  
  222.  
  223.  
  224. static const char *LookWinEntries[] =
  225. {
  226.     "Open window",
  227.     "Close window",
  228.     NULL
  229. };
  230.  
  231.  
  232. static const char *FlagModesEntries[] =
  233. {
  234.     "only icons + view by icon",
  235.     "only icons + view by name",
  236.     "only icons + view by date",
  237.     "only icons + view by size",
  238.     "all files + view by icon",
  239.     "all files + view by name",
  240.     "all files + view by date",
  241.     "all files + view by size",
  242.     NULL
  243. };
  244.  
  245.  
  246. /**********************************************************************/
  247. /*                            Display Hook                            */
  248. /**********************************************************************/
  249. static struct Hook    DispViewHook =
  250. {
  251.     {NULL},
  252.     (APTR)DispViewFunc,
  253.     NULL,
  254.     NULL
  255. };
  256.  
  257.  
  258.  
  259. static struct Hook    DisableHook =
  260. {
  261.     {NULL},
  262.     (APTR)DisableFunc,
  263.     NULL,
  264.     NULL
  265. };
  266.  
  267.  
  268.  
  269. static struct Hook    PageChangeHook =
  270. {
  271.     {NULL},
  272.     (APTR)PageChangeFunc,
  273.     NULL,
  274.     NULL
  275. };
  276.  
  277.  
  278.  
  279. /**********************************************************************/
  280. /*                      This is our main program                      */
  281. /**********************************************************************/
  282. ULONG __saveds main(void)
  283. {
  284.     struct    Process        *MyProc;
  285.     struct    WBStartup    *WBenchMsg    = NULL;
  286.     struct    VolEntry    *EditEntryPtr    = NULL;
  287.     struct    Window        *PosWindow    = NULL,
  288.                 *DrawerWindow    = NULL;
  289.     ULONG            MySig,
  290.                 ReturnID;
  291.     BOOL            GoOn        = TRUE;
  292.  
  293.  
  294.  
  295.  
  296.         // Get SysBase
  297.  
  298.     SysBase    = *((struct ExecBase **)0x4L);
  299.  
  300.  
  301.         // Get address of our process
  302.  
  303.     MyProc = (struct Process *)FindTask(NULL);
  304.  
  305.  
  306.  
  307.         // Determine where we were started from
  308.  
  309.     if(!MyProc->pr_CLI)
  310.     {
  311.         WaitPort(&MyProc->pr_MsgPort);
  312.         WBenchMsg = (struct WBStartup *)GetMsg(&MyProc->pr_MsgPort);
  313.     }
  314.  
  315.  
  316.  
  317.         // Don`t run under OS < 37
  318.  
  319.     if(((struct Library *)SysBase)->lib_Version >= 37)
  320.     {
  321.             // Open libraries
  322.  
  323.         if(OpenAll())
  324.         {
  325.             if((FIconSema = FindFIconSema()))
  326.             {
  327.                     // Check for ToolTypes/commandline options
  328.  
  329.                 CheckToolTypes(WBenchMsg);
  330.  
  331.                 if(InitApp())
  332.                 {
  333.                     while(GoOn)
  334.                     {
  335.                         switch(ReturnID = DoMethod(AppObject, MUIM_Application_Input, &MySig))
  336.                         {
  337.                                 // Handle MAINWINDOW
  338.  
  339.  
  340.                                 // Save ?!?!
  341.  
  342.                             case ID_SAVE :
  343.                             {
  344.                                 SavePrefs(FALSE);
  345.                                 GoOn    = FALSE;
  346.                                 break;
  347.                             }
  348.  
  349.                                 // Use ?!?!
  350.  
  351.                             case ID_USE :
  352.                             {
  353.                                 SavePrefs(TRUE);
  354.                                 GoOn    = FALSE;
  355.                                 break;
  356.                             }
  357.  
  358.                                 // About ???
  359.  
  360.                             case ID_ABOUT :
  361.                             {
  362.                                 DisplayError(ERR_ABOUT, VERNUM, REVNUM, REVDATE, NULL);
  363.                                 break;
  364.                             }
  365.  
  366.                                 // Hide/Quit Prefs ?!?
  367.  
  368.                             case ID_HIDE :
  369.                             {
  370.                                 GoOn    = FALSE;
  371.                                 break;
  372.                             }
  373.  
  374.                                 // Hide/Quit Prefs and server ???
  375.  
  376.                             case ID_QUIT :
  377.                             {
  378.                                 struct    Task    *ServerTask;
  379.  
  380.                                 ObtainSemaphore(&FIconSema->FIconSema);
  381.                                 Forbid();
  382.                                 ServerTask    = FIconSema->ServerTask;
  383.                                 ReleaseSemaphore(&FIconSema->FIconSema);
  384.  
  385.                                     // Tell server to go away
  386.  
  387.                                 if(ServerTask)
  388.                                     Signal(ServerTask, SIGBREAKF_CTRL_C);
  389.                                 Permit();
  390.  
  391.                                 GoOn    = FALSE;
  392.                                 break;
  393.                             }
  394.  
  395.                             case ID_USEDLIST :
  396.                             case ID_EDITENTRY :
  397.                             {
  398.                                 struct    VolEntry    *ThisEntry;
  399.  
  400.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  401.  
  402.                                 if(ThisEntry)
  403.                                 {
  404.                                     set(VolumeName, MUIA_String_Contents, ThisEntry->VolName);
  405.                                     set(VolumeType, MUIA_Cycle_Active, (ThisEntry->Link.ln_Type == LDF_DEVICES));
  406.                                     set(IconPos[0], MUIA_Cycle_Active, ThisEntry->IconPos);
  407.                                     set(IconPos[1], MUIA_Cycle_Active, ThisEntry->IconPos);
  408.                                     set(IconX, MUIA_String_Integer, ThisEntry->Left);
  409.                                     set(IconX, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  410.                                     set(IconY, MUIA_String_Integer, ThisEntry->Top);
  411.                                     set(IconY, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  412.                                     set(Position, MUIA_Cycle_Active, 0);
  413.                                     set(Position, MUIA_Disabled, (ThisEntry->IconPos != MODE_USE));
  414.                                     set(UseIcon[0], MUIA_Cycle_Active, ThisEntry->UseAlt);
  415.                                     set(UseIcon[1], MUIA_Cycle_Active, ThisEntry->UseAlt);
  416.                                     set(IconName, MUIA_String_Contents, ThisEntry->IconName);
  417.                                     set(IconName, MUIA_Disabled, (ThisEntry->UseAlt != MODE_USE));
  418.                                     set(UseWindow[0], MUIA_Cycle_Active, ThisEntry->UseWin);
  419.                                     set(UseWindow[1], MUIA_Cycle_Active, ThisEntry->UseWin);
  420.                                     set(WinX, MUIA_String_Integer, ThisEntry->WinX);
  421.                                     set(WinX, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  422.                                     set(WinY, MUIA_String_Integer, ThisEntry->WinY);
  423.                                     set(WinY, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  424.                                     set(WinWidth, MUIA_String_Integer, ThisEntry->WinWidth);
  425.                                     set(WinWidth, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  426.                                     set(WinHeight, MUIA_String_Integer, ThisEntry->WinHeight);
  427.                                     set(WinHeight, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  428.                                     set(LookWin, MUIA_Cycle_Active, 0);
  429.                                     set(LookWin, MUIA_Disabled, (ThisEntry->UseWin != MODE_USE));
  430.                                     set(UseFlags[0], MUIA_Cycle_Active, ThisEntry->UseFlags);
  431.                                     set(UseFlags[1], MUIA_Cycle_Active, ThisEntry->UseFlags);
  432.                                     set(FlagModes, MUIA_Cycle_Active, ThisEntry->WinFlags);
  433.                                     set(FlagModes, MUIA_Disabled, (ThisEntry->UseFlags != MODE_USE));
  434.  
  435.                                     set(MainWindow, MUIA_Window_Sleep, TRUE);
  436.  
  437.                                     set(EditWindow, MUIA_Window_Open, TRUE);
  438.  
  439.                                     EditEntryPtr    = ThisEntry;
  440.                                 }
  441.                                 break;
  442.                             }
  443.  
  444.                                 // Copy an entry ???
  445.  
  446.                             case ID_COPYENTRY :
  447.                             {
  448.                                 struct    VolEntry    *ThisEntry;
  449.  
  450.  
  451.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  452.  
  453.                                 if(ThisEntry)
  454.                                 {
  455.                                     set(ManVolName, MUIA_String_Contents, ThisEntry->VolName);
  456.                                     set(ManVolType, MUIA_Cycle_Active, (ThisEntry->Link.ln_Type == LDF_DEVICES));
  457.  
  458.                                     set(MainWindow, MUIA_Window_Sleep, TRUE);
  459.                                     set(ManWindow, MUIA_Window_Title, "Copy entry");
  460.                                     set(ManWindow, MUIA_Window_Open, TRUE);
  461.  
  462.                                     EditEntryPtr    = ThisEntry;
  463.                                 }
  464.                                 break;
  465.                             }
  466.  
  467.  
  468.                                 // Remove an entry ???
  469.  
  470.                             case ID_REMOVEENTRY :
  471.                             {
  472.                                 struct    VolEntry    *ThisEntry;
  473.  
  474.                                 DoMethod(UsedList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  475.  
  476.                                 if(ThisEntry)
  477.                                 {
  478.                                     ObtainSemaphore(&FIconSema->FIconSema);
  479.  
  480.                                         // Remove entry from listview
  481.  
  482.                                     DoMethod(UsedList, MUIM_List_Remove, MUIV_List_Remove_Active);
  483.  
  484.                                         // Remove entry from internal list
  485.  
  486.                                     Remove(ThisEntry);
  487.                                     FreeVecPool(FIconSema, ThisEntry);
  488.  
  489.                                     FIconSema->VolumeList.lh_Type--;
  490.  
  491.                                     ReleaseSemaphore(&FIconSema->FIconSema);
  492.                                 }
  493.                                 break;
  494.                             }
  495.  
  496.                                 // Add an entry ???
  497.  
  498.                             case ID_AVAILLIST :
  499.                             case ID_ADDENTRY :
  500.                             {
  501.                                 struct    VolEntry    *ThisEntry;
  502.  
  503.                                     // Really get entry ???
  504.  
  505.                                 DoMethod(AvailList, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ThisEntry);
  506.  
  507.                                 if(ThisEntry)
  508.                                     AddNewVolume(ThisEntry->VolName, ThisEntry->Link.ln_Type, NULL);
  509.                                 break;
  510.                             }
  511.  
  512.  
  513.                                 // Manually add an entry ???
  514.  
  515.                             case ID_ADDENTRYMAN :
  516.                             {
  517.                                 set(ManVolName, MUIA_String_Contents, "");
  518.                                 set(ManVolType, MUIA_Cycle_Active, 0);
  519.  
  520.                                 set(MainWindow, MUIA_Window_Sleep, TRUE);
  521.                                 set(ManWindow, MUIA_Window_Title, "Add manually");
  522.                                 set(ManWindow, MUIA_Window_Open, TRUE);
  523.  
  524.                                 EditEntryPtr    = NULL;
  525.                                 break;
  526.                             }
  527.  
  528.  
  529.                                 // Rescan list ???
  530.  
  531.                             case ID_RESCANLIST :
  532.                             {
  533.                                 struct    VolEntry    *ThisEntry;
  534.  
  535.  
  536.                                     // Remove List from listview
  537.  
  538.                                 DoMethod(AvailList, MUIM_List_Clear, NULL);
  539.  
  540.                                     // FreeList
  541.  
  542.                                 FreeDevVolList(&AvailableList);
  543.                                 GetDevVolList(&AvailableList);
  544.  
  545.                                     // Add list of available entries
  546.  
  547.                                 ThisEntry    = (struct VolEntry *)AvailableList.lh_Head;
  548.                                 while(ThisEntry->Link.ln_Succ)
  549.                                 {
  550.                                     DoMethod(AvailList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  551.  
  552.                                     ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  553.                                 }
  554.                                 break;
  555.                             }
  556.  
  557.  
  558.  
  559.                                 // Check Edit window
  560.  
  561.                                 // Open/Close position window ???
  562.  
  563.                             case ID_POSITION :
  564.                             {
  565.                                 ULONG    State;
  566.  
  567.                                 get(Position, MUIA_Cycle_Active, &State);
  568.  
  569.                                 if(State && !PosWindow && EditEntryPtr)
  570.                                 {
  571.                                     struct    Screen    *WBScreen;
  572.  
  573.                                     if((WBScreen = LockPubScreen(NULL)))
  574.                                     {
  575.                                         PosWindow = OpenWindowTags(NULL,
  576.                                                 WA_Left,    EditEntryPtr->Left,
  577.                                                 WA_Top,        EditEntryPtr->Top,
  578.                                                 WA_Width,    (WBScreen->BarLayer->rp->Font->tf_XSize * 8) + 30 + WBScreen->WBorLeft + WBScreen->WBorRight,
  579.                                                 WA_Height,    WBScreen->WBorTop + WBScreen->Font->ta_YSize + 1,
  580.                                                 WA_IDCMP,    IDCMP_CHANGEWINDOW,
  581.                                                 WA_Flags,    WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_RMBTRAP,
  582.                                                 WA_Title,    "IconPos",
  583.                                                 WA_PubScreen,    WBScreen,
  584.                                         TAG_DONE);
  585.  
  586.                                         UnlockPubScreen(NULL, WBScreen);
  587.  
  588.                                         if(!PosWindow)
  589.                                         {
  590.                                             set(Position, MUIA_Cycle_Active, 0);
  591.                                             DisplayError(ERR_NOMEM, NULL);
  592.                                         }
  593.                                     }
  594.                                 }
  595.                                 else if(PosWindow)
  596.                                 {
  597.                                     CloseWindow(PosWindow);
  598.                                     PosWindow    = NULL;
  599.                                 }
  600.                                 break;
  601.                             }
  602.  
  603.                                 // Open/Close Drawer Window ???
  604.  
  605.                             case ID_DRAWER :
  606.                             {
  607.                                 ULONG    State;
  608.  
  609.                                 get(LookWin, MUIA_Cycle_Active, &State);
  610.  
  611.                                 if(State && !DrawerWindow && EditEntryPtr)
  612.                                 {
  613.                                     struct    Screen    *WBScreen;
  614.  
  615.                                     if((WBScreen = LockPubScreen(NULL)))
  616.                                     {
  617.                                         DrawerWindow = OpenWindowTags(NULL,
  618.                                                 WA_Left,    EditEntryPtr->WinX,
  619.                                                 WA_Top,        EditEntryPtr->WinY,
  620.                                                 WA_Width,    (EditEntryPtr->WinWidth ? EditEntryPtr->WinWidth : 50),
  621.                                                 WA_Height,    (EditEntryPtr->WinHeight ? EditEntryPtr->WinHeight : 50),
  622.                                                 WA_MaxWidth,    -1,
  623.                                                 WA_MaxHeight,    -1,
  624.                                                 WA_IDCMP,    IDCMP_CHANGEWINDOW,
  625.                                                 WA_Flags,    WFLG_DEPTHGADGET|WFLG_DRAGBAR|WFLG_RMBTRAP|WFLG_SIZEBRIGHT|WFLG_SIZEBBOTTOM,
  626.                                                 WA_Title,    "Drawer window (demo)",
  627.                                                 WA_PubScreen,    WBScreen,
  628.                                                 WA_SizeGadget,    TRUE,
  629.                                         TAG_DONE);
  630.  
  631.                                         UnlockPubScreen(NULL, WBScreen);
  632.                                         
  633.                                         if(!DrawerWindow)
  634.                                         {
  635.                                             set(LookWin, MUIA_Cycle_Active, 0);
  636.                                             DisplayError(ERR_NOMEM, NULL);
  637.                                         }
  638.                                     }
  639.                                 }
  640.                                 else if(DrawerWindow)
  641.                                 {
  642.                                     CloseWindow(DrawerWindow);
  643.                                     DrawerWindow    = NULL;
  644.                                 }
  645.                                 break;
  646.                             }
  647.  
  648.                                 // Ok ???
  649.  
  650.                             case ID_EDITOK :
  651.                             {
  652.                                 ULONG    OldType,
  653.                                     NewName,
  654.                                     PopAslState;
  655.                                 BOOL    DoSort    = FALSE;
  656.  
  657.  
  658.                                     // Don`t close window, when FileRequester is open
  659.  
  660.                                 get(IconName, MUIA_Popasl_Active, &PopAslState);
  661.                                 if(!PopAslState)
  662.                                 {
  663.                                     set(EditWindow, MUIA_Window_Open, FALSE);
  664.                                     if(PosWindow)
  665.                                     {
  666.                                         CloseWindow(PosWindow);
  667.                                         PosWindow    = NULL;
  668.                                     }
  669.                                     if(DrawerWindow)
  670.                                     {
  671.                                         CloseWindow(DrawerWindow);
  672.                                         DrawerWindow    = NULL;
  673.                                     }
  674.                                     set(MainWindow, MUIA_Window_Sleep, FALSE);
  675.  
  676.                                         // Copy contents of gadgets to selected entry
  677.  
  678.                                     if(EditEntryPtr)
  679.                                     {
  680.                                         ULONG    Dummy;
  681.  
  682.                                         ObtainSemaphore(&FIconSema->FIconSema);
  683.  
  684.                                             // Get new settings
  685.  
  686.                                         get(VolumeName, MUIA_String_Contents, &Dummy);
  687.                                         NewName = stricmp(EditEntryPtr->VolName, (char *)Dummy);
  688.                                         strcpy(EditEntryPtr->VolName, (char *)Dummy);
  689.  
  690.                                         get(VolumeType, MUIA_Cycle_Active, &Dummy);
  691.                                         OldType                = EditEntryPtr->Link.ln_Type;
  692.                                         EditEntryPtr->Link.ln_Type    = (Dummy ? LDF_DEVICES : LDF_VOLUMES);
  693.  
  694.                                         get(IconX, MUIA_String_Integer, &Dummy);
  695.                                         EditEntryPtr->Left        = Dummy;
  696.  
  697.                                         get(IconY, MUIA_String_Integer, &Dummy);
  698.                                         EditEntryPtr->Top        = Dummy;
  699.  
  700.                                         get(IconPos[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  701.                                         EditEntryPtr->IconPos    = Dummy;
  702.  
  703.                                         get(IconName, MUIA_String_Contents, &Dummy);
  704.                                         strcpy(EditEntryPtr->IconName, (char *)Dummy);
  705.  
  706.                                         get(UseIcon[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  707.                                         EditEntryPtr->UseAlt    = Dummy;
  708.  
  709.                                         get(UseWindow[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  710.                                         EditEntryPtr->UseWin    = Dummy;
  711.  
  712.                                         get(WinX, MUIA_String_Integer, &Dummy);
  713.                                         EditEntryPtr->WinX    = Dummy;
  714.  
  715.                                         get(WinY, MUIA_String_Integer, &Dummy);
  716.                                         EditEntryPtr->WinY    = Dummy;
  717.  
  718.                                         get(WinWidth, MUIA_String_Integer, &Dummy);
  719.                                         EditEntryPtr->WinWidth    = Dummy;
  720.  
  721.                                         get(WinHeight, MUIA_String_Integer, &Dummy);
  722.                                         EditEntryPtr->WinHeight    = Dummy;
  723.  
  724.                                         get(UseFlags[(UWORD)(EditEntryPtr->Link.ln_Type == LDF_DEVICES)], MUIA_Cycle_Active, &Dummy);
  725.                                         EditEntryPtr->UseFlags    = Dummy;
  726.  
  727.                                         get(FlagModes, MUIA_Cycle_Active, &Dummy);
  728.                                         EditEntryPtr->WinFlags    = Dummy;
  729.  
  730.                                         if(!strstr(EditEntryPtr->IconName, ".info") && strlen(EditEntryPtr->IconName))
  731.                                             strcat(EditEntryPtr->IconName, ".info");
  732.  
  733.  
  734.  
  735.                                             // Type of entry changed ???
  736.  
  737.                                         if(OldType != EditEntryPtr->Link.ln_Type)
  738.                                         {
  739.                                             Remove(EditEntryPtr);
  740.  
  741.                                             if(EditEntryPtr->Link.ln_Type == LDF_DEVICES)
  742.                                                 AddTail(&FIconSema->VolumeList, (struct Node *)EditEntryPtr);
  743.                                             else
  744.                                                 AddHead(&FIconSema->VolumeList, (struct Node *)EditEntryPtr);
  745.  
  746.                                             DoSort    = TRUE;
  747.                                         }
  748.  
  749.                                             // Name changed ???
  750.  
  751.                                         if(!DoSort)
  752.                                             DoSort    = (BOOL)(NewName != 0);
  753.  
  754.                                             // Rearrange volume`s/device`s icon
  755.  
  756.                                         DskChange(EditEntryPtr);
  757.  
  758.                                             // Sort list
  759.  
  760.                                         if(DoSort)
  761.                                         {
  762.                                             SortList(&FIconSema->VolumeList, TRUE);
  763.  
  764.                                                 // Remove list
  765.  
  766.                                             DoMethod(UsedList, MUIM_List_Clear, NULL);
  767.  
  768.                                             EditEntryPtr    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  769.                                             while(EditEntryPtr->Link.ln_Succ)
  770.                                             {
  771.                                                 DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)EditEntryPtr, MUIV_List_Insert_Bottom);
  772.  
  773.                                                 EditEntryPtr    = (struct VolEntry *)EditEntryPtr->Link.ln_Succ;
  774.                                             }
  775.                                         }
  776.                                         ReleaseSemaphore(&FIconSema->FIconSema);
  777.                                     }
  778.                                     EditEntryPtr    = NULL;
  779.                                 }
  780.                                 break;
  781.                             }
  782.  
  783.                                 // Cancel ???
  784.  
  785.                             case ID_EDITCANCEL :
  786.                             {
  787.                                 ULONG    PopAslState;
  788.  
  789.                                     // Don`t close window, when FileRequester is open
  790.  
  791.                                 get(IconName, MUIA_Popasl_Active, &PopAslState);
  792.                                 if(!PopAslState)
  793.                                 {
  794.                                     set(EditWindow, MUIA_Window_Open, FALSE);
  795.                                     if(PosWindow)
  796.                                     {
  797.                                         CloseWindow(PosWindow);
  798.                                         PosWindow    = NULL;
  799.                                     }
  800.                                     if(DrawerWindow)
  801.                                     {
  802.                                         CloseWindow(DrawerWindow);
  803.                                         DrawerWindow    = NULL;
  804.                                     }
  805.                                     set(MainWindow, MUIA_Window_Sleep, FALSE);
  806.                                     EditEntryPtr    = NULL;
  807.                                 }
  808.                                 break;
  809.                             }
  810.  
  811.  
  812.  
  813.                                 // Check man window
  814.  
  815.                             case ID_MANOK :
  816.                             {
  817.                                 char            *VolName;
  818.                                 ULONG            Type;
  819.  
  820.                                 set(ManWindow, MUIA_Window_Open, FALSE);
  821.                                 set(MainWindow, MUIA_Window_Sleep, FALSE);
  822.  
  823.  
  824.                                 get(ManVolName, MUIA_String_Contents, &VolName);
  825.                                 get(ManVolType, MUIA_Cycle_Active, &Type);
  826.                                 Type    = (Type ? LDF_DEVICES : LDF_VOLUMES);
  827.  
  828.                                 AddNewVolume(VolName, Type, EditEntryPtr);
  829.                                 EditEntryPtr    = NULL;
  830.                                 break;
  831.                             }
  832.  
  833.                             case ID_MANCANCEL :
  834.                             {
  835.                                 set(ManWindow, MUIA_Window_Open, FALSE);
  836.                                 set(MainWindow, MUIA_Window_Sleep, FALSE);
  837.                                 EditEntryPtr    = NULL;
  838.                                 break;
  839.                             }
  840.                         }
  841.  
  842.  
  843.                         if(GoOn && MySig)
  844.                         {
  845.                             if(PosWindow)
  846.                                 MySig    |= (1 << PosWindow->UserPort->mp_SigBit);
  847.  
  848.                             if(DrawerWindow)
  849.                                 MySig    |= (1 << DrawerWindow->UserPort->mp_SigBit);
  850.  
  851.                             MySig    = Wait(MySig);
  852.  
  853.                                 // Check for action on PosWindow
  854.  
  855.                             if(PosWindow && (MySig & (1 << PosWindow->UserPort->mp_SigBit)))
  856.                             {
  857.                                 struct    IntuiMessage    *MyMsg;
  858.                                 ULONG    MsgClass;
  859.  
  860.                                 while((MyMsg = (struct IntuiMessage *)GetMsg(PosWindow->UserPort)))
  861.                                 {
  862.                                     MsgClass    = MyMsg->Class;
  863.  
  864.                                     ReplyMsg((struct Message *)MyMsg);
  865.  
  866.                                     if(MsgClass == IDCMP_CHANGEWINDOW)
  867.                                     {
  868.                                         set(IconX, MUIA_String_Integer, PosWindow->LeftEdge);
  869.                                         set(IconY, MUIA_String_Integer, PosWindow->TopEdge);
  870.                                     }
  871.                                 }
  872.                             }
  873.  
  874.                                 // Check for action on DrawerWindow
  875.  
  876.                             if(DrawerWindow && (MySig & (1 << DrawerWindow->UserPort->mp_SigBit)))
  877.                             {
  878.                                 struct    IntuiMessage    *MyMsg;
  879.                                 ULONG    MsgClass;
  880.  
  881.                                 while((MyMsg = (struct IntuiMessage *)GetMsg(DrawerWindow->UserPort)))
  882.                                 {
  883.                                     MsgClass    = MyMsg->Class;
  884.  
  885.                                     ReplyMsg((struct Message *)MyMsg);
  886.  
  887.                                     if(MsgClass == IDCMP_CHANGEWINDOW)
  888.                                     {
  889.                                         set(WinX, MUIA_String_Integer, DrawerWindow->LeftEdge);
  890.                                         set(WinY, MUIA_String_Integer, DrawerWindow->TopEdge);
  891.                                         set(WinWidth, MUIA_String_Integer, DrawerWindow->Width);
  892.                                         set(WinHeight, MUIA_String_Integer, DrawerWindow->Height);
  893.                                     }
  894.                                 }
  895.                             }
  896.                         }
  897.                     }
  898.  
  899.                     if(PosWindow)
  900.                         CloseWindow(PosWindow);
  901.  
  902.                         // Free list of available volumes
  903.  
  904.                     FreeDevVolList(&AvailableList);
  905.                 }
  906.  
  907.                 RemoveApp();
  908.             }
  909.  
  910.             RemoveFIconSema(FIconSema);
  911.         }
  912.     }
  913.  
  914.  
  915.         // Close libs
  916.  
  917.     CloseAll();
  918.  
  919.  
  920.         // Flush memory when requested
  921.  
  922.     if(FlushMemory)
  923.     {
  924.         APTR    FlushPtr;
  925.         int    i;
  926.  
  927.         for(i = 0; i < 10; i++)
  928.         {
  929.             if((FlushPtr = AllocMem(0x1DCD6500, MEMF_PUBLIC)))
  930.                 FreeMem(FlushPtr, 0x1DCD6500);
  931.         }
  932.     }
  933.  
  934.         // Send back WBStartUp Message
  935.  
  936.     if(WBenchMsg)
  937.     {
  938.         Forbid();
  939.         ReplyMsg((struct Message *)WBenchMsg);
  940.     }
  941.     return(0);
  942. }
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949. /**********************************************************************/
  950. /*                        Functionreplacements                        */
  951. /**********************************************************************/
  952. void chkabort(void){;}
  953. void __stdargs _XCEXIT(LONG Val){;}
  954.  
  955.  
  956.  
  957.  
  958. /**********************************************************************/
  959. /*                           Open libraries                           */
  960. /**********************************************************************/
  961. static BOOL OpenAll(void)
  962. {
  963.     if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37)))
  964.     {
  965.         DisplayError(ERR_OPEN, (ULONG)"intuition.library", 37);
  966.         return(FALSE);
  967.     }
  968.  
  969.     if(!(MUIMasterBase = OpenLibrary("muimaster.library", 0)))
  970.     {
  971.         DisplayError(ERR_OPEN, (ULONG)"muimaster.library", 7);
  972.         return(FALSE);
  973.     }
  974.  
  975.     if(!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37)))
  976.     {
  977.         DisplayError(ERR_OPEN, (ULONG)"dos.library", 37);
  978.         return(FALSE);
  979.     }
  980.  
  981.     if(!(IconBase = OpenLibrary("icon.library", 37)))
  982.     {
  983.         DisplayError(ERR_OPEN, (ULONG)"icon.library", 37);
  984.         return(FALSE);
  985.     }
  986.  
  987.     if(!(UtilityBase = OpenLibrary("utility.library", 37)))
  988.     {
  989.         DisplayError(ERR_OPEN, (ULONG)"utility.library", 37);
  990.         return(FALSE);
  991.     }
  992.  
  993.     if(!(IFFParseBase = OpenLibrary("iffparse.library", 37)))
  994.     {
  995.         DisplayError(ERR_OPEN, (ULONG)"iffparse.library", 37);
  996.         return(FALSE);
  997.     }
  998.  
  999.     if(!(AslBase = OpenLibrary("asl.library", 36)))
  1000.     {
  1001.         DisplayError(ERR_OPEN, (ULONG)"asl.library", 36);
  1002.         return(FALSE);
  1003.     }
  1004.  
  1005.     return(TRUE);
  1006. }
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015. /**********************************************************************/
  1016. /*                          Close libraries                           */
  1017. /**********************************************************************/
  1018. static void CloseAll(void)
  1019. {
  1020.     if(MUIMasterBase)
  1021.         CloseLibrary(MUIMasterBase);
  1022.  
  1023.     if(AslBase)
  1024.         CloseLibrary(AslBase);
  1025.  
  1026.     if(IFFParseBase)
  1027.         CloseLibrary(IFFParseBase);
  1028.  
  1029.     if(UtilityBase)
  1030.         CloseLibrary(UtilityBase);
  1031.  
  1032.     if(IconBase)
  1033.         CloseLibrary(IconBase);
  1034.  
  1035.     if(DOSBase)
  1036.         CloseLibrary((struct Library *)DOSBase);
  1037.  
  1038.     if(IntuitionBase)
  1039.         CloseLibrary((struct Library *)IntuitionBase);
  1040. }
  1041.  
  1042.  
  1043.  
  1044.  
  1045.  
  1046.  
  1047.  
  1048. /**********************************************************************/
  1049. /*                         Create application                         */
  1050. /**********************************************************************/
  1051. static BOOL InitApp(void)
  1052. {
  1053.         // Init list, in case the App can not be created
  1054.  
  1055.     NewList(&AvailableList);
  1056.  
  1057.         // Create the Application window
  1058.  
  1059.     AppObject    = ApplicationObject,
  1060.                 MUIA_Application_Title,        "ForceIcon",
  1061.                 MUIA_Application_Version,    MUIVERS,
  1062.                 MUIA_Application_Copyright,    "©1993/94 Kai Iske",
  1063.                 MUIA_Application_Author,    "Kai Iske",
  1064.                 MUIA_Application_Description,    "Forces Disk.info to image/position",
  1065.                 MUIA_Application_Base,        "FIcon",
  1066.                 MUIA_Application_SingleTask,    TRUE,
  1067.                 MUIA_Application_DiskObject,    DObj    = GetDiskObjectNew("PROGDIR:ForceIcon"),
  1068.                 MUIA_HelpFile,            "ForceIcon.guide",
  1069.  
  1070.             // Now head for the main window
  1071.  
  1072.         SubWindow, MainWindow =    WindowObject,
  1073.                         MUIA_Window_Title,    "ForceIcon "REVISION" - "REVDATE,
  1074.                         MUIA_Window_ID,        'FIMW',
  1075.                         MUIA_Window_SizeGadget,    TRUE,
  1076.                         MUIA_HelpNode,        NODE_MAIN,
  1077.  
  1078.                 // Do the gadgets
  1079.  
  1080.             WindowContents,
  1081.             VGroup,
  1082.  
  1083.                     // Columns of input
  1084.  
  1085.                 Child,
  1086.                 ColGroup(2),
  1087.  
  1088.                         // Create left column
  1089.  
  1090.                     Child, VGroup,
  1091.                         MUIA_HelpNode,    NODE_LEFT,
  1092.                         GroupFrameT("Used volumes/devices"),
  1093.  
  1094.  
  1095.                             // Create ListView
  1096.  
  1097.                         Child, UsedList        =    ListviewObject,
  1098.                                             MUIA_Listview_Input,        TRUE,
  1099.                                             MUIA_Listview_List,        ListObject, InputListFrame,
  1100.                                                 MUIA_Background,        MUII_ListBack,
  1101.                                                 MUIA_List_Format,        "COL=0",
  1102.                                                 MUIA_List_DisplayHook,        &DispViewHook,
  1103.                                             End,
  1104.                                         End,
  1105.  
  1106.                         Child, EditEntry    =    TextObject, ButtonFrame,
  1107.                                             MUIA_Text_Contents,    "Edit entry...",
  1108.                                             MUIA_Text_PreParse,    "\33c",
  1109.                                             MUIA_Background,    MUII_ButtonBack,
  1110.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1111.                                             MUIA_Text_HiChar,    'E',
  1112.                                             MUIA_ControlChar,    'e',
  1113.                                             MUIA_Disabled,        TRUE,
  1114.                                         End,
  1115.  
  1116.                         Child, CopyEntry    =    TextObject, ButtonFrame,
  1117.                                             MUIA_Text_Contents,    "Copy entry...",
  1118.                                             MUIA_Text_PreParse,    "\33c",
  1119.                                             MUIA_Background,    MUII_ButtonBack,
  1120.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1121.                                             MUIA_Text_HiChar,    'C',
  1122.                                             MUIA_ControlChar,    'c',
  1123.                                             MUIA_Disabled,        TRUE,
  1124.                                         End,
  1125.  
  1126.                         Child, RemoveEntry    =    TextObject, ButtonFrame,
  1127.                                             MUIA_Text_Contents,    "Remove entry",
  1128.                                             MUIA_Text_PreParse,    "\33c",
  1129.                                             MUIA_Background,    MUII_ButtonBack,
  1130.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1131.                                             MUIA_Text_HiChar,    'R',
  1132.                                             MUIA_ControlChar,    'r',
  1133.                                             MUIA_Disabled,        TRUE,
  1134.                                         End,
  1135.                     End, // First column
  1136.  
  1137.  
  1138.                         // Create right column
  1139.  
  1140.                     Child, VGroup,
  1141.                         MUIA_HelpNode,    NODE_RIGHT,
  1142.                         GroupFrameT("Available volumes/devices"),
  1143.  
  1144.                             // Create ListView
  1145.  
  1146.                         Child, AvailList    =    ListviewObject,
  1147.                                             MUIA_Listview_Input,        TRUE,
  1148.                                             MUIA_Listview_List,        ListObject, InputListFrame,
  1149.                                                 MUIA_Background,        MUII_ListBack,
  1150.                                                 MUIA_List_Format,        "COL=0",
  1151.                                                 MUIA_List_DisplayHook,        &DispViewHook,
  1152.                                             End,
  1153.                                         End,
  1154.  
  1155.                         Child, AddEntry        =    TextObject, ButtonFrame,
  1156.                                             MUIA_Text_Contents,    "Add entry",
  1157.                                             MUIA_Text_PreParse,    "\33c",
  1158.                                             MUIA_Background,    MUII_ButtonBack,
  1159.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1160.                                             MUIA_Text_HiChar,    'd',
  1161.                                             MUIA_ControlChar,    'd',
  1162.                                             MUIA_Disabled,        TRUE,
  1163.                                         End,
  1164.  
  1165.                         Child, AddEntryMan    =    TextObject, ButtonFrame,
  1166.                                             MUIA_Text_Contents,    "Add manually...",
  1167.                                             MUIA_Text_PreParse,    "\33c",
  1168.                                             MUIA_Background,    MUII_ButtonBack,
  1169.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1170.                                             MUIA_Text_HiChar,    'm',
  1171.                                             MUIA_ControlChar,    'm',
  1172.                                         End,
  1173.  
  1174.                         Child, RescanList    =    TextObject, ButtonFrame,
  1175.                                             MUIA_Text_Contents,    "Rescan list",
  1176.                                             MUIA_Text_PreParse,    "\33c",
  1177.                                             MUIA_Background,    MUII_ButtonBack,
  1178.                                             MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1179.                                             MUIA_Text_HiChar,    'l',
  1180.                                             MUIA_ControlChar,    'l',
  1181.                                         End,
  1182.                     End, // Second column
  1183.                 End, // Columns
  1184.  
  1185.  
  1186.                 Child, VSpace(1),
  1187.  
  1188.                     // Create control gadgets
  1189.  
  1190.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1191.  
  1192.                     Child, SaveObj        =    TextObject, ButtonFrame,
  1193.                                         MUIA_Text_Contents,    "Save",
  1194.                                         MUIA_Text_PreParse,    "\33c",
  1195.                                         MUIA_Background,    MUII_ButtonBack,
  1196.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1197.                                         MUIA_Text_HiChar,    'S',
  1198.                                         MUIA_ControlChar,    's',
  1199.                                     End,
  1200.  
  1201.                     Child, UseObj        =    TextObject, ButtonFrame,
  1202.                                         MUIA_Text_Contents,    "Use",
  1203.                                         MUIA_Text_PreParse,    "\33c",
  1204.                                         MUIA_Background,    MUII_ButtonBack,
  1205.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1206.                                         MUIA_Text_HiChar,    'U',
  1207.                                         MUIA_ControlChar,    'u',
  1208.                                     End,
  1209.  
  1210.                     Child, AboutObj        =    TextObject, ButtonFrame,
  1211.                                         MUIA_Text_Contents,    "About",
  1212.                                         MUIA_Text_PreParse,    "\33c",
  1213.                                         MUIA_Background,    MUII_ButtonBack,
  1214.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1215.                                         MUIA_Text_HiChar,    'A',
  1216.                                         MUIA_ControlChar,    'a',
  1217.                                     End,
  1218.  
  1219.                     Child, HideObj        =    TextObject, ButtonFrame,
  1220.                                         MUIA_Text_Contents,    "Hide",
  1221.                                         MUIA_Text_PreParse,    "\33c",
  1222.                                         MUIA_Background,    MUII_ButtonBack,
  1223.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1224.                                         MUIA_Text_HiChar,    'H',
  1225.                                         MUIA_ControlChar,    'h',
  1226.                                     End,
  1227.  
  1228.                     Child, QuitObj        =    TextObject, ButtonFrame,
  1229.                                         MUIA_Text_Contents,    "Quit",
  1230.                                         MUIA_Text_PreParse,    "\33c",
  1231.                                         MUIA_Background,    MUII_ButtonBack,
  1232.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1233.                                         MUIA_Text_HiChar,    'Q',
  1234.                                         MUIA_ControlChar,    'q',
  1235.                                     End,
  1236.                 End, // Control panel
  1237.             End, // main group
  1238.         End, // Main window
  1239.  
  1240.  
  1241.  
  1242.  
  1243.  
  1244.             // Head for Editwindow
  1245.  
  1246.         SubWindow, EditWindow = WindowObject,
  1247.                         MUIA_Window_Title,    "Edit entry",
  1248.                         MUIA_Window_ID,        'FIEW',
  1249.                         MUIA_Window_SizeGadget,    TRUE,
  1250.                         MUIA_Window_NoMenus,    TRUE,
  1251.                         MUIA_HelpNode,        NODE_EDIT,
  1252.  
  1253.             WindowContents, VGroup,
  1254.  
  1255.                     // Volume group
  1256.  
  1257.                 Child, VGroup, GroupFrameT("Entry type/name"), MUIA_Group_SameWidth, TRUE,
  1258.                     Child, ColGroup(2),
  1259.                         Child, KeyLabel1("Volume", 'V'),
  1260.                         Child, VolumeName    =    StringObject, StringFrame,
  1261.                                             MUIA_String_Contents,    "",
  1262.                                             MUIA_String_MaxLen,    128,
  1263.                                             MUIA_String_Format,    MUIV_String_Format_Left,
  1264.                                             MUIA_String_BufferPos,    0,
  1265.                                             MUIA_String_Reject,    ":/",
  1266.                                             MUIA_ControlChar,    'v',
  1267.                                         End,
  1268.  
  1269.                         Child, KeyLabel1("Type", 'e'),
  1270.                         Child, VolumeType    =    KeyCycle(TypeEntries, 'e'),
  1271.                     End,
  1272.                 End, // Volume group
  1273.  
  1274.  
  1275.                 Child, ColGroup(2),
  1276.                         // Position group
  1277.  
  1278.                     Child, VGroup, GroupFrameT("Position settings"), MUIA_Group_SameWidth, TRUE,
  1279.  
  1280.                         Child, ColGroup(2),
  1281.  
  1282.                             Child, KeyLabel1("IconPos", 's'),
  1283.                             Child, IconPosGroup = PageGroup,
  1284.  
  1285.                                 Child, IconPos[0] =    CycleObject, ButtonFrame,
  1286.                                                     MUIA_Cycle_Active,    0,
  1287.                                                     MUIA_Cycle_Entries,    ModeEntriesVol,
  1288.                                                     MUIA_ControlChar,    's',
  1289.                                             End,
  1290.  
  1291.                                 Child, IconPos[1] =    CycleObject, ButtonFrame,
  1292.                                                     MUIA_Cycle_Active,    0,
  1293.                                                     MUIA_Cycle_Entries,    ModeEntriesDev,
  1294.                                                     MUIA_ControlChar,    's',
  1295.                                             End,
  1296.                             End,
  1297.  
  1298.                             Child, KeyLabel1("Current X", 'X'),
  1299.                             Child, HGroup,
  1300.                                 Child, IconX    =    StringObject, StringFrame,
  1301.                                                 MUIA_String_Contents,    "",
  1302.                                                 MUIA_String_MaxLen,    5,
  1303.                                                 MUIA_String_Format,    MUIV_String_Format_Center,
  1304.                                                 MUIA_String_BufferPos,    1,
  1305.                                                 MUIA_String_Integer,    TRUE,
  1306.                                                 MUIA_ControlChar,    'x',
  1307.                                             End,
  1308.  
  1309.                                 Child, KeyLabel1("Current Y", 'Y'),
  1310.                                 Child, IconY    =    StringObject, StringFrame,
  1311.                                                 MUIA_String_Contents,    "",
  1312.                                                 MUIA_String_MaxLen,    5,
  1313.                                                 MUIA_String_Format,    MUIV_String_Format_Center,
  1314.                                                 MUIA_String_BufferPos,    1,
  1315.                                                 MUIA_String_Integer,    TRUE,
  1316.                                                 MUIA_ControlChar,    'y',
  1317.                                             End,
  1318.                             End,
  1319.  
  1320.                             Child, KeyLabel1("Position", 'P'),
  1321.                             Child, Position    =    CycleObject, ButtonFrame,
  1322.                                                 MUIA_Cycle_Active,    0,
  1323.                                                 MUIA_Cycle_Entries,    PositionEntries,
  1324.                                                 MUIA_ControlChar,    'p',
  1325.                                         End,
  1326.                         End,
  1327.                     End, // position group
  1328.  
  1329.  
  1330.  
  1331.                         // Icon group
  1332.  
  1333.                     Child, VGroup, GroupFrameT("Icon settings"), MUIA_Group_SameWidth, TRUE,
  1334.  
  1335.                         Child, VSpace(0),
  1336.                         Child, ColGroup(2),
  1337.  
  1338.                             Child, KeyLabel1("Use Icon", 'U'),
  1339.                             Child, UseIconGroup    = PageGroup,
  1340.  
  1341.                                 Child, UseIcon[0] =    CycleObject, ButtonFrame,
  1342.                                                     MUIA_Cycle_Active,    0,
  1343.                                                     MUIA_Cycle_Entries,    ModeEntriesVol,
  1344.                                                     MUIA_ControlChar,    'u',
  1345.                                             End,
  1346.  
  1347.                                 Child, UseIcon[1] =    CycleObject, ButtonFrame,
  1348.                                                     MUIA_Cycle_Active,    0,
  1349.                                                     MUIA_Cycle_Entries,    ModeEntriesDev,
  1350.                                                     MUIA_ControlChar,    'u',
  1351.                                             End,
  1352.                             End,
  1353.  
  1354.  
  1355.                             Child, KeyLabel1("Icon", 'I'),
  1356.                             Child, IconName            = PopaslObject,
  1357.                                                 MUIA_Popstring_String,        KeyString(0, 254, 'i'),
  1358.                                                 MUIA_Popstring_Button,        PopButton(MUII_PopFile),
  1359.                                                 MUIA_Popasl_Type,        ASL_FileRequest,
  1360.                                                 ASLFR_TitleText,        "Please select an icon...",
  1361.                                             End,
  1362.                         End,
  1363.                         Child, VSpace(0),
  1364.                     End, // Icon group
  1365.                 End,
  1366.  
  1367.                     // Create window group
  1368.  
  1369.                 Child, VGroup, GroupFrameT("Window settings"), MUIA_Group_SameWidth, TRUE,
  1370.  
  1371.                     Child, ColGroup(2),
  1372.  
  1373.                         Child, KeyLabel1("Use window", 'd'),
  1374.                         Child, UseWindowGroup    = PageGroup,
  1375.  
  1376.                             Child, UseWindow[0] =    CycleObject, ButtonFrame,
  1377.                                                 MUIA_Cycle_Active,    0,
  1378.                                                 MUIA_Cycle_Entries,    ModeEntriesVol,
  1379.                                                 MUIA_ControlChar,    'd',
  1380.                                         End,
  1381.  
  1382.                             Child, UseWindow[1] =    CycleObject, ButtonFrame,
  1383.                                                 MUIA_Cycle_Active,    0,
  1384.                                                 MUIA_Cycle_Entries,    ModeEntriesDev,
  1385.                                                 MUIA_ControlChar,    'd',
  1386.                                         End,
  1387.                         End,
  1388.  
  1389.  
  1390.                         Child, KeyLabel2("Left", 'L'),
  1391.                         Child, HGroup,
  1392.                             Child, WinX    =    StringObject, StringFrame,
  1393.                                             MUIA_String_Contents,    "",
  1394.                                             MUIA_String_MaxLen,    5,
  1395.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1396.                                             MUIA_String_BufferPos,    1,
  1397.                                             MUIA_String_Integer,    TRUE,
  1398.                                             MUIA_ControlChar,    'l',
  1399.                                         End,
  1400.  
  1401.                             Child, KeyLabel1("Top", 'T'),
  1402.                             Child, WinY    =    StringObject, StringFrame,
  1403.                                             MUIA_String_Contents,    "",
  1404.                                             MUIA_String_MaxLen,    5,
  1405.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1406.                                             MUIA_String_BufferPos,    1,
  1407.                                             MUIA_String_Integer,    TRUE,
  1408.                                             MUIA_ControlChar,    't',
  1409.                                         End,
  1410.  
  1411.                             Child, KeyLabel2("Width", 'W'),
  1412.                             Child, WinHeight =    StringObject, StringFrame,
  1413.                                             MUIA_String_Contents,    "",
  1414.                                             MUIA_String_MaxLen,    5,
  1415.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1416.                                             MUIA_String_BufferPos,    1,
  1417.                                             MUIA_String_Integer,    TRUE,
  1418.                                             MUIA_ControlChar,    'w',
  1419.                                         End,
  1420.  
  1421.                             Child, KeyLabel1("Height", 'H'),
  1422.                             Child, WinWidth    =    StringObject, StringFrame,
  1423.                                             MUIA_String_Contents,    "",
  1424.                                             MUIA_String_MaxLen,    5,
  1425.                                             MUIA_String_Format,    MUIV_String_Format_Center,
  1426.                                             MUIA_String_BufferPos,    1,
  1427.                                             MUIA_String_Integer,    TRUE,
  1428.                                             MUIA_ControlChar,    'h',
  1429.                                         End,
  1430.                         End,
  1431.  
  1432.                         Child, KeyLabel1("Window", 'n'),
  1433.                         Child, LookWin =    CycleObject, ButtonFrame,
  1434.                                             MUIA_Cycle_Active,    0,
  1435.                                             MUIA_Cycle_Entries,    LookWinEntries,
  1436.                                             MUIA_ControlChar,    'n',
  1437.                                     End,
  1438.  
  1439.  
  1440.  
  1441.                         Child, KeyLabel1("Use flags", 'f'),
  1442.                         Child, UseFlagsGroup    = PageGroup,
  1443.  
  1444.                             Child, UseFlags[0] =    CycleObject, ButtonFrame,
  1445.                                                 MUIA_Cycle_Active,    0,
  1446.                                                 MUIA_Cycle_Entries,    ModeEntriesVol,
  1447.                                                 MUIA_ControlChar,    'f',
  1448.                                         End,
  1449.  
  1450.                             Child, UseFlags[1] =    CycleObject, ButtonFrame,
  1451.                                                 MUIA_Cycle_Active,    0,
  1452.                                                 MUIA_Cycle_Entries,    ModeEntriesDev,
  1453.                                                 MUIA_ControlChar,    'f',
  1454.                                         End,
  1455.                         End,
  1456.  
  1457.                         Child, KeyLabel1("Flags", 'g'),
  1458.                         Child, FlagModes    =    CycleObject, ButtonFrame,
  1459.                                             MUIA_Cycle_Active,    0,
  1460.                                             MUIA_Cycle_Entries,    FlagModesEntries,
  1461.                                             MUIA_ControlChar,    'g',
  1462.                                     End,
  1463.                     End,
  1464.                 End, // window group
  1465.  
  1466.  
  1467.  
  1468.                 Child, VSpace(1),
  1469.  
  1470.                     // Create control gadgets
  1471.  
  1472.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1473.  
  1474.                     Child, EditOkObj    =    TextObject, ButtonFrame,
  1475.                                         MUIA_Text_Contents,    "Ok",
  1476.                                         MUIA_Text_PreParse,    "\33c",
  1477.                                         MUIA_Background,    MUII_ButtonBack,
  1478.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1479.                                         MUIA_Text_HiChar,    'O',
  1480.                                         MUIA_ControlChar,    'o',
  1481.                                     End,
  1482.  
  1483.                     Child, EditCancelObj    =    TextObject, ButtonFrame,
  1484.                                         MUIA_Text_Contents,    "Cancel",
  1485.                                         MUIA_Text_PreParse,    "\33c",
  1486.                                         MUIA_Background,    MUII_ButtonBack,
  1487.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1488.                                         MUIA_Text_HiChar,    'C',
  1489.                                         MUIA_ControlChar,    'c',
  1490.                                     End,
  1491.                 End, // Control gadgets
  1492.             End, // Edit contents
  1493.         End, // Edit window
  1494.  
  1495.  
  1496.  
  1497.  
  1498.             // Head for "manually" window
  1499.  
  1500.         SubWindow, ManWindow = WindowObject,
  1501.                         MUIA_Window_Title,    "",
  1502.                         MUIA_Window_ID,        'FINW',
  1503.                         MUIA_Window_SizeGadget,    TRUE,
  1504.                         MUIA_Window_NoMenus,    TRUE,
  1505.                         MUIA_HelpNode,        NODE_MANUAL,
  1506.  
  1507.             WindowContents, VGroup,
  1508.  
  1509.                 Child, VGroup, GroupFrameT("Entry type/name"),
  1510.  
  1511.                         // String gadget
  1512.  
  1513.                     Child, ColGroup(2),
  1514.  
  1515.                         Child, KeyLabel1("Volume", 'V'),
  1516.                         Child, ManVolName    =    StringObject, StringFrame,
  1517.                                         MUIA_String_Contents,    "",
  1518.                                         MUIA_String_MaxLen,    128,
  1519.                                         MUIA_String_Format,    MUIV_String_Format_Left,
  1520.                                         MUIA_String_BufferPos,    1,
  1521.                                         MUIA_String_Reject,    ":/",
  1522.                                         MUIA_ControlChar,    'v',
  1523.                                     End,
  1524.  
  1525.                         Child, KeyLabel1("Type", 'T'),
  1526.                         Child, ManVolType    =    KeyCycle(TypeEntries, 't'),
  1527.                     End,
  1528.                 End,
  1529.  
  1530.                 Child, VSpace(1),
  1531.  
  1532.                     // Control gadgets
  1533.  
  1534.                 Child, HGroup, MUIA_Group_SameWidth, TRUE,
  1535.  
  1536.                     Child, ManOkObj    =        TextObject, ButtonFrame,
  1537.                                         MUIA_Text_Contents,    "Ok",
  1538.                                         MUIA_Text_PreParse,    "\33c",
  1539.                                         MUIA_Background,    MUII_ButtonBack,
  1540.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1541.                                         MUIA_Text_HiChar,    'O',
  1542.                                         MUIA_ControlChar,    'o',
  1543.                                     End,
  1544.  
  1545.                     Child, ManCancelObj    =    TextObject, ButtonFrame,
  1546.                                         MUIA_Text_Contents,    "Cancel",
  1547.                                         MUIA_Text_PreParse,    "\33c",
  1548.                                         MUIA_Background,    MUII_ButtonBack,
  1549.                                         MUIA_InputMode,        MUIV_InputMode_RelVerify,
  1550.                                         MUIA_Text_HiChar,    'C',
  1551.                                         MUIA_ControlChar,    'c',
  1552.                                     End,
  1553.                 End, // Control gadgets
  1554.             End, // Man contents
  1555.         End, // Man window
  1556.     End; // End application
  1557.  
  1558.         // Appobject there and got a list of available entries ???
  1559.  
  1560.     if(AppObject && GetDevVolList(&AvailableList))
  1561.     {
  1562.         struct    VolEntry    *ThisEntry;
  1563.         int            i;
  1564.  
  1565.  
  1566.             // Main window settings
  1567.  
  1568.  
  1569.             // SetCycle chain
  1570.  
  1571.         DoMethod(MainWindow, MUIM_Window_SetCycleChain,
  1572.             UsedList,
  1573.             AvailList,
  1574.             EditEntry,
  1575.             CopyEntry,
  1576.             RemoveEntry,
  1577.             AddEntry,
  1578.             AddEntryMan,
  1579.             RescanList,
  1580.             SaveObj,
  1581.             UseObj,
  1582.             AboutObj,
  1583.             HideObj,
  1584.             QuitObj,
  1585.         NULL);
  1586.  
  1587.             // Set default object
  1588.  
  1589.         set(MainWindow, MUIA_Window_DefaultObject, AvailList);
  1590.  
  1591.             // Set notifications
  1592.  
  1593.         DoMethod(MainWindow, MUIM_Notify,
  1594.             MUIA_Window_CloseRequest,    TRUE,
  1595.             AppObject,            2,
  1596.             MUIM_Application_ReturnID,    ID_HIDE);
  1597.  
  1598.             // Set IDs for gadgets
  1599.  
  1600.         DoMethod(UsedList, MUIM_Notify,
  1601.             MUIA_Listview_DoubleClick,    TRUE,
  1602.             AppObject,            2,
  1603.             MUIM_Application_ReturnID,    ID_USEDLIST);
  1604.  
  1605.         DoMethod(EditEntry, MUIM_Notify,
  1606.             MUIA_Pressed,            FALSE,
  1607.             AppObject,            2,
  1608.             MUIM_Application_ReturnID,    ID_EDITENTRY);
  1609.  
  1610.         DoMethod(CopyEntry, MUIM_Notify,
  1611.             MUIA_Pressed,            FALSE,
  1612.             AppObject,            2,
  1613.             MUIM_Application_ReturnID,    ID_COPYENTRY);
  1614.  
  1615.         DoMethod(RemoveEntry, MUIM_Notify,
  1616.             MUIA_Pressed,            FALSE,
  1617.             AppObject,            2,
  1618.             MUIM_Application_ReturnID,    ID_REMOVEENTRY);
  1619.  
  1620.         DoMethod(AvailList, MUIM_Notify,
  1621.             MUIA_Listview_DoubleClick,    TRUE,
  1622.             AppObject,            2,
  1623.             MUIM_Application_ReturnID,    ID_AVAILLIST);
  1624.  
  1625.         DoMethod(AddEntry, MUIM_Notify,
  1626.             MUIA_Pressed,            FALSE,
  1627.             AppObject,            2,
  1628.             MUIM_Application_ReturnID,    ID_ADDENTRY);
  1629.  
  1630.         DoMethod(AddEntryMan, MUIM_Notify,
  1631.             MUIA_Pressed,            FALSE,
  1632.             AppObject,            2,
  1633.             MUIM_Application_ReturnID,    ID_ADDENTRYMAN);
  1634.  
  1635.         DoMethod(RescanList, MUIM_Notify,
  1636.             MUIA_Pressed,            FALSE,
  1637.             AppObject,            2,
  1638.             MUIM_Application_ReturnID,    ID_RESCANLIST);
  1639.  
  1640.         DoMethod(SaveObj, MUIM_Notify,
  1641.             MUIA_Pressed,            FALSE,
  1642.             AppObject,            2,
  1643.             MUIM_Application_ReturnID,    ID_SAVE);
  1644.  
  1645.         DoMethod(UseObj, MUIM_Notify,
  1646.             MUIA_Pressed,            FALSE,
  1647.             AppObject,            2,
  1648.             MUIM_Application_ReturnID,    ID_USE);
  1649.  
  1650.         DoMethod(AboutObj, MUIM_Notify,
  1651.             MUIA_Pressed,            FALSE,
  1652.             AppObject,            2,
  1653.             MUIM_Application_ReturnID,    ID_ABOUT);
  1654.  
  1655.         DoMethod(HideObj, MUIM_Notify,
  1656.             MUIA_Pressed,            FALSE,
  1657.             AppObject,            2,
  1658.             MUIM_Application_ReturnID,    ID_HIDE);
  1659.  
  1660.         DoMethod(QuitObj, MUIM_Notify,
  1661.             MUIA_Pressed,            FALSE,
  1662.             AppObject,            2,
  1663.             MUIM_Application_ReturnID,    ID_QUIT);
  1664.  
  1665.             // Set disable notify-hooks
  1666.  
  1667.         DoMethod(UsedList, MUIM_Notify,
  1668.             MUIA_List_Active,        MUIV_EveryTime,
  1669.             AppObject,            3,
  1670.             MUIM_CallHook,            &DisableHook, UsedList);
  1671.  
  1672.  
  1673.         DoMethod(AvailList, MUIM_Notify,
  1674.             MUIA_List_Active,        MUIV_EveryTime,
  1675.             AppObject,            3,
  1676.             MUIM_CallHook,            &DisableHook, AvailList);
  1677.  
  1678.  
  1679.  
  1680.             // Edit window settings
  1681.  
  1682.             // Set cycle chain
  1683.  
  1684.         DoMethod(EditWindow, MUIM_Window_SetCycleChain,
  1685.             VolumeName,
  1686.             VolumeType,
  1687.             IconPos[0],
  1688.             IconPos[1],
  1689.             IconX,
  1690.             IconY,
  1691.             Position,
  1692.             UseIcon[0],
  1693.             UseIcon[1],
  1694.             IconName,
  1695.             UseWindow[0],
  1696.             UseWindow[1],
  1697.             WinX,
  1698.             WinY,
  1699.             WinWidth,
  1700.             WinHeight,
  1701.             UseFlags[0],
  1702.             UseFlags[1],
  1703.             FlagModes,
  1704.             EditOkObj,
  1705.             EditCancelObj,
  1706.         NULL);
  1707.  
  1708.  
  1709.             // Set notifications
  1710.  
  1711.         DoMethod(EditWindow, MUIM_Notify,
  1712.             MUIA_Window_CloseRequest,    TRUE,
  1713.             AppObject,            2,
  1714.             MUIM_Application_ReturnID,    ID_EDITCANCEL);
  1715.  
  1716.  
  1717.         DoMethod(EditOkObj, MUIM_Notify,
  1718.             MUIA_Pressed,            FALSE,
  1719.             AppObject,            2,
  1720.             MUIM_Application_ReturnID,    ID_EDITOK);
  1721.  
  1722.  
  1723.         DoMethod(EditCancelObj, MUIM_Notify,
  1724.             MUIA_Pressed,            FALSE,
  1725.             AppObject,            2,
  1726.             MUIM_Application_ReturnID,    ID_EDITCANCEL);
  1727.  
  1728.         DoMethod(Position, MUIM_Notify,
  1729.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1730.             AppObject,            2,
  1731.             MUIM_Application_ReturnID,    ID_POSITION);
  1732.  
  1733.         DoMethod(LookWin, MUIM_Notify,
  1734.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1735.             AppObject,            2,
  1736.             MUIM_Application_ReturnID,    ID_DRAWER);
  1737.  
  1738.  
  1739.         DoMethod(VolumeType, MUIM_Notify,
  1740.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1741.             IconPosGroup,            3,
  1742.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1743.  
  1744.         DoMethod(VolumeType, MUIM_Notify,
  1745.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1746.             AppObject,            2,
  1747.             MUIM_CallHook, &PageChangeHook);
  1748.  
  1749.  
  1750.  
  1751.         DoMethod(VolumeType, MUIM_Notify,
  1752.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1753.             UseIconGroup,            3,
  1754.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1755.  
  1756.         DoMethod(VolumeType, MUIM_Notify,
  1757.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1758.             UseWindowGroup,            3,
  1759.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1760.  
  1761.         DoMethod(VolumeType, MUIM_Notify,
  1762.             MUIA_Cycle_Active,        MUIV_EveryTime,
  1763.             UseFlagsGroup,            3,
  1764.             MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
  1765.  
  1766.  
  1767.         for(i = 0; i < 2; i++)
  1768.         {
  1769.             DoMethod(IconPos[i], MUIM_Notify,
  1770.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1771.                 AppObject,            3,
  1772.                 MUIM_CallHook,            &DisableHook, IconPos[i]);
  1773.  
  1774.  
  1775.             DoMethod(UseIcon[i], MUIM_Notify,
  1776.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1777.                 AppObject,            3,
  1778.                 MUIM_CallHook,            &DisableHook, UseIcon[i]);
  1779.  
  1780.  
  1781.             DoMethod(UseWindow[i], MUIM_Notify,
  1782.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1783.                 AppObject,            3,
  1784.                 MUIM_CallHook,            &DisableHook, UseWindow[i]);
  1785.  
  1786.  
  1787.             DoMethod(UseFlags[i], MUIM_Notify,
  1788.                 MUIA_Cycle_Active,        MUIV_EveryTime,
  1789.                 AppObject,            3,
  1790.                 MUIM_CallHook,            &DisableHook, UseFlags[i]);
  1791.         }
  1792.  
  1793.  
  1794.  
  1795.  
  1796.             // Man window settings
  1797.  
  1798.             // Set cycle chaing
  1799.  
  1800.         DoMethod(ManWindow, MUIM_Window_SetCycleChain,
  1801.             ManVolName,
  1802.             ManVolType,
  1803.             ManOkObj,
  1804.             ManCancelObj,
  1805.         NULL);
  1806.  
  1807.  
  1808.             // Set notifications
  1809.  
  1810.         DoMethod(ManWindow, MUIM_Notify,
  1811.             MUIA_Window_CloseRequest,    TRUE,
  1812.             AppObject,            2,
  1813.             MUIM_Application_ReturnID,    ID_MANCANCEL);
  1814.  
  1815.  
  1816.         DoMethod(ManOkObj, MUIM_Notify,
  1817.             MUIA_Pressed,            FALSE,
  1818.             AppObject,            2,
  1819.             MUIM_Application_ReturnID,    ID_MANOK);
  1820.  
  1821.  
  1822.         DoMethod(ManCancelObj, MUIM_Notify,
  1823.             MUIA_Pressed,            FALSE,
  1824.             AppObject,            2,
  1825.             MUIM_Application_ReturnID,    ID_MANCANCEL);
  1826.  
  1827.  
  1828.  
  1829.  
  1830.             // Add list of used entries
  1831.  
  1832.         ObtainSemaphore(&FIconSema->FIconSema);
  1833.         ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  1834.  
  1835.         while(ThisEntry->Link.ln_Succ)
  1836.         {
  1837.             DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  1838.  
  1839.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1840.         }
  1841.         ReleaseSemaphore(&FIconSema->FIconSema);
  1842.  
  1843.  
  1844.             // Add list of available entries
  1845.  
  1846.         ThisEntry    = (struct VolEntry *)AvailableList.lh_Head;
  1847.  
  1848.         while(ThisEntry->Link.ln_Succ)
  1849.         {
  1850.             DoMethod(AvailList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  1851.  
  1852.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  1853.         }
  1854.  
  1855.  
  1856.  
  1857.  
  1858.             // Open main window
  1859.  
  1860.         set(MainWindow, MUIA_Window_Open, TRUE);
  1861.     }
  1862.     else
  1863.     {
  1864.         if(MUI_Error() != MUIE_SingleTask)
  1865.             DisplayError(ERR_NO_APP, NULL);
  1866.     }
  1867.  
  1868.  
  1869.     return((BOOL)(AppObject != NULL));
  1870. }
  1871.  
  1872.  
  1873.  
  1874.  
  1875. /**********************************************************************/
  1876. /*                       Remove our application                       */
  1877. /**********************************************************************/
  1878. static void RemoveApp(void)
  1879. {
  1880.     if(AppObject)
  1881.     {
  1882.         set(MainWindow, MUIA_Window_Open, FALSE);
  1883.         MUI_DisposeObject(AppObject);
  1884.     }
  1885.  
  1886.         // Dispose DiskObject
  1887.  
  1888.     if(DObj)
  1889.         FreeDiskObject(DObj);
  1890. }
  1891.  
  1892.  
  1893.  
  1894.  
  1895.  
  1896.  
  1897.  
  1898. /**********************************************************************/
  1899. /*                          Display function                          */
  1900. /**********************************************************************/
  1901. static ULONG    __saveds __asm DispViewFunc(register __a0 struct Hook *MyHook, register __a2 char **array, register __a1 struct VolEntry *Data)
  1902. {
  1903.     static        char    Buffer[140];
  1904.  
  1905.     if(Data->Link.ln_Type == LDF_VOLUMES)
  1906.     {
  1907.         strcpy(Buffer, "\0338");
  1908.         strcat(Buffer, Data->VolName);
  1909.     }
  1910.     else
  1911.         strcpy(Buffer, Data->VolName);
  1912.  
  1913.     *array        = Buffer;
  1914.  
  1915.     return(NULL);
  1916. }
  1917.  
  1918.  
  1919.  
  1920.  
  1921.  
  1922.  
  1923. /**********************************************************************/
  1924. /*                   Hook for setting gadgetstates                    */
  1925. /**********************************************************************/
  1926. static ULONG    __saveds __asm DisableFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data)
  1927. {
  1928.     ULONG    State;
  1929.  
  1930.     if(*Data == UsedList)
  1931.     {
  1932.         get(UsedList, MUIA_List_Active, &State);
  1933.         State    = (State == MUIV_List_Active_Off ? TRUE : FALSE);
  1934.         set(EditEntry, MUIA_Disabled, State);
  1935.         set(CopyEntry, MUIA_Disabled, State);
  1936.         set(RemoveEntry, MUIA_Disabled, State);
  1937.     }
  1938.     else if(*Data == AvailList)
  1939.     {
  1940.         get(AvailList, MUIA_List_Active, &State);
  1941.         State    = (State == MUIV_List_Active_Off ? TRUE : FALSE);
  1942.         set(AddEntry, MUIA_Disabled, State);
  1943.     }
  1944.     else if((*Data == IconPos[0]) || (*Data == IconPos[1]))
  1945.     {
  1946.         get(*Data, MUIA_Cycle_Active, &State);
  1947.         set(IconX, MUIA_Disabled, (State != MODE_USE));
  1948.         set(IconY, MUIA_Disabled, (State != MODE_USE));
  1949.         set(Position, MUIA_Disabled, (State != MODE_USE));
  1950.     }
  1951.     else if((*Data == UseIcon[0]) || (*Data == UseIcon[1]))
  1952.     {
  1953.         get(*Data, MUIA_Cycle_Active, &State);
  1954.         set(IconName, MUIA_Disabled, (State != MODE_USE));
  1955.     }
  1956.     else if((*Data == UseWindow[0]) || (*Data == UseWindow[1]))
  1957.     {
  1958.         get(*Data, MUIA_Cycle_Active, &State);
  1959.         set(WinX, MUIA_Disabled, (State != MODE_USE));
  1960.         set(WinY, MUIA_Disabled, (State != MODE_USE));
  1961.         set(WinWidth, MUIA_Disabled, (State != MODE_USE));
  1962.         set(WinHeight, MUIA_Disabled, (State != MODE_USE));
  1963.         set(LookWin, MUIA_Disabled, (State != MODE_USE));
  1964.     }
  1965.     else if((*Data == UseFlags[0]) || (*Data == UseFlags[1]))
  1966.     {
  1967.         get(*Data, MUIA_Cycle_Active, &State);
  1968.         set(FlagModes, MUIA_Disabled, (State != MODE_USE));
  1969.     }
  1970.  
  1971.     return(0);
  1972. }
  1973.  
  1974.  
  1975.  
  1976.  
  1977.  
  1978.  
  1979. /**********************************************************************/
  1980. /*   Change gadget states on settings of cycle gadget (VolumeType)    */
  1981. /**********************************************************************/
  1982. static ULONG    __saveds __asm PageChangeFunc(register __a0 struct Hook *MyHook, register __a2 APTR Obj, register __a1 APTR *Data)
  1983. {
  1984.     ULONG    Page;
  1985.     ULONG    State;
  1986.  
  1987.         // Get current page
  1988.  
  1989.     get(VolumeType, MUIA_Cycle_Active, &Page);
  1990.  
  1991.         // Set gadget states
  1992.  
  1993.     get(IconPos[Page], MUIA_Cycle_Active, &State);
  1994.     set(IconX, MUIA_Disabled, (State != MODE_USE));
  1995.     set(IconY, MUIA_Disabled, (State != MODE_USE));
  1996.     set(Position, MUIA_Disabled, (State != MODE_USE));
  1997.  
  1998.     get(UseIcon[Page], MUIA_Cycle_Active, &State);
  1999.     set(IconName, MUIA_Disabled, (State != MODE_USE));
  2000.  
  2001.     get(UseWindow[Page], MUIA_Cycle_Active, &State);
  2002.     set(WinX, MUIA_Disabled, (State != MODE_USE));
  2003.     set(WinY, MUIA_Disabled, (State != MODE_USE));
  2004.     set(WinWidth, MUIA_Disabled, (State != MODE_USE));
  2005.     set(WinHeight, MUIA_Disabled, (State != MODE_USE));
  2006.     set(LookWin, MUIA_Disabled, (State != MODE_USE));
  2007.  
  2008.     get(UseFlags[Page], MUIA_Cycle_Active, &State);
  2009.     set(FlagModes, MUIA_Disabled, (State != MODE_USE));
  2010.  
  2011.     return(0);
  2012. }
  2013.  
  2014.  
  2015.  
  2016.  
  2017.  
  2018.  
  2019.  
  2020.  
  2021.  
  2022.  
  2023.  
  2024.  
  2025. /**********************************************************************/
  2026. /*             Add a new volumes/device to the used list              */
  2027. /**********************************************************************/
  2028. static struct VolEntry *AddNewVolume(char *Name, ULONG Type, struct VolEntry *CopyPtr)
  2029. {
  2030.     struct    VolEntry    *NewEntry    = NULL,
  2031.                 *ThisEntry;
  2032.  
  2033.         // Check for exitance
  2034.  
  2035.     if(CheckExists(Name))
  2036.     {
  2037.         DisplayError(ERR_EXISTS, (ULONG)Name);
  2038.         return(NewEntry);
  2039.     }
  2040.  
  2041.         // Try to get our semaphore
  2042.  
  2043.     ObtainSemaphore(&FIconSema->FIconSema);
  2044.  
  2045.         // Get memory for new entry
  2046.  
  2047.     if((NewEntry = AllocVecPool(FIconSema, sizeof(struct VolEntry))))
  2048.     {
  2049.             // One entry plus
  2050.  
  2051.         FIconSema->VolumeList.lh_Type++;
  2052.  
  2053.             // Add entry and fill out structure
  2054.  
  2055.         if(Type == LDF_VOLUMES)
  2056.             AddHead(&FIconSema->VolumeList, (struct Node *)NewEntry);
  2057.         else
  2058.             AddTail(&FIconSema->VolumeList, (struct Node *)NewEntry);
  2059.  
  2060.         NewEntry->Link.ln_Name    = NewEntry->VolName;
  2061.         NewEntry->Link.ln_Type    = Type;
  2062.         strcpy(NewEntry->VolName, Name);
  2063.  
  2064.             // Copy contents of other entry ???
  2065.  
  2066.         if(CopyPtr)
  2067.         {
  2068.             strcpy(NewEntry->IconName, CopyPtr->IconName);
  2069.             NewEntry->Left        = CopyPtr->Left;
  2070.             NewEntry->Top        = CopyPtr->Top;
  2071.             NewEntry->IconPos    = CopyPtr->IconPos;
  2072.             NewEntry->UseAlt    = CopyPtr->UseAlt;
  2073.             NewEntry->UseWin    = CopyPtr->UseWin;
  2074.             NewEntry->WinX        = CopyPtr->WinX;
  2075.             NewEntry->WinY        = CopyPtr->WinY;
  2076.             NewEntry->WinWidth    = CopyPtr->WinWidth;
  2077.             NewEntry->WinHeight    = CopyPtr->WinHeight;
  2078.             NewEntry->UseFlags    = CopyPtr->UseFlags;
  2079.             NewEntry->WinFlags    = CopyPtr->WinFlags;
  2080.         }
  2081.  
  2082.             // Remove entries from listview (Used)
  2083.  
  2084.         DoMethod(UsedList, MUIM_List_Clear, NULL);
  2085.  
  2086.             // Sort the list again
  2087.  
  2088.         SortList(&FIconSema->VolumeList, TRUE);
  2089.  
  2090.             // Readd list
  2091.  
  2092.         ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2093.         while(ThisEntry->Link.ln_Succ)
  2094.         {
  2095.             DoMethod(UsedList, MUIM_List_InsertSingle, (APTR)ThisEntry, MUIV_List_Insert_Bottom);
  2096.  
  2097.             ThisEntry    = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2098.         }
  2099.     }
  2100.     else
  2101.     {
  2102.         DisplayError(ERR_NOMEM, NULL);
  2103.         NewEntry    = NULL;
  2104.     }
  2105.  
  2106.         // Free our semaphore
  2107.  
  2108.     ReleaseSemaphore(&FIconSema->FIconSema);
  2109.  
  2110.     return(NewEntry);
  2111. }
  2112.  
  2113.  
  2114.  
  2115.  
  2116.  
  2117.  
  2118.  
  2119.  
  2120. /**********************************************************************/
  2121. /*        Check for existance of a volume within the user list        */
  2122. /**********************************************************************/
  2123. static BOOL CheckExists(char *Name)
  2124. {
  2125.     BOOL    RetVal = FALSE;
  2126.  
  2127.     ObtainSemaphore(&FIconSema->FIconSema);
  2128.  
  2129.     if(!IsListEmpty(&FIconSema->VolumeList))
  2130.     {
  2131.         struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2132.  
  2133.         do
  2134.         {
  2135.             if(!stricmp(ThisEntry->VolName, Name))
  2136.                 RetVal = TRUE;
  2137.  
  2138.             ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2139.         } while(!RetVal && ThisEntry->Link.ln_Succ);
  2140.     }
  2141.  
  2142.     ReleaseSemaphore(&FIconSema->FIconSema);
  2143.  
  2144.     return(RetVal);
  2145. }
  2146.  
  2147.  
  2148.  
  2149.  
  2150.  
  2151.  
  2152.  
  2153. /**********************************************************************/
  2154. /*                       Save Prefs to disk/env                       */
  2155. /**********************************************************************/
  2156. static BOOL            DoSavePrefs(char *PrefsName);
  2157. static BOOL SavePrefs(BOOL EnvMode)
  2158. {
  2159.         // On ENV: mode, simply save to ENV: only
  2160.  
  2161.     if(DoSavePrefs("ENV:ForceIcon_prefs.iff"))
  2162.     {
  2163.             // Otherwise write to envarc: as well
  2164.  
  2165.         if(!EnvMode)
  2166.             return(DoSavePrefs("ENVARC:ForceIcon_prefs.iff"));
  2167.         else
  2168.             return(TRUE);
  2169.     }
  2170.     return(FALSE);
  2171. }
  2172. static BOOL DoSavePrefs(char *PrefsName)
  2173. {
  2174.     struct    IFFHandle    *PrefsHandle;
  2175.     LONG    Error;
  2176.     BOOL    GoOn = FALSE;
  2177.     UWORD    VersChunk[] =
  2178.     {
  2179.         VERNUM,
  2180.         REVNUM
  2181.     };
  2182.  
  2183.  
  2184.     ObtainSemaphore(&FIconSema->FIconSema);
  2185.  
  2186.         // Get handle for IFF
  2187.  
  2188.     if((PrefsHandle = AllocIFF()))
  2189.     {
  2190.             // Open file for save
  2191.  
  2192.         if((PrefsHandle->iff_Stream = Open(PrefsName, MODE_NEWFILE)))
  2193.         {
  2194.                 // Init Handle
  2195.  
  2196.             InitIFFasDOS(PrefsHandle);
  2197.  
  2198.                 // Open Handle
  2199.  
  2200.             if(!(Error = OpenIFF(PrefsHandle, IFFF_WRITE)))
  2201.             {
  2202.                     // Write FORM chunk
  2203.  
  2204.                 if(!(Error = PushChunk(PrefsHandle, 'FOIC', 'FORM', IFFSIZE_UNKNOWN)))
  2205.                 {
  2206.                         // Write version chunk
  2207.  
  2208.                     if(!(Error = PushChunk(PrefsHandle, 'FOIC', 'VERS', IFFSIZE_UNKNOWN)))
  2209.                     {
  2210.                         if((Error = WriteChunkBytes(PrefsHandle, &VersChunk[0], (sizeof(UWORD) * 2))) == (sizeof(UWORD) * 2))
  2211.                             Error = PopChunk(PrefsHandle);
  2212.                         else
  2213.                             Error = IoErr();
  2214.                     }
  2215.  
  2216.                         // Write Prefs chunk
  2217.  
  2218.                     if(!Error && !(Error = PushChunk(PrefsHandle, 'FOIC', 'PREF', IFFSIZE_UNKNOWN)))
  2219.                     {
  2220.                         struct    VolEntry    *ThisEntry    = (struct VolEntry *)FIconSema->VolumeList.lh_Head;
  2221.                         UWORD    NumEntries            = FIconSema->VolumeList.lh_Type;
  2222.                         BOOL    NoErr = TRUE;
  2223.  
  2224.                                 // Write all entries of volume list
  2225.  
  2226.                         if((Error = WriteChunkBytes(PrefsHandle, &NumEntries, sizeof(UWORD))) == sizeof(UWORD))
  2227.                         {
  2228.                             while(NumEntries-- && NoErr)
  2229.                             {
  2230.                                 UWORD    EntryType = ThisEntry->Link.ln_Type;
  2231.  
  2232.                                 if((Error = WriteChunkBytes(PrefsHandle, &EntryType, sizeof(UWORD))) == sizeof(UWORD))
  2233.                                 {
  2234.                                     if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->VolName, 130)) == 130)
  2235.                                     {
  2236.                                         if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->IconName, 256)) == 256)
  2237.                                         {
  2238.                                             if((Error = WriteChunkBytes(PrefsHandle, &ThisEntry->Left, (sizeof(UWORD) * 36))) != (sizeof(UWORD) * 36))
  2239.                                                 NoErr = FALSE;
  2240.                                         }
  2241.                                     }
  2242.                                 }
  2243.  
  2244.                                 ThisEntry = (struct VolEntry *)ThisEntry->Link.ln_Succ;
  2245.                             }
  2246.  
  2247.                             if(NoErr)
  2248.                             {
  2249.                                 if(!(Error = PopChunk(PrefsHandle)))
  2250.                                     GoOn = TRUE;
  2251.                             }
  2252.                         }
  2253.                     }
  2254.                 }
  2255.  
  2256.                 if((Error = PopChunk(PrefsHandle)))
  2257.                     GoOn = FALSE;
  2258.  
  2259.                 CloseIFF(PrefsHandle);
  2260.             }
  2261.  
  2262.             Close(PrefsHandle->iff_Stream);
  2263.         }
  2264.         else
  2265.             Error = IoErr();
  2266.  
  2267.         FreeIFF(PrefsHandle);
  2268.     }
  2269.     else
  2270.         Error = ERR_NOMEM;
  2271.  
  2272.     if(!GoOn)
  2273.         DisplayError(Error, (ULONG)PrefsName);
  2274.  
  2275.     ReleaseSemaphore(&FIconSema->FIconSema);
  2276.  
  2277.     return(GoOn);
  2278. }
  2279.  
  2280.  
  2281.  
  2282.  
  2283.  
  2284. /**********************************************************************/
  2285. /*                  Make a specific entry diskchange                  */
  2286. /**********************************************************************/
  2287. static void DskChange(struct VolEntry *ListEntry)
  2288. {
  2289.     struct    List    ChangeList;
  2290.  
  2291.     NewList(&ChangeList);
  2292.  
  2293.  
  2294.         // Create list of connected devices
  2295.  
  2296.     if(GetDosEntries(&ChangeList, LDF_VOLUMES))
  2297.     {
  2298.         struct    DosList        *DList;
  2299.         struct    VolEntry    *ThisEntry;
  2300.         struct    DevProc        *DevProc;
  2301.         char            DevName[130];
  2302.         BOOL            FoundDev,
  2303.                     DoDskCh;
  2304.  
  2305.             // Loop for all volumes in list
  2306.  
  2307.         while((ThisEntry = (struct VolEntry *)RemHead(&ChangeList)))
  2308.         {
  2309.             FoundDev    = FALSE;
  2310.  
  2311.                 // Find name of device this volume resides in
  2312.  
  2313.             if((DList = LockDosList(LDF_DEVICES|LDF_READ)))
  2314.             {
  2315.                 while((DList = NextDosEntry(DList, LDF_DEVICES|LDF_READ)))
  2316.                 {
  2317.                     if(ThisEntry->DriverTask == DList->dol_Task)
  2318.                     {
  2319.                         setmem(DevName, 130, 0);
  2320.                         strncpy(DevName, ((char *)BADDR(DList->dol_Name) + 1), *((char *)BADDR(DList->dol_Name)));
  2321.                         FoundDev    = TRUE;
  2322.                     }
  2323.                 }
  2324.                 UnLockDosList(LDF_DEVICES|LDF_READ);
  2325.             }
  2326.  
  2327.                 // Found corresponding device ???
  2328.  
  2329.             if(FoundDev)
  2330.             {
  2331.                     // Check whether to diskchange
  2332.  
  2333.                 if(ListEntry->Link.ln_Type == LDF_DEVICES)
  2334.                     DoDskCh    = (MyStrCmp(ListEntry->VolName, DevName) == 0);
  2335.                 else
  2336.                     DoDskCh    = (MyStrCmp(ListEntry->VolName, ThisEntry->VolName) == 0);
  2337.  
  2338.                     // Diskchange device ???
  2339.  
  2340.                 if(DoDskCh)
  2341.                 {
  2342.                     strcat(DevName, ":");
  2343.  
  2344.                     if(ThisEntry->DriverTask && (DevProc = GetDeviceProc(DevName, NULL)))
  2345.                     {
  2346.                         if(TypeOfMem(DevProc->dvp_Port))
  2347.                         {
  2348.                             if(DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSTRUE, NULL, NULL, NULL, NULL))
  2349.                                 DoPkt(DevProc->dvp_Port, ACTION_INHIBIT, DOSFALSE, NULL, NULL, NULL, NULL);
  2350.                         }
  2351.                         FreeDeviceProc(DevProc);
  2352.                     }
  2353.                 }
  2354.             }
  2355.  
  2356.             FreeVecPool(FIconSema, ThisEntry);
  2357.         }
  2358.     }
  2359. }
  2360.  
  2361.  
  2362.  
  2363.  
  2364.  
  2365.  
  2366. /**********************************************************************/
  2367. /*       Now include the LoadRoutine and the VolumeList routine       */
  2368. /**********************************************************************/
  2369. #include    "LoadPrefs.h"
  2370. #include    "VolList.h"
  2371. #include    "Error.h"
  2372. #include    "Rendezvous.h"
  2373. #include    "CheckToolTypes.h"
  2374. #include    "PoolVec.h"
  2375.