gobject.c

LastWave

    /*  
     * First we perform the messages that cannot be redifined by class messages
     */  
  
    /* Delete message */
    if (!strcmp(msge,"delete")) { 
      SetResultInt((int) DeleteGObject(o));
      continue;
    }

    /* Back message */
    if (!strcmp(msge,"back")) { 
      BackGObject(o,YES);      
      SetResultInt(1);
      continue;
    }

    /* Front message */
    if (!strcmp(msge,"front")) { 
      FrontGObject(o,YES);      
      SetResultInt(1);
      continue;
    }
  
    /* IsIn message */
    if (!strcmp(msge,"isin")) { 
      argv = ParseArgv(argv,tFLOAT,&fx,tFLOAT,&fy,0);
      Local2Global(o,fx,fy,&x,&y);
      SetResultInt(IsInGObject(o,&o1,x,y)>=0);
      o->classCur = o->gclass;
      continue;
    }

    /* move message */
    if (!strcmp(msge,"move")) { 
      argv = ParseArgv(argv,tFLOAT,&rx,tFLOAT,&ry,0);
      MoveResizeDrawGObject(o,rx,ry,o->rw,o->rh);
      SetResultInt(1);
      o->classCur = o->gclass;
      continue;
    }

    /* pmove message */
    if (!strcmp(msge,"pmove")) { 
      argv = ParseArgv(argv,tINT,&w,tINT,&h,0);
      if (!IsWin(o)) {
        Local2Global((GOBJECT) o->father,o->rx,o->ry,&x,&y);
        Global2Local((GOBJECT) o->father,x+w,y+h,&rx,&ry);
      }
      else {
        rx = o->x+w;
        ry = o->y+h;
      }
      MoveResizeDrawGObject(o,rx,ry,o->rw,o->rh);
      SetResultInt(1);
      o->classCur = o->gclass;
      continue;
    }

    /* class message */
    if (!strcmp(msge,"class")) { 
      argv = ParseArgv(argv,tSTR_,NULL,&str,0);
      if (str != NULL) {
        class = (GCLASS) GetElemHashTable(theGClasses,str);
        if (class == NULL) Errorf("Class '%s' does not exist",str);
        SetResultInt((int) IsSubClass(o->gclass,class));
      }
      else SetResultStr(o->gclass->name);
      o->classCur = o->gclass;
      continue;
    }

    /* id message */
    if (!strcmp(msge,"id")) { 
      NoMoreArgs(argv);
      SetResultf("%p",o);
      o->classCur = o->gclass;
      continue;
    }
    
    /* resize message */
    if (!strcmp(msge,"resize")) { 
      argv = ParseArgv(argv,tFLOAT,&rw,tFLOAT,&rh,0);
      MoveResizeDrawGObject(o,o->rx,o->ry,rw,rh);
      SetResultInt(1);
      o->classCur = o->gclass;
      continue;
    }

    /* g2l message */
    if (!strcmp(msge,"g2l")) { 
      argv = ParseArgv(argv,tINT,&x,tINT,&y,tINT_,-1,&w,tINT_,-1,&h,0);
      if (w < 0 || h < 0)  {
        Global2Local(o,x,y,&rx,&ry);
        lv = TNewListv();
        AppendFloat2Listv(lv,rx);
        AppendFloat2Listv(lv,ry);
        SetResultValue(lv);
      }
      else {
        Global2LocalRect(o,x,y,w,h,&rx,&ry,&rw,&rh,NormalRect);
        lv = TNewListv();
        AppendFloat2Listv(lv,rx);
        AppendFloat2Listv(lv,ry);
        AppendFloat2Listv(lv,rw);
        AppendFloat2Listv(lv,rh);
        SetResultValue(lv);
      }
      o->classCur = o->gclass;
      continue;
    }

    /* l2g message */
    if (!strcmp(msge,"l2g")) { 
      argv = ParseArgv(argv,tFLOAT,&rx,tFLOAT,&ry,tFLOAT_,-1.,&rw,tFLOAT_,-1.,&rh,0);
      if (rw < 0 || rh < 0)  {
        Local2Global(o,rx,ry,&x,&y);
        lv = TNewListv();
        AppendInt2Listv(lv,x);
        AppendInt2Listv(lv,y);
        SetResultValue(lv);
      }
      else {
        Local2GlobalRect(o,rx,ry,rw,rh,LargeRect,&x,&y,&w,&h);
        lv = TNewListv();
        AppendInt2Listv(lv,x);
        AppendInt2Listv(lv,y);
        AppendInt2Listv(lv,w);
        AppendInt2Listv(lv,h);
        SetResultValue(lv);
      }
      o->classCur = o->gclass;
      continue;
    }

    /* father message */
    if (!strcmp(msge,"father")) { 
      NoMoreArgs(argv);
      if (o->father == NULL) SetResultValue(nullValue);
      else {
        SetResultStr(GetNameGObject((GOBJECT) (o->father)));
        o->classCur = o->gclass;
      }
      continue;
    }

    /* Hide message */
    if (!strcmp(msge,"hide")) { 
      NoMoreArgs(argv);
      HideGObject(o);
      SetResultInt(1);
      o->classCur = o->gclass;
      continue;
    }

    /* Show message */
    if (!strcmp(msge,"show")) { 
      NoMoreArgs(argv);
      ShowGObject(o);
      SetResultInt(1);
      o->classCur = o->gclass;
      continue;
    }

    /* Class dependent messages */
    class = o->classCur;
    while (class != NULL) {
      /* Should we execute a script ? */
      if (class->msgeSCommand && strcmp(*argv1,"add")) {
        DoScriptArgv(o,class->msgeSCommand,argv1);
        if (toplevelCur->flagReturn) break;
      }
      /* Should we execute a C function ? */
      else if (class->msge) {
        if ((*(class->msge))(o,msge,argv)) break;
      }
      /* Try the fatherClass */
      class = class->fatherClass;
    }    
    o->classCur = o->gclass;
  }
}


