workbench/prefs/trackdisk/trackdisk_prefs.c

   1 #define DEBUG 0
   2
   3 #include <clib/alib_protos.h>
   4 #include <devices/trackdisk.h>
   5 #include <dos/dosextens.h>
   6 #include <intuition/imageclass.h>
   7 #include <libraries/iffparse.h>
   8 #include <libraries/mui.h>
   9 #include <utility/tagitem.h>
  10 #include <workbench/startup.h>
  11
  12 #include <proto/dos.h>
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/muimaster.h>
  16
  17 #include <stdio.h>
  18
  19 #if defined(__AROS__)
  20 #include <aros/debug.h>
  21 #include <prefs/trackdisk.h>
  22 #else
  23 #include "prefs_common.h"
  24 #define D(x)
  25 #endif
  26 #include "trackdisk_prefs.h"
  27
  28 #include "locale.h"
  29
  30 Object                *App = NULL,
  31                       *MainWin = NULL,
  32                       *SaveButton = NULL,
  33                       *UseButton = NULL,
  34                       *CancelButton = NULL;
  35 struct DriveControls  Drives[TD_NUMUNITS];
  36 struct WindowGroup    MainGrp;
  37 struct TrackdiskPrefs TDPrefs;
  38 struct IORequest      TDIO;
  39 int res = RETURN_OK;
  40
  41 int __nocommandline;
  42
  43 int main(void)
  44 {
  45     ULONG signals;
  46     int i;
  47     ULONG retval = 0;
  48
  49     D(bug("[Trackdisk.Prefs] Main()\n"));
  50
  51     Locale_Initialize();
  52
  53     for (i = 0; i < TD_NUMUNITS; i++)
  54             InitUnitPrefs(&TDPrefs.UnitPrefs[i], i);
  55     LoadPrefs();
  56     for (i = 0; i < TD_NUMUNITS; i++) {
  57             MainGrp.DriveGroup[i].ti_Tag = MUIA_Group_Child;
  58             MainGrp.DriveGroup[i].ti_Data = (IPTR)CreateDriveControls(&Drives[i], i);
  59     }
  60     MainGrp.TagChild = MUIA_Group_Child;
  61     MainGrp.ButtonsGroup = MUI_NewObject("Group.mui", MUIA_Group_Horiz, TRUE,
  62             MUIA_Group_Child,
  63         SaveButton = ImageButton(_(MSG_SAVE), "THEME:Images/Gadgets/Prefs/Save"),
  64             MUIA_Group_Child,
  65         UseButton = ImageButton(_(MSG_USE), "THEME:Images/Gadgets/Prefs/Use"),
  66             MUIA_Group_Child,
  67             CancelButton = ImageButton(_(MSG_CANCEL), "THEME:Images/Gadgets/Prefs/Cancel"),
  68     TAG_DONE);
  69     MainGrp.TagDone = TAG_DONE;
  70     App = MUI_NewObject("Application.mui", MUIA_Application_Author, "Pavel Fedin and Team AROS",
  71             MUIA_Application_Base, (IPTR)"TRACKDISKPREFS",
  72             MUIA_Application_Copyright, (IPTR)"(c) 2006-2007 Pavel Fedin and Team AROS",
  73         MUIA_Application_Description, __(MSG_DESCRIPTION),
  74             MUIA_Application_SingleTask, TRUE,
  75         MUIA_Application_Title, __(MSG_NAME),
  76         MUIA_Application_Version, (IPTR)"$VER: Trackdisk 41.5 (30.11.2007) ©2007 Pavel Fedin and Team AROS",
  77             MUIA_Application_Window,
  78             MainWin = MUI_NewObject("Window.mui", MUIA_Window_ID, MAKE_ID('M', 'A', 'I', 'N'),
  79             MUIA_Window_Title,__(MSG_WINDOW_TITLE),
  80                     MUIA_Window_RootObject, MUI_NewObjectA("Group.mui", (struct TagItem *)&MainGrp),
  81             TAG_DONE),
  82     TAG_DONE);
  83     if (App) {
  84             DoMethod(SaveButton, MUIM_Notify, MUIA_Pressed, FALSE, App, 2, MUIM_Application_ReturnID, 1);
  85             DoMethod(UseButton, MUIM_Notify, MUIA_Pressed, FALSE, App, 2, MUIM_Application_ReturnID, 2);
  86             DoMethod(CancelButton, MUIM_Notify, MUIA_Pressed, FALSE, App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  87             DoMethod(MainWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  88             SetAttrs(MainWin, MUIA_Window_Open, TRUE, TAG_DONE);
  89             while (retval != MUIV_Application_ReturnID_Quit) {
  90                     retval = DoMethod(App, MUIM_Application_NewInput, &signals);
  91                     if (retval && (retval != MUIV_Application_ReturnID_Quit)) {
  92                             for (i = 0; i < TD_NUMUNITS; i++)
  93                                     ControlsToPrefs(&Drives[i], &TDPrefs.UnitPrefs[i]);
  94                             if (retval == 1)
  95                                     SavePrefs();
  96                             UsePrefs();
  97                             retval = MUIV_Application_ReturnID_Quit;
  98                     }
  99                     if (signals)
 100                             signals = Wait(signals);
 101             }
 102             MUI_DisposeObject(App);
 103     } else res = RETURN_ERROR;
 104     Locale_Deinitialize();
 105     return res;
 106 }
 107
 108 void InitUnitPrefs(struct TDU_Prefs *UnitPrefs, int nunit)
 109 {
 110         D(bug("[Trackdisk.Prefs] InitUnitPrefs()\n"));
 111         UnitPrefs->TagUnitNum   = TDPR_UnitNum;
 112         UnitPrefs->Unit         = nunit;
 113         UnitPrefs->TagPubFlags  = TDPR_PubFlags;
 114         UnitPrefs->PubFlags     = 0;
 115         UnitPrefs->TagRetryCnt  = TDPR_RetryCnt;
 116         UnitPrefs->RetryCnt     = 3;
 117 }
 118
 119 Object *CreateDriveControls(struct DriveControls *dc, int ndrive)
 120 {
 121         D(bug("[Trackdisk.Prefs] CreateDriveControls()\n"));
 122     sprintf(dc->DriveLabel, _(MSG_DRIVE), ndrive);
 123         return MUI_NewObject("Group.mui", MUIA_Group_Horiz, TRUE,
 124                 MUIA_Disabled, dc->Disabled,
 125                 MUIA_FrameTitle, dc->DriveLabel,
 126                 MUIA_Background, MUII_GroupBack,
 127                 MUIA_Frame, MUIV_Frame_Group,
 128         MUIA_Group_Child, MUI_MakeObject(MUIO_Label, _(MSG_NOCLICK), 0),
 129                 MUIA_Group_Child,
 130                 dc->NoClickSwitch = MUI_NewObject("Image.mui", MUIA_Image_Spec, MUII_CheckMark,
 131                         MUIA_InputMode, MUIV_InputMode_Toggle,
 132                         MUIA_Selected, TDPrefs.UnitPrefs[ndrive].PubFlags & TDPF_NOCLICK,
 133                         MUIA_CycleChain, TRUE,
 134                         MUIA_Frame, MUIV_Frame_ImageButton,
 135                         MUIA_ShowSelState, FALSE,
 136                 TAG_DONE),
 137         MUIA_Group_Child, MUI_MakeObject(MUIO_Label, _(MSG_RETRIES), 0),
 138                 MUIA_Group_Child,
 139                 dc->RetriesSlider = MUI_NewObject("Slider.mui", MUIA_CycleChain, TRUE,
 140                         MUIA_Numeric_Min, 1, MUIA_Numeric_Max, 10,
 141                         MUIA_Numeric_Value, TDPrefs.UnitPrefs[ndrive].RetryCnt,
 142                 TAG_DONE),
 143         TAG_DONE);
 144 }
 145
 146 void LoadPrefs(void)
 147 {
 148         ULONG i;
 149         struct TDU_PublicUnit *tdu = NULL;
 150
 151         D(bug("[Trackdisk.Prefs] LoadPrefs()\n"));
 152
 153         for (i = 0; i < TD_NUMUNITS; i++) {
 154                 if (OpenDevice("trackdisk.device", i, &TDIO, 0))
 155                         Drives[i].Disabled = TRUE;
 156                 else {
 157                         tdu = (struct TDU_PublicUnit *)TDIO.io_Unit;
 158                         TDPrefs.UnitPrefs[i].PubFlags = tdu->tdu_PubFlags;
 159                         TDPrefs.UnitPrefs[i].RetryCnt = tdu->tdu_RetryCnt;
 160                         CloseDevice(&TDIO);
 161                         Drives[i].Disabled = FALSE;
 162                 }
 163         }
 164 }
 165
 166 void ControlsToPrefs(struct DriveControls *dc, struct TDU_Prefs *pr)
 167 {
 168         IPTR data;
 169
 170         D(bug("[Trackdisk.Prefs] ControlsToPrefs()\n"));
 171
 172         GetAttr(MUIA_Selected, dc->NoClickSwitch, &data);
 173         pr->PubFlags = data ? TDPF_NOCLICK : 0 ;
 174         GetAttr(MUIA_Numeric_Value, dc->RetriesSlider, &data);
 175         pr->RetryCnt = data;
 176 }
 177
 178 void SavePrefs(void)
 179 {
 180         BPTR cf;
 181
 182         D(bug("[Trackdisk.Prefs] SavePrefs()\n"));
 183
 184         cf = Open(TRACKDISK_PREFS_NAME, MODE_NEWFILE);
 185         if (cf) {
 186                 TDPrefs.TagDone = TAG_DONE;
 187                 Write(cf, &TDPrefs, sizeof(TDPrefs));
 188                 Close(cf);
 189         }
 190 }
 191
 192 void UsePrefs(void)
 193 {
 194         ULONG i;
 195         struct TDU_PublicUnit *tdu = NULL;
 196
 197         D(bug("[Trackdisk.Prefs] UsePrefs()\n"));
 198
 199         for (i = 0; i < TD_NUMUNITS; i++) {
 200                 if ((!Drives[i].Disabled) && (!OpenDevice("trackdisk.device", i, &TDIO, 0))) {
 201                         tdu = (struct TDU_PublicUnit *)TDIO.io_Unit;
 202                         tdu->tdu_PubFlags = TDPrefs.UnitPrefs[i].PubFlags;
 203                         tdu->tdu_RetryCnt = TDPrefs.UnitPrefs[i].RetryCnt;
 204                         CloseDevice(&TDIO);
 205                 }
 206         }
 207 }
 208