home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / audio / MultiPlayer132sr.lha / prefswin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-14  |  9.5 KB  |  431 lines
  1. /*
  2.  * MultiPlayer
  3.  * Copyright (C) 1992 Bryan Ford
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  * I (the author of MultiPlayer) can be contacted on the Internet at
  20.  * "bryan.ford@m.cc.utah.edu".  See "Player.doc" for other addresses.
  21.  *
  22.  * $Id: prefswin.c,v 5.1 92/09/14 18:39:04 BAF Exp $
  23.  *
  24.  * $Log:    prefswin.c,v $
  25.  * Revision 5.1  92/09/14  18:39:04  BAF
  26.  * Added nasty audio gadget support
  27.  * 
  28.  * Revision 4.5  92/07/21  19:18:35  BAF
  29.  * Updated progsave() calling convention
  30.  *
  31.  * Revision 4.4  92/07/19  18:08:05  BAF
  32.  * Adjustment for putting localdata back into RemindNodes
  33.  *
  34.  * Revision 4.3  92/07/12  08:25:56  BAF
  35.  * end() waits with an EasyRequester as necessary until font requester comes down
  36.  *
  37.  * Revision 4.2  92/06/21  11:13:07  BAF
  38.  * Migrated regargs to stdargs
  39.  *
  40.  * Revision 4.1  92/06/06  19:56:10  BAF
  41.  * Major_code_cleanup
  42.  *
  43.  * Revision 3.1  92/05/25  07:53:08  BAF
  44.  * GNU-ized.
  45.  *
  46.  *
  47.  */
  48.  
  49. /* System includes */
  50. #include <exec/types.h>
  51. #include <dos/dos.h>
  52. #include <intuition/intuition.h>
  53. #include <libraries/asl.h>
  54. #include <proto/exec.h>
  55. #include <proto/dos.h>
  56. #include <proto/intuition.h>
  57. #include <string.h>
  58.  
  59. #include "bry/macros.h"
  60. #include "bry/remind.h"
  61. #include "bry/misc.h"
  62. #include "bry/guido.h"
  63.  
  64. #include "player.h"
  65.  
  66. extern GuidoSpec prefswinspec, prefswinfontspec;
  67. extern short prefswinleft;
  68.  
  69. struct Gadget
  70.   *prefswinmainfontgad, *prefswinmainfontsizegad,
  71.   *prefswinlistfontgad, *prefswinlistfontsizegad,
  72.   *prefswinshowgad, *prefswinplaygad,
  73.   *prefswinspectrumgad, *prefswinscopegad,
  74.   *prefswinqscopegad, *prefswinnotegad,
  75.   *prefswinpausefadegad,
  76.   *prefswinkeepgad, *prefswinnastygad,
  77.   *prefswinicongad, *prefswiniconagad,
  78.   *prefswincontgad, *prefswinhotkeygad;
  79.  
  80. void prefswinupdate(void);
  81. static long check(long sigmask);
  82. static long close(int remake);
  83.  
  84. static struct MPWin mpwin = {prefswinspec,&prefswinleft,prefswinupdate,
  85.   {0},{{0},check},{{0},close}};
  86.  
  87. void *fontreq;
  88. char whichfont;
  89.  
  90. static long
  91. check(long sigmask)
  92. {
  93.   if((sigmask & mpwin.sigmask) && GCheckPanel(mpwin.win,standardcallback,0L))
  94.     setfinmpwin(&mpwin);
  95.   return(0);
  96. }
  97.  
  98. static long
  99. close(int remake)
  100. {
  101.   closempwin(&mpwin);
  102.   if(remake)
  103.     showerr(openmpwin(&mpwin));
  104.   return(0);
  105. }
  106.  
  107. static void
  108. fontprefsupdate(void)
  109. {
  110. extern char mainfontname[], listfontname[];
  111. extern short mainfontsize, listfontsize;
  112. struct Window *win;
  113.  
  114.   if(win = mpwin.win)
  115.     {
  116.       GSetText(win,prefswinmainfontgad,mainfontname);
  117.       GSetNumber(win,prefswinmainfontsizegad,mainfontsize);
  118.       GSetText(win,prefswinlistfontgad,listfontname);
  119.       GSetNumber(win,prefswinlistfontsizegad,listfontsize);
  120.     }
  121. }
  122.  
  123. void
  124. prefswinupdate(void)
  125. {
  126.   extern char pausefade, keepprog, nasty_audio, appicon, appicona, contprogonerr, stopfade, hotkey[];
  127.   extern struct Library *CxBase;
  128.   struct Window *win;
  129.  
  130.   if(win = mpwin.win)
  131.     {
  132.       GSetCycleActive(win,prefswinplaygad,playmode);
  133.       GSetCycleActive(win,prefswinshowgad,showmode);
  134.       GSetCheckboxChecked(win,prefswinspectrumgad,flashflags & FF_SPECTRUM);
  135.       GSetCheckboxChecked(win,prefswinscopegad,flashflags & FF_SCOPE);
  136.       GSetCheckboxChecked(win,prefswinqscopegad,flashflags & FF_QSCOPE);
  137.       GSetCheckboxChecked(win,prefswinnotegad,flashflags & FF_NOTES);
  138.       GSetCheckboxChecked(win,prefswinpausefadegad,pausefade);
  139.       GSetCheckboxChecked(win,prefswinkeepgad,keepprog);
  140.       GSetCheckboxChecked(win,prefswinnastygad,nasty_audio);
  141.       GSetCheckboxChecked(win,prefswinicongad,appicon);
  142.       GSetCheckboxChecked(win,prefswiniconagad,appicona);
  143.       GSetCheckboxChecked(win,prefswincontgad,contprogonerr);
  144.       GEnDisGadget(win,CxBase,prefswinhotkeygad);
  145.       GSetString(win,prefswinhotkeygad,hotkey);
  146.       fontprefsupdate();
  147.     }
  148. }
  149.  
  150. static void
  151. prefschanged(void)
  152. {
  153.   extern char hotkey[], prefsglob[];
  154.  
  155.   if(mpwin.win)
  156.     strcpy(hotkey,GGetString(prefswinhotkeygad));
  157.   GlobPostMod(prefsglob,prefswinupdate);
  158.   sysflags |= SF_WINDOWUP;
  159. }
  160.  
  161. void
  162. gui_prefswinplay(struct GuidoMessage *im)
  163. {
  164.   playmode = im->Code;
  165.   prefschanged();
  166. }
  167.  
  168. void
  169. gui_prefswinshow(struct GuidoMessage *im)
  170. {
  171.   showmode = im->Code;
  172.   prefschanged();
  173. }
  174.  
  175. static void
  176. setflash(struct Gadget *gad,char flagbit)
  177. {
  178.   extern char *flashywinopenclose(void);
  179.  
  180.   if(GGetCheckboxChecked(gad))
  181.     flashflags |= flagbit;
  182.   else
  183.     flashflags &= ~flagbit;
  184.   flashywinopenclose();
  185.   prefschanged();
  186. }
  187.  
  188. void
  189. gui_prefswinspectrogram(struct GuidoMessage *im)
  190. {
  191.   setflash(prefswinspectrumgad,FF_SPECTRUM);
  192. }
  193.  
  194. void
  195. gui_prefswinscope(struct GuidoMessage *im)
  196. {
  197.   setflash(prefswinscopegad,FF_SCOPE);
  198. }
  199.  
  200. void
  201. gui_prefswinqscope(struct GuidoMessage *im)
  202. {
  203.   setflash(prefswinqscopegad,FF_QSCOPE);
  204. }
  205.  
  206. void
  207. gui_prefswinnote(struct GuidoMessage *im)
  208. {
  209.   setflash(prefswinnotegad,FF_NOTES);
  210. }
  211.  
  212. void
  213. gui_prefswinpausefade(struct GuidoMessage *gm)
  214. {
  215.   extern char pausefade;
  216.  
  217.   pausefade = GGetCheckboxChecked(prefswinpausefadegad);
  218.   prefschanged();
  219. }
  220.  
  221. void
  222. gui_prefswinkeep(struct GuidoMessage *gm)
  223. {
  224.   extern char keepprog;
  225.  
  226.   keepprog = GGetCheckboxChecked(prefswinkeepgad);
  227.   prefschanged();
  228. }
  229.  
  230. void
  231. gui_prefswinnasty(struct GuidoMessage *gm)
  232. {
  233.   extern char nasty_audio;
  234.  
  235.   nasty_audio = GGetCheckboxChecked(prefswinnastygad);
  236.   prefschanged();
  237. }
  238.  
  239. void
  240. gui_prefswinicon(struct GuidoMessage *gm)
  241. {
  242.   extern char appicon;
  243.  
  244.   appicon = GGetCheckboxChecked(prefswinicongad);
  245.   prefschanged();
  246. }
  247.  
  248. void
  249. gui_prefswinicona(struct GuidoMessage *gm)
  250. {
  251.   extern char appicona;
  252.  
  253.   appicona = GGetCheckboxChecked(prefswiniconagad);
  254.   prefschanged();
  255. }
  256.  
  257. void
  258. gui_prefswincont(struct GuidoMessage *gm)
  259. {
  260.   extern char contprogonerr;
  261.  
  262.   contprogonerr = GGetCheckboxChecked(prefswincontgad);
  263.   prefschanged();
  264. }
  265.  
  266. void
  267. gui_prefswinhotkey(struct GuidoMessage *gm)
  268. {
  269.   prefschanged();
  270. }
  271.  
  272. /* Check to see if the font requester has been closed */
  273. static long
  274. fontcheck(void)
  275. {
  276.   struct TextAttr *attr;
  277.   long count;
  278.  
  279.   if(fontreq && ((count = GCheckRequester(fontreq,&attr)) >= 0))
  280.     {
  281.     extern char mainfontname[], listfontname[];
  282.     extern short fontreqleft, mainfontsize, listfontsize;
  283.  
  284.       GGetRequesterLocation(fontreq,&fontreqleft);
  285.       if(count)
  286.         {
  287.           if(whichfont == 0)
  288.             {
  289.               mainfontsize = attr->ta_YSize;
  290.               strncpy(mainfontname,attr->ta_Name,30);
  291.             }
  292.           else
  293.             {
  294.               listfontsize = attr->ta_YSize;
  295.               strncpy(listfontname,attr->ta_Name,30);
  296.             }
  297.           fontprefsupdate();
  298.           prefschanged();
  299.         }
  300.     }
  301.   return(0);
  302. }
  303.  
  304. static struct RemindNode fontchecknode = {{0},fontcheck};
  305.  
  306. static long
  307. fontend(void)
  308. {
  309.   if(fontreq)
  310.     {
  311.       while(GDeleteRequester(fontreq))
  312.         {
  313.           static struct EasyStruct easy = {
  314.             sizeof(easy),0,"MultiPlayer","Please close all file and font requesters","OK"};
  315.  
  316.           EasyRequestArgs(0,&easy,0,0);
  317.         }
  318.       fontreq = 0L;
  319.     }
  320.   remind_rem(&fontchecknode);
  321.   return(0);
  322. }
  323.  
  324. static struct RemindNode fontendnode = {{0},fontend,-100};
  325.  
  326. static void
  327. addfontcalls(void)
  328. {
  329.   addcalls(&fontchecknode,0,0,&fontendnode);
  330. }
  331.  
  332. static void
  333. openfontreq(int which,char *hailtext,char *font,int size)
  334. {
  335.   struct {
  336.     struct Window *win;
  337.     char *hailtext;
  338.     int fixedwidth;
  339.     char *font;
  340.     int size;
  341.     } parms;
  342.   int rc;
  343.  
  344.   parms.fixedwidth = whichfont = which;
  345.   parms.hailtext = hailtext;
  346.   parms.font = font;
  347.   parms.size = size;
  348.   parms.win = mpwin.win;
  349.   if(!fontreq && !(fontreq = GCreateRequester(prefswinfontspec)))
  350.     showerr("Font requester unavailable");
  351.   else
  352.     {
  353.       if((rc = GOpenRequester(fontreq,prefswinfontspec,&parms)) == 0)
  354.         showerr("Font requester in use");
  355.       else if(rc < 0)
  356.         showerr("Not enough memory");
  357.       addfontcalls();
  358.     }
  359. }
  360.  
  361. void gui_prefswinmainfont(struct GuidoMessage *gm)
  362. {
  363.   extern char mainfontname[], listfontname[];
  364.   extern short mainfontsize, listfontsize;
  365.  
  366.   openfontreq(0,"Select font for control panels",mainfontname,mainfontsize);
  367. }
  368.  
  369. void gui_prefswinlistfont(struct GuidoMessage *gm)
  370. {
  371.   extern char mainfontname[], listfontname[];
  372.   extern short mainfontsize, listfontsize;
  373.  
  374.   openfontreq(1,"Select font for listings",listfontname,listfontsize);
  375. }
  376.  
  377. static char *
  378. save(char *filename)
  379. {
  380.   BPTR han;
  381.   char *err = "Error saving preferences";
  382.   extern char prefs[], prefsend[];
  383.  
  384.   remind_call(&snaplist,0L);
  385.  
  386.   if(!(han = Open(filename,MODE_NEWFILE)))
  387.     goto err1;
  388.   if(Write(han,prefs,(long)(prefsend-prefs)) <= 0)
  389.     goto err2;
  390.   err = 0L;
  391.   err2:
  392.   Close(han);
  393.   err1:
  394.   return(err);
  395. }
  396.  
  397. void
  398. gui_prefswinsave(void)
  399. {
  400.   extern char keepprog;
  401.  
  402.   if(!showerr(save("ENV:MultiPlayerPrefs")) &&
  403.     !showerr(save("ENVARC:MultiPlayerPrefs")) &&
  404.     (!keepprog || (!showerr(progsave(0,"ENV:MultiPlayerProgram")) &&
  405.       !showerr(progsave(0,"ENVARC:MultiPlayerProgram")))))
  406.     showerr("Preferences saved");
  407. }
  408.  
  409. void
  410. gui_prefswinok(void)
  411. {
  412.   setfinmpwin(&mpwin);
  413. }
  414.  
  415. char *
  416. prefswinopenclose(void)
  417. {
  418.   if(mpwin.win)
  419.     {
  420.       setfinmpwin(&mpwin);
  421.       return(0L);
  422.     }
  423.   return(openmpwin(&mpwin));
  424. }
  425.  
  426. void
  427. gui_prefswinopenclose(void)
  428. {
  429.   showerr(prefswinopenclose());
  430. }
  431.