workbench/libs/realtime/setplayerattrsa.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #include <proto/exec.h>
   6 #include <proto/utility.h>
   7 #include <proto/realtime.h>
   8 #include <exec/lists.h>
   9 #include "realtime_intern.h"
  10
  11 /*****************************************************************************
  12
  13     NAME */
  14
  15 #include <utility/tagitem.h>
  16 #include <libraries/realtime.h>
  17
  18     AROS_LH2(BOOL, SetPlayerAttrsA,
  19
  20 /*  SYNOPSIS */
  21
  22         AROS_LHA(struct Player  *, player , A0),
  23         AROS_LHA(struct TagItem *, tagList, A1),
  24
  25 /*  LOCATION */
  26
  27         struct Library *, RealTimeBase, 9, RealTime)
  28
  29 /*  FUNCTION
  30
  31     Sets the attributes of a player. An attribute not specified in the array
  32     of tags is unchanged after this procedure.
  33
  34     INPUTS
  35
  36     player   --  The player the attributes of which to set.
  37     tagList  --  Pointer to an array of tags describing the player's
  38                  attributes or NULL.
  39
  40     TAGS
  41
  42     The same tags as for CreatePlayerA().
  43
  44     RESULT
  45
  46     Success/failure indicator. If failure, then, in case the PLAYER_ErrorCode
  47     is provided, more information can be obtained via that pointer.
  48
  49     NOTES
  50
  51     EXAMPLE
  52
  53     BUGS
  54
  55     SEE ALSO
  56
  57     DeletePlayer(), GetPlayerAttrs(), SetPlayerAttrs()
  58
  59     INTERNALS
  60
  61 ******************************************************************************/
  62
  63 {
  64     AROS_LIBFUNC_INIT
  65
  66     LONG           *error = NULL;
  67     struct TagItem *tag, *tl = tagList;
  68     APTR            lock;
  69
  70     error = (LONG *)GetTagData(PLAYER_ErrorCode, NULL, tl);
  71
  72     while ((tag = NextTagItem(&tl)) != NULL)
  73     {
  74         switch(tag->ti_Tag)
  75         {
  76         case PLAYER_Name:
  77             player->pl_Link.ln_Name = (APTR)tag->ti_Data;
  78             break;
  79
  80         case PLAYER_Hook:
  81             player->pl_Hook = (struct Hook *)tag->ti_Data;
  82             break;
  83
  84         case PLAYER_Priority:
  85             player->pl_Link.ln_Pri = (BYTE)tag->ti_Data;
  86
  87             if (player->pl_Link.ln_Succ != NULL)
  88             {
  89                 /* If this node has been (is) inserted before, then remove it
  90                    and put it in the right place. */
  91
  92                 /* Is this player attached to a conductor? */
  93                 if (player->pl_Source != NULL)
  94                 {
  95                     lock = LockRealTime(RT_CONDUCTORS);
  96                     Remove((struct Node *)player);
  97                     Enqueue((struct List *)&player->pl_Source->cdt_Players,
  98                             (struct Node *)player);
  99                     UnlockRealTime(lock);
 100                 }
 101                 else
 102                 {
 103                     if(error != NULL)
 104                     {
 105                         *error = RTE_NOCONDUCTOR;
 106                     }
 107
 108                     return FALSE;
 109                 }
 110             }
 111
 112             break;
 113
 114         case PLAYER_Conductor:
 115             if (tag->ti_Data == NULL)
 116             {
 117                 player->pl_Source = NULL;
 118             }
 119             else
 120             {
 121                 struct Conductor *conductor;
 122
 123                 lock = LockRealTime(RT_CONDUCTORS);
 124                 conductor = FindConductor((STRPTR)tag->ti_Data);
 125                 UnlockRealTime(lock);
 126
 127                 if (conductor == NULL)
 128                 {
 129                     if (error != NULL)
 130                     {
 131                         *error = RTE_NOCONDUCTOR;
 132                     }
 133
 134                     return FALSE;
 135                 }
 136             }
 137
 138             break;
 139
 140         case PLAYER_Ready:
 141             if ((BOOL)tag->ti_Data)
 142             {
 143                 struct Conductor *conductor = player->pl_Source;
 144
 145                 player->pl_Flags |= PLAYERF_READY;
 146
 147                 if (conductor != NULL)
 148                 {
 149                     ObtainSemaphoreShared(&conductor->cdt_Lock);
 150
 151                     if (conductor->cdt_Barrier != NULL)
 152                     {
 153                         Signal(conductor->cdt_Barrier, SIGF_SINGLE);
 154                     }
 155
 156                     ReleaseSemaphore(&conductor->cdt_Lock);
 157                 }
 158             }
 159             else
 160             {
 161                 player->pl_Flags &= ~PLAYERF_READY;
 162             }
 163
 164             break;
 165
 166         case PLAYER_AlarmTime:
 167             player->pl_Flags |= PLAYERF_ALARMSET;
 168             player->pl_AlarmTime = (LONG)tag->ti_Data;
 169             break;
 170
 171         case PLAYER_Alarm:
 172             if ((BOOL)tag->ti_Data)
 173             {
 174                 player->pl_Flags |= PLAYERF_ALARMSET;
 175             }
 176             else
 177             {
 178                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 179             }
 180
 181             break;
 182
 183         case PLAYER_AlarmSigTask:
 184             if ((struct Task *)tag->ti_Data == NULL)
 185             {
 186                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 187             }
 188
 189             player->pl_Task = (struct Task *)tag->ti_Data;
 190             break;
 191
 192         case PLAYER_AlarmSigBit:
 193             if ((BYTE)tag->ti_Data == -1)
 194             {
 195                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 196             }
 197
 198             /* We could use player->pl_Link.ln_Type here */
 199             player->pl_Reserved0 = (BYTE)tag->ti_Data;      /* NOTE! */
 200             break;
 201
 202         case PLAYER_Quiet:
 203             if ((BOOL)tag->ti_Data)
 204             {
 205                 player->pl_Flags |= PLAYERF_QUIET;
 206             }
 207             else
 208             {
 209                 player->pl_Flags &= ~PLAYERF_QUIET;
 210             }
 211
 212             break;
 213
 214         case PLAYER_UserData:
 215             player->pl_UserData = (APTR)tag->ti_Data;
 216             break;
 217
 218         case PLAYER_ID:
 219             player->pl_PlayerID = (UWORD)tag->ti_Data;
 220             break;
 221
 222         case PLAYER_Conducted:
 223             if ((BOOL)tag->ti_Data)
 224             {
 225                 player->pl_Flags |= PLAYERF_CONDUCTED;
 226             }
 227             else
 228             {
 229                 player->pl_Flags &= ~PLAYERF_CONDUCTED;
 230             }
 231
 232             break;
 233
 234         case PLAYER_ExtSync:
 235             lock = LockRealTime(RT_CONDUCTORS);
 236
 237             if ((BOOL)tag->ti_Data)
 238             {
 239                 if (player->pl_Source->cdt_Flags & CONDUCTF_EXTERNAL)
 240                 {
 241                     /* Only one external synchronizer at a time, please */
 242                     UnlockRealTime(lock);
 243
 244                     return FALSE;
 245                 }
 246
 247                 player->pl_Source->cdt_Flags |= CONDUCTF_EXTERNAL;
 248                 player->pl_Flags |= PLAYERF_EXTSYNC;
 249             }
 250             else
 251             {
 252                 /* If this player was the external synchronizer, we
 253                    clean up */
 254                 if (player->pl_Flags & PLAYERF_EXTSYNC)
 255                 {
 256                     player->pl_Source->cdt_Flags &= ~CONDUCTF_EXTERNAL;
 257                     player->pl_Source->cdt_Flags &= ~CONDUCTF_GOTTICK;
 258                 }
 259
 260                 player->pl_Flags &= ~PLAYERF_EXTSYNC;
 261             }
 262
 263             UnlockRealTime(lock);
 264
 265             break;
 266         }
 267     }
 268
 269     /* Consistency checks */
 270     if (player->pl_Task == NULL)
 271     {
 272         player->pl_Flags &= ~PLAYERF_ALARMSET;
 273     }
 274
 275     return TRUE;
 276
 277     AROS_LIBFUNC_EXIT
 278 } /* SetPlayerAttrsA */