workbench/devs/AHI/AHI/gui_mui.c

   1 /*
   2      AHI - The AHI preferences program
   3      Copyright (C) 2017 The AROS Dev Team
   4      Copyright (C) 1996-2005 Martin Blom <martin@blom.org>
   5
   6      This program is free software; you can redistribute it and/or
   7      modify it under the terms of the GNU General Public License
   8      as published by the Free Software Foundation; either version 2
   9      of the License, or (at your option) any later version.
  10
  11      This program is distributed in the hope that it will be useful,
  12      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14      GNU General Public License for more details.
  15
  16      You should have received a copy of the GNU General Public License
  17      along with this program; if not, write to the Free Software
  18      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19 */
  20
  21 #define DEBUG 1
  22 #include <aros/debug.h>
  23
  24 #include <config.h>
  25
  26 #include <exec/memory.h>
  27 #include <libraries/asl.h>
  28 #include <libraries/gadtools.h>
  29 #include <libraries/mui.h>
  30
  31 #include <clib/alib_protos.h>
  32 #include <proto/ahi.h>
  33 #include <proto/exec.h>
  34 #include <proto/dos.h>
  35 #include <proto/intuition.h>
  36 #include <proto/utility.h>
  37
  38 #define NO_INLINE_STDARG
  39 #include <proto/muimaster.h>
  40 #undef NO_INLINE_STDARG
  41
  42 #include <math.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45
  46 #include "ahi.h"
  47 #include "ahiprefs_Cat.h"
  48 #include "support.h"
  49 #include "gui.h"
  50
  51
  52
  53 #if defined( __morphos__ ) || defined( __MORPHOS__ )
  54
  55 #ifndef DoMethod
  56 #define DoMethod(obj, ... )         \
  57 ({                                  \
  58   ULONG _args[] = { __VA_ARGS__ };  \
  59   DoMethodA(obj,(Msg) _args);       \
  60 })
  61 #endif
  62
  63 /* Why the #$*@ is this not in libamiga.a?! */
  64
  65 static ULONG
  66 gw_HookEntry( void )
  67 {
  68   struct Hook* h   = (struct Hook*) REG_A0;
  69   void*        o   = (void*)        REG_A2;
  70   void*        msg = (void*)        REG_A1;
  71
  72   return ( ( (ULONG(*)(struct Hook*, void*, void*)) *h->h_SubEntry)( h, o, msg ) );
  73 }
  74
  75 struct EmulLibEntry _HookEntry =
  76 {
  77   TRAP_LIB, 0, (void (*)(void)) &gw_HookEntry
  78 };
  79
  80 __asm( ".globl HookEntry;HookEntry=_HookEntry" );
  81
  82
  83 #elif defined(__AMIGAOS4__)
  84
  85 ULONG HookEntry(struct Hook* h, void* o, void* msg) {
  86   return ( ( (ULONG(*)(struct Hook*, void*, void*)) *h->h_SubEntry)( h, o, msg ) );
  87 }
  88
  89 #endif
  90
  91
  92
  93 static void GUINewSettings(void);
  94 static void GUINewUnit(void);
  95 static void GUINewMode(void);
  96
  97
  98 enum windowIDs {
  99   WINID_MAIN=1,
 100   WINID_COUNT
 101 };
 102
 103 enum actionIDs {
 104   ACTID_OPEN=1, ACTID_SAVEAS, ACTID_ABOUT, ACTID_QUIT,
 105   ACTID_DEFAULT, ACTID_LASTSAVED, ACTID_RESTORE,
 106   ACTID_ICONS,
 107   ACTID_HELP, ACTID_GUIDE, ACTID_HELPINDEX,
 108   ACTID_SAVE, ACTID_USE,
 109
 110   ACTID_TABS, ACTID_PAGE,
 111
 112   ACTID_UNIT, ACTID_MODE,
 113   SHOWID_MODE,
 114
 115   ACTID_FREQ, ACTID_CHANNELS, ACTID_OUTVOL, ACTID_MONVOL, ACTID_GAIN,
 116   ACTID_INPUT, ACTID_OUTPUT,
 117   SHOWID_FREQ, SHOWID_CHANNELS, SHOWID_OUTVOL, SHOWID_MONVOL, SHOWID_GAIN,
 118   SHOWID_INPUT, SHOWID_OUTPUT,
 119
 120   ACTID_PLAY,
 121
 122   ACTID_DEBUG, ACTID_SURROUND, ACTID_ECHO, ACTID_CLIPMV,
 123   ACTID_CPULIMIT, SHOWID_CPULIMIT,
 124   ACTID_ACTIME, SHOWID_ACTIME,
 125   ACTID_SCALEMODE,
 126
 127
 128   ACTID_COUNT
 129 };
 130
 131 #define Title(t)        { NM_TITLE, t, NULL, 0, 0, NULL }
 132 #define Item(t,s,i)     { NM_ITEM, t, s, 0, 0, (APTR)i }
 133 #define ItemBar         { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL }
 134 #define SubItem(t,s,i)  { NM_SUB, t, s, 0, 0, (APTR)i }
 135 #define SubBar          { NM_SUB, NM_BARLABEL, NULL, 0, 0, NULL }
 136 #define EndMenu         { NM_END, NULL, NULL, 0, 0, NULL }
 137 #define ItCk(t,s,i,f)   { NM_ITEM, t, s, f, 0, (APTR)i }
 138
 139 struct Library       *MUIMasterBase  = NULL;
 140
 141 #ifdef __AMIGAOS4__
 142 struct MUIMasterIFace *IMUIMaster = NULL;
 143 #endif
 144
 145 static struct NewMenu Menus[] = {
 146   Title( NULL /* Project */ ),
 147     Item( NULL /* Open... */,             NULL, ACTID_OPEN      ),
 148     Item( NULL /* Save As... */,          NULL, ACTID_SAVEAS    ),
 149     ItemBar,
 150     Item( NULL /* About... */,            NULL, ACTID_ABOUT     ),
 151     ItemBar,
 152     Item( NULL /* Quit */,                NULL, ACTID_QUIT      ),
 153   Title( NULL /* Edit */ ),
 154     Item( NULL /* Reset To Defaults */,   NULL, ACTID_DEFAULT   ),
 155     Item( NULL /* Last Saved */,          NULL, ACTID_LASTSAVED ),
 156     Item( NULL /* Restore */,             NULL, ACTID_RESTORE   ),
 157   Title( NULL /* Settings */ ),
 158     ItCk( NULL /* Create Icons? */,       NULL, ACTID_ICONS, CHECKIT|MENUTOGGLE ),
 159   Title( NULL /* Help */ ),
 160     ItCk( NULL /* Help... */,             NULL, ACTID_HELP, COMMSEQ),
 161     ItemBar,
 162     Item( NULL /* AHI User's guide... */, NULL, ACTID_GUIDE),
 163     Item( NULL /* Concept Index... */,    NULL, ACTID_HELPINDEX ),
 164   EndMenu
 165 };
 166
 167 static char *PageNames[] =
 168 {
 169   NULL,  /* Mode settings */
 170   NULL,  /* Advanced settings */
 171   NULL
 172 };
 173
 174 static char * ScaleLabels[] = {
 175   NULL,  /* Safe */
 176   NULL,  /* Safe, dynamic */
 177   NULL,  /* Full volume */
 178   NULL,  /* -3 dB */
 179   NULL,  /* -6 dB */
 180   NULL
 181 };
 182
 183 static char * DebugLabels[] = {
 184   NULL,  /* None */
 185   NULL,  /* Low */
 186   NULL,  /* High */
 187   NULL,  /* Full */
 188   NULL
 189 };
 190
 191 static char * EchoLabels[] = {
 192   NULL,  /* Enabled */
 193   NULL,  /* Fast */
 194   NULL,  /* Disabled */
 195   NULL
 196 };
 197
 198 static char * SurroundLabels[] = {
 199   NULL,  /* Enabled */
 200   NULL,  /* Disabled */
 201   NULL
 202 };
 203
 204 static char * ClipMVLabels[] = {
 205   NULL,  /* Without clipping */
 206   NULL,  /* With clipping */
 207   NULL
 208 };
 209
 210 /***** Local function to update the strings above ****************************/
 211
 212 static void UpdateStrings(void) {
 213   char ** strings[] =
 214   {
 215     (char**) &msgMenuProject,
 216     (char**) &msgItemOpen,
 217     (char**) &msgItemSaveAs,
 218     (char**) &msgItemAbout,
 219     (char**) &msgItemQuit,
 220     (char**) &msgMenuEdit,
 221     (char**) &msgItemDefaults,
 222     (char**) &msgItemLastSaved,
 223     (char**) &msgItemRestore,
 224     (char**) &msgMenuSettings,
 225     (char**) &msgItemCreateIcons,
 226     (char**) &msgMenuHelp,
 227     (char**) &msgItemHelp,
 228     (char**) &msgItemUsersGuide,
 229     (char**) &msgItemConceptIndex
 230   };
 231
 232   struct NewMenu   *menuptr;
 233   char           ***stringptr;
 234
 235   D(bug("[AHI:Prefs] %s()\n", __func__);)
 236
 237   menuptr   = (struct NewMenu *) &Menus;
 238   stringptr = (char ***) &strings;
 239
 240   while(menuptr->nm_Type != NM_END)
 241   {
 242     if(menuptr->nm_Label == NULL)
 243     {
 244       if(strlen(**stringptr) != 0) {
 245         menuptr->nm_CommKey = **stringptr;
 246       }
 247       menuptr->nm_Label = **stringptr + strlen(**stringptr) + 1;
 248       stringptr++;
 249     }
 250     menuptr++;
 251   }
 252
 253   PageNames[0] = (char *) msgPageMode;
 254   PageNames[1] = (char *) msgPageAdvanced;
 255   DebugLabels[0] = (char *) msgDebugNone;
 256   DebugLabels[1] = (char *) msgDebugLow;
 257   DebugLabels[2] = (char *) msgDebugHigh;
 258   DebugLabels[3] = (char *) msgDebugFull;
 259   EchoLabels[0] = (char *) msgEchoEnabled;
 260   EchoLabels[1] = (char *) msgEchoFast;
 261   EchoLabels[2] = (char *) msgEchoDisabled;
 262   SurroundLabels[0] = (char *) msgSurroundEnabled;
 263   SurroundLabels[1] = (char *) msgSurroundDisabled;
 264   ClipMVLabels[0] = (char *) msgMVNoClip;
 265   ClipMVLabels[1] = (char *) msgMVClip;
 266   ScaleLabels[0] = (char *) msgSMFixedSafe;
 267   ScaleLabels[1] = (char *) msgSMDynSafe;
 268   ScaleLabels[2] = (char *) msgSM0dB;
 269   ScaleLabels[3] = (char *) msgSM3dB;
 270   ScaleLabels[4] = (char *) msgSM6dB;
 271 }
 272
 273 static Object *MUIWindow,*MUIList,*MUIInfos,*MUIUnit;
 274 static Object *MUIFreq,*MUIChannels,*MUIOutvol,*MUIMonvol,*MUIGain,*MUIInput,*MUIOutput;
 275 static Object *MUILFreq,*MUILChannels,*MUILOutvol,*MUILMonvol,*MUILGain,*MUILInput,*MUILOutput,*MUIPlay;
 276 static Object *MUIDebug,*MUIEcho,*MUISurround,*MUIClipvol,*MUICpu,*MUIACTime,*MUIScalemode;
 277
 278 SIPTR xget(Object * obj, ULONG attribute)
 279 {
 280   LONG x = 0;
 281
 282   get(obj, attribute, &x);
 283   return (x);
 284 }
 285
 286 static void GUINewSettings(void)
 287 {
 288   D(bug("[AHI:Prefs] %s()\n", __func__);)
 289
 290   set(MUIUnit,MUIA_Cycle_Entries,Units);
 291   set(MUIUnit,MUIA_Cycle_Active,state.UnitSelected);
 292   set(MUIDebug, MUIA_Cycle_Active, globalprefs.ahigp_DebugLevel);
 293   set(MUIEcho, MUIA_Cycle_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0)|(globalprefs.ahigp_FastEcho    ? 1 : 0));
 294   set(MUISurround, MUIA_Cycle_Active, globalprefs.ahigp_DisableSurround);
 295   set(MUIClipvol, MUIA_Cycle_Active, globalprefs.ahigp_ClipMasterVolume);
 296   set(MUICpu, MUIA_Cycle_Active, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16);
 297   set(MUIACTime, MUIA_Cycle_Active, (globalprefs.ahigp_AntiClickTime * 1000 + 32768) >> 16);
 298   set(MUIScalemode, MUIA_Cycle_Active, globalprefs.ahigp_ScaleMode);
 299
 300   GUINewUnit();
 301 }
 302
 303 static void GUINewUnit(void)
 304 {
 305   D(bug("[AHI:Prefs] %s()\n", __func__);)
 306
 307   DoMethod(MUIList, MUIM_List_Clear);
 308   set(MUIList, MUIA_List_Quiet, TRUE);
 309   DoMethod(MUIList, MUIM_List_Insert, Modes, -1, MUIV_List_Insert_Bottom);
 310   set(MUIList, MUIA_List_Quiet, FALSE);
 311   set(MUIList, MUIA_List_Active, state.ModeSelected != ~0 ? state.ModeSelected : MUIV_List_Active_Off);
 312   GUINewMode();
 313 }
 314
 315 static void GUINewMode(void)
 316 {
 317   int Max, Sel, Dis;
 318   char* buffer;
 319   char* arg1 = getRecord();
 320   char* arg2 = getAuthor();
 321   char* arg3 = getCopyright();
 322   char* arg4 = getDriver();
 323   char* arg5 = getVersion();
 324   char* arg6 = getAnnotation();
 325
 326   D(bug("[AHI:Prefs] %s()\n", __func__);)
 327
 328   buffer = AllocVec( strlen( arg1 ) +
 329                      strlen( arg2 ) +
 330                      strlen( arg3 ) +
 331                      strlen( arg4 ) +
 332                      strlen( arg5 ) +
 333                      strlen( arg6 ) +
 334                      128,
 335                      MEMF_ANY);
 336
 337   if( buffer != NULL )
 338   {
 339     sprintf( buffer,"0x%08lx\n%s\n%s\n%s\nDevs:AHI/%s.audio\n%s\n%s",
 340       (ULONG)getAudioMode(),
 341       arg1,
 342       arg2,
 343       arg3,
 344       arg4,
 345       arg5,
 346       arg6 );
 347
 348     set(MUIInfos, MUIA_Text_Contents, (IPTR) buffer);
 349
 350     FreeVec(buffer);
 351   }
 352
 353   Max = max(state.Frequencies -1, 0);
 354   Sel = min(Max, state.FreqSelected);
 355   Dis = Max==0;
 356   set(MUIFreq, MUIA_Disabled, Dis);
 357   if( !Dis )
 358   {
 359     set(MUIFreq, MUIA_Numeric_Max, Max);
 360     set(MUIFreq, MUIA_Numeric_Value, Sel);
 361   }
 362   set(MUILFreq, MUIA_Text_Contents, (IPTR) getFreq());
 363
 364   Max = max(state.Channels, 0);
 365   Sel = min(Max, state.ChannelsSelected);
 366   Dis = (Max == 0 || Max == 1) || state.ChannelsDisabled;
 367   set(MUIChannels, MUIA_Disabled, Dis);
 368   if( !Dis )
 369   {
 370     set(MUIChannels, MUIA_Numeric_Max, Max);
 371     set(MUIChannels, MUIA_Numeric_Value, Sel);
 372   }
 373   set(MUILChannels, MUIA_Text_Contents, (IPTR) getChannels());
 374
 375   Max = max(state.OutVols -1, 0);
 376   Sel = min(Max, state.OutVolSelected);
 377   Dis = Max==0;
 378   set(MUIOutvol, MUIA_Disabled, Dis);
 379   if( !Dis )
 380   {
 381     set(MUIOutvol, MUIA_Numeric_Max, Max);
 382     set(MUIOutvol, MUIA_Numeric_Value, Sel);
 383   }
 384   set(MUILOutvol, MUIA_Text_Contents, (IPTR) getOutVol());
 385
 386   Max = max(state.MonVols -1, 0);
 387   Sel = min(Max, state.MonVolSelected);
 388   Dis = Max==0;
 389   set(MUIMonvol, MUIA_Disabled, Dis);
 390   if( !Dis )
 391   {
 392     set(MUIMonvol, MUIA_Numeric_Max, Max);
 393     set(MUIMonvol, MUIA_Numeric_Value, Sel);
 394   }
 395   set(MUILMonvol, MUIA_Text_Contents, (IPTR) getMonVol());
 396
 397   Max = max(state.Gains -1, 0);
 398   Sel = min(Max, state.GainSelected);
 399   Dis = Max==0;
 400   set(MUIGain, MUIA_Disabled, Dis);
 401   if( !Dis )
 402   {
 403     set(MUIGain, MUIA_Numeric_Max, Max);
 404     set(MUIGain, MUIA_Numeric_Value, Sel);
 405   }
 406   set(MUILGain, MUIA_Text_Contents, (IPTR) getGain());
 407
 408   Max = max(state.Inputs -1, 0);
 409   Sel = min(Max, state.InputSelected);
 410   Dis = Max==0;
 411   set(MUIInput, MUIA_Disabled, Dis);
 412   if( !Dis )
 413   {
 414     set(MUIInput, MUIA_Numeric_Max, Max);
 415     set(MUIInput, MUIA_Numeric_Value, Sel);
 416   }
 417   set(MUILInput, MUIA_Text_Contents, (IPTR) getInput());
 418
 419   Max = max(state.Outputs -1, 0);
 420   Sel = min(Max, state.OutputSelected);
 421   Dis = Max==0;
 422   set(MUIOutput, MUIA_Disabled, Dis);
 423   if( !Dis )
 424   {
 425     set(MUIOutput, MUIA_Numeric_Max, Max);
 426     set(MUIOutput, MUIA_Numeric_Value, Sel);
 427   }
 428   set(MUILOutput, MUIA_Text_Contents, (IPTR) getOutput());
 429
 430
 431   set(MUIPlay, MUIA_Disabled, getAudioMode() == AHI_INVALID_ID);
 432 }
 433
 434 static VOID
 435 SliderHookFunc( struct Hook *hook,
 436                 Object *obj,
 437                 IPTR** arg )
 438 {
 439   D(bug("[AHI:Prefs] %s()\n", __func__);)
 440
 441   if(obj == MUIFreq)
 442   {
 443     state.FreqSelected = (LONG)(IPTR)(*arg);
 444     set(MUILFreq, MUIA_Text_Contents, (IPTR) getFreq());
 445   }
 446   else if(obj == MUIChannels )
 447   {
 448     state.ChannelsSelected = (LONG)(IPTR)(*arg);
 449     set(MUILChannels, MUIA_Text_Contents, (IPTR) getChannels());
 450   }
 451   else if(obj == MUIOutvol )
 452   {
 453     state.OutVolSelected = (LONG)(IPTR)(*arg);
 454     set(MUILOutvol, MUIA_Text_Contents, (IPTR) getOutVol());
 455   }
 456   else if(obj == MUIMonvol )
 457   {
 458     state.MonVolSelected = (LONG)(IPTR)(*arg);
 459     set(MUILMonvol, MUIA_Text_Contents, (IPTR) getMonVol());
 460   }
 461   else if(obj == MUIGain )
 462   {
 463     state.GainSelected = (LONG)(IPTR)(*arg);
 464     set(MUILGain, MUIA_Text_Contents, (IPTR) getGain());
 465   }
 466   else if(obj == MUIInput )
 467   {
 468     state.InputSelected = (LONG)(IPTR)(*arg);
 469     set(MUILInput, MUIA_Text_Contents, (IPTR) getInput());
 470   }
 471   else if(obj == MUIOutput )
 472   {
 473   state.OutputSelected = (LONG)(IPTR)(*arg);
 474   set(MUILOutput, MUIA_Text_Contents, (IPTR) getOutput());
 475   }
 476 }
 477
 478 static struct Hook hookSlider =
 479 {
 480   { NULL, NULL },
 481   HookEntry,
 482   (HOOKFUNC) SliderHookFunc,
 483   NULL
 484 };
 485
 486 /******************************************************************************
 487 **** Call to open the window **************************************************
 488 ******************************************************************************/
 489
 490 static Object *MUIApp,*MUIMenu;
 491
 492 static Object* SpecialLabel(STRPTR label)
 493 {
 494   D(bug("[AHI:Prefs] %s()\n", __func__);)
 495
 496   return(TextObject,
 497       MUIA_HorizWeight, 75,
 498       MUIA_Text_Contents, label,
 499       MUIA_Text_PreParse, "\33l",
 500     End);
 501 }
 502
 503 static Object* SpecialButton(STRPTR label)
 504 {
 505   Object *button = NULL;
 506   STRPTR lab;
 507
 508   D(bug("[AHI:Prefs] %s()\n", __func__);)
 509
 510   lab = AllocVec(strlen(label)+1,0);
 511
 512   if( lab != NULL )
 513   {
 514     char ctrlchar = 0;
 515     STRPTR l = lab;
 516
 517     while(*label)
 518     {
 519       *l = *label;
 520       if(*label++ == '_')
 521       {
 522         ctrlchar = ToLower(*label);
 523         *l = *label++;
 524       }
 525       l++;
 526     }
 527     *l = '\0';
 528     button = TextObject,
 529       MUIA_HorizWeight, 0,
 530       MUIA_Text_Contents, lab,
 531       MUIA_Text_PreParse, "\33r",
 532       MUIA_Text_HiChar, ctrlchar,
 533       MUIA_ControlChar, ctrlchar,
 534       MUIA_InputMode, MUIV_InputMode_RelVerify,
 535       MUIA_ShowSelState, FALSE,
 536     End;
 537     FreeVec(lab);
 538   }
 539   return button;
 540 }
 541
 542 static Object* SpecialSlider(LONG min, LONG max, LONG value)
 543 {
 544   D(bug("[AHI:Prefs] %s()\n", __func__);)
 545
 546   return(SliderObject,
 547          MUIA_CycleChain,     1,
 548          MUIA_Slider_Quiet,   TRUE,
 549          MUIA_Numeric_Min,    min,
 550          MUIA_Numeric_Max,    max >= min ? max : min,
 551          MUIA_Numeric_Value,  value >= min && value <=max ? value : min,
 552          MUIA_Numeric_Format, "",
 553     End);
 554 }
 555
 556 BOOL BuildGUI(char *screenname)
 557 {
 558   Object *MUISave, *MUIUse, *MUICancel;
 559   Object *page1,*page2;
 560   Object *MUITFreq,*MUITChannels,*MUITOutvol,*MUITMonvol,*MUITGain,*MUITInput,*MUITOutput,*MUITDebug,*MUITEcho,*MUITSurround,*MUITClipvol,*MUITCpu,*MUITACTime,*MUITScalemode;
 561
 562   D(bug("[AHI:Prefs] %s()\n", __func__);)
 563
 564   UpdateStrings();
 565
 566   MUIMasterBase = (void *)OpenLibrary("muimaster.library", MUIMASTER_VLATEST);
 567   if(MUIMasterBase == NULL)
 568   {
 569     Printf((char *) msgTextNoOpen, "muimaster.library", MUIMASTER_VLATEST);
 570     Printf("\n");
 571     return FALSE;
 572   }
 573
 574 #ifdef __AMIGAOS4__
 575   IMUIMaster = (struct MUIMasterIFace *) GetInterface(MUIMasterBase, "main", 1, NULL);
 576   if(IMUIMaster == NULL)
 577   {
 578     Printf((char *) msgTextNoOpen, "MUIMaster main interface", 1);
 579     Printf("\n");
 580     CloseLibrary((struct Library*) MUIMasterBase);
 581     return FALSE;
 582   }
 583 #endif
 584
 585   page1 = HGroup,
 586     Child, VGroup,
 587       Child, MUIUnit = CycleObject,
 588         MUIA_CycleChain, 1,
 589         MUIA_Cycle_Entries, Units,
 590         MUIA_Cycle_Active, state.UnitSelected,
 591       End,
 592       Child, ListviewObject,
 593         MUIA_CycleChain, 1,
 594         MUIA_Listview_List, MUIList = ListObject,
 595           InputListFrame,
 596           MUIA_List_AutoVisible, TRUE,
 597         End,
 598       End,
 599       Child, HGroup,
 600         ReadListFrame,
 601         MUIA_Background, MUII_TextBack,
 602         Child, TextObject,
 603           MUIA_Text_Contents, msgProperties,
 604           MUIA_Text_SetMax, TRUE,
 605         End,
 606         Child, MUIInfos = TextObject,
 607           MUIA_Text_Contents, "\n\n\n\n\n\n",
 608           MUIA_Text_SetMin, FALSE,
 609         End,
 610       End,
 611     End,
 612     Child, BalanceObject,
 613     End,
 614     Child, VGroup,
 615       Child, HVSpace,
 616       Child, ColGroup(3),
 617         GroupFrameT(msgOptions),
 618         Child, MUITFreq = SpecialButton((STRPTR)msgOptFrequency),
 619         Child, MUIFreq = SpecialSlider(0,max(state.Frequencies-1,0),state.FreqSelected),
 620         Child, MUILFreq = SpecialLabel(getFreq()),
 621         Child, MUITChannels = SpecialButton((STRPTR)msgOptChannels),
 622         Child, MUIChannels = SpecialSlider(1,state.Channels,state.ChannelsSelected),
 623         Child, MUILChannels = SpecialLabel(getChannels()),
 624         Child, MUITOutvol = SpecialButton((STRPTR)msgOptVolume),
 625         Child, MUIOutvol = SpecialSlider(0,max(state.OutVols-1,0),state.OutVolSelected),
 626         Child, MUILOutvol = SpecialLabel(getOutVol()),
 627         Child, MUITMonvol = SpecialButton((STRPTR)msgOptMonitor),
 628         Child, MUIMonvol = SpecialSlider(0,max(state.MonVols-1,1),state.MonVolSelected),
 629         Child, MUILMonvol = SpecialLabel(getMonVol()),
 630         Child, MUITGain = SpecialButton((STRPTR)msgOptGain),
 631         Child, MUIGain = SpecialSlider(0,max(state.Gains-1,0),state.GainSelected),
 632         Child, MUILGain = SpecialLabel(getGain()),
 633         Child, MUITInput = SpecialButton((STRPTR)msgOptInput),
 634         Child, MUIInput = SpecialSlider(0,max(state.Inputs-1,0),state.InputSelected),
 635         Child, MUILInput = SpecialLabel(getInput()),
 636         Child, MUITOutput = SpecialButton((STRPTR)msgOptOutput),
 637         Child, MUIOutput = SpecialSlider(0,max(state.Outputs-1,0),state.OutputSelected),
 638         Child, MUILOutput = SpecialLabel(getOutput()),
 639       End,
 640       Child, MUIPlay = SimpleButton(msgButtonPlay),
 641       Child, HVSpace,
 642     End,
 643   End;
 644
 645   page2 = VGroup,
 646     Child, HVSpace,
 647     Child, HGroup,
 648       Child, HVSpace,
 649       Child, ColGroup(2),
 650         GroupFrameT(msgGlobalOptions),
 651         Child, MUITDebug = SpecialButton((STRPTR)msgGlobOptDebugLevel),
 652         Child, MUIDebug = CycleObject,
 653           MUIA_CycleChain, 1,
 654           MUIA_Cycle_Entries, DebugLabels,
 655           MUIA_Cycle_Active, globalprefs.ahigp_DebugLevel,
 656         End,
 657         Child, MUITEcho = SpecialButton((STRPTR)msgGlobOptEcho),
 658         Child, MUIEcho  = CycleObject,
 659           MUIA_CycleChain, 1,
 660           MUIA_Cycle_Entries, EchoLabels,
 661           MUIA_Cycle_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) | (globalprefs.ahigp_FastEcho ? 1 : 0),
 662           MUIA_Disabled, AHIBase->lib_Version >= 5,
 663         End,
 664         Child, MUITSurround = SpecialButton((STRPTR)msgGlobOptSurround),
 665         Child, MUISurround = CycleObject,
 666           MUIA_CycleChain, 1,
 667           MUIA_Cycle_Entries, SurroundLabels,
 668           MUIA_Cycle_Active, globalprefs.ahigp_DisableSurround,
 669           MUIA_Disabled, AHIBase->lib_Version >= 5,
 670         End,
 671         Child, MUITClipvol = SpecialButton((STRPTR)msgGlobOptMasterVol),
 672         Child, MUIClipvol = CycleObject,
 673           MUIA_CycleChain, 1,
 674           MUIA_Cycle_Entries, ClipMVLabels,
 675           MUIA_Cycle_Active, globalprefs.ahigp_ClipMasterVolume,
 676           MUIA_Disabled, AHIBase->lib_Version >= 5,
 677         End,
 678         Child, MUITCpu = SpecialButton((STRPTR)msgGlobOptCPULimit),
 679         Child, MUICpu = SliderObject,
 680           MUIA_CycleChain, 1,
 681           MUIA_Slider_Horiz, TRUE,
 682           MUIA_Numeric_Min, 0,
 683           MUIA_Numeric_Max, 100,
 684           MUIA_Numeric_Value,(globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
 685           MUIA_Numeric_Format,msgPercentFmt,
 686         End,
 687         Child, MUITACTime = SpecialButton((STRPTR)msgGlobOptACTime),
 688         Child, MUIACTime = SliderObject,
 689           MUIA_CycleChain, 1,
 690           MUIA_Slider_Horiz, TRUE,
 691           MUIA_Numeric_Min, 0,
 692           MUIA_Numeric_Max, 100,
 693           MUIA_Numeric_Value,(globalprefs.ahigp_AntiClickTime * 1000 + 32768) >> 16,
 694           MUIA_Numeric_Format,msgACTimeFmt,
 695           MUIA_Disabled, AHIBase->lib_Version <= 4,
 696         End,
 697         Child, MUITScalemode = SpecialButton((STRPTR)msgOptScalemode),
 698         Child, MUIScalemode = CycleObject,
 699           MUIA_CycleChain, 1,
 700           MUIA_Cycle_Entries, ScaleLabels,
 701           MUIA_Cycle_Active, globalprefs.ahigp_ScaleMode,
 702           MUIA_Disabled, AHIBase->lib_Version <= 4,
 703         End,
 704       End,
 705       Child, HVSpace,
 706     End,
 707     Child, HVSpace,
 708   End;
 709
 710   MUIApp = ApplicationObject,
 711     MUIA_Application_Title, (IPTR) msgTextProgramName,
 712     MUIA_Application_Version, Version,
 713     MUIA_Application_Copyright, (IPTR) "©1996-2005 Martin Blom",
 714     MUIA_Application_Author, (IPTR) "Stéphane Barbaray/Martin Blom",
 715     MUIA_Application_Description, (IPTR) msgTextProgramName,
 716     MUIA_Application_Base, (IPTR) "AHI",
 717     MUIA_Application_HelpFile, HELPFILE,
 718     MUIA_Application_Menustrip, MUIMenu = MUI_MakeObject(MUIO_MenustripNM,Menus,0),
 719     MUIA_Application_SingleTask, TRUE,
 720     SubWindow, MUIWindow = WindowObject,
 721       MUIA_Window_Title, (IPTR) msgTextProgramName,
 722       MUIA_Window_ID   , MAKE_ID('M','A','I','N'),
 723       MUIA_HelpNode, (IPTR) "AHI",
 724       WindowContents, VGroup,
 725        Child, RegisterGroup(PageNames),
 726          MUIA_CycleChain, 1,
 727          Child, page1,
 728          Child, page2,
 729        End,
 730        Child, HGroup,
 731           Child, MUISave = ImageButton(msgButtonSave, "THEME:Images/Gadgets/Save"),
 732           Child, MUIUse =  ImageButton(msgButtonUse,"THEME:Images/Gadgets/Use"),
 733           Child, MUICancel =  ImageButton(msgButtonCancel,"THEME:Images/Gadgets/Cancel"),
 734         End,
 735       End,
 736     End,
 737   End;
 738
 739   if( MUIApp != NULL )
 740   {
 741     APTR item = (APTR)DoMethod(MUIMenu,MUIM_FindUData,ACTID_ICONS);
 742     if(item)
 743     {
 744       set(item, MUIA_Menuitem_Checked, SaveIcons);
 745     }
 746     DoMethod(MUIWindow, MUIM_MultiSet, MUIA_Text_PreParse,"\033l",MUILFreq,MUILChannels,MUILOutvol,MUILMonvol,MUILGain,MUILInput,MUILOutput,NULL);
 747     DoMethod(MUIWindow, MUIM_MultiSet, MUIA_CycleChain, 1, MUISave,MUIUse,MUICancel,NULL);
 748
 749     DoMethod(MUITFreq, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIFreq);
 750     DoMethod(MUITChannels, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIChannels);
 751     DoMethod(MUITOutvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutvol);
 752     DoMethod(MUITMonvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIMonvol);
 753     DoMethod(MUITGain, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIGain);
 754     DoMethod(MUITInput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIInput);
 755     DoMethod(MUITOutput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutput);
 756     DoMethod(MUIPlay, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_PLAY);
 757     DoMethod(MUITDebug, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIDebug);
 758     DoMethod(MUITEcho, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIEcho);
 759     DoMethod(MUITSurround, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUISurround);
 760     DoMethod(MUITClipvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIClipvol);
 761     DoMethod(MUITCpu, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUICpu);
 762     DoMethod(MUITACTime, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIACTime);
 763     DoMethod(MUITScalemode, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIScalemode);
 764
 765     DoMethod(MUIWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 766     DoMethod(MUISave, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SAVE);
 767     DoMethod(MUIUse, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_USE);
 768     DoMethod(MUICancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 769     DoMethod(MUIUnit, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_UNIT);
 770     DoMethod(MUIList, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_MODE);
 771     DoMethod(MUIDebug, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_DEBUG);
 772     DoMethod(MUISurround, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_SURROUND);
 773     DoMethod(MUIEcho, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_ECHO);
 774     DoMethod(MUICpu, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_CPULIMIT);
 775     DoMethod(MUIClipvol, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_CLIPMV);
 776     DoMethod(MUIACTime, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_ACTIME);
 777     DoMethod(MUIScalemode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID,  ACTID_SCALEMODE);
 778     DoMethod(MUIFreq, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 779     DoMethod(MUIChannels, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 780     DoMethod(MUIOutvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 781     DoMethod(MUIMonvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 782     DoMethod(MUIGain, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 783     DoMethod(MUIInput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 784     DoMethod(MUIOutput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
 785     set(MUIWindow, MUIA_Window_Open, TRUE);
 786     GUINewUnit();
 787     return TRUE;
 788   }
 789   return FALSE;
 790 }
 791
 792 /******************************************************************************
 793 **** Call to close the window *************************************************
 794 ******************************************************************************/
 795
 796 void CloseGUI(void)
 797 {
 798   D(bug("[AHI:Prefs] %s()\n", __func__);)
 799
 800   if (MUIApp)
 801     MUI_DisposeObject(MUIApp);
 802   if (MUIMasterBase)
 803     CloseLibrary(MUIMasterBase);
 804 #ifdef __AMIGAOS4__
 805   DropInterface((struct Interface*) IMUIMaster);
 806 #endif
 807 }
 808
 809
 810 /******************************************************************************
 811 **** Handles the input events *************************************************
 812 ******************************************************************************/
 813
 814 void EventLoop(void)
 815 {
 816   ULONG sigs = 0UL;
 817
 818   D(bug("[AHI:Prefs] %s()\n", __func__);)
 819
 820   while (1)
 821   {
 822     IPTR rc = DoMethod(MUIApp, MUIM_Application_NewInput, &sigs);
 823
 824     switch(rc)
 825     {
 826       case MUIV_Application_ReturnID_Quit:
 827         return;
 828
 829       case ACTID_OPEN:
 830       {
 831         struct FileRequester *request;
 832
 833         request = MUI_AllocAslRequestTags(ASL_FileRequest,
 834             ASLFR_Window, xget(MUIWindow, MUIA_Window_Window),
 835             ASLFR_TitleText, msgTextProgramName,
 836             ASLFR_RejectIcons, TRUE,
 837             ASLFR_InitialDrawer, (IPTR)"SYS:Prefs/Presets",
 838             TAG_DONE );
 839
 840         if( request != NULL )
 841         {
 842           DoMethod(MUIApp, MUIA_Application_Sleep, TRUE);
 843           if (MUI_AslRequest(request, NULL))
 844           {
 845             char *file;
 846
 847             DoMethod(MUIApp, MUIA_Application_Sleep, FALSE);
 848
 849             file = AllocVec(strlen(request->fr_Drawer)+128,0);
 850
 851             if( file != NULL )
 852             {
 853               CopyMem(request->fr_Drawer, file, strlen(request->fr_Drawer)+1);
 854               AddPart(file, request->fr_File, 128);
 855               NewSettings(file);
 856               GUINewSettings();
 857               FreeVec(file);
 858             }
 859           }
 860           else
 861           {
 862             DoMethod(MUIApp, MUIA_Application_Sleep, FALSE);
 863           }
 864           MUI_FreeAslRequest(request);
 865         }
 866         break;
 867       }
 868
 869       case ACTID_SAVEAS:
 870       {
 871         struct FileRequester *request;
 872
 873         request = MUI_AllocAslRequestTags(ASL_FileRequest,
 874             ASLFR_Window, xget(MUIWindow, MUIA_Window_Window),
 875             ASLFR_TitleText, msgTextProgramName,
 876             ASLFR_RejectIcons, TRUE,
 877             ASLFR_DoSaveMode, TRUE,
 878             ASLFR_InitialDrawer, (IPTR)"SYS:Prefs/Presets",
 879             TAG_DONE);
 880
 881         if(request != NULL )
 882         {
 883           DoMethod(MUIApp, MUIA_Application_Sleep, TRUE);
 884           FillUnit();
 885           if (MUI_AslRequest(request, NULL))
 886           {
 887             char *file;
 888
 889             DoMethod(MUIApp, MUIA_Application_Sleep, FALSE);
 890
 891             file = AllocVec(strlen(request->fr_Drawer)+128,0);
 892
 893             if( file != NULL )
 894             {
 895               CopyMem(request->fr_Drawer, file, strlen(request->fr_Drawer)+1);
 896               AddPart(file, request->fr_File, 128);
 897               SaveSettings(file, UnitList);
 898               if(SaveIcons)
 899               {
 900                 WriteIcon(file);
 901               }
 902               FreeVec(file);
 903             }
 904           }
 905           else
 906           {
 907             DoMethod(MUIApp, MUIA_Application_Sleep, FALSE);
 908           }
 909           MUI_FreeAslRequest(request);
 910         }
 911         break;
 912       }
 913
 914       case ACTID_ABOUT:
 915       {
 916         char* args[] = { "\033c",
 917                          (char*)msgTextProgramName,
 918                          "1996-2005 Stéphane Barbaray/Martin Blom"
 919                        };
 920
 921         MUI_RequestA(MUIApp, MUIWindow, 0, (char *) msgTextProgramName,
 922             (char*)msgButtonOK, (char*)msgTextCopyright, args );
 923         break;
 924       }
 925
 926       case ACTID_SAVE:
 927         FillUnit();
 928         SaveSettings(ENVFILE, UnitList);
 929         SaveSettings(ENVARCFILE, UnitList);
 930         return;
 931
 932       case ACTID_USE:
 933         FillUnit();
 934         SaveSettings(ENVFILE, UnitList);
 935         return;
 936
 937       case ACTID_QUIT:
 938         return;
 939
 940       case ACTID_DEFAULT:
 941         NewSettings(NULL);
 942         GUINewSettings();
 943         break;
 944
 945       case ACTID_LASTSAVED:
 946         NewSettings(ENVARCFILE);
 947         GUINewSettings();
 948         break;
 949
 950       case ACTID_RESTORE:
 951         NewSettings(args.from);
 952         GUINewSettings();
 953         break;
 954
 955       case ACTID_ICONS:
 956       {
 957         APTR item = (APTR)DoMethod(MUIMenu,MUIM_FindUData,ACTID_ICONS);
 958
 959         if(item)
 960         {
 961           if(xget(item, MUIA_Menuitem_Checked))
 962           {
 963             SaveIcons = TRUE;
 964           }
 965           else
 966           {
 967             SaveIcons = FALSE;
 968           }
 969         }
 970         break;
 971       }
 972
 973       case ACTID_HELP:
 974         DoMethod(MUIApp,MUIM_Application_ShowHelp,NULL,NULL,"AHI",0);
 975         break;
 976
 977       case ACTID_GUIDE:
 978         DoMethod(MUIApp,MUIM_Application_ShowHelp,NULL,NULL,"MAIN",0);
 979         break;
 980
 981       case ACTID_HELPINDEX:
 982         DoMethod(MUIApp,MUIM_Application_ShowHelp,NULL,NULL,"Concept Index",0);
 983         break;
 984
 985       case ACTID_UNIT:
 986         FillUnit();
 987         NewUnit(xget(MUIUnit,MUIA_Cycle_Active));
 988         GUINewUnit();
 989         break;
 990
 991       case ACTID_MODE:
 992         FillUnit();
 993         NewMode(xget(MUIList, MUIA_List_Active));
 994         GUINewMode();
 995         break;
 996
 997       case ACTID_PLAY:
 998       {
 999         int              unit_id;
1000         struct UnitNode* unit;
1001
1002         FillUnit();
1003         unit_id = xget( MUIUnit, MUIA_Cycle_Active );
1004         unit    = (struct UnitNode *) GetNode( unit_id, UnitList );
1005
1006         PlaySound( &unit->prefs );
1007         break;
1008       }
1009
1010       case ACTID_DEBUG:
1011       case ACTID_SURROUND:
1012       case ACTID_ECHO:
1013       case ACTID_CPULIMIT:
1014       case ACTID_CLIPMV:
1015       case ACTID_ACTIME:
1016       case ACTID_SCALEMODE:
1017       {
1018         IPTR debug = AHI_DEBUG_NONE, surround = FALSE, echo = 0, cpu = 90;
1019         IPTR clip = FALSE, actime = 0, scalemode = AHI_SCALE_FIXED_0_DB;
1020
1021         get(MUIDebug, MUIA_Cycle_Active, &debug);
1022         get(MUISurround, MUIA_Cycle_Active, &surround);
1023         get(MUIEcho, MUIA_Cycle_Active, &echo);
1024         get(MUIClipvol, MUIA_Cycle_Active, &clip);
1025         get(MUICpu, MUIA_Numeric_Value, &cpu);
1026         get(MUIACTime, MUIA_Numeric_Value, &actime);
1027         get(MUIScalemode, MUIA_Cycle_Active, &scalemode);
1028
1029         globalprefs.ahigp_DebugLevel       = debug;
1030         globalprefs.ahigp_DisableSurround  = surround;
1031         globalprefs.ahigp_DisableEcho      = (echo == 2);
1032         globalprefs.ahigp_FastEcho         = (echo == 1);
1033         globalprefs.ahigp_MaxCPU           = ((cpu << 16) + 50) / 100;
1034         globalprefs.ahigp_ClipMasterVolume = clip;
1035         globalprefs.ahigp_AntiClickTime    = ((actime << 16) + 500) / 1000;
1036         globalprefs.ahigp_ScaleMode        = scalemode;
1037
1038         break;
1039       }
1040     }
1041
1042     if (sigs)
1043     {
1044       sigs = Wait(sigs | SIGBREAKF_CTRL_C);
1045       if (sigs & SIGBREAKF_CTRL_C)
1046         return;
1047     }
1048   }
1049 }
1050