home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / utility / misc / toolmana.lha / ToolManager / Source / library / objects.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-26  |  8.5 KB  |  267 lines
  1. /*
  2.  * objects.c  V2.0
  3.  *
  4.  * TMObject managment routines
  5.  *
  6.  * (c) 1990-1992 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerLib.h"
  10.  
  11. static void *dummyfunc(void) {return(NULL);};
  12.  
  13. /* object functions arrays */
  14. typedef struct TMObject *CreateFunc(struct TMHandle *, char *,
  15.                                     struct TagItem *);
  16. extern CreateFunc        CreateTMObjectExec;
  17. extern CreateFunc        CreateTMObjectImage;
  18. extern CreateFunc        CreateTMObjectSound;
  19. extern CreateFunc        CreateTMObjectMenu;
  20. extern CreateFunc        CreateTMObjectIcon;
  21. extern CreateFunc        CreateTMObjectDock;
  22. static CreateFunc       *CreateFuncTab[TMOBJTYPES]={CreateTMObjectExec,
  23.                                                     CreateTMObjectImage,
  24.                                                     CreateTMObjectSound,
  25.                                                     CreateTMObjectMenu,
  26.                                                     CreateTMObjectIcon,
  27.                                                     CreateTMObjectDock};
  28.  
  29. typedef BOOL       DeleteFunc(struct TMObject *);
  30. extern DeleteFunc  DeleteTMObjectExec;
  31. extern DeleteFunc  DeleteTMObjectImage;
  32. extern DeleteFunc  DeleteTMObjectSound;
  33. extern DeleteFunc  DeleteTMObjectMenu;
  34. extern DeleteFunc  DeleteTMObjectIcon;
  35. extern DeleteFunc  DeleteTMObjectDock;
  36. static DeleteFunc *DeleteFuncTab[TMOBJTYPES]={DeleteTMObjectExec,
  37.                                               DeleteTMObjectImage,
  38.                                               DeleteTMObjectSound,
  39.                                               DeleteTMObjectMenu,
  40.                                               DeleteTMObjectIcon,
  41.                                               DeleteTMObjectDock};
  42.  
  43. typedef BOOL       ChangeFunc(struct TMHandle *, struct TMObject *,
  44.                               struct TagItem *);
  45. extern ChangeFunc  ChangeTMObjectExec;
  46. /* extern ChangeFunc  ChangeTMObjectImage; */
  47. extern ChangeFunc  ChangeTMObjectSound;
  48. extern ChangeFunc  ChangeTMObjectMenu;
  49. extern ChangeFunc  ChangeTMObjectIcon;
  50. extern ChangeFunc  ChangeTMObjectDock;
  51. static ChangeFunc *ChangeFuncTab[TMOBJTYPES]={ChangeTMObjectExec,
  52.                                               dummyfunc,
  53.                                               ChangeTMObjectSound,
  54.                                               ChangeTMObjectMenu,
  55.                                               ChangeTMObjectIcon,
  56.                                               ChangeTMObjectDock};
  57.  
  58. typedef struct TMLink *AllocLinkFunc(struct TMObject *);
  59. extern AllocLinkFunc   AllocLinkTMObjectExec;
  60. extern AllocLinkFunc   AllocLinkTMObjectImage;
  61. extern AllocLinkFunc   AllocLinkTMObjectSound;
  62. static AllocLinkFunc  *AllocLinkFuncTab[TMOBJTYPES]={AllocLinkTMObjectExec,
  63.                                                      AllocLinkTMObjectImage,
  64.                                                      AllocLinkTMObjectSound,
  65.                                                      dummyfunc,
  66.                                                      dummyfunc,
  67.                                                      dummyfunc};
  68.  
  69. typedef void           DeleteLinkFunc(struct TMLink *);
  70. extern DeleteLinkFunc  DeleteLinkTMObjectMenu;
  71. extern DeleteLinkFunc  DeleteLinkTMObjectIcon;
  72. extern DeleteLinkFunc  DeleteLinkTMObjectDock;
  73. static DeleteLinkFunc *DeleteLinkFuncTab[TMOBJTYPES]={dummyfunc,
  74.                                                       dummyfunc,
  75.                                                       dummyfunc,
  76.                                                       DeleteLinkTMObjectMenu,
  77.                                                       DeleteLinkTMObjectIcon,
  78.                                                       DeleteLinkTMObjectDock};
  79.  
  80. typedef void         ActivateFunc(struct TMLink *, void *);
  81. extern ActivateFunc  ActivateTMObjectExec;
  82. extern ActivateFunc  ActivateTMObjectImage;
  83. extern ActivateFunc  ActivateTMObjectSound;
  84. extern ActivateFunc  ActivateTMObjectMenu;
  85. extern ActivateFunc  ActivateTMObjectIcon;
  86. extern ActivateFunc  ActivateTMObjectDock;
  87. static ActivateFunc *ActivateFuncTab[TMOBJTYPES]={ActivateTMObjectExec,
  88.                                                   ActivateTMObjectImage,
  89.                                                   ActivateTMObjectSound,
  90.                                                   ActivateTMObjectMenu,
  91.                                                   ActivateTMObjectIcon,
  92.                                                   ActivateTMObjectDock};
  93.  
  94. /* Allocate a TMObject structure */
  95. struct TMObject *AllocateTMObject(ULONG size)
  96. {
  97.  struct TMObject *tmobj;
  98.  
  99.  /* Get memory for TMObject */
  100.  if (tmobj=AllocMem(size,MEMF_CLEAR|MEMF_PUBLIC)) {
  101.   /* Init link list */
  102.   NewList(&tmobj->tmo_Links);
  103.  
  104.   /* All OK */
  105.   return(tmobj);
  106.  }
  107.  
  108.  /* call failed */
  109.  return(NULL);
  110. }
  111.  
  112. /* Find an object by name of a specified type */
  113. static struct TMObject *FindObjectInList(struct TMHandle *handle, char *name,
  114.                                          UBYTE type)
  115. {
  116.  struct TMObject *tmobj=GetHead(&handle->tmh_ObjectLists[type]);
  117.  
  118.  /* Scan list */
  119.  while (tmobj)
  120.   if (strcmp(name,tmobj->tmo_Name))
  121.    tmobj=GetSucc(tmobj);            /* Object not found --> Next object */
  122.   else
  123.    break;                           /* Object found --> Leave loop */
  124.  
  125.  /* return pointer to object */
  126.  return(tmobj);
  127. }
  128.  
  129. /* Find an object by name in a specified TMHandle */
  130. static struct TMObject *FindObjectInTMHandle(struct TMHandle *handle,
  131.                                              char *name)
  132. {
  133.  int i;
  134.  struct TMObject *tmobj;
  135.  
  136.  /* Scan all lists in TMHandle */
  137.  for (i=0; i<TMOBJTYPES; i++)
  138.   if (tmobj=FindObjectInList(handle,name,i)) break; /* Object found */
  139.  
  140.  /* return pointer to object */
  141.  return(tmobj);
  142. }
  143.  
  144. /* Create a TMObject of the specified type */
  145. BOOL InternalCreateTMObject(struct TMHandle *handle, char *object, ULONG type,
  146.                             struct TagItem *tags)
  147. {
  148.  struct TMObject *tmobj;
  149.  
  150.  /* Call type specific create function */
  151.  if (tmobj=(*CreateFuncTab[type])(handle,object,tags)) {
  152.   /* Object created */
  153.   tmobj->tmo_Type=type;
  154.   tmobj->tmo_Name=object;
  155.  
  156.   /* Add it to the TMHandle */
  157.   AddTail(&handle->tmh_ObjectLists[type],(struct Node *) tmobj);
  158.  
  159.   /* call succeeded */
  160.   return(TRUE);
  161.  }
  162.  
  163.  /* call failed */
  164.  return(FALSE);
  165. }
  166.  
  167. /* Delete a TMObject (NOTE: object MUST Remove() itself from list!!!) */
  168. BOOL CallDeleteTMObject(struct TMObject *tmobj)
  169. {
  170.  return((*DeleteFuncTab[tmobj->tmo_Type])(tmobj));
  171. }
  172.  
  173. /* Delete a TMObject (NOTE: object MUST Remove() itself from list!!!) */
  174. BOOL InternalDeleteTMObject(struct TMHandle *handle, char *object)
  175. {
  176.  struct TMObject *tmobj;
  177.  
  178.  /* find object */
  179.  if (tmobj=FindObjectInTMHandle(handle,object))
  180.   /* Object found, remove delete it */
  181.   return((*DeleteFuncTab[tmobj->tmo_Type])(tmobj));
  182.  
  183.  /* call failed */
  184.  return(FALSE);
  185. }
  186.  
  187. /* Change a TMObject */
  188. BOOL InternalChangeTMObject(struct TMHandle *handle, char *object,
  189.                             struct TagItem *tags)
  190. {
  191.  struct TMObject *tmobj;
  192.  
  193.  /* find object */
  194.  if (tmobj=FindObjectInTMHandle(handle,object)){
  195.   /* Object found */
  196.  
  197.   /* any tags specified? */
  198.   if (tags==NULL) return(TRUE); /* call succeeded :-) */
  199.  
  200.   /* Change object */
  201.   return((ChangeFuncTab[tmobj->tmo_Type])(handle,tmobj,tags));
  202.  }
  203.  
  204.  /* call failed */
  205.  return(FALSE);
  206. }
  207.  
  208. /* Add a link to a TMObject */
  209. struct TMLink *AddLinkTMObject(struct TMHandle *handle, char *object,
  210.                                ULONG type, struct TMObject *linkedto)
  211. {
  212.  struct TMObject *tmobj;
  213.  
  214.  /* Find object of specified type */
  215.  if (tmobj=FindObjectInList(handle,object,type)) {
  216.   struct TMLink *tml;
  217.  
  218.   /* Allocate TMLink structure */
  219.   if (tml=(AllocLinkFuncTab[tmobj->tmo_Type])(tmobj)) {
  220.    /* Initialize link */
  221.    tml->tml_Linked=tmobj;
  222.    tml->tml_LinkedTo=linkedto;
  223.  
  224.    /* Add link to list */
  225.    AddTail(&tmobj->tmo_Links,(struct Node *) tml);
  226.  
  227.    /* All OK */
  228.    return(tml);
  229.   }
  230.  }
  231.  
  232.  /* call failed */
  233.  return(NULL);
  234. }
  235.  
  236. /* Remove a link to a TMObject */
  237. void RemLinkTMObject(struct TMLink *tml)
  238. {
  239.  /* Remove it from list */
  240.  Remove((struct Node *) tml);
  241.  
  242.  /* Free link structure */
  243.  FreeMem(tml,tml->tml_Size);
  244. }
  245.  
  246. /* Remove all links to a TMObject (updating objects this object is linked to) */
  247. void DeleteAllLinksTMObject(struct TMObject *tmobj)
  248. {
  249.  struct List *l=&tmobj->tmo_Links;
  250.  struct TMLink *tml;
  251.  
  252.  /* Scan list */
  253.  while (tml=RemHead(l)) {
  254.   /* Notify linkedTo object, that this link will be removed */
  255.   (DeleteLinkFuncTab[tml->tml_LinkedTo->tmo_Type])(tml);
  256.  
  257.   /* Free link structure */
  258.   FreeMem(tml,tml->tml_Size);
  259.  }
  260. }
  261.  
  262. /* Activate a TMObject */
  263. void CallActivateTMObject(struct TMLink *tml, void *args)
  264. {
  265.  (ActivateFuncTab[tml->tml_Linked->tmo_Type])(tml,args);
  266. }
  267.