/* 
 * Copyright (C) 1996-1998 Szeredi Miklos
 * Email: mszeredi@inf.bme.hu
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version. See the file COPYING. 
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/*
 *
 *       ax.c
 *
 *
 *
 *       Created: 94/11/11 Szeredi Miklos
 *
 *       Version: 0.1  94/11/11
 *                0.2  95/06/12
 *
 */

/* #define DEBUG_EVENTS */

#include "ax.h"
#include <X11/Xutil.h>
#include <X11/Xresource.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/time.h>
#include <sys/types.h>
#include <signal.h>


#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
typedef int boolean;
#define max(x, y) ((x) < (y) ? (y) : (x))
#define min(x, y) ((x) < (y) ? (x) : (y))
#define minmax(a, l, u) ((a) < (l) ? (l) : ((a) > (u) ? (u) : (a)))

#define MAX_PROG_NAME_LEN 128
#define MAX_CLASS_NAME_LEN MAX_PROG_NAME_LEN 
#define MAX_PRES_LEN 256
#define MAX_FILENAME_LEN 1024

static const char *empty_str = "";

typedef void (*eventproc_t)(XEvent *, void *);

typedef struct _event_proc_struct {
  eventproc_t                  event_proc;
  unsigned long                event_mask;
  Display                      *disp;
  void                         *ptr;
  Window                       event_win;
  boolean                      done_proc;
  struct _event_proc_struct    *next_proc;
} event_proc_struct;

typedef struct {
  const char        *event_name;
  boolean           win_given;
  event_proc_struct *next_proc;
} event_struct;

typedef struct _disp_struct{
  Display *disp;
  XFontStruct *font;
  struct _disp_struct *next_disp;
} disp_struct;

     
#define  EVENT_NUM     LASTEvent

static event_struct event_info[EVENT_NUM];

static disp_struct disp_start = {NULL, NULL, NULL};

static boolean disp_chain_modified;

static char prog_name[MAX_PROG_NAME_LEN + 1];
static char class_name[MAX_CLASS_NAME_LEN + 1];

static XrmDatabase rDB = NULL; /* Has to be global otherwise Xlib hangs */

static int opTableEntries = 19;
static aX_options opTable[] = {
  {"-display",       ".display",      XrmoptionSepArg,     NULL},
  {"-geometry",      ".geometry",     XrmoptionSepArg,     NULL},
  {"-bg",            ".background",   XrmoptionSepArg,     NULL},
  {"-background",    ".background",   XrmoptionSepArg,     NULL},
  {"-bd",            ".borderColor",  XrmoptionSepArg,     NULL},
  {"-bordercolor",   ".borderColor",  XrmoptionSepArg,     NULL},
  {"-bw",            ".borderWidth",  XrmoptionSepArg,     NULL},
  {"-borderwidth",   ".borderWidth",  XrmoptionSepArg,     NULL},
  {"-fg",            ".foreground",   XrmoptionSepArg,     NULL},
  {"-foreground",    ".foreground",   XrmoptionSepArg,     NULL},
  {"-fn",            ".font",         XrmoptionSepArg,     NULL},
  {"-font",          ".font",         XrmoptionSepArg,     NULL},
  {"-name",          ".name",         XrmoptionSepArg,     NULL},
  {"-rv",            ".reverseVideo", XrmoptionNoArg,      "on"},
  {"-reverse",       ".reverseVideo", XrmoptionNoArg,      "on"},
  {"+rv",            ".reverseVideo", XrmoptionNoArg,      "off"},
  {"-bg",            ".background",   XrmoptionSepArg,     NULL},
  {"-title",         ".title",        XrmoptionSepArg,     NULL},
  {"-xrm",           NULL,            XrmoptionResArg,     NULL}
};

static char *addstr(const char str1[], const char str2[], char str12[],
		    unsigned int str12len)
{
  unsigned int i, j, k;
  
  str12[str12len-1] = '\0';

  for(i=0, j=0, k=0; i + 1 < str12len; ) {
    if(str1[j]) str12[i] = str1[j++];
    else        str12[i] = str2[k++];
    if(! str12[i++]) break;
  }
  return str12;
}


static char *pname(const char *resource) {
  static char pnameres[MAX_PRES_LEN];

  return addstr(prog_name, resource, pnameres, MAX_PRES_LEN);
}

static char *pclass(const char *resource) {
  static char pclassres[MAX_PRES_LEN];

  return addstr(class_name, resource, pclassres, MAX_PRES_LEN);
}


static void fill_event_info(void)
{
  int i;

  for(i = 0; i < EVENT_NUM; i++) {
    event_info[i].event_name = empty_str;
    event_info[i].win_given = TRUE;
    event_info[i].next_proc = NULL;
  }
  
  event_info[MappingNotify].win_given = FALSE;

  event_info[ButtonPress].event_name = "ButtonPress";
  event_info[ButtonRelease].event_name = "ButtonRelease";
  event_info[CirculateNotify].event_name = "CirculateNotify";
  event_info[CirculateRequest].event_name = "CirculateRequest";
  event_info[ClientMessage].event_name = "ClientMessage";
  event_info[ColormapNotify].event_name = "ColormapNotify";
  event_info[ConfigureNotify].event_name = "ConfigureNotify";
  event_info[ConfigureRequest].event_name = "ConfigureRequest";
  event_info[CreateNotify].event_name = "CreateNotify";
  event_info[DestroyNotify].event_name = "DestroyNotify";
  event_info[EnterNotify].event_name = "EnterNotify";
  event_info[LeaveNotify].event_name = "LeaveNotify";
  event_info[Expose].event_name = "Expose";
  event_info[FocusIn].event_name = "FocusIn";
  event_info[FocusOut].event_name = "FocusOut";
  event_info[GraphicsExpose].event_name = "GraphicsExpose";
  event_info[NoExpose].event_name = "NoExpose";
  event_info[GravityNotify].event_name = "GravityNotify";
  event_info[KeymapNotify].event_name = "KeymapNotify";
  event_info[KeyPress].event_name = "KeyPress";
  event_info[KeyRelease].event_name = "KeyRelease";
  event_info[MapNotify].event_name = "MapNotify";
  event_info[UnmapNotify].event_name = "UnmapNotify";
  event_info[MappingNotify].event_name = "MappingNotify";
  event_info[MapRequest].event_name = "MapRequest";
  event_info[MotionNotify].event_name = "MotionNotify";
  event_info[PropertyNotify].event_name = "PropertyNotify";
  event_info[ReparentNotify].event_name = "ReparentNotify";
  event_info[ResizeRequest].event_name = "ResizeRequest";
  event_info[SelectionClear].event_name = "SelectionClear";
  event_info[SelectionNotify].event_name = "SelectionNotify";
  event_info[SelectionRequest].event_name = "SelectionRequest";
  event_info[VisibilityNotify].event_name = "VisibilityNotify";

}

static void get_def_res(aX_default_resources *defres)
{
  XrmValue value;
  char *str_type;
  int flags;
  XColor color_def;
  unsigned long tmp_pixel;
  Colormap def_map;
  int font_spec;


  defres->window_name = prog_name;
  defres->icon_name = prog_name;


  defres->scr = DefaultScreen(defres->disp);  
  defres->scr_ptr = ScreenOfDisplay(defres->disp, defres->scr);
  def_map = DefaultColormapOfScreen(defres->scr_ptr);


  if(XrmGetResource(rDB, pname(".title"), pclass(".Title"), 
		    &str_type, &value)) 
    defres->window_name = (char *) value.addr;  

  defres->sflags = PSize;
  if(XrmGetResource(rDB, pname(".geometry"), pclass(".Geometry"), 
		    &str_type, &value)) {
    flags = XParseGeometry((char *) value.addr, &(defres->x), &(defres->y),
			   &(defres->width), &(defres->height));
    if((XValue | YValue) & flags) defres->sflags |= USPosition;
    if((WidthValue | HeightValue) & flags) 
      defres->sflags = (defres->sflags & ~PSize) | USSize;
  }

  defres->background = defres->background ? 
    WhitePixel(defres->disp, defres->scr) : 
      BlackPixel(defres->disp, defres->scr);

  if(XrmGetResource(rDB, pname(".background"), pclass(".Background"), 
		    &str_type, &value)) {
    if(XParseColor(defres->disp, def_map, value.addr, &color_def)) {
      if(XAllocColor(defres->disp, def_map, &color_def)) 
	defres->background = color_def.pixel;
    }
    else fprintf(stderr, "%s: aX: warning: Invalid color specification %s\n", 
		 prog_name, value.addr);
  }
      
  defres->foreground = defres->foreground ? 
    WhitePixel(defres->disp, defres->scr) : 
      BlackPixel(defres->disp, defres->scr);

  if(XrmGetResource(rDB, pname(".foreground"), pclass(".Foreground"), 
		    &str_type, &value)) {
    if(XParseColor(defres->disp, def_map, value.addr, &color_def)) {
      if(XAllocColor(defres->disp, def_map, &color_def)) 
	defres->foreground = color_def.pixel;
    }
    else fprintf(stderr, "%s: aX: warning: Invalid color specification %s\n", 
		 prog_name, value.addr);
  }

  if(XrmGetResource(rDB, pname(".borderWidth"), pclass(".BorderWidth"),
			       &str_type, &value)) {
    defres->border_width = atoi(value.addr);
  }

  defres->border_color = defres->foreground;
  if(XrmGetResource(rDB, pname(".borderColor"), pclass(".BorderColor"), 
		    &str_type, &value)) {
    if(XParseColor(defres->disp, def_map, value.addr, &color_def)) {
      if(XAllocColor(defres->disp, def_map, &color_def)) 
	defres->border_color = color_def.pixel;
    }
    else fprintf(stderr, "%s: aX: warning: Invalid color specification %s\n", 
		 prog_name, value.addr);
  }

  font_spec = 0;
  if(XrmGetResource(rDB, pname(".font"), pclass(".Font"),
		    &str_type, &value)) {
    defres->font_name = value.addr;
    if(defres->font_name != NULL) font_spec = 1;

  }

  if(XrmGetResource(rDB, pname(".fallbackFont"), pclass(".Font"),
		    &str_type, &value)) 
    defres->fallback_font_name = value.addr;

  if(defres->font_name == NULL || 
     (defres->font = XLoadQueryFont(defres->disp, defres->font_name)) 
     == NULL) {
    
    if(font_spec) 
      fprintf(stderr, "%s: aX: warning: cannot open %s font, ",
	      prog_name, defres->font_name);
    
    defres->font_name = defres->fallback_font_name;

    if(font_spec && defres->font_name != NULL) 
      fprintf(stderr, "trying %s...\n",defres->font_name);

    if(defres->font_name == NULL || 
       (defres->font = 
	XLoadQueryFont(defres->disp, defres->fallback_font_name)) == NULL) {
      
      if(defres->font_name != NULL) {
	
	fprintf(stderr, "%s: aX: warning: cannot open %s font, ",
		prog_name, defres->font_name);
      }

      defres->font_name = "fixed";
      
      fprintf(stderr, "trying %s...\n",defres->font_name);

      if((defres->font = XLoadQueryFont(defres->disp, defres->font_name)) 
	 == NULL) {
	
	fprintf(stderr, "%s: aX: warning: cannot open %s font\n",
		prog_name, defres->font_name);
	
	exit(-1);
      }
    }
    else defres->font_name = defres->fallback_font_name;
  }
  
  if(XrmGetResource(rDB, pname(".reverseVideo"), pclass(".ReverseVideo"),
			       &str_type, &value)) 
    if(strcmp(value.addr, "on") == 0) {
      tmp_pixel = defres->foreground;
      defres->foreground = defres->background;
      defres->background = tmp_pixel;
    } 

}


static void add_disp(aX_default_resources *defres)
{
  disp_struct *last;

  for(last = &disp_start; last->next_disp != NULL; last = last->next_disp);
  
  if((last->next_disp = malloc(sizeof(disp_struct))) == NULL) {
    fprintf(stderr, "%s: aX: Not enough memory.\n", prog_name);
    exit(-1);
  };

  last = last->next_disp;
  
  last->disp = defres->disp;
  last->font = defres->font;
  last->next_disp = NULL;


  disp_chain_modified = TRUE;
}

void aX_open_disp(aX_options *useropt, int useroptlen, 
		 int *argcp, char *argv[],
		 aX_default_resources *defres)
{

  XrmValue value;
  char *str_type;
  char *disp_res;
  char *environment;
  char *display_name = NULL;
  char filename[MAX_FILENAME_LEN];
  int i;
  XrmDatabase commandlineDB = NULL, usercommandlineDB = NULL;
  XrmDatabase homeDB, serverDB, applicationDB;

/*  
  if(disp_start.next_disp != NULL) {
    fprintf(stderr, "aX_open_disp: Cannot open first display twice.\n");
    exit(-1);
  }
*/

  XrmInitialize();

  class_name[0] = '\0';
  class_name[MAX_CLASS_NAME_LEN] = '\0';
  if(defres->class_name != NULL) 
    strncpy(class_name, defres->class_name, MAX_CLASS_NAME_LEN);


  fill_event_info();

  for(i = 1; i < *argcp; i++) 
    if(strcmp(argv[i], "-name") == 0 && ++i < *argcp){
      defres->prog_name = argv[i];
      break;
    }


  prog_name[0] = '\0';
  prog_name[MAX_PROG_NAME_LEN] = '\0';
  if(defres->prog_name != NULL) 
    strncpy(prog_name, defres->prog_name, MAX_PROG_NAME_LEN);
  else
    strncpy(prog_name, argv[0], MAX_PROG_NAME_LEN);

  defres->prog_name = prog_name;

  XrmParseCommand(&commandlineDB, (XrmOptionDescRec *) opTable, 
		  opTableEntries, prog_name, argcp, argv);

  if(useropt != NULL)
    XrmParseCommand(&usercommandlineDB, (XrmOptionDescRec *) useropt, 
		    useroptlen, prog_name, argcp, argv);
  else usercommandlineDB = NULL;

/*
  if(*argcp != 1) {
    fprintf(stderr, 
    "%s: aX_open_disp: Unrecognised options in command line!\n", 
	    prog_name);
    exit(-1);
  }
*/

  if(XrmGetResource(commandlineDB, pname(".display"), pclass(".Display"),
		    &str_type, &value)) display_name = (char *) value.addr;
  
  if((defres->disp = XOpenDisplay(display_name)) == NULL) {
    fprintf(stderr, "%s: aX_open_disp: cannot connect to X server %s\n", 
	    prog_name, XDisplayName(display_name));
    exit(-1);
  }

  applicationDB = XrmGetFileDatabase(
				     addstr("/usr/lib/X11/app-defaults/",
					    class_name,
					    filename,
					    MAX_FILENAME_LEN));
/*  
  if(defres->disp->xdefaults) 
  serverDB = XrmGetStringDatabase(defres->disp->xdefaults);
  else serverDB = NULL;
*/


  disp_res = XResourceManagerString(defres->disp);

  if(disp_res) serverDB = XrmGetStringDatabase(disp_res);
  else serverDB = NULL;

  
  if((environment = getenv("XENVIRONMENT")) != NULL) 
    homeDB = XrmGetFileDatabase(environment);
  else homeDB = NULL;

  
  XrmMergeDatabases(applicationDB, &rDB);
  XrmMergeDatabases(serverDB, &rDB);
  XrmMergeDatabases(homeDB, &rDB);
  XrmMergeDatabases(commandlineDB, &rDB);
  XrmMergeDatabases(usercommandlineDB, &rDB);

  get_def_res(defres);

  add_disp(defres);

} 

 
void aX_open_second_disp(char *display_name, 
			 aX_default_resources *defres)
{
  char *disp_res;

  XrmDatabase serverDB;


  if((defres->disp = XOpenDisplay(display_name)) == NULL) {
    fprintf(stderr, 
	    "%s: aX_open_second_disp: cannot connect to X server %s\n", 
	    prog_name, XDisplayName(display_name));
    exit(-1);
  }


  disp_res = XResourceManagerString(defres->disp);

  if(disp_res) serverDB = XrmGetStringDatabase(disp_res);
  else serverDB = NULL;

  
  XrmMergeDatabases(serverDB, &rDB);

  get_def_res(defres);

  add_disp(defres);
} 

/*
  
void smallwait(boolean event_prev)
{
  event_prev = event_prev;
  sleep(1);
}

*/


static void sigalrm_handler(int i)
{
  i = i;
  signal(SIGALRM, SIG_IGN);
}


static void smallwait(boolean event_prev)
{
  struct itimerval value;

  signal(SIGALRM, sigalrm_handler);

  event_prev = event_prev;

  value.it_interval.tv_sec = 0L;
  value.it_interval.tv_usec = 0L;
  value.it_value.tv_sec = 0L;
  value.it_value.tv_usec = 100000L;
  setitimer(ITIMER_REAL, &value, NULL);

  pause();
}

/* This aX_wait_all_muck needs to be cleared out! */

void aX_wait_event(int eventtype)
{
  XEvent ev;
  event_proc_struct **curr;
  int i;
  disp_struct *dsp, *dsp1;

  boolean event_prev;


start:;

  if(disp_start.next_disp == NULL) {
    fprintf(stderr, "%s: aX_wait_event: No connection to any display\n", 
	    prog_name);
    exit(-1);
  }

  dsp = disp_start.next_disp;


  do {
    event_prev = TRUE;

    dsp1 = dsp;
    if((disp_start.next_disp)->next_disp != NULL || 
       eventtype == AX_LOOK_EVENTS)
      while(XPending(dsp->disp) == 0) {
	dsp = dsp->next_disp;
	if(dsp == NULL) dsp = disp_start.next_disp;

	if(dsp == dsp1) {
	  if(eventtype == AX_LOOK_EVENTS) return;
	  
	  smallwait(event_prev);
	  event_prev = FALSE;
	  dsp = dsp1 = disp_start.next_disp;
	}
      }    

    XNextEvent(dsp->disp, &ev);
#ifdef DEBUG_EVENTS
      fprintf(stderr,"Event: %s (%i) in win: %li)\n",
	      event_info[ev.type].event_name,
	      ev.type,
	      ev.xany.window);
#endif
    

    if(dsp->disp != ev.xany.display) 
      fprintf(stderr, "Ha! Event read from wrong display! Stupid XLib!!!\n");
    
    curr = &(event_info[ev.type].next_proc);
    i = 0;
    while(*curr != NULL) {
      if((*curr)->disp == dsp->disp && 
	 (!event_info[ev.type].win_given || 
	  ev.xany.window == (*curr)->event_win) && 
	 !(*curr)->done_proc) {
	i++;
	(*curr)->done_proc = TRUE;
	disp_chain_modified = FALSE;

	if((*curr)->event_proc != NULL) {
	    (*((*curr)->event_proc))(&ev, (*curr)->ptr);
	}

	if(disp_chain_modified) goto start;
	curr = &(event_info[ev.type].next_proc);
      }
      else curr = &((*curr)->next_proc);
    }
    curr = &(event_info[ev.type].next_proc);
    while(*curr != NULL) {
      (*curr)->done_proc = FALSE;
      curr = &((*curr)->next_proc);
    }

    if(i == 0) 
      fprintf(stderr, "%s: aX_wait_event: warning: "
	      "Unexpected event: %s (%i) in win: %li)\n",
	      prog_name,
	      event_info[ev.type].event_name,
	      ev.type,
	      ev.xany.window);

  } while(eventtype != ev.type && eventtype != AX_ANY_EVENT);
}

  
void aX_look_events(void)
{
  aX_wait_event(AX_LOOK_EVENTS);
}

char *aX_get_prog_res(const char *resname, const char* resclass)
{
  XrmValue value;
  char *str_type;

  if(XrmGetResource(rDB, pname(resname), pclass(resclass),
			       &str_type, &value)) 
    return (char *)value.addr;
  else return NULL;
}

char *aX_get_resource(const char *resname, const char* resclass)
{
  XrmValue value;
  char *str_type;

  if(XrmGetResource(rDB, resname, resclass,
			       &str_type, &value)) 
    return (char *)value.addr;
  else return NULL;
}

static long get_win_mask(Display *disp, Window win)
{
  int evt;
  event_proc_struct *ep;
  long winmask;

  for(evt = 0, winmask = 0; evt < EVENT_NUM; evt++) {
    ep = event_info[evt].next_proc;
    while(ep != NULL) {
      if(ep->event_win == win && ep->disp == disp) winmask |= ep->event_mask;
      ep = ep->next_proc;
    }
  }
  return winmask;
} 



void aX_add_event_proc(Display *disp, 
			      Window win, 
			      int eventtype,
			      void (*eventproc)(XEvent *, void *),
			      unsigned long eventmask,
			      void *ptr)
{
  event_proc_struct **epp;
  long winmask;
  
  epp = &(event_info[eventtype].next_proc);
  while(*epp != NULL) epp = &((*epp)->next_proc);
  
  if((*epp = (event_proc_struct *)
      malloc((size_t) sizeof(event_proc_struct))) == NULL) {
    fprintf(stderr, 
	    "%s: aX_add_event_proc_disp: Not enough memory.\n", prog_name);
    exit(-1);
  }

  (*epp)->event_proc = eventproc;
  (*epp)->ptr = ptr;
  (*epp)->event_mask = eventmask;
  (*epp)->disp = disp;
  (*epp)->event_win = win;
  (*epp)->done_proc = FALSE;
  (*epp)->next_proc = NULL;

  if(win) {
    winmask = get_win_mask(disp, win);
    XSelectInput(disp, win, winmask);
  } 
}

void aX_remove_event_proc(Display *disp, 
				 Window win, 
				 int eventtype,
				 void (*eventproc)(XEvent *, void *))
{
  event_proc_struct **epp;
  event_proc_struct *tmp;
  long winmask;
  
  epp = &(event_info[eventtype].next_proc);
  while(*epp != NULL) {
    if((*epp)->disp == disp && 
       (*epp)->event_win == win && 
       (*epp)->event_proc == eventproc) {
      tmp = (*epp)->next_proc;
      free(*epp);
      *epp = tmp;
      if(win) {
	winmask = get_win_mask(disp, win);
	XSelectInput(disp, win, winmask);
      }
      return;
    }
    else epp = &((*epp)->next_proc);
  }
  fprintf(stderr, "%s: aX_remove_event_proc_disp: warning: "
	  "Could not remove event proc (event: %s (%i), window: %lX)\n",
          prog_name, event_info[eventtype].event_name, eventtype, win);
 
}

void aX_close_one_disp(Display *disp)
{
/*  int evt;
  event_proc_struct **curr; */
  disp_struct *dsp, *dsp_tmp;

/*
  for(evt = 0; evt < EVENT_NUM; evt++) {
    curr = &(event_info[evt].next_proc);
    while(*curr != NULL) {
      if(disp == (*curr)->disp) {
	aX_remove_event_proc_disp((*curr)->disp, (*curr)->event_win,
				  evt, (*curr)->event_proc);
	curr = &(event_info[evt].next_proc);      
      }
      else curr = &((*curr)->next_proc);
    }
  }

*/

  for(dsp = &disp_start; dsp->next_disp->disp != disp; dsp = dsp->next_disp)
    if(dsp->next_disp == NULL) {
      fprintf(stderr,
	      "%s: aX_close_one_disp: warning: Trying to close unopened display.\n", 
	      prog_name);
      return;
    }

  XUnloadFont(dsp->next_disp->disp, dsp->next_disp->font->fid);
  XCloseDisplay(dsp->next_disp->disp);

  dsp_tmp = dsp->next_disp;
  dsp->next_disp = dsp->next_disp->next_disp;
  free(dsp_tmp);

  disp_chain_modified = TRUE;

}

void aX_close_disp(void)
{

  while(disp_start.next_disp != NULL) 
    aX_close_one_disp(disp_start.next_disp->disp);

}


unsigned long aX_get_color(Display *disp, int scr, unsigned long def_col, 
			   const char *color_name)
{
  XColor color_def;
  Colormap def_map;
  Screen *scr_ptr;


  if(color_name == NULL) return def_col;

  scr_ptr = ScreenOfDisplay(disp, scr);
  def_map = DefaultColormapOfScreen(scr_ptr);

  if(XParseColor(disp, def_map, color_name, &color_def)) {
    if(XAllocColor(disp, def_map, &color_def)) 
      return color_def.pixel;
  }
  else fprintf(stderr, 
	       "%s: aX_get_color: warning: Invalid color specification %s\n", 
	       prog_name, color_name);

  return def_col;

}