prj/tech/libsrc/mp/mplist.c

   1 //
   2 // mplist.c - Multiped motion list management.
   3 //
   4
   5 #include <multiped.h>
   6
   7
   8 extern mps_motion_state_callback mp_motion_start_callback;
   9 extern mps_motion_state_callback mp_motion_end_callback;
  10
  11 //
  12
  13 void mp_list_init(mps_motion_list * list)
  14 {
  15         list->count = 0;
  16         list->head = NULL;
  17         list->tail = NULL;
  18         list->flags = 0;
  19 }
  20
  21 //
  22
  23 void mp_list_free(mps_motion_list * list)
  24 {
  25         mps_stack_node * node = list->head, * temp;
  26
  27         while (node)
  28         {
  29                 temp = node->next;
  30                 if (node->type == MN_MOTION)
  31                 {
  32                         mps_motion_node * m = (mps_motion_node *) node;
  33                         if (m->targets)
  34                         {
  35                                 mp_free(m->targets);
  36                                 m->targets = NULL;
  37                         }
  38          if(mp_motion_end_callback)
  39          {
  40             int mnum=MP_MOTNUM_FROM_NODE_HANDLE(m->handle);
  41
  42             // check motion is not a pose
  43             if(mnum!=MP_MOTNUM_FROM_NODE_HANDLE(-1))
  44                mp_motion_end_callback(mnum);
  45          }
  46                 }
  47
  48                 mp_free(node);
  49                 node = temp;
  50         }
  51
  52         list->head = NULL;
  53         list->tail = NULL;
  54         list->count = 0;
  55 }
  56
  57 //
  58
  59 void mp_list_add(mps_motion_list * list, mps_stack_node * node)
  60 {
  61    if(node->type==MN_MOTION && mp_motion_start_callback)
  62    {
  63       mps_motion_node *m=(mps_motion_node *)node;
  64       int mnum=MP_MOTNUM_FROM_NODE_HANDLE(m->handle);
  65
  66       // check motion is not a pose
  67       if(mnum!=MP_MOTNUM_FROM_NODE_HANDLE(-1))
  68          mp_motion_start_callback(mnum);
  69    }
  70         if (list->tail)
  71         {
  72                 list->tail->next = node;
  73                 node->prev = list->tail;
  74                 node->next = NULL;
  75                 list->tail = node;
  76         }
  77         else
  78         {
  79         // Empty list.
  80                 list->head =
  81                 list->tail = node;
  82                 node->prev =
  83                 node->next = NULL;
  84         }
  85
  86         list->count++;
  87 }
  88
  89 //
  90
  91 void mp_list_remove(mps_motion_list * list, mps_stack_node * node)
  92 {
  93         mps_stack_node * p = node->prev;
  94         mps_stack_node * n = node->next;
  95
  96    if(node->type==MN_MOTION && mp_motion_end_callback)
  97    {
  98       mps_motion_node *m=(mps_motion_node *)node;
  99       int mnum=MP_MOTNUM_FROM_NODE_HANDLE(m->handle);
 100
 101       // check motion is not a pose
 102       if(mnum!=MP_MOTNUM_FROM_NODE_HANDLE(-1))
 103          mp_motion_end_callback(mnum);
 104    }
 105         if (p)
 106         {
 107                 p->next = n;
 108         }
 109         else
 110         {
 111         // Node is head of list.
 112                 list->head = n;
 113         }
 114
 115         if (n)
 116         {
 117                 n->prev = p;
 118         }
 119         else
 120         {
 121         // Node is tail of list.
 122                 list->tail = p;
 123         }
 124
 125         if (node->type == MN_MOTION)
 126         {
 127                 mps_motion_node * m = (mps_motion_node *) node;
 128                 if (m->targets)
 129                 {
 130                         mp_free(m->targets);
 131                         m->targets = NULL;
 132                 }
 133         }
 134
 135         mp_free(node);
 136
 137         list->count--;
 138 }
 139
 140 //
 141
 142 mps_stack_node * mp_list_traverse(mps_motion_list * list, mps_stack_node * node)
 143 {
 144         mps_stack_node * result;
 145         if (node)
 146         {
 147                 result = node->next;
 148         }
 149         else
 150         {
 151                 result = list->head;
 152         }
 153         return result;
 154 }
 155
 156 //
 157
 158 BOOL mp_list_clone(mps_motion_list *dst, mps_motion_list *src)
 159 {
 160    mps_stack_node *node=NULL,*newnode;
 161
 162    mp_list_init(dst);
 163
 164    while(node=mp_list_traverse(src,node))
 165    {
 166       if(node->type==MN_MOTION)
 167       {
 168          if(!(newnode=mp_alloc(sizeof(mps_motion_node),__FILE__, __LINE__)))
 169          {
 170             mp_list_free(dst);
 171             return FALSE;
 172          }
 173          memcpy(newnode,node,sizeof(mps_motion_node));
 174          if(((mps_motion_node *)node)->targets)
 175          {
 176             ((mps_motion_node *)newnode)->targets=Malloc(MSize(((mps_motion_node *)node)->targets)); // XXX this may copy more than necessary
 177             memcpy(((mps_motion_node *)newnode)->targets,((mps_motion_node *)node)->targets,MSize(((mps_motion_node *)node)->targets));
 178          }
 179       } else
 180       {
 181          if(!(newnode=mp_alloc(sizeof(mps_transition_node),__FILE__, __LINE__)))
 182          {
 183             mp_list_free(dst);
 184             return FALSE;
 185          }
 186          memcpy(newnode,node,sizeof(mps_transition_node));
 187       }
 188       mp_list_add(dst,newnode);
 189    }
 190    return TRUE;
 191 }