xsend.c

来自「speech signal process tools」· C语言 代码 · 共 1,229 行 · 第 1/3 页

				 * registered. */
   Window          commWindow;	/* X identifier for comm. window of
				 * application.  */
{
   char            id[30];
   char           *newProp;
   int             idLength, newBytes;

   sprintf(id, "%x ", (unsigned int) commWindow);
   idLength = strlen(id);
   newBytes = idLength + strlen(name) + 1;
   newProp = (char *) malloc((unsigned) (regPtr->propLength + newBytes));
   strcpy(newProp, id);
   strcpy(newProp + idLength, name);
   if (regPtr->propLength > 0) {
      memcpy((void *) (newProp + newBytes), (void *) regPtr->property,
	     regPtr->propLength);
      if (regPtr->allocedByX) {
	 XFree(regPtr->property);
      } else {
	 free(regPtr->property);
      }
   }
   regPtr->modified = 1;
   regPtr->propLength += newBytes;
   regPtr->property = newProp;
   regPtr->allocedByX = 0;
}

static void
RegClose(regPtr)
   NameRegistry   *regPtr;	/* Pointer to a registry opened with a
				 * previous call to RegOpen. */
{
   if (regPtr->modified) {
      if (!regPtr->locked && !debug_level) {
	 fprintf(stderr,
		 "The name registry was modified without being locked!");
	 return;
      }
      XChangeProperty(regPtr->display,
		      RootWindow(regPtr->display, 0),
		      registryProperty, XA_STRING, 8,
		      PropModeReplace, (unsigned char *) regPtr->property,
		      (int) regPtr->propLength);
   }
   if (regPtr->locked) {
      XUngrabServer(regPtr->display);
   }
   XFlush(regPtr->display);

   if (regPtr->propLength > 0) {
      if (regPtr->allocedByX) {
	 XFree(regPtr->property);
      } else {
	 free(regPtr->property);
      }
   }
   free((char *) regPtr);
}

static int
SplitList(list, argc, argv)
   char           *list;
   int            *argc;
   char         ***argv;
{
   char           *p, *s, *strtok(), *strdup();

   *argc = 0;
   if (!list)
      return 0;

   *argv = (char **) malloc(sizeof(char *));
   p = list;
   while (s = strtok(p, "\0")) {
      p = NULL;
      if (debug_level)
	 fprintf(stderr, "Split: %s\n", s);
      *argv = (char **) realloc(*argv, sizeof(char *) + *argc);
      (*argv)[*argc] = strdup(s);
      *argc += 1;
   }
   return 1;
}

static int
ValidateName(display, name, window)
   Display        *display;
   char           *name;
   Window          window;
{
   int             argc, result, actualFormat, i;
   unsigned long   length, bytesAfter;
   Atom            actualType;
   char           *property;
   char          **argv;
   int             (*defaultHandler) () = NULL;


   spsassert(display, "ValidateName: display is NULL");
   spsassert(name, "ValidateName: name is NULL");
   spsassert(window, "ValidateName: window is zero");

   /*
    * Be sure window matches Tk 4.0 commWindow specs.  This version does not
    * allow pre 4.0 windows to work.
    */
   if (debug_level)
      fprintf(stderr, "ValidateName display: %x, window: %x, name: %s\n",
	      display, window, name);

   property = NULL;

   defaultHandler = XSetErrorHandler(XSend_Handler);

   result = XGetWindowProperty(display, window,
			       appNameProperty, 0, MAX_PROP_WORDS,
			       False, XA_STRING, &actualType, &actualFormat,
			&length, &bytesAfter, (unsigned char **) &property);

   (void) XSetErrorHandler(defaultHandler);

   if (debug_level)
      fprintf(stderr, "ValidateName: Got property from X\n");

   if ((result == Success) && (actualFormat == 8)
       && (actualType == XA_STRING)) {
      result = 0;
      if (debug_level)
	 print_data(property, length);
      if (SplitList(property, &argc, &argv) == 1) {
	 for (i = 0; i < argc; i++) {
	    if (strcmp(argv[i], name) == 0) {
	       result = 1;
	       break;
	    }
	 }
	 for (i = 0; i < argc; i++)
	    free(argv[i]);
	 free((char *) argv);
      }
   } else {
      result = 0;
   }
   if (property != NULL) {
      XFree(property);
   }
   return result;
}

static void
AppendProp(display, window, property, data, length)
   Display        *display;
   Window          window;
   Atom            property;
   char           *data;
   int             length;
{
   int             (*defaultHandler) () = NULL;

   if (debug_level) {
      fprintf(stderr, "AppendProp:\n");
      fprintf(stderr, "display: %x, win: %x, len: %d\n",
	      display, window, length);
   }
   defaultHandler = XSetErrorHandler(XSend_Handler);

   XChangeProperty(display, window, property, XA_STRING, 8,
		   PropModeAppend, data, length);
   XSync(display, FALSE);

   (void) XSetErrorHandler(defaultHandler);
}

static void
print_prop(regPtr)
   NameRegistry   *regPtr;	/* Pointer to a registry opened with a
				 * previous call to RegOpen. */
{
   char           *p, *entry;
   Window          commWindow;

   commWindow = None;
   for (p = regPtr->property; (p - regPtr->property) < regPtr->propLength;) {
      entry = p;
      fprintf(stderr, "%s\n", entry);
      while ((*p != 0) && (!isspace(UCHAR(*p)))) {
	 p++;
      }
      while (*p != 0) {
	 p++;
      }
      p++;
   }
   return;
}

static void
print_data(ptr, len)
   char           *ptr;
   int             len;
{
   int             i;
   fprintf(stderr, "print_data: len: %d\n", len);
   for (i = 0; i < len; i++)
      if (ptr[i] == '\0')
	 fprintf(stderr, "<null>");
      else
	 fputc(ptr[i], stderr);
   fprintf(stderr, ":end:\n");
}

static int
XSend_Handler(display, error)
   Display        *display;
   XErrorEvent    *error;
{
   if (debug_level) {
      char            msg[80];
      fprintf(stderr, "XSend_Handler called\n");
      XGetErrorText(display, error->error_code, msg, 80);
      fprintf(stderr, "Error code %s\n", msg);
   }
   XSend_Error = 1;
   return 0;
}

static int
XSend_Update_Handler(display, error)
   Display        *display;
   XErrorEvent    *error;
{
   fprintf(stderr, "Unexpected X error in UpdateCommWindow, ignored.\n");
   fprintf(stderr, "Cound not update Comm window property\n");
   if (debug_level) {
      char            msg[80];
      XGetErrorText(display, error->error_code, msg, 80);
      fprintf(stderr, "Error code %s\n", msg);
   }
   return 0;
}

static void
Usleep(usecs)
   unsigned int    usecs;
{
   struct timeval  tval;

   tval.tv_sec = usecs / 1000000;
   tval.tv_usec = usecs % 1000000;
   select(0, NULL, NULL, NULL, &tval);
}


int
SendXwavesNoReply(display_name, dest, sxarg, msg)
   char           *display_name;
   char           *dest;
   Sxptr          *sxarg;
   char           *msg;
{
   int             res;
   Sxptr          *sxptr;

   if (!msg || (!sxarg && !dest))	/* bad args */
      return 0;

   if (!sxarg) {
      if ((sxptr = OpenXwaves(display_name, dest, SendXwaves_defname)) == NULL)
	 return 0;
   } else
      sxptr = sxarg;

   res = Send_X_Msg(sxptr->display, sxptr->dest_name, sxptr->dest_window,
		    IMMEDIATE_RESPONSE, msg, strlen(msg));
   if (!sxarg)
      CloseXwaves(sxptr);

   return res;
}

char           *
SendXwavesReply(display_name, dest, sxarg, msg, timeout)
   char           *display_name;
   char           *dest;
   Sxptr          *sxarg;
   char           *msg;
   unsigned int    timeout;	/* in ms. */
{
   int             res;
   XEvent          event;
   char           *result = NULL;
   int             serial, loop_count = 0;
   Sxptr          *sxptr;

   if (!msg || (!sxarg && !dest))	/* bad args */
      return NULL;

   if (!sxarg) {
      if ((sxptr = OpenXwaves(display_name, dest, SendXwaves_defname)) == NULL)
	 return NULL;
   } else
      sxptr = sxarg;

   if( !ValidateName(sxptr->display, sxptr->dest_name, sxptr->dest_window) )
      return NULL;

   XSelectInput(sxptr->display, sxptr->my_window, PropertyChangeMask);
   res = Send_X_Msg(sxptr->display, sxptr->dest_name, sxptr->dest_window,
		    INTERLOCK_DELAY_RESPONSE, msg, strlen(msg));
   if (!res) {
      XSelectInput(sxptr->display, sxptr->my_window, NoEventMask);
      if (sxarg)
	 CloseXwaves(sxptr);
      return NULL;
   }
   while (1) {
      if (XCheckMaskEvent(sxptr->display, PropertyChangeMask, &event)
	  != False) {
	 if (event.type == PropertyNotify &&
	     event.xproperty.window == sxptr->my_window) {
	    result = Read_X_Reply(sxptr->display, sxptr->my_window,
				  &event, SendSerial);
	    if (result)
	       break;
	 }
      }
      Usleep((unsigned) 1000);
      if (loop_count++ > timeout)
	 break;
   }
   XSelectInput(sxptr->display, sxptr->my_window, NoEventMask);
   if (!sxarg)
      CloseXwaves(sxptr);
   return result;
}


Sxptr          *
OpenXwaves(display_name, dest, myname)
   char           *display_name;
   char           *dest;
   char           *myname;
{
   Sxptr          *sxptr = (Sxptr *) malloc(sizeof(Sxptr));
   int             screen_num;
   char           *strdup();

   if (!dest || !sxptr) {
      return NULL;
   }
   if (!myname)
      myname = SendXwaves_defname;

   if ((sxptr->display = XOpenDisplay(display_name)) == NULL) {
      fprintf(stderr, "%s: Cannot connect to X server %s\n",
	      myname, XDisplayName(display_name));
      return NULL;
   }
   screen_num = DefaultScreen(sxptr->display);
   sxptr->my_window = XCreateSimpleWindow(sxptr->display,
				     RootWindow(sxptr->display, screen_num),
					  0, 0, 1, 1, 1,
				     BlackPixel(sxptr->display, screen_num),
				    WhitePixel(sxptr->display, screen_num));
   sxptr->my_name = Setup_X_Comm(myname, sxptr->display, sxptr->my_window);
   if (!sxptr->my_name) {
      free(sxptr);
      return NULL;
   }
   sxptr->my_name = strdup(sxptr->my_name);
   sxptr->dest_window = Get_X_Comm_Win(sxptr->display, dest);
   if (!sxptr->dest_window) {
      free(sxptr->my_name);
      free(sxptr);
      return NULL;
   }
   sxptr->dest_name = strdup(dest);
   return sxptr;
}

void
CloseXwaves(sxptr)
   Sxptr          *sxptr;
{
   if (sxptr) {
      Close_X_Comm(sxptr->display, sxptr->my_name);
      XCloseDisplay(sxptr->display);
      free(sxptr->dest_name);
      free(sxptr->my_name);
      free(sxptr);
   }
}

char           *
StripReturn(msg)
   char           *msg;
{
   char           *ptr = NULL;

   if (msg) {
      ptr = msg;
      if (!strncmp("returned", msg, 8))
	 ptr += 9;
   }
   return ptr;
}