home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 1 / Amiga Tools.iso / wb-tools / toolmanager / source / prefs / selectwindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-06  |  11.2 KB  |  438 lines
  1. /*
  2.  * selectwindow.c  V2.1
  3.  *
  4.  * AppMessage select window handling
  5.  *
  6.  * (c) 1990-1993 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerConf.h"
  10.  
  11. /* Window data */
  12. static struct Gadget *gl;          /* Gadget list */
  13. static struct Window *w;           /* Window */
  14. static struct MsgPort *wp;         /* Window user port */
  15. static UWORD ww,wh;                /* Window size */
  16. static struct WBArg *CurrentWBArg;
  17. static ULONG SelectAction=0;
  18. static ULONG OldSelAction=0;
  19.  
  20. /* Action codes */
  21. #define SELACT_EXEC     0
  22. #define SELACT_IMAGE    1
  23. #define SELACT_MENU     2
  24. #define SELACT_ICON     3
  25. #define SELACT_MENUICON 4
  26. #define SELACTIONS      5
  27.  
  28. /* Gadget data */
  29. #define GAD_NAME_STR 0
  30. #define GAD_OBJ_TXT  1
  31. #define GAD_OBJECT   2
  32. #define GAD_OK       3
  33. #define GAD_CANCEL   4
  34. #define GADGETS      5
  35. static struct GadgetData gdata[GADGETS];
  36.  
  37. /* Gadget tags */
  38. static struct TagItem nametags[]={GTST_String,   NULL,
  39.                                   GTST_MaxChars, SGBUFLEN,
  40.                                   TAG_DONE};
  41.  
  42. static char *mxlabels[SELACTIONS+1]={NULL, NULL, NULL, NULL, NULL, NULL};
  43. static struct TagItem mxtags[]={GTMX_Labels, (ULONG) mxlabels,
  44.                                 GTMX_Active, 0,
  45.                                 GTMX_Scaled, TRUE,
  46.                                 TAG_DONE};
  47.  
  48. /* Gadget vanilla key data */
  49. #define KEY_NAME   0
  50. #define KEY_OBJECT 1
  51. #define KEY_OK     2
  52. #define KEY_CANCEL 3
  53. static char KeyArray[KEY_CANCEL+1];
  54.  
  55.  
  56. /* Init select window */
  57. void InitSelectWindow(UWORD left, UWORD fheight)
  58. {
  59.  ULONG labwidth,mxwidth,butwidth;
  60.  ULONG strheight=fheight+2;
  61.  ULONG i,tmp;
  62.  struct GadgetData *gd;
  63.  
  64.  /* Init strings */
  65.  gdata[GAD_NAME_STR].name=AppStrings[MSG_WINDOW_NAME_GAD];
  66.  gdata[GAD_OBJ_TXT].name =AppStrings[MSG_SELECTWIN_OBJECT_GAD];
  67.  mxlabels[0]             =AppStrings[MSG_MAINWIN_TYPE_EXEC_CYCLE_LABEL];
  68.  mxlabels[1]             =AppStrings[MSG_MAINWIN_TYPE_IMAGE_CYCLE_LABEL];
  69.  mxlabels[2]             =AppStrings[MSG_SELECTWIN_MENU_MX_LABEL];
  70.  mxlabels[3]             =AppStrings[MSG_SELECTWIN_ICON_MX_LABEL];
  71.  mxlabels[4]             =AppStrings[MSG_SELECTWIN_MENUICON_MX_LABEL];
  72.  gdata[GAD_OK].name      =AppStrings[MSG_WINDOW_OK_GAD];
  73.  gdata[GAD_CANCEL].name  =AppStrings[MSG_WINDOW_CANCEL_GAD];
  74.  
  75.  /* Calculate maximum label width for name gadget */
  76.  labwidth=TextLength(&TmpRastPort,AppStrings[MSG_WINDOW_NAME_GAD],
  77.                      strlen(AppStrings[MSG_WINDOW_NAME_GAD]))+INTERWIDTH;
  78.  
  79.  /* Calculate minimum window width */
  80.  ww=labwidth+TextLength(&TmpRastPort,AppStrings[MSG_EXECWIN_NEWNAME],
  81.                         strlen(AppStrings[MSG_EXECWIN_NEWNAME]))
  82.     +4*INTERWIDTH;
  83.  
  84.  /* Calculate maximum MX gadget width */
  85.  {
  86.   char **s;
  87.  
  88.   mxwidth=0;
  89.   s=mxlabels;
  90.   for (i=0; i<=4; i++, s++)
  91.    if ((tmp=TextLength(&TmpRastPort,*s,strlen(*s))) > mxwidth)
  92.     mxwidth=tmp;
  93.   mxwidth+=CHECKBOX_WIDTH;
  94.  }
  95.  if (mxwidth > ww) ww=mxwidth+INTERWIDTH;
  96.  
  97.  /* Calculate button gadgets width */
  98.  gd=&gdata[GAD_OK];
  99.  butwidth=TextLength(&TmpRastPort,gd->name,strlen(gd->name));
  100.  gd++;
  101.  if ((tmp=TextLength(&TmpRastPort,gd->name,strlen(gd->name))) > butwidth)
  102.   butwidth=tmp;
  103.  butwidth+=2*INTERWIDTH;
  104.  if ((tmp=2*(butwidth+INTERWIDTH)) > ww) ww=tmp;
  105.  
  106.  /* window height */
  107.  wh=8*fheight+5*INTERHEIGHT-8;
  108.  
  109.  /* Init gadgets */
  110.  gd=gdata;
  111.  tmp=WindowTop+INTERHEIGHT;
  112.  
  113.  /* Name string gadget */
  114.  gd->type=STRING_KIND;
  115.  gd->flags=PLACETEXT_LEFT;
  116.  gd->tags=nametags;
  117.  gd->left=labwidth+left;
  118.  gd->top=tmp;
  119.  gd->width=ww-labwidth-INTERWIDTH;
  120.  gd->height=strheight;
  121.  tmp+=strheight+INTERHEIGHT;
  122.  
  123.  /* Object text gadget */
  124.  gd++;
  125.  gd->type=TEXT_KIND;
  126.  gd->flags=PLACETEXT_IN;
  127.  gd->left=left;
  128.  gd->top=tmp;
  129.  gd->width=ww-INTERWIDTH;
  130.  gd->height=fheight;
  131.  tmp+=fheight+INTERHEIGHT;
  132.  
  133.  /* Object MX gadget */
  134.  gd++;
  135.  gd->type=MX_KIND;
  136.  gd->flags=PLACETEXT_RIGHT;
  137.  gd->tags=mxtags;
  138.  gd->left=left+(ww-mxwidth-INTERWIDTH)/2;
  139.  gd->top=tmp;
  140.  gd->width=MX_WIDTH;
  141.  gd->height=fheight-INTERHEIGHT;
  142.  tmp+=5*fheight-10+INTERHEIGHT;
  143.  
  144.  /* OK button gadget */
  145.  gd++;
  146.  gd->type=BUTTON_KIND;
  147.  gd->flags=PLACETEXT_IN;
  148.  gd->left=left;
  149.  gd->top=tmp;
  150.  gd->width=butwidth;
  151.  gd->height=fheight;
  152.  
  153.  /* Cancel button gadget */
  154.  gd++;
  155.  gd->type=BUTTON_KIND;
  156.  gd->flags=PLACETEXT_IN;
  157.  gd->left=ww-butwidth-INTERWIDTH+left;
  158.  gd->top=tmp;
  159.  gd->width=butwidth;
  160.  gd->height=fheight;
  161.  
  162.  /* Init vanilla key array */
  163.  KeyArray[KEY_NAME]  =FindVanillaKey(gdata[GAD_NAME_STR].name);
  164.  KeyArray[KEY_OBJECT]=FindVanillaKey(gdata[GAD_OBJ_TXT].name);
  165.  KeyArray[KEY_OK]    =FindVanillaKey(gdata[GAD_OK].name);
  166.  KeyArray[KEY_CANCEL]=FindVanillaKey(gdata[GAD_CANCEL].name);
  167. }
  168.  
  169. /* Free WBArg */
  170. static void FreeWBArg(struct WBArg *wa)
  171. {
  172.  if (wa->wa_Name) free(wa->wa_Name);
  173.  if (wa->wa_Lock) UnLock(wa->wa_Lock);
  174.  
  175.  FreeMem(wa,sizeof(struct WBArg));
  176. }
  177.  
  178. /* Copy WBArg */
  179. static struct WBArg *CopyWBArg(struct WBArg *oldwa)
  180. {
  181.  struct WBArg *newwa;
  182.  
  183.  /* Allocate memory for new WBArg */
  184.  if (newwa=AllocMem(sizeof(struct WBArg),MEMF_PUBLIC|MEMF_CLEAR)) {
  185.  
  186.   /* Copy WBArg */
  187.   if ((newwa->wa_Lock=DupLock(oldwa->wa_Lock)) &&
  188.       (newwa->wa_Name=(BYTE *) strdup(oldwa->wa_Name)))
  189.    /* Return pointer to new */
  190.    return(newwa);
  191.  
  192.   FreeWBArg(newwa);
  193.  }
  194.  /* Call failed */
  195.  return(NULL);
  196. }
  197.  
  198. /* Activate name string gadget */
  199. static void ActivateNameGadget(void)
  200. {
  201.  ActivateGadget(gdata[GAD_NAME_STR].gadget,w,NULL);
  202. }
  203.  
  204. /* Open select window */
  205. BOOL OpenSelectWindow(struct WBArg *wa, struct Window *parent)
  206. {
  207.  /* Copy WBArg */
  208.  if (CurrentWBArg=CopyWBArg(wa)) {
  209.   /* Set tags */
  210.   nametags[0].ti_Data=(ULONG) CurrentWBArg->wa_Name;
  211.   mxtags[1].ti_Data=SelectAction;
  212.  
  213.   /* Create gadgets */
  214.   if (gl=CreateGadgetList(gdata,GADGETS)) {
  215.    /* Open window */
  216.    if (w=OpenWindowTags(NULL,WA_Left,        parent->LeftEdge,
  217.                              WA_Top,         parent->TopEdge+WindowTop,
  218.                              WA_InnerWidth,  ww,
  219.                              WA_InnerHeight, wh,
  220.                              WA_AutoAdjust,  TRUE,
  221.                              WA_Title,       AppStrings[MSG_SELECTWIN_TITLE],
  222.                              WA_PubScreen,   PublicScreen,
  223.                              WA_Flags,       WFLG_CLOSEGADGET|WFLG_DRAGBAR|
  224.                                              WFLG_DEPTHGADGET|WFLG_RMBTRAP|
  225.                                              WFLG_ACTIVATE,
  226.                              TAG_DONE)) {
  227.     /* Add gadgets to window */
  228.     AddGList(w,gl,(UWORD) -1,(UWORD) -1,NULL);
  229.     RefreshGList(gl,w,NULL,(UWORD) -1);
  230.     GT_RefreshWindow(w,NULL);
  231.  
  232.     /* Activate name string gadget */
  233.     ActivateNameGadget();
  234.  
  235.     /* Set local variables */
  236.     w->UserPort=IDCMPPort;
  237.     w->UserData=(BYTE *) HandleSelectWindowIDCMP;
  238.     ModifyIDCMP(w,IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW|BUTTONIDCMP|
  239.                   STRINGIDCMP|MXIDCMP|IDCMP_VANILLAKEY);
  240.     CurrentWindow=w;
  241.     OldSelAction=SelectAction;
  242.  
  243.     /* All OK. */
  244.     return(TRUE);
  245.    }
  246.    FreeGadgets(gl);
  247.   }
  248.   FreeWBArg(CurrentWBArg);
  249.  }
  250.  /* Call failed */
  251.  return(FALSE);
  252. }
  253.  
  254. /* Close select window */
  255. static void CloseSelectWindow(void)
  256. {
  257.  /* Free resources */
  258.  RemoveGList(w,gl,(UWORD) -1);
  259.  CloseWindowSafely(w);
  260.  FreeGadgets(gl);
  261. }
  262.  
  263. /* OK gadget function */
  264. static void *OKGadgetFunc(void)
  265. {
  266.  char *name;
  267.  
  268.  /* Get object name */
  269.  name=((struct StringInfo *) gdata[GAD_NAME_STR].gadget->SpecialInfo)->Buffer;
  270.  
  271.  switch(SelectAction) {
  272.   case SELACT_EXEC: {
  273.     struct Node *en;
  274.  
  275.     /* Create exec node */
  276.     if (en=CreateExecNode(name,CurrentWBArg)) {
  277.      /* Add node */
  278.      AddHead(&ObjectLists[TMOBJTYPE_EXEC],en);
  279.      return((void *) 1);
  280.     }
  281.    }
  282.    break;
  283.   case SELACT_IMAGE: {
  284.     struct Node *in;
  285.  
  286.     /* Create exec node */
  287.     if (in=CreateImageNode(name,CurrentWBArg)) {
  288.      /* Add node */
  289.      AddHead(&ObjectLists[TMOBJTYPE_IMAGE],in);
  290.      return((void *) 1);
  291.     }
  292.    }
  293.    break;
  294.   case SELACT_MENU:     {
  295.     struct Node *en;
  296.  
  297.     /* Create exec node */
  298.     if (en=CreateExecNode(name,CurrentWBArg)) {
  299.      struct Node *mn;
  300.  
  301.      /* Create menu node */
  302.      if (mn=CreateMenuNode(name)) {
  303.  
  304.       /* Add nodes */
  305.       AddHead(&ObjectLists[TMOBJTYPE_EXEC],en);
  306.       AddHead(&ObjectLists[TMOBJTYPE_MENU],mn);
  307.       return((void *) 1);
  308.      }
  309.      FreeExecNode(en);
  310.     }
  311.    }
  312.    break;
  313.   case SELACT_ICON: {
  314.     struct Node *en;
  315.  
  316.     /* Create exec node */
  317.     if (en=CreateExecNode(name,CurrentWBArg)) {
  318.      struct Node *in;
  319.  
  320.      /* Create image node */
  321.      if (in=CreateImageNode(name,CurrentWBArg)) {
  322.       struct Node *icn;
  323.  
  324.       /* Create icon node */
  325.       if (icn=CreateIconNode(name)) {
  326.  
  327.        /* Add nodes */
  328.        AddHead(&ObjectLists[TMOBJTYPE_EXEC],en);
  329.        AddHead(&ObjectLists[TMOBJTYPE_IMAGE],in);
  330.        AddHead(&ObjectLists[TMOBJTYPE_ICON],icn);
  331.        return((void *) 1);
  332.       }
  333.       FreeImageNode(in);
  334.      }
  335.      FreeExecNode(en);
  336.     }
  337.    }
  338.    break;
  339.   case SELACT_MENUICON: {
  340.     struct Node *en;
  341.  
  342.     /* Create exec node */
  343.     if (en=CreateExecNode(name,CurrentWBArg)) {
  344.      struct Node *in;
  345.  
  346.      /* Create image node */
  347.      if (in=CreateImageNode(name,CurrentWBArg)) {
  348.       struct Node *mn;
  349.  
  350.       /* Create menu node */
  351.       if (mn=CreateMenuNode(name)) {
  352.        struct Node *icn;
  353.  
  354.        /* Create icon node */
  355.        if (icn=CreateIconNode(name)) {
  356.  
  357.         /* Add nodes */
  358.         AddHead(&ObjectLists[TMOBJTYPE_EXEC],en);
  359.         AddHead(&ObjectLists[TMOBJTYPE_IMAGE],in);
  360.         AddHead(&ObjectLists[TMOBJTYPE_MENU],mn);
  361.         AddHead(&ObjectLists[TMOBJTYPE_ICON],icn);
  362.         return((void *) 1);
  363.        }
  364.        FreeMenuNode(mn);
  365.       }
  366.       FreeImageNode(in);
  367.      }
  368.      FreeExecNode(en);
  369.     }
  370.    }
  371.    break;
  372.  }
  373.  return((void *) -1);
  374. }
  375.  
  376. /* Handle select window IDCMP events */
  377. void *HandleSelectWindowIDCMP(struct IntuiMessage *msg)
  378. {
  379.  void *rc=NULL;
  380.  
  381.  /* Which IDCMP class? */
  382.  switch (msg->Class) {
  383.   case IDCMP_CLOSEWINDOW:   rc=(void *) -1;
  384.                             SelectAction=OldSelAction;
  385.                             break;
  386.   case IDCMP_REFRESHWINDOW: GT_BeginRefresh(w);
  387.                             GT_EndRefresh(w,TRUE);
  388.                             break;
  389.   case IDCMP_GADGETUP:
  390.    switch (((struct Gadget *) msg->IAddress)->GadgetID) {
  391.     case GAD_OK:     rc=OKGadgetFunc();
  392.                      break;
  393.     case GAD_CANCEL: rc=(void *) -1;
  394.                      SelectAction=OldSelAction;
  395.                      break;
  396.    }
  397.    break;
  398.   case IDCMP_GADGETDOWN:
  399.    if (((struct Gadget *) msg->IAddress)->GadgetID==GAD_OBJECT)
  400.     SelectAction=msg->Code;
  401.    break;
  402.   case IDCMP_VANILLAKEY:
  403.    switch (MatchVanillaKey(msg->Code,KeyArray)) {
  404.     case KEY_NAME:   ActivateNameGadget();
  405.                      break;
  406.     case KEY_OBJECT: /* Forward or backward cycle? */
  407.                      if (islower(msg->Code))
  408.                       SelectAction=(SelectAction+1) % SELACTIONS;
  409.                      else
  410.                       SelectAction=(SelectAction>0) ? SelectAction-1 :
  411.                                                       SELACTIONS-1;
  412.  
  413.                      /* Set cycle gadget */
  414.                      GT_SetGadgetAttrs(gdata[GAD_OBJECT].gadget,w,NULL,
  415.                                        GTMX_Active, SelectAction,
  416.                                        TAG_DONE);
  417.  
  418.                      break;
  419.     case KEY_OK:     rc=OKGadgetFunc();
  420.                      break;
  421.     case KEY_CANCEL: rc=(void *) -1;
  422.                      SelectAction=OldSelAction;
  423.                      break;
  424.    }
  425.    break;
  426.  }
  427.  
  428.  /* Close window? */
  429.  if (rc) {
  430.   /* Yes. But first reply message!!! */
  431.   GT_ReplyIMsg(msg);
  432.   FreeWBArg(CurrentWBArg);
  433.   CloseSelectWindow();
  434.  }
  435.  
  436.  return(rc);
  437. }
  438.