activity.c

/*
 *    Copyright (C) 2010,2011 by Milan Kazarka
 *
 *    You may distribute under the terms of the Artistic License,
 *    as specified in the README file.
 *
 */

/** activities should be viewed as ways of how to communicate between
 *  our applications and their managers - for example the rootController
 */

#include "activity.h"
#include "activityObject.h"
#include "rootControllerSync.h"
#include "os.h"
#include "system.h"
#include "config.h"

/** in general it's easier to sync the activities
 *  with the rootController's locking mechanism
 */
#define _ACTIVITY_LOCK_ON_ROOT_NO

/** the locking & unlocking of activity data should be
 *  done here for every access (todo if elsewhere)
 */
int activityLock( struct activity *act )
{
  if (!act)		 return 1;
  if (!act->sem)	 return 1;
  #ifdef _ACTIVITY_LOCK_ON_ROOT
    #ifdef _DEBUG
      printf("activityLock.start\n");
    #endif
    rootControllerLock();
    #ifdef _DEBUG
      printf("activityLock.finish\n");
    #endif
  #else
    binarySemaphoreWait(act->sem->id);
  #endif
  return 0;
}

int activityUnlock( struct activity *act )
{
  if (!act)		return 1;
  if (!act->sem)	return 1;
  #ifdef _ACTIVITY_LOCK_ON_ROOT
    #ifdef _DEBUG
      printf("activityUnlock.start\n");
    #endif
    rootControllerUnlock();
    #ifdef _DEBUG
      printf("activityUnlock.finish\n");
    #endif
  #else
    binarySemaphorePost(act->sem->id);
  #endif
  return 0;
}

/**
 *  register activity over socket
 */
int activityRegisterOverSocket(
  struct activity *act
)
{
  if (!act)
    return -1;
  
  #ifdef _DEBUG
    printf("activityRegisterOverSocket start shm(%d) sem(%d)\n",
      act->shm->id,act->sem->id);
  #endif
  trop_IPC *client = trop_IPCInit(NULL);
  unsigned char msg[128];
  sprintf((char*)msg,"NEWACT\nANAME %s\nSHMID %d\nSEMID %d\nSHMSZ %d\n",
    (char*)act->name,
    act->shm->id,
    act->sem->id,
    act->shm->size);
  trop_IPCUdsHandshake(client,"./mika.sock",(char*)msg);
  free(client);
  #ifdef _DEBUG
    printf("activityRegisterOverSocket finish\n");
  #endif
  
  return 0;
}

/** register the access to the activity to a file
 */
int activityRegisterAccess( struct activity *act, unsigned char *filename )
{
  if (!act || !filename)
  {
    #ifdef _DEBUG
      printf("activityRegisterAccess error, invalid arguments\n");
    #endif
    return 1;
  }
  
  unsigned char line[64];
  FILE *out = fopen((char*)filename,"w");
  if (out)
  {
    sprintf((char*)line,"%d\n",act->sem->id);
    fwrite((char*)line,strlen((char*)line),1,out);
    sprintf((char*)line,"%d\n",act->shm->id);
    fwrite((char*)line,strlen((char*)line),1,out);
    fclose(out);
  }
  
  return 0;
}

/** register an exposure event over a socket
 */
int activityEventExposeOverSocket(
  struct activity *act
)
{
  if (!act)
    return -1;
  
  #ifdef _DEBUG
    printf("activityEventExposeOverSocket start\n");
  #endif
  trop_IPC *client = trop_IPCInit(NULL);
  unsigned char msg[128];
  sprintf((char*)msg,"EVEXP\n");
  trop_IPCUdsHandshake(client,"./mika.sock",(char*)msg);
  free(client);  
  #ifdef _DEBUG
    printf("activityEventExposeOverSocket finish\n");
  #endif  
    
  return 0;
}

struct activity *activityAlloc(
  struct activity *act
)
{
  if (!act)
  {
    act = (struct activity*)malloc(sizeof(struct activity));
  }
  
  act->shm = (struct rootShm*)malloc(sizeof(struct rootShm));
  act->sem = (struct rootSem*)malloc(sizeof(struct rootSem));
  
  return act;
}

/** parse activity data as string
 *
 */