/***************************************************
 *
 *
 * Functions that deal with parsing GObjects
 *
 *
 ***************************************************/

/*
 * Search for a list  of  gobjects whose name matches the pattern 'filter'
 * The gobjects must be direct son (if flagDeepSearch == NO) of 'o' or any 
 * son of 'o' (if flagDeepSearch == YES).
 * If list == NULL then the gobjects we are searching for are windows.
 * The gobjects must be of class 'class' (unless class == NULL)
 * The result list is set in the array 'gobjects' and the length of this list is set in '*nGObjects'.
 * The list must have a maximum length of 'maxNGObjects'
 *
 * It returns NO if an error occurred otherwise it returns YES.
 */  


static char SearchGObjectList(GOBJECT o, char *filter, GCLASS class, int maxNGObjects, GOBJECT *gobjects,int *nGObjects, char flagDeepSearch) 
{
  GOBJECT obj;
  GLIST list;
  HASHTABLE hash;
  GOBJECT back;
  char *str;
  char flagWild;
    
  /* If name is ^ then we must go 1 level up */
  if (!strcmp(filter,"^")) {
    if (o == NULL) return(YES);
    if (class && !IsSubClass(o->father->gclass,class)) return(YES);
    gobjects[(*nGObjects)++] = (GOBJECT) o->father;
    return(YES);
  }
  
  if (o && !IsGList(o)) Errorf("SearchGObjectList() : Weird error");
  list = (GLIST) o;
  
  /* If list  is NULL we must use the window hashtable otherwise we use the glist hashtable */
  if (list == NULL) {
    hash = theWindowsHT;
    back = (GOBJECT) theWindows;
  }
  else {
    hash = list->theGObjects;
    back = list->back;
  }
  
  /* Does the filter contain a wild card character ? */
  flagWild = NO;
  str = filter;
  while (*str != '\0') {
    if (*str == '*' || *str == '[' || *str == '?') {
      flagWild = YES;
      break;
    }
    str++;
  }
     
  /* Look at the first level of the glist */
  /* If there is no wild card character we just use the hash table */
  if (!flagWild) {
    obj = (GOBJECT) GetElemHashTable(hash,filter);
    if (obj != NULL) {
      if (*nGObjects>=maxNGObjects) return(YES);
      if (!class || IsSubClass(obj->gclass,class)) {
        gobjects[(*nGObjects)++] = obj;
      }
    }
  }
  else {
    /* Otherwise we have to go through the whole 'back' list */
    for (obj = back; obj != NULL; obj = obj->front) {
      if (class && !IsSubClass(obj->gclass,class)) continue;
      if (MatchStr(obj->name,filter)) {
        if (*nGObjects>=maxNGObjects) return(YES);
        gobjects[(*nGObjects)++] = obj;
      }
    }
  }
  
  if (!flagDeepSearch) return(YES);
  
  /* Recursive search */
  for (obj = back; obj != NULL; obj = obj->front) {
    if (IsGList(obj)) {
      if (!SearchGObjectList(obj,filter,class,maxNGObjects,gobjects,nGObjects,flagDeepSearch)) return(NO);
    }
  }
  
  return(YES);
}


/*
 * Parse the string 'str0' which must be a valid gobject filter name (using wild cards) and returns the list of the matching gobjects
 *
 * The result list is set in the array 'gobjects' and the length of this list is set in '*nGObjects'.
 * The list must have a maximum length of 'maxNGObjects'
 * If 'glist' is not NULL then 'str0' starts with a dot and the objects should be sons (direct or not) of 'glist'.
 *
 * It returns NO if an error occurred otherwise it returns YES.
 */  

static char ParseGObjectList__(char *str0, GLIST glist, int maxNGObjects, GOBJECT *gobjects,int *nGObjects)
{
  WINDOW win;
  GOBJECT *list1,*list2,*list;
  int nList1,nList2,n,i;
  char c;
  char *str1, *str2;
  char flagDeepSearch;
  GCLASS class,class1;
  static GOBJECT gobjList1[MaxSizeGObjectList],gobjList2[MaxSizeGObjectList];
  
  /* init the result */
  *nGObjects = 0;

  /* Some basic tests */  
  if (str0 == NULL) return(YES);
  if (*str0 == '\0') return(YES);
  
  /* If glist is not NULL then the begining is easy */
  if (glist != NULL) {
    if (*str0 != '.') {
      SetErrorf("ParseGObjectList__() : Bad name '%s' for gobject of glist '%s'",str0,GetNameGObject((GOBJECT) glist));
      return(NO);
    }
    str1 = str0;
    class = NULL;
    *gobjList1 = (GOBJECT) glist;
    nList1 = 1;
  }
  
  /* Otherwise it's a whole different story ! */
  else {
    
    /*
     * Getting an eventual class conversion 'class:a.b.c' 
     */
    class = NULL;
    str1 = str0;
    while (*str1 != '\0' && *str1 != ':') str1++;
    if (*str1 == ':') {
      *str1 = '\0';
      class = (GCLASS) GetElemHashTable(theGClasses,str0);
      if (class == NULL) {
        SetErrorf("ParseGObjectList__() : Bad class name in gobject name '%s'",str0);
        *str1 = ':';
        return(NO);
      }
      *str1 = ':';
      str0 = str1+1;
    }
             
    /* If it starts with a '.', we must get the current window */
    if (*str0 == '.') {
    
      if (ParseWindow_(".",NULL,&win) == NO) return(NO);
   
      /* If there is nothing else then we must check the class if any and return */
      if (str0[1] == '\0') {
        if (class && !IsSubClass(win->gclass,class)) {
          SetErrorf("ParseGObjectList__() : Bad class '%s' for current window '%s'",class->name,win->name);
          return (NO);
        } 
        *gobjects = (GOBJECT) win;
        (*nGObjects)++;
        if (class) gobjects[0]->classCur = class;
        else gobjects[0]->classCur = gobjects[0]->gclass;
        return(YES);
      }
      str1 = str0;
    
      gobjList1[0] = (GOBJECT) win;
      nList1 = 1;  
    }
  
    /* Otherwise we look for the first name */
    else {
      str1 = str0;
      while(*str1 != '\0' && *str1 != '.') str1++;
      c = *str1;
      *str1 = '\0';
    
      /* Search for @Variables first */
      if (*str0 == '@') { 
        if (toplevelCur->lastEvent == NULL || toplevelCur->lastEvent->type == NoEvent || toplevelCur->lastEvent->object == NULL) {
          SetErrorf("ParseGObjectList__() : No current gobject event for @ variable",str0);
          *str1 = c;
          return(NO);    
        }
        if (!strncmp(str0,"@object",7)) {
          str2 = str0+7;
          *gobjList1 = toplevelCur->lastEvent->object;
        }
        else if (!strncmp(str0,"@father",7)) {
          *gobjList1 = (GOBJECT) toplevelCur->lastEvent->object->father;
          if (*gobjList1 == NULL) {
            SetErrorf("ParseGObjectList__() : Current event gobject does not have any father",str0);
            *str1 = c;
            return(NO);
          }
          str2 = str0+7;
        }
        else if (!strncmp(str0,"window",7)) {
          *gobjList1 = (GOBJECT) GetWin(toplevelCur->lastEvent->object);
          str2 = str0+6;
        }
        else {
          SetErrorf("ParseGObjectList__() : Bad object name '%s'",str0);
          return(NO);
        }
    
        /* Are we done ? */ 
        *str1 = c;    
        if (c != '.' && c != '\0') {
          SetErrorf("ParseGObjectList__() : Bad event variable '%s'",str0);
          return(NO);
        }
        if (c == '\0') {
          if (class && !IsSubClass((*gobjList1)->gclass,class)) {
            SetErrorf("ParseGObjectList__() : Bad class '%s' for gobject '%s'",class->name,(*gobjList1)->name);
            return (NO);
          }
          *gobjects = *gobjList1;
          *nGObjects = 1;
          if (class) gobjects[0]->classCur = class;
          else gobjects[0]->classCur = gobjects[0]->gclass;
          return(YES);
        }
      
        /* Get ready for the following */
        nList1 = 1;
        str1 = str2;      
      }
  
      /* Regular variables */
      else {
        if (c == '\0') {
          SearchGObjectList(NULL,str0,class,maxNGObjects,gobjects,nGObjects,NO);
          *str1 = c;
          if (class) {
            for (i=0;i< (*nGObjects);i++) {
              gobjects[i]->classCur = class;
            }
          }
          return(YES);
        }
        else if (str1[1] != '^') {
          n = 0;
          SearchGObjectList(NULL,str0,theGListClass,MaxSizeGObjectList,gobjList1,&n,NO);
          nList1 = n;
        }
        else {
          n = 0;
          SearchGObjectList(NULL,str0,NULL,MaxSizeGObjectList,gobjList1,&n,NO);
          nList1 = n;
        }
        *str1 = c;
        if (n == 0) return(YES);
      }
    }
  }
  
  /* Some inits before the loop */
  list1 = gobjList1;
  list2 = gobjList2;
  nList2 = 0;

  if (*str1 != '.') Errorf("MERDE");  
  if (nList1 != 1) Errorf("MERDE1");  

  /* Now we start The Loop ! (str1 is pointing to a '.') */
  while(1) {
  
  if (*str1 != '.') Errorf("MERDE2");  

    /* If there is two dots then we should 'deep search' the next object */
    str1++;
    if (str1[0] == '.') {
      flagDeepSearch = YES;
      str1++;
    } else flagDeepSearch = NO;
    
    /* Look for the next name */
    str2 = str1;
    while(*str2 != '\0' && *str2 != '.') str2++;
    c = *str2;
    *str2 = '\0';
    
    /* Let's loop on the object of list1 and get list2 */
    if (c == '\0') class1 = class;
    else if (str2[1] != '^') class1 = theGListClass;
    else class1 = NULL;
    nList2 = 0;
    for (i=0;i<nList1;i++) {
      SearchGObjectList(list1[i],str1,class1,MaxSizeGObjectList,list2,&nList2,flagDeepSearch);