home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 633.lha / ToolManager_v1.5 / Source.LZH / Source / toollist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-10  |  10.7 KB  |  405 lines
  1. /*
  2.  * toollist.c   V1.5
  3.  *
  4.  * tool list handling
  5.  *
  6.  * (c) 1991 by Stefan Becker
  7.  *
  8.  */
  9. #include "ToolManager.h"
  10.  
  11. /* Read a DiskObject, strip trailing ".info" first */
  12. static struct DiskObject *MyGetDiskObject(char *cp)
  13. {
  14.  int len=strlen(cp);
  15.  
  16.  /* Strip trailing "\n" & ".info" */
  17.  if ((len>4) && !stricmp(cp+len-5,".info")) cp[len-5]='\0';
  18.  
  19.  return(GetDiskObject(cp));
  20. }
  21.  
  22.  
  23. /* Add one program to tool list */
  24. BOOL AddToolNode(struct ConfigBlock *cb, BPTR fl)
  25. {
  26.  register struct ToolNode *tn;
  27.  BOOL ndummy;
  28.  
  29.  /* This limitation exists because of AppAddMenuItem */
  30.  if (ToolCount>=99) goto e1; /* Not more than 99 Tools :-) possible */
  31.  
  32.  /* Get memory for ToolNode */
  33.  if (!(tn=malloc(sizeof(struct ToolNode))))
  34.   goto e1;
  35.  
  36.  /* Initialize the other parameters */
  37.  tn->tn_Type=cb->cb_Type;
  38.  tn->tn_Flags=cb->cb_Flags;
  39.  if (tn->tn_Type!=TNTYPE_CLI) tn->tn_Flags&=~TNFLAGS_COUT;
  40.  tn->tn_Stack=cb->cb_Stack;
  41.  if (tn->tn_Stack<STACKMIN) tn->tn_Stack=STACKMIN; /* Sanity check */
  42.  ndummy=tn->tn_Type!=TNTYPE_DUMMY;
  43.  
  44.  /* No alias? */
  45.  if (cb->cb_Alias[0]=='\0')
  46.   {
  47.    /* Yes, copy real name and set real name to null */
  48.    strcpy(cb->cb_Alias,cb->cb_RealName);
  49.    if (cb->cb_Alias[0]=='\0') goto e2;   /* Empty name --> error */
  50.    cb->cb_RealName[0]='\0';
  51.   }
  52.  
  53.  /* Get memory for menu item name and copy it */
  54.  if (!(tn->tn_Node.ln_Name=strdup(cb->cb_Alias)))
  55.   goto e2;
  56.  
  57.  /* Does the program have a real name? */
  58.  if (ndummy && (cb->cb_RealName[0]!='\0'))
  59.   {
  60.    /* Get memory for real program name and copy it */
  61.    if (!(tn->tn_RealName=strdup(cb->cb_RealName)))
  62.     goto e3;
  63.   }
  64.  else
  65.   tn->tn_RealName=NULL; /* Otherwise: menu item name == real program name */
  66.  
  67.  /* Does the user want a hotkey for the tool? */
  68.  if (ndummy && (cb->cb_HotKey[0]!='\0'))
  69.   {
  70.    /* Get memory for hot key string and copy it */
  71.    if (!(tn->tn_HotKey=strdup(cb->cb_HotKey)))
  72.     goto e4;
  73.  
  74.    /* Build the commodities object from the hot key string */
  75.    if (!(tn->tn_CxObj=HotKey(tn->tn_HotKey,MyBrokerPort,(ULONG) tn)))
  76.     goto e5;
  77.  
  78.    /* Attach it to to our broker */
  79.    AttachCxObj(MyBroker,tn->tn_CxObj);
  80.    if (CxObjError(MyBroker)) goto e6;
  81.   }
  82.  else
  83.   {
  84.    tn->tn_HotKey=NULL;
  85.    tn->tn_CxObj=NULL;
  86.   }
  87.  
  88.  /* If the user wants a menu, add new menu entry, ID == Address of ToolNode */
  89.  if (tn->tn_Flags&TNFLAGS_MENU)
  90.   {
  91.    if (!(tn->tn_MenuItem=AddAppMenuItemA((ULONG) tn,NULL,tn->tn_Node.ln_Name,
  92.                                          MyMP,NULL)))
  93.     goto e6;
  94.   }
  95.  else tn->tn_MenuItem=NULL;
  96.  
  97.  /* User supplied working directory? */
  98.  if (ndummy && (cb->cb_WorkDir[0]!='\0'))
  99.   {
  100.    if (!(tn->tn_WorkDir=strdup(cb->cb_WorkDir)))
  101.     goto e7;
  102.  
  103.    tn->tn_DirLock=Lock(tn->tn_WorkDir,ACCESS_READ);
  104.   }
  105.  else
  106.   {
  107.    tn->tn_WorkDir=NULL;
  108.    tn->tn_DirLock=NULL;
  109.   }
  110.  
  111.  /* Valid directory? No --> duplicate supplied DirLock */
  112.  if (!tn->tn_DirLock && !(tn->tn_DirLock=DupLock(fl)))
  113.   goto e8;
  114.  
  115.  /* User supplied a path string? (CLI tools only!) */
  116.  if ((tn->tn_Type==TNTYPE_CLI) && (cb->cb_Path[0]!='\0'))
  117.   {
  118.    if (!(tn->tn_Path=strdup(cb->cb_Path)))
  119.     goto e9;
  120.   }
  121.  else
  122.   tn->tn_Path=NULL;
  123.  
  124.  /* User supplied an output file name? (CLI tools only!) */
  125.  if ((tn->tn_Type==TNTYPE_CLI) && (cb->cb_OutFile[0]!='\0'))
  126.   {
  127.    if (!(tn->tn_OutFile=strdup(cb->cb_OutFile)))
  128.     goto e10;
  129.   }
  130.  else
  131.   tn->tn_OutFile=NULL;
  132.  
  133.  /* If the user wants an icon, add new AppIcon, ID == Address of ToolNode */
  134.  if (ndummy && (tn->tn_Flags&TNFLAGS_ICON))
  135.   {
  136.    BPTR oldfl;
  137.    char *cp;
  138.  
  139.    /* Get icon file name */
  140.    tn->tn_IconFile=NULL;
  141.    if (cb->cb_IconFile[0]!='\0')
  142.     {
  143.      if (!(cp=tn->tn_IconFile=strdup(cb->cb_IconFile)))
  144.       goto e11;
  145.     }
  146.    else if (tn->tn_RealName) cp=tn->tn_RealName;
  147.    else cp=tn->tn_Node.ln_Name;
  148.  
  149.    /* Go to tools directory */
  150.    oldfl=CurrentDir(tn->tn_DirLock);
  151.  
  152.    /* Get icon data */
  153.    if (tn->tn_Flags&TNFLAGS_DOBJ)
  154.     tn->tn_Icon=MyGetDiskObject(cp);
  155.    else
  156.     tn->tn_Icon=LoadIFFIcon(cp);
  157.  
  158.    /* Go back to old directory */
  159.    CurrentDir(oldfl);
  160.  
  161.    /* Icon data loaded? */
  162.    if (!tn->tn_Icon) goto e12;
  163.  
  164.    /* Create AppIcon */
  165.    tn->tn_Icon->do_CurrentX=cb->cb_IconX;
  166.    tn->tn_Icon->do_CurrentY=cb->cb_IconY;
  167.    if (!(tn->tn_AppIcon=AddAppIconA((ULONG) tn,NULL,
  168.                          (cb->cb_Flags&TNFLAGS_NNAM)?"":tn->tn_Node.ln_Name,
  169.                          MyMP,NULL,tn->tn_Icon,NULL)))
  170.     goto e13;
  171.   }
  172.  else
  173.   {
  174.    tn->tn_Flags&=~TNFLAGS_NNAM; /* reset to defaults */
  175.    tn->tn_Flags|=TNFLAGS_DOBJ;
  176.    tn->tn_IconFile=NULL;
  177.    tn->tn_Icon=NULL;
  178.    tn->tn_AppIcon=NULL;
  179.   }
  180.  
  181.  /* If the user wants a dock, add it */
  182.  tn->tn_DockFile=NULL;
  183.  if (ndummy && (tn->tn_Flags&TNFLAGS_DOCK))
  184.   {
  185.    if (tn->tn_Flags&TNFLAGS_SICN) /* Use same image as icon? */
  186.     {                             /* Yes --> Copy pointer */
  187.      if (!(tn->tn_Dock=tn->tn_Icon)) /* Image pointer NULL? Yes --> Error */
  188.       goto e14;
  189.     }
  190.    else                           /* No  --> Load seperate image */
  191.     {
  192.      BPTR oldfl;
  193.      char *cp;
  194.  
  195.      /* Get icon file name */
  196.      if (cb->cb_DockFile[0]!='\0')
  197.       {
  198.        if (!(cp=tn->tn_DockFile=strdup(cb->cb_DockFile)))
  199.         goto e14;
  200.        }
  201.      else if (tn->tn_RealName) cp=tn->tn_RealName;
  202.      else cp=tn->tn_Node.ln_Name;
  203.  
  204.      /* Go to tools directory */
  205.      oldfl=CurrentDir(tn->tn_DirLock);
  206.  
  207.      /* Get dock image data */
  208.      if (tn->tn_Flags&TNFLAGS_DDOB)
  209.       tn->tn_Dock=MyGetDiskObject(cp);
  210.      else
  211.       tn->tn_Dock=LoadIFFIcon(cp);
  212.  
  213.      /* Go back to old directory */
  214.      CurrentDir(oldfl);
  215.  
  216.      /* Icon data loaded? */
  217.      if (!tn->tn_Dock) goto e15;
  218.     }
  219.  
  220.    if (!AddDock(tn)) goto e16;
  221.   }
  222.  else
  223.   { /* Reset to defaults */
  224.    tn->tn_Flags|=TNFLAGS_DDOB;
  225.    tn->tn_Dock=NULL;
  226.   }
  227.  
  228.  /* Add node to tool list */
  229.  ToolCount++;           /* Increment active tool count */
  230.  DetachToolList();      /* Detach list from ListView gadget */
  231.  AddTail(&ToolList,(struct Node *) tn);
  232.  AttachToolList();      /* Attach list to ListView gadget */
  233.  
  234.  /* Node successfully added to list! */
  235.  return(TRUE);
  236.  
  237.  /* Something went wrong.... */
  238. e16: if (tn->tn_Dock && !(tn->tn_Flags&TNFLAGS_SICN))
  239.       if (tn->tn_Flags&TNFLAGS_DDOB)
  240.        FreeDiskObject(tn->tn_Dock);
  241.       else
  242.        FreeIFFIcon(tn->tn_Dock);
  243. e15: if (tn->tn_DockFile) free(tn->tn_DockFile);
  244. e14: if (tn->tn_AppIcon) RemoveAppIcon(tn->tn_AppIcon);
  245. e13: if (tn->tn_Icon)
  246.       if (tn->tn_Flags&TNFLAGS_DOBJ)
  247.        FreeDiskObject(tn->tn_Icon);
  248.       else
  249.        FreeIFFIcon(tn->tn_Icon);
  250. e12: if (tn->tn_IconFile) free(tn->tn_IconFile);
  251. e11: if (tn->tn_OutFile) free(tn->tn_OutFile);
  252. e10: if (tn->tn_Path) free(tn->tn_Path);
  253. e9:  UnLock(tn->tn_DirLock);
  254. e8:  if (tn->tn_WorkDir) free(tn->tn_WorkDir);
  255. e7:  if (tn->tn_MenuItem) RemoveAppMenuItem(tn->tn_MenuItem);
  256. e6:  if (tn->tn_CxObj)
  257.       {
  258.        DeleteCxObjAll(tn->tn_CxObj);
  259. /*       ClearCxObjError(MyBroker); */   /* reset error flag */
  260.       }
  261. e5:  if (tn->tn_HotKey) free(tn->tn_HotKey);
  262. e4:  if (tn->tn_RealName) free(tn->tn_RealName);
  263. e3:  free(tn->tn_Node.ln_Name);
  264. e2:  free(tn);
  265. e1:  return(FALSE);
  266. }
  267.  
  268. /* Scan Workbench parameters and add them to tool list */
  269. BOOL WBAddToolNode(struct WBArg *wbarg, int numargs)
  270. {
  271.  struct ConfigBlock *cb;
  272.  int i;
  273.  BOOL rc=TRUE;
  274.  BPTR fl;
  275.  struct DiskObject *dobj;
  276.  struct ToolNode *tn=FindTool();
  277.  
  278.  /* Get memory */
  279.  if (!(cb=malloc(sizeof(struct ConfigBlock)))) return(rc);
  280.  
  281.  /* Init config block */
  282.  InitConfigBlock(cb);
  283.  
  284.  for (i=numargs; i; i--,wbarg++)            /* Scan all parameters */
  285.   /* Sanity check */
  286.   if (wbarg->wa_Lock && wbarg->wa_Name && (strlen(wbarg->wa_Name)!=0))
  287.    {
  288.     /* Change to icon's directory */
  289.     fl=CurrentDir(wbarg->wa_Lock);
  290.  
  291.     /* Get name of directory */
  292.     if (!NameFromLock(wbarg->wa_Lock,cb->cb_WorkDir,BUFLEN))
  293.      cb->cb_WorkDir[0]='\0'; /* No directory found */
  294.  
  295.     if (dobj=GetDiskObject(wbarg->wa_Name)) /* Get icon data */
  296.      {
  297.       switch (dobj->do_Type) /* Perform action depending on icon type */
  298.        {
  299.         case WBTOOL:    /* Icon is a Tool or */
  300.         case WBPROJECT: /* Icon is a Project, add it as WB tool, no HotKey  */
  301.          cb->cb_Type=TNTYPE_WB;
  302.          strncpy(cb->cb_Alias,wbarg->wa_Name,BUFLEN-1);
  303.          rc&=AddToolNode(cb,wbarg->wa_Lock);
  304.          break;
  305.         default:        /* Every other icon type is erroneous */
  306.          rc&=FALSE;
  307.          break;
  308.        }
  309.       FreeDiskObject(dobj); /* Release icon data */
  310.      }
  311.     else /* Can't get icon data, so we add it as a CLI tool, no HotKey */
  312.      {
  313.       cb->cb_Type=TNTYPE_CLI;
  314.       strncpy(cb->cb_Alias,wbarg->wa_Name,BUFLEN-1);
  315.       rc&=AddToolNode(cb,wbarg->wa_Lock);
  316.      }
  317.  
  318.     CurrentDir(fl); /* Change to old directory */
  319.  
  320.     /* If a tool was selected in the status window, move new tool behind it */
  321.     if (tn && rc)
  322.      {
  323.       register struct ToolNode *ntn;
  324.  
  325.       /* New tool was added at the end of list */
  326.       ntn=RemTail(&ToolList);
  327.  
  328.       /* Insert it after the selected one */
  329.       Insert(&ToolList,(struct Node *) ntn, (struct Node *) tn);
  330.  
  331.       /* We have changed the list */
  332.       AttachToolList();
  333.  
  334.       /* Next new tool must be inserted after the actual one */
  335.       tn=ntn;
  336.      }
  337.    }
  338.   else
  339.    rc&=FALSE; /* Error: Bad Workbench parameter */
  340.  
  341.  free(cb);
  342.  return(rc); /* Return TRUE if no error */
  343. }
  344.  
  345. /* Remove ONE node from the tool list */
  346. void RemToolNode(struct ToolNode *tn)
  347. {
  348.  Remove((struct Node *) tn);                 /* Remove node from list */
  349.  
  350.  /* Free Dock stuff */
  351.  if (tn->tn_Flags&TNFLAGS_DOCK)
  352.   {
  353.    RemDock(tn);
  354.    if (!(tn->tn_Flags&TNFLAGS_SICN))
  355.     {
  356.      if (tn->tn_Flags&TNFLAGS_DDOB)              /* Free image data */
  357.       FreeDiskObject(tn->tn_Dock);
  358.      else
  359.       FreeIFFIcon(tn->tn_Dock);
  360.      if (tn->tn_DockFile) free(tn->tn_DockFile); /* Free dock file name */
  361.     }
  362.   }
  363.  
  364.  /* Free Icon stuff */
  365.  if (tn->tn_Flags&TNFLAGS_ICON)
  366.   {
  367.    if (tn->tn_AppIcon) RemoveAppIcon(tn->tn_AppIcon); /* Remove AppIcon */
  368.    if (tn->tn_Flags&TNFLAGS_DOBJ)            /* Free icon data */
  369.     FreeDiskObject(tn->tn_Icon);
  370.    else
  371.     FreeIFFIcon(tn->tn_Icon);
  372.    if (tn->tn_IconFile) free(tn->tn_IconFile); /* Free icon file name */
  373.   }
  374.  
  375.  if (tn->tn_Path) free(tn->tn_Path);
  376.  if (tn->tn_OutFile) free(tn->tn_OutFile);
  377.  if (tn->tn_WorkDir) free(tn->tn_WorkDir);   /* Free directory name */
  378.  UnLock(tn->tn_DirLock);                     /* Free directory lock */
  379.  if (tn->tn_MenuItem) RemoveAppMenuItem(tn->tn_MenuItem); /* Rem. menu entry */
  380.  
  381.  /* Free HotKey stuff */
  382.  if (tn->tn_CxObj)
  383.   {
  384.    DeleteCxObjAll(tn->tn_CxObj);             /* Free commodities objects */
  385.    free(tn->tn_HotKey);                      /* Free HotKey string */
  386.   }
  387.  
  388.  if (tn->tn_RealName) free(tn->tn_RealName); /* Free memory */
  389.  free(tn->tn_Node.ln_Name);
  390.  free(tn);
  391.  ToolCount--;                                /* decrement active tool count */
  392. }
  393.  
  394. /* Remove ALL nodes from the tool list */
  395. void RemoveTools(void)
  396. {
  397.  struct ToolNode *tn1,*tn2=GetHead(&ToolList); /* Begin of list */
  398.  
  399.  while (tn1=tn2)
  400.   {
  401.    tn2=GetSucc(tn1); /* Next in list */
  402.    RemToolNode(tn1); /* Remove node */
  403.   }
  404. }
  405.