home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 1 / Amiga Tools.iso / wb-tools / toolmanager / source / prefs / soundwindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-06  |  11.1 KB  |  407 lines
  1. /*
  2.  * soundwindow.c  V2.1
  3.  *
  4.  * sound edit window handling
  5.  *
  6.  * (c) 1990-1993 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerConf.h"
  10.  
  11. /* Sound node */
  12. struct SoundNode {
  13.                   struct Node  sn_Node;
  14.                   char        *sn_Command;
  15.                   char        *sn_Port;
  16.                  };
  17.  
  18. /* Window data */
  19. static struct Gadget *gl;             /* Gadget list */
  20. static struct Window *w;              /* Window */
  21. static struct MsgPort *wp;            /* Window user port */
  22. static UWORD ww,wh;                   /* Window size */
  23. static struct SoundNode *CurrentNode;
  24.  
  25. /* Gadget data */
  26. #define GAD_NAME_STR  0
  27. #define GAD_COMM_STR  1
  28. #define GAD_AREXX_STR 2
  29. #define GAD_OK        3
  30. #define GAD_CANCEL    4
  31. #define GADGETS       5
  32. static struct GadgetData gdata[GADGETS];
  33.  
  34. /* Gadget tags */
  35. static struct TagItem nametags[]={GTST_String,   NULL,
  36.                                   GTST_MaxChars, SGBUFLEN,
  37.                                   TAG_DONE};
  38.  
  39. static struct TagItem commtags[]={GTST_String,   NULL,
  40.                                   GTST_MaxChars, SGBUFLEN,
  41.                                   TAG_DONE};
  42.  
  43. static struct TagItem arexxtags[]={GTST_String,   NULL,
  44.                                    GTST_MaxChars, SGBUFLEN,
  45.                                    TAG_DONE};
  46.  
  47. /* Gadget vanilla key data */
  48. #define KEY_NAME   0
  49. #define KEY_COMM   1
  50. #define KEY_AREXX  2
  51. #define KEY_OK     3
  52. #define KEY_CANCEL 4
  53. static char KeyArray[KEY_CANCEL+1];
  54.  
  55. /* Init sound edit window */
  56. void InitSoundEditWindow(UWORD left, UWORD fheight)
  57. {
  58.  ULONG tmp,tmp2,maxw1,maxw2;
  59.  ULONG strheight=fheight+2;
  60.  struct GadgetData *gd;
  61.  
  62.  /* Init strings */
  63.  gdata[GAD_NAME_STR].name =AppStrings[MSG_WINDOW_NAME_GAD];
  64.  gdata[GAD_COMM_STR].name =AppStrings[MSG_WINDOW_COMMAND_GAD];
  65.  gdata[GAD_AREXX_STR].name=AppStrings[MSG_SOUNDWIN_AREXX_GAD];
  66.  gdata[GAD_OK].name       =AppStrings[MSG_WINDOW_OK_GAD];
  67.  gdata[GAD_CANCEL].name   =AppStrings[MSG_WINDOW_CANCEL_GAD];
  68.  
  69.  /* Calculate maximum label width for string gadgets */
  70.  gd=gdata;
  71.  maxw1=0;
  72.  for (tmp=GAD_NAME_STR; tmp<=GAD_AREXX_STR; tmp++, gd++)
  73.   if ((tmp2=TextLength(&TmpRastPort,gd->name,strlen(gd->name))) > maxw1)
  74.    maxw1=tmp2;
  75.  maxw1+=INTERWIDTH;
  76.  
  77.  /* Calculate minimal string gadgets width */
  78.  ww=TextLength(&TmpRastPort,AppStrings[MSG_SOUNDWIN_NEWNAME],
  79.                strlen(AppStrings[MSG_SOUNDWIN_NEWNAME]))+
  80.     maxw1+3*INTERWIDTH;
  81.  
  82.  /* Calculate button gadgets width */
  83.  maxw2=TextLength(&TmpRastPort,gd->name,strlen(gd->name));
  84.  gd++;
  85.  if ((tmp=TextLength(&TmpRastPort,gd->name,strlen(gd->name))) > maxw2)
  86.   maxw2=tmp;
  87.  maxw2+=2*INTERWIDTH;
  88.  if ((tmp=2*(maxw2+INTERWIDTH)) > ww) ww=tmp;
  89.  
  90.  /* window height */
  91.  wh=4*fheight+5*INTERHEIGHT+6;
  92.  
  93.  /* Init gadgets */
  94.  gd=gdata;
  95.  tmp=WindowTop+INTERHEIGHT;
  96.  tmp2=ww-maxw1-INTERWIDTH;
  97.  maxw1+=left;
  98.  
  99.  /* Name string gadget */
  100.  gd->type=STRING_KIND;
  101.  gd->flags=PLACETEXT_LEFT;
  102.  gd->tags=nametags;
  103.  gd->left=maxw1;
  104.  gd->top=tmp;
  105.  gd->width=tmp2;
  106.  gd->height=strheight;
  107.  tmp+=strheight+INTERHEIGHT;
  108.  
  109.  /* File name string gadget */
  110.  gd++;
  111.  gd->type=STRING_KIND;
  112.  gd->flags=PLACETEXT_LEFT;
  113.  gd->tags=commtags;
  114.  gd->left=maxw1;
  115.  gd->top=tmp;
  116.  gd->width=tmp2;
  117.  gd->height=strheight;
  118.  tmp+=strheight+INTERHEIGHT;
  119.  
  120.  /* ARexx port gadget */
  121.  gd++;
  122.  gd->type=STRING_KIND;
  123.  gd->flags=PLACETEXT_LEFT;
  124.  gd->tags=arexxtags;
  125.  gd->left=maxw1;
  126.  gd->top=tmp;
  127.  gd->width=tmp2;
  128.  gd->height=strheight;
  129.  tmp+=strheight+INTERHEIGHT;
  130.  
  131.  /* OK button gadget */
  132.  gd++;
  133.  gd->type=BUTTON_KIND;
  134.  gd->flags=PLACETEXT_IN;
  135.  gd->left=left;
  136.  gd->top=tmp;
  137.  gd->width=maxw2;
  138.  gd->height=fheight;
  139.  
  140.  /* Cancel button gadget */
  141.  gd++;
  142.  gd->type=BUTTON_KIND;
  143.  gd->flags=PLACETEXT_IN;
  144.  gd->left=ww-maxw2-INTERWIDTH+left;
  145.  gd->top=tmp;
  146.  gd->width=maxw2;
  147.  gd->height=fheight;
  148.  
  149.  /* Init vanilla key array */
  150.  KeyArray[KEY_NAME]  =FindVanillaKey(gdata[GAD_NAME_STR].name);
  151.  KeyArray[KEY_COMM]  =FindVanillaKey(gdata[GAD_COMM_STR].name);
  152.  KeyArray[KEY_AREXX] =FindVanillaKey(gdata[GAD_AREXX_STR].name);
  153.  KeyArray[KEY_OK]    =FindVanillaKey(gdata[GAD_OK].name);
  154.  KeyArray[KEY_CANCEL]=FindVanillaKey(gdata[GAD_CANCEL].name);
  155. }
  156.  
  157. /* Free sound node */
  158. void FreeSoundNode(struct Node *node)
  159. {
  160.  struct SoundNode *sn=(struct SoundNode *) node;
  161.  char *s;
  162.  
  163.  if (s=sn->sn_Node.ln_Name) free(s);
  164.  if (s=sn->sn_Command) free(s);
  165.  if (s=sn->sn_Port) free(s);
  166.  
  167.  /* Free node */
  168.  FreeMem(sn,sizeof(struct SoundNode));
  169. }
  170.  
  171. /* Copy sound node */
  172. struct Node *CopySoundNode(struct Node *node)
  173. {
  174.  struct SoundNode *sn,*orignode=(struct SoundNode *) node;
  175.  
  176.  /* Alloc memory for sound node */
  177.  if (sn=AllocMem(sizeof(struct SoundNode),MEMF_CLEAR)) {
  178.  
  179.   /* Got an old node? */
  180.   if (orignode) {
  181.    /* Yes, copy it */
  182.    if ((!orignode->sn_Node.ln_Name || (sn->sn_Node.ln_Name=
  183.                                         strdup(orignode->sn_Node.ln_Name))) &&
  184.        (!orignode->sn_Command || (sn->sn_Command=
  185.                                    strdup(orignode->sn_Command))) &&
  186.        (!orignode->sn_Port || (sn->sn_Port=strdup(orignode->sn_Port))))
  187.     return(sn);
  188.   } else
  189.    /* No, set defaults */
  190.    if (sn->sn_Node.ln_Name=strdup(AppStrings[MSG_SOUNDWIN_NEWNAME]))
  191.     /* Return pointer to new node */
  192.     return(sn);
  193.  
  194.   FreeSoundNode((struct Node *) sn);
  195.  }
  196.  /* Call failed */
  197.  return(NULL);
  198. }
  199.  
  200. /* Activate gadget and save pointer to it */
  201. static void MyActivateGadget(ULONG num)
  202. {
  203.  ActivateGadget(gdata[num].gadget,w,NULL);
  204. }
  205.  
  206. /* Open sound edit window */
  207. BOOL OpenSoundEditWindow(struct Node *node, struct Window *parent)
  208. {
  209.  /* Copy node */
  210.  if (CurrentNode=(struct SoundNode *) CopySoundNode(node)) {
  211.   /* Set tags */
  212.   nametags[0].ti_Data=(ULONG) CurrentNode->sn_Node.ln_Name;
  213.   commtags[0].ti_Data=(ULONG) CurrentNode->sn_Command;
  214.   arexxtags[0].ti_Data=(ULONG) CurrentNode->sn_Port;
  215.  
  216.   /* Create gadgets */
  217.   if (gl=CreateGadgetList(gdata,GADGETS)) {
  218.    /* Open window */
  219.    if (w=OpenWindowTags(NULL,WA_Left,        parent->LeftEdge,
  220.                              WA_Top,         parent->TopEdge+WindowTop,
  221.                              WA_InnerWidth,  ww,
  222.                              WA_InnerHeight, wh,
  223.                              WA_AutoAdjust,  TRUE,
  224.                              WA_Title,       AppStrings[MSG_SOUNDWIN_TITLE],
  225.                              WA_PubScreen,   PublicScreen,
  226.                              WA_Flags,       WFLG_CLOSEGADGET|WFLG_DRAGBAR|
  227.                                              WFLG_DEPTHGADGET|WFLG_RMBTRAP|
  228.                                              WFLG_ACTIVATE,
  229.                              TAG_DONE)) {
  230.     /* Add gadgets to window */
  231.     AddGList(w,gl,(UWORD) -1,(UWORD) -1,NULL);
  232.     RefreshGList(gl,w,NULL,(UWORD) -1);
  233.     GT_RefreshWindow(w,NULL);
  234.  
  235.     /* Activate first gadget */
  236.     MyActivateGadget(GAD_NAME_STR);
  237.  
  238.     /* Set local variables */
  239.     w->UserPort=IDCMPPort;
  240.     w->UserData=(BYTE *) HandleSoundEditWindowIDCMP;
  241.     ModifyIDCMP(w,IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW|BUTTONIDCMP|
  242.                   STRINGIDCMP|IDCMP_VANILLAKEY);
  243.     CurrentWindow=w;
  244.  
  245.     /* Set up file requester parameters */
  246.     FileReqParms.frp_Window=w;
  247.     FileReqParms.frp_Title=AppStrings[MSG_FILEREQ_TITLE_FILE];
  248.     FileReqParms.frp_OKText=AppStrings[MSG_FILEREQ_OK_GAD];
  249.     FileReqParms.frp_Flags1=FRF_DOPATTERNS;
  250.     FileReqParms.frp_Flags2=0;
  251.  
  252.     /* All OK. */
  253.     return(TRUE);
  254.    }
  255.    FreeGadgets(gl);
  256.   }
  257.   FreeSoundNode((struct Node *) CurrentNode);
  258.  }
  259.  /* Call failed */
  260.  return(FALSE);
  261. }
  262.  
  263. /* Close sound edit window */
  264. static void CloseSoundEditWindow(void)
  265. {
  266.  /* Free resources */
  267.  RemoveGList(w,gl,(UWORD) -1);
  268.  CloseWindowSafely(w);
  269.  FreeGadgets(gl);
  270. }
  271.  
  272. /* OK gadget function */
  273. static struct Node *OKGadgetFunc(void)
  274. {
  275.  struct Node *rc;
  276.  char *s;
  277.  
  278.  /* Free old strings */
  279.  if (s=CurrentNode->sn_Node.ln_Name) free(s);
  280.  CurrentNode->sn_Node.ln_Name=NULL;
  281.  if (s=CurrentNode->sn_Command) free(s);
  282.  CurrentNode->sn_Command=NULL;
  283.  if (s=CurrentNode->sn_Port) free(s);
  284.  CurrentNode->sn_Port=NULL;
  285.  
  286.  /* Duplicate new strings */
  287.  if (((CurrentNode->sn_Node.ln_Name=
  288.         DuplicateBuffer(gdata[GAD_NAME_STR].gadget)) != (char *) -1) &&
  289.      ((CurrentNode->sn_Command=
  290.         DuplicateBuffer(gdata[GAD_COMM_STR].gadget)) != (char *) -1) &&
  291.      ((CurrentNode->sn_Port=
  292.         DuplicateBuffer(gdata[GAD_AREXX_STR].gadget)) != (char *) -1))
  293.   rc=(struct Node *) CurrentNode;
  294.  else {
  295.   /* Couldn't copy strings */
  296.   rc=(struct Node *) -1;
  297.   FreeSoundNode((struct Node *) CurrentNode);
  298.  }
  299.  return(rc);
  300. }
  301.  
  302. /* Handle sound edit window IDCMP events */
  303. void *HandleSoundEditWindowIDCMP(struct IntuiMessage *msg)
  304. {
  305.  struct Node *NewNode=NULL;
  306.  
  307.  /* Which IDCMP class? */
  308.  switch (msg->Class) {
  309.   case IDCMP_CLOSEWINDOW:   NewNode=(struct Node *) -1;
  310.                             FreeSoundNode((struct Node *) CurrentNode);
  311.                             break;
  312.   case IDCMP_REFRESHWINDOW: GT_BeginRefresh(w);
  313.                             GT_EndRefresh(w,TRUE);
  314.                             break;
  315.   case IDCMP_GADGETUP:
  316.    switch (((struct Gadget *) msg->IAddress)->GadgetID) {
  317.     case GAD_OK:     NewNode=OKGadgetFunc();
  318.                      break;
  319.     case GAD_CANCEL: NewNode=(struct Node *) -1;
  320.                      FreeSoundNode((struct Node *) CurrentNode);
  321.                      break;
  322.    }
  323.    break;
  324.   case IDCMP_VANILLAKEY:
  325.    switch (MatchVanillaKey(msg->Code,KeyArray)) {
  326.     case KEY_NAME:   MyActivateGadget(GAD_NAME_STR);
  327.                      break;
  328.     case KEY_COMM:   MyActivateGadget(GAD_COMM_STR);
  329.                      break;
  330.     case KEY_AREXX:  MyActivateGadget(GAD_AREXX_STR);
  331.                      break;
  332.     case KEY_OK:     NewNode=OKGadgetFunc();
  333.                      break;
  334.     case KEY_CANCEL: NewNode=(struct Node *) -1;
  335.                      FreeSoundNode((struct Node *) CurrentNode);
  336.                      break;
  337.    }
  338.    break;
  339.  }
  340.  
  341.  /* Close window? */
  342.  if (NewNode) {
  343.   /* Yes. But first reply message!!! */
  344.   GT_ReplyIMsg(msg);
  345.   CloseSoundEditWindow();
  346.  }
  347.  
  348.  return(NewNode);
  349. }
  350.  
  351. /* Read TMSO IFF chunk into Sound node */
  352. struct Node *ReadSoundNode(UBYTE *buf)
  353. {
  354.  struct SoundNode *sn;
  355.  
  356.  /* Allocate memory for node */
  357.  if (sn=AllocMem(sizeof(struct SoundNode),MEMF_PUBLIC|MEMF_CLEAR)) {
  358.   struct SoundPrefsObject *spo=(struct SoundPrefsObject *) buf;
  359.   ULONG sbits=spo->spo_StringBits;
  360.   UBYTE *ptr=(UBYTE *) &spo[1];
  361.  
  362.   if ((!(sbits & SOPO_NAME) || (sn->sn_Node.ln_Name=GetConfigStr(&ptr))) &&
  363.       (!(sbits & SOPO_COMMAND) || (sn->sn_Command=GetConfigStr(&ptr))) &&
  364.       (!(sbits & SOPO_PORT) || (sn->sn_Port=GetConfigStr(&ptr))))
  365.    /* All OK. */
  366.    return(sn);
  367.  
  368.   /* Call failed */
  369.   FreeSoundNode((struct Node *) sn);
  370.  }
  371.  return(NULL);
  372. }
  373.  
  374. /* Write Sound node to TMSO IFF chunk */
  375. BOOL WriteSoundNode(struct IFFHandle *iff, UBYTE *buf, struct Node *node)
  376. {
  377.  struct SoundNode *sn=(struct SoundNode *) node;
  378.  struct SoundPrefsObject *spo=(struct SoundPrefsObject *) buf;
  379.  ULONG sbits=0;
  380.  UBYTE *ptr=(UBYTE *) &spo[1];
  381.  
  382.  /* Copy strings */
  383.  if (PutConfigStr(sn->sn_Node.ln_Name,&ptr)) sbits|=SOPO_NAME;
  384.  if (PutConfigStr(sn->sn_Command,&ptr)) sbits|=SOPO_COMMAND;
  385.  if (PutConfigStr(sn->sn_Port,&ptr)) sbits|=SOPO_PORT;
  386.  
  387.  /* set string bits */
  388.  spo->spo_StringBits=sbits;
  389.  
  390.  /* calculate length */
  391.  sbits=ptr-buf;
  392.  
  393.  DEBUG_PRINTF("chunk size %ld\n",sbits);
  394.  
  395.  /* Open chunk */
  396.  if (PushChunk(iff,0,ID_TMSO,sbits)) return(FALSE);
  397.  
  398.  /* Write chunk */
  399.  if (WriteChunkBytes(iff,buf,sbits)!=sbits) return(FALSE);
  400.  
  401.  /* Close chunk */
  402.  if (PopChunk(iff)) return(FALSE);
  403.  
  404.  /* All OK. */
  405.  return(TRUE);
  406. }
  407.