int activityInitData(
  struct activity *act,
  unsigned char *data
)
{
  if (!act || !data)
    return -1;
  
  #ifdef _DEBUG
    printf("activityInitData data(%s)\n",data);
  #endif
  
  int i;
  int state = 0;
  int pos = 0;
  unsigned char line[32];
  unsigned char tmp[32];
  for(i = 0; i < strlen(data); i++)
  {
    if (data[i]=='\n')
    {
      strncpy((char*)line,data+pos,i-pos);
      line[i-pos] = 0x00;
      #ifdef _DEBUG
        printf("activityInitData line(%s)\n",(char*)line);
      #endif
    
      if (state == 0)
      {
        if (strncmp((char*)line,"NEWACT",6)==0)
        {
          act->type = _ACTIVITY_TYPE_APP;
          #ifdef _DEBUG
            printf("activityInitData NEWACT\n");
          #endif
          state = 1;
          pos = i+1;
          continue;
        }
        else if (strncmp((char*)line,"EVEXP",5)==0)
        {
          act->type = _ACTIVITY_TYPE_EVENT;
          #ifdef _DEBUG
            printf("activityInitData EVEXP\n");
          #endif
          state = 2;
          pos = i+1;
          continue;
        }
      }
    
      switch(state)
      {
        case 1:
          if (strncmp((char*)line,"SHMID",5)==0)
          {
            strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
            tmp[strlen((char*)line)-6] = 0x00;
            act->shm->id = atoi((char*)tmp);
          }
          else if (strncmp((char*)line,"ANAME",5)==0)
          {
            strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
            tmp[strlen((char*)line)-6] = 0x00;
            strcpy((char*)act->name,(char*)tmp);
          }
          else if (strncmp((char*)line,"SHMSZ",5)==0)
          {
            strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
            tmp[strlen((char*)line)-6] = 0x00;
            act->shm->size = atoi((char*)tmp);
          }
          else if (strncmp((char*)line,"SEMID",5)==0)
          {
            strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
            tmp[strlen((char*)line)-6] = 0x00;
            act->sem->id = atoi((char*)tmp);
          }
          
          /** refactoring - insure that the SHM exists at this moment
           */
          
          break;
        case 2:
          break;
      }
      pos = i+1;
    }
  }
  
  return 0;
}

/**  read activity attributes, needs to be synced - basically creates
 *   a copy of the activity attributes
 */
int activityInit(
  struct activity *act,
  unsigned char *path
)
{
  FILE *fd = NULL;
  unsigned char line[256];
  unsigned char tmp[256];

  if (!act || !path)
    return -1;
  
  if ((fd = fopen(path,"r"))==NULL)
  {
    #ifdef _DEBUG
      printf("activityInit could not open file(%s)\n",
        path);
    #endif
    return -1;
  }
  
  while(1)
  {
    fgets((char*)line,256,fd);
    if (feof(fd))
      break;
    if (line[strlen((char*)line)-1])
    {
      line[strlen((char*)line)-1] = 0x00;
    }
    
    if (strlen((char*)line)>6)
    {
      if (strncmp((char*)line,"SHMID",5)==0)
      {
        strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
        tmp[strlen((char*)line)-6] = 0x00;
        act->shm->id = atoi((char*)tmp);
      }
      
      if (strncmp((char*)line,"SHMSZ",5)==0)
      {
        strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
        tmp[strlen((char*)line)-6] = 0x00;
        act->shm->size = atoi((char*)tmp);
      }
      
      if (strncmp((char*)line,"SEMID",5)==0)
      {
        strncpy((char*)tmp,(char*)line+6,strlen((char*)line)-6);
        tmp[strlen((char*)line)-6] = 0x00;
        act->sem->id = atoi((char*)tmp);
      }
    }
  }
    
  return 0;
}

/** create the rootShm of the activity & allocate all needd space
 */
int activitySHMCreate( 
  struct activity *act, 
  int surfaceSize 
)
{
  #ifdef _DEBUG
    printf("activitySHMCreate surfaceSize(%d)\n",surfaceSize);
  #endif

  struct activityData *aData = NULL;

  int size = 
          sizeof(struct activityData) + 
          surfaceSize;
  
  if (
    os_rshmAlloc(act->shm,size,act->type,(unsigned char*)act->name) == -1
  )
  {
    #ifdef _DEBUG
      printf("activitySHMCreate error\n");
    #endif
    return -1;
  }
  
  act->shm->data = shmat(act->shm->id,0,0);
  aData = (struct activityData*)act->shm->data;
  aData->surface = act->shm->data+
              sizeof(struct activityData);
  
  struct activityEvent *event;
  event = &aData->event;
  event->active = 0;
  event->type = _ACTIVITY_EVENT_NONE;
  
  activitySHMInitAttributes(act);
  
  aData = NULL;
  shmdt(act->shm->data);

  #ifdef _DEBUG
    printf("activitySHMCreate ptr finish\n");
  #endif
  
  return 0;
}

int activitySHMGetEvent( // activityData
  struct activity *act,
  struct activityEvent *event
)
{
  struct activityData *aData = NULL;
  
  #ifdef _DEBUG
    printf("activitySHMGetEvent\n");
  #endif
  
  if (!act || !event)
    return -1;

  aData = (struct activityData*)act->shm->data;
  struct activityEvent *_eventPtr = &aData->event; //(struct activityEvent *)act->shm->data;
  if (!_eventPtr)
    return -1;
    
  if (_eventPtr->active==1)
  {
    event->type = _eventPtr->type;
  }
  #ifdef _DEBUG
    printf("activitySHMGetEvent finish\n");
  #endif
  
  return 0;
}

/** use this only when we are creating the actual prototype 
 *  of the activity
 */
int activitySHMInitAttributes(
  struct activity *act
)
{
  struct activityData *aData = NULL;
  
  #ifdef _DEBUG
    printf("activitySHMInitAttributes\n");
  #endif
  
  if (!act)
    return -1;
  
  aData = (struct activityData*)act->shm->data;
  
  aData->attributes.w = 0;
  aData->attributes.h = 0;
  aData->attributes.x = 0;
  aData->attributes.y = 0;
  aData->attributes.movable = 1;
  aData->attributes.visible = 1;
  aData->attributes.toplevel = 0;
    
  return 0;
}

int activitySHMGetAttributes(
  struct activity *act,
  struct activityAttributes *attributes
)
{
  struct activityData *aData = NULL;
  
  #ifdef _DEBUG
    printf("activitySHMGetAttributes\n");
  #endif
  
  if (!act || !attributes)
    return -1;
  
  aData = (struct activityData*)act->shm->data;
  struct activityAttributes *_attributesPtr = &aData->attributes;
  
  memcpy(attributes,_attributesPtr,sizeof(struct activityAttributes));
  
  #ifdef _DEBUG
    printf("activitySHMGetAttributes (%dx%d) movable(%d) visible(%d) toplevel(%d) finish\n",
      attributes->w,
      attributes->h,
      attributes->movable,
      attributes->visible,
      attributes->toplevel);
  #endif
  
  return 0;
}

int activitySHMSetAttributes(
  struct activity *act,
  struct activityAttributes *attributes
)
{
  struct activityData *aData = NULL;
  
  if (!act || !attributes)
    return -1;
  
  aData = (struct activityData*)act->shm->data;
  struct activityAttributes *_attributesPtr = &aData->attributes;
  if (!_attributesPtr)
    return -1;
  
  memcpy(_attributesPtr,attributes,sizeof(struct activityAttributes));
  
  #ifdef _DEBUG
    printf("activitySHMSetAttributes finish\n");
  #endif
  
  return 0;
}

/**  set an event for the activity
 */
int activitySHMPutEvent( // activityData
  struct activity *act,
  struct activityEvent *event
)
{
  struct activityData *aData = NULL;

  #ifdef _DEBUG
    printf("activitySHMPutEvent\n");
  #endif

  if (!act || !event)
    return -1;

  aData = (struct activityData*)act->shm->data;
  struct activityEvent *_eventPtr = &aData->event;
  if (!_eventPtr)
    return -1;

  event->active = 1;
  memcpy(_eventPtr,event,sizeof(struct activityEvent));
  #ifdef _DEBUG
    printf("activitySHMPutEvent finish\n");
  #endif

  return 0;
}

/**  get the pointer to the surface from the SHM data
 */
void *activitySHMGetSurface( // activityData
  struct activity *act
)
{
  struct activityData *aData = NULL;
  void *surface;
  
  #ifdef _DEBUG
    printf("activitySHMGetSurface\n");
  #endif
  
  /** need to connect the shared memmory before this
   *  function (shmat) and (shmdt) afterwards
   */
  aData = (struct activityData*)act->shm->data;
  aData->surface = act->shm->data+
              sizeof(struct activityData);
  surface = aData->surface;
  
  #ifdef _DEBUG
    printf("activitySHMGetSurface ptr(%p) finish\n",surface);
  #endif
  
  return surface;
}

int _activity_add_event_button(
  struct activityEvent *event,
  int x,
  int y
)
{
  if (!event)
    return -1;
  event->button.x = x;
  event->button.y = y;
  event->active = 1;
  return 0;
}

int activityAddEventButtonDown( // activityData
  struct activity *act,
  int x,
  int y
)
{
  struct activityEvent *event = NULL;
  struct activityData *aData = NULL;
  
  if (!act)
    return -1;
  
  #ifdef _DEBUG
    printf("activityAddEventButtonDown EVENTFLOW\n");
  #endif
  
  void *data = shmat(act->shm->id,0,0);
  aData = data;
  event = &aData->event;
  _activity_add_event_button(event,x,y);
  event->type = _ACTIVITY_EVENT_BUTTONDOWN;
  shmdt(data);
  
  #ifdef _DEBUG
    printf("activityAddEventButtonDown finish EVENTFLOW\n");
  #endif
    
  return 0;
}

int activityAddEventButtonUp( // activityData
  struct activity *act,
  int x,
  int y
)
{
  struct activityData *aData = NULL;
  struct activityEvent *event = NULL;
  
  if (!act)
    return -1;
  
  #ifdef _DEBUG
    printf("activityAddEventButtonUp EVENTFLOW\n");
  #endif
  
  void *data = shmat(act->shm->id,0,0);
  aData = data;
  event = &aData->event;
  _activity_add_event_button(event,x,y);
  event->type = _ACTIVITY_EVENT_BUTTONUP;
  shmdt(data);
  
  #ifdef _DEBUG
    printf("activityAddEventButtonUp finish EVENTFLOW\n");
  #endif
    
  return 0;
}

/**  event for the desktop to repaint the surface
 */
int activityAddEventExpose( // activityData
  struct activity *act
)
{
  struct activityData *aData = NULL;
  struct activityEvent *event = NULL;

  if (!act)
    return -1;
  
  if (!act->shm)
    return -1;
    
  #ifdef _DEBUG
    printf("activityAddEventExpose\n");
  #endif
  
  void *data = shmat(act->shm->id,0,0);
  if (!data)
    return -1;
  aData = data;
  event = &aData->event;
  event->active = 1;
  event->type = _ACTIVITY_EVENT_EXPOSE;
  shmdt(data);
  #ifdef _DEBUG
    printf("activityAddEventExpose finish\n");
  #endif
    
  return 0;
}

/**  event for the application to repaint it's surface
 */
int activityAddEventRepaint( // activityData
  struct activity *act
)
{
  struct activityEvent *event = NULL;
  struct activityData *aData = NULL;
  static int run = 0;
  
  if (!act)
    return -1;
  
  #ifdef _DEBUG
    printf("activityAddEventRepaint UEVENT %d\n",run);
  #endif
  
  void *data = shmat(act->shm->id,0,0);
  aData = data;
  event = &aData->event;
  
  event->active = 1;
  event->type = _ACTIVITY_EVENT_REPAINT;
  shmdt(data);
  
  #ifdef _DEBUG
    printf("activityAddEventRepaint finish UEVENT %d\n",run);
  #endif
    
  run++;  
  return 0;
}

int activityEventActive( // activityData - needs to be synced
  struct activity *act
)
{  
  int active = 0;
  void *data = NULL;
  struct activityEvent *event = NULL;
  struct activityData *aData = NULL;

  data = shmat(act->shm->id,0,0);
  aData = (struct activityData*)data;
  event = &aData->event;
  active = event->active;
  shmdt(data);
  
  return active;
}

int activityEventGet( // activityData
  struct activity *act,
  struct activityEvent *remoteEvent
)
{
  #ifdef _DEBUG
    printf("activityEventGet\n");
  #endif

  void *data = NULL;
  struct activityEvent *event = NULL;
  struct activityData *aData = NULL;

  data = shmat(act->shm->id,0,0);
  aData = data;
  
  event = &aData->event;
  event->active = 0;
  
  #ifdef _DEBUG
    printf("activityEventGet ");
    switch(event->type)
    {
      case _ACTIVITY_EVENT_REPAINT:
        printf("_ACTIVITY_EVENT_REPAINT\n");
        break;
      case _ACTIVITY_EVENT_EXPOSE:
        printf("_ACTIVITY_EVENT_EXPOSE\n");
        break;
      case _ACTIVITY_EVENT_BUTTONDOWN:
        printf("_ACTIVITY_EVENT_BUTTONDOWN\n");
        break;
      case _ACTIVITY_EVENT_BUTTONUP:
        printf("_ACTIVITY_EVENT_BUTTONUP\n");
        break;
    }
  #endif
  
  memcpy(remoteEvent,event,sizeof(struct activityEvent)); 
  shmdt(data);
  
  #ifdef _DEBUG
    printf("activityEventGet finish\n");
  #endif
  
  return 0;
}

int activityEventIsEvent( // activityData - needs to be synced
  struct activity *act,
  int type
)
{
  #ifdef _DEBUG
    printf("activityEventIsEvent\n");
  #endif
  
  if (!act)
    return 0;
  
  void *data = NULL;
  struct activityData *aData = NULL;

  data = shmat(act->shm->id,0,0);
  aData = data;
  if (aData->event.type==type)
  {
    shmdt(data);
    return 1;
  }
  
  shmdt(data);  
    
  return 0;
}

#define _OVERRIDE_ACTIVITY_ATTRIBUTES_NO
/**  remake (to somin like a list of attributes..)
 */
int activitySetMovable( struct activity *act, int movable, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activitySetMovable\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif

  if (!act) return 1;
  if (sync==1) activityLock(act); 
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  aData->attributes.movable = movable;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activitySetMovable finish\n");
  #endif
  return 0;
}

int activityGetMovable( struct activity *act, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activityGetMovable\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 1;
  #endif
  
  if (!act) return -1;
  int movable = 0;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  movable = aData->attributes.movable;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activityGetMovable finish\n");
  #endif
  return movable;
}

int activitySetVisible( struct activity *act, int visible, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activitySetVisible\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif

  if (!act) return 1;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  aData->attributes.visible = visible;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activitySetVisible finish\n");
  #endif
  return 0;
}

int activityGetVisible( struct activity *act, int sync )
{
  struct activityData *aData;
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 1;
  #endif
  
  if (!act) return -1;
  int visible = 0;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  visible = aData->attributes.visible;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  return visible;
}

int activitySetToplevel( struct activity *act, int toplevel, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activitySetToplevel\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif
  
  if (!act) return 1;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  aData->attributes.toplevel = toplevel;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activitySetToplevel finish\n");
  #endif
  return 0;
}

int activityGetToplevel( struct activity *act, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activityGetToplevel\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif
  
  if (!act) return -1;
  int toplevel = 0;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  toplevel = aData->attributes.toplevel;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activityGetToplevel finish\n");
  #endif
  return toplevel;
}

int activitySetAngle( struct activity *act, int angle, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activitySetAngle\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif
  
  if (!act) return 1;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  aData->attributes.angle = angle;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activitySetAngle finish\n");
  #endif
  return 0;
}

int activityGetAngle( struct activity *act, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activityGetAngle\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return -1;
  #endif
  
  if (!act) return -1;
  int angle = 0;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  angle = aData->attributes.angle;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activityGetAngle finish\n");
  #endif
  return angle;
}

int activitySetForceangle( struct activity *act, int angle, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activitySetForceangle\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return 0;
  #endif
  
  if (!act) return 1;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  aData->attributes.forceangle = angle;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activitySetForecast finish\n");
  #endif
  return 0;
}

int activityGetForceangle( struct activity *act, int sync )
{
  struct activityData *aData;
  #ifdef _DEBUG
    printf("activityGetForceangle\n");
  #endif
  #ifdef _OVERRIDE_ACTIVITY_ATTRIBUTES
    return -1;
  #endif
  
  if (!act) return -1;
  int angle = 0;
  if (sync==1) activityLock(act);
  
  aData = (struct activityData*)shmat(act->shm->id,0,0);
  angle = aData->attributes.forceangle;
  shmdt(aData);
  
  if (sync==1) activityUnlock(act);
  #ifdef _DEBUG
    printf("activityGetForceangle finish\n");
  #endif
  return angle;
}