#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <math.h>
#include <unistd.h>
#include "mview_view.h"
#include "mview_misc.h"
#include "mview_macros.h"
#include "mview_widgets.h"

#include <Xm/Text.h>

#ifdef underscore
#define sic_ctrans sic_ctrans_
#define hsv_to_rgb hsv_to_rgb_
#endif
#ifdef f2c
#define sic_ctrans sic_ctrans__
#define hsv_to_rgb hsv_to_rgb__
#endif

#define k_hdraw         1
#define k_sdraw         2
#define k_vdraw         3
#define k_single_draw_a 4
#define k_wedge         5

#define MAXCOL 127
#define MAXCOLWITHB 128
#define MAXPOINT 5
#define NFIRST 120

static int nfirstcol = NFIRST;

#define L 126
#define R 3
/*
typedef char *caddr_t;
*/
static Widget hsvshell, hdraw, sdraw, vdraw, lowboundscale, highboundscale;
static Widget lutcol, single_draw_a, return_to_hsv_control;
static Widget scrolled_list, lutmenu, *savlut=NULL;

static float *lutr=NULL;
static float *lutg=NULL;
static float *lutb=NULL;
static XPoint *luth=NULL, *luts=NULL, *lutv=NULL;

static float *lutAH=NULL, *lutAS=NULL, *lutAV=NULL;
static float *lutBH=NULL, *lutBS=NULL, *lutBV=NULL;
static int count=1;
static int firstind, *lutind=NULL;

static char dumstr[80];
static char lutpath[64], tmppath[64];

static float hp[127], lp[127];
static XPoint h[5], s[5], v[5];
static float AH[4], AS[4], AV[4];
static float BH[4], BS[4], BV[4];

static float hue[MAXCOL];
static float sat[MAXCOL];
static float val[MAXCOL];
static float red[MAXCOL];
static float green[MAXCOL];
static float blue[MAXCOL];

unsigned long ncolors; 
unsigned char colmap[MAXCOLWITHB];
unsigned long blackpix, graypix, redpix;

static XColor cdef, rdef;
static unsigned long colors[MAXCOL];
static unsigned long firstcolors[NFIRST];

static char *namec[MAXCOL];
static Colormap cmap, cmap1, cmap2, default_cmap;
static XColor exact_defs[MAXCOL];
static XColor first_defs[NFIRST];

static char colnam[8];


#define CTRLZONE(x, y) ((x >= 0) && (x <= L) && \
			(y >= 0) && (y <= L))

#define DRAW(w, p) XSetForeground(display, gc, \
				  BlackPixel(display, screen)); \
                   XFillRectangle (display, \
				   XtWindow(w), \
				   gc, 0, 0, L+1, L+1); \
                   XSetForeground(display, gc, \
				  WhitePixel(display, screen)); \
                   XDrawArc(display, XtWindow(w), gc, \
			    p[0].x - R, p[0].y - R, 2*R, 2*R, 360*64, 360*64);\
                   XDrawArc(display, XtWindow(w), gc, \
			    p[1].x - R, p[1].y - R, 2*R, 2*R, 360*64, 360*64);\
                   XDrawArc(display, XtWindow(w), gc, \
			    p[2].x - R, p[2].y - R, 2*R, 2*R, 360*64, 360*64);\
                   XDrawArc(display, XtWindow(w), gc, \
			    p[3].x - R, p[3].y - R, 2*R, 2*R, 360*64, 360*64);\
                   XDrawArc(display, XtWindow(w), gc, \
			    p[4].x - R, p[4].y - R, 2*R, 2*R, 360*64, 360*64);\
                   XDrawLines(display, XtWindow(w), gc, p, 5, CoordModeOrigin)
 

extern void create_hsvcontrol();
extern void expose_hsvcontrol();
extern void dismiss_hsv();
extern void hardsave_lut();
extern void return_to_hsv();

static MRMRegisterArg reglist[] = {
  {"CREATE_HSVCONTROL", (caddr_t) create_hsvcontrol},
  {"EXPOSE_HSVCONTROL", (caddr_t) expose_hsvcontrol},
  {"DISMISS_HSV", (caddr_t) dismiss_hsv},
  {"HARDSAVE_LUT", (caddr_t) hardsave_lut},
  {"RETURN_TO_HSV", (caddr_t) return_to_hsv},
}; 

extern void color_input();
extern void reset();

/* Actions to be added to the Translation Manager */
static XtActionsRec actions_list[] = {
  {"color_input", color_input},
  {"reset", reset},
};

static char color_translations [] = 
              "<Btn1Down>: color_input()\n\
               <Btn2Down>: color_input()\n\
               <Btn3Down>: reset()\n\
               Button1<Motion>: color_input()\n\
               Button2<Motion>: color_input()";

static XPoint huepoints[127], satpoints[127], valpoints[127], lutpoints[127];


void cmap_transfert_function()
{
  int k;

  for (k=0; k < ncolors; k++)
    if (!XParseColor(display,
		     cmap,
		     namec[(short) lp[k]],
		     &exact_defs[k])){
      sprintf(dumstr,
	      "I can't parse col # %d, value %s.\n",
	      k, namec[(short) lp[k]]);
      fprintf(stderr, "%s\n", dumstr);
    }

  XStoreColors(display, cmap, exact_defs, ncolors);
  
}

void transfert_function()
{
  int k;

  for (k = 0; k < ncolors; k++)
    sprintf(namec[k], "#%02X%02X%02X",
	    (unsigned short) (255*red[k]),
	    (unsigned short) (255*green[k]),
	    (unsigned short) (255*blue[k]));



  for (k=0; k < ncolors; k++)
    if (!XParseColor(display,
		     cmap,
		     namec[k],
		     &exact_defs[k])){
      sprintf(dumstr,
	      "I can't parse col # %d, value %s.\n",
	      k, namec[k]);
      fprintf(stderr, "%s\n", dumstr);
    }

  XStoreColors(display, cmap, exact_defs, ncolors);

}

static int lowbound = 0;
static int highbound = 360;

void return_to_hsv(w, tag, cbs)
Widget w;
int *tag;
XmAnyCallbackStruct *cbs;
{
  int j;

  XtUnmapWidget(lutcol);
  XtUnmapWidget(return_to_hsv_control);
  for (j=0; j<ncolors; j++)
    hsv_to_rgb(&hue[j], &sat[j], &val[j], &red[j], &green[j], &blue[j]);

  transfert_function();
}

void change_bounds(w, tag, cbs)
Widget w;
int *tag;
XmScaleCallbackStruct *cbs;
{
  int j;
  
  if (strcmp(XtName(w), "LOWBOUNDSCALE") == 0)
    lowbound = cbs->value;
  else highbound = cbs->value;

  for (j=0; j<ncolors; j++) {
    hue[j] = (float) (lowbound) + hp[j]*(highbound-lowbound);
    hsv_to_rgb(&hue[j], &sat[j], &val[j], &red[j], &green[j], &blue[j]);
  }
  transfert_function();


}



void init_lut()
{
  int i;
  float t;

  h[0].x = 0; h[0].y = L; h[1].x = L/4; h[1].y = (3*L)/4 + 1; 
  h[2].x = L/2; h[2].y = L/2 + 1; h[3].x = (3*L)/4; h[3].y = L/4 + 1;
  h[4].x = L; h[4].y = 0;
  s[0].x = 0; s[0].y = 0; s[1].x = L/4; s[1].y = 0; s[2].x = 2*L/4; s[2].y = 0;
  s[3].x = 3*L/4; s[3].y = 0; s[4].x = L; s[4].y = 0;
  v[0].x = 0; v[0].y = 0; v[1].x = L/4; v[1].y = 0; v[2].x = 2*L/4; v[2].y = 0;
  v[3].x = 3*L/4; v[3].y = 0; v[4].x = L; v[4].y = 0;

  for (i = 0; i < ncolors; i++) {
    huepoints[i].x = i;
    satpoints[i].x = i;
    valpoints[i].x = i;
    lutpoints[i].x = i;

    t = (float) i/(ncolors - 1);

    hp[i] = t;
    huepoints[i].y = (L-1)*(1-t);

    lp[i] = t*(ncolors-1);
    lutpoints[i].y = (L-1)*(1-t);

    satpoints[i].y = 0;
    valpoints[i].y = 0;

    hue[i] = 360.*t;
    val[i] = 1.;
    sat[i] = 1.;
  }
  for (i=0; i<ncolors; i++)
    hsv_to_rgb(&hue[i], &sat[i], &val[i], &red[i], &green[i], &blue[i]);

  transfert_function();

}


void set_colormap(Widget w)
{

  XSetWindowColormap(display, XtWindow(w), cmap);
  
}


void hsv()
{

  MrmCode class;
  Widget hsv_w;

  if (hsvshell != 0) {
    XMapRaised(display, XtWindow(hsvshell));
    return;
  }

  hsvshell = XtVaAppCreateShell("HSV control",
				"hsvshell",
				topLevelShellWidgetClass,
				XtDisplay(toplevel),
				XmNmwmDecorations, MWM_DECOR_TITLE |
				MWM_DECOR_BORDER | MWM_DECOR_MINIMIZE,
				NULL);

  /* Registering callbacks before fetching */ 
  MrmRegisterNames(reglist, sizeof(reglist)/sizeof(reglist[0]));

  if (MrmFetchWidget(Hierarchie,
		     "HSV_W",
		     hsvshell,
		     &hsv_w,
		     &class)
      != MrmSUCCESS ){
    sprintf(dumstr, "Can't fetch widget.\n");
    printf(dumstr);
    exit(0);
  }
  else {
    XtManageChild(hsv_w);
  }      

  /*
  ** Add actions to the Translation manager 
  */
  XtAppAddActions(app, actions_list, XtNumber(actions_list));

  XtRealizeWidget(hsvshell);
  set_colormap(hsvshell);
}

void get_luts(Widget w)
{
  int i, np, k;
  XmString elem;
  FILE *fid;
  char buff[64];
  char lutname[32];
  char string[128];

  np = 256;
  /*  
   *      i = 3;
   * sic_ctrans("PR:",&i,lutpath,&np); 
   */
  i = 8;
  sic_ctrans("LUT_DIR:",&i,lutpath,&np);
  lutpath[np] = 0;
  np = 256;
  i = 8;
  sic_ctrans("GAG_TMP:",&i,tmppath,&np);
  tmppath[np] = 0;
  /*
  fprintf(stderr, "%s %s\n", lutpath, tmppath);
  */
  k = 1;
  sprintf(string,"ls -1 %s/*.lut %s/*.lut", tmppath, lutpath) ;
  if ((fid = popen(string, "r")) != NULL) {
    while(fgets(buff, 64, fid) != NULL) {
      buff[strlen(buff)-1] = 0;
      strcpy(lutname, strrchr(buff, '/'));
      elem = XmStringCreateSimple(&lutname[1]);
      XmListAddItem(w, elem, k); k++;
      XmStringFree(elem);
    }
    pclose(fid);
  }
  else perror("popen\n");
}

static Widget shell_list = NULL;
XmStringCharSet  charset = XmSTRING_DEFAULT_CHARSET;

void item_selection(list_w, tag, cbs)
Widget list_w;
int *tag;
XmListCallbackStruct *cbs;
{
  char *choice;
  int   ret, i, local = 1;
  FILE *lut_id;
  char lutname[128];

  XmStringGetLtoR(cbs->item, charset, &choice);
    
  sprintf(lutname, "%s/%s", tmppath, choice);
  lut_id = fopen(lutname, "r");

  if (lut_id == NULL) {
    local = 0;
    sprintf(lutname, "%s/%s", lutpath, choice);
    lut_id = fopen(lutname, "r");
  }


  if (lut_id != NULL) {
    for (i = 0; i<ncolors; i++)
      fscanf(lut_id, "%f %f %f", &red[i], &green[i], &blue[i]);
    fclose(lut_id);
  }

  transfert_function();
  cmap_transfert_function();
  
  XtMapWidget(lutcol);
  XtMapWidget(return_to_hsv_control);
  XMapRaised(display, XtWindow(return_to_hsv_control));
}

void create_hsvcontrol(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  char dum[80];
  XmString string;

  if (strcmp(XtName(w), "LOWBOUNDSCALE") == 0) {
    lowboundscale = w;
    sprintf(dum, "%s", "lowbound");
    string = XmStringCreateLocalized(dum);

    XtVaSetValues(w,
		  XmNtitleString, string,
		  XmNvalue, 0,
		  XmNminimum, 0,
		  XmNmaximum, 360*5,
		  XmNtraversalOn, False,
		  XmNshowValue, True,
		  XmNscaleMultiple, 10,
		  NULL);
    XmStringFree(string);
    XtAddCallback(w, XmNdragCallback,
		  (XtCallbackProc) change_bounds, NULL);
    
    XtAddCallback(w, XmNvalueChangedCallback,
		  (XtCallbackProc) change_bounds, NULL);
  }
  else if (strcmp(XtName(w), "HIGHBOUNDSCALE") == 0) {
    highboundscale = w;

    sprintf(dum, "%s", "highbound");
    string = XmStringCreateLocalized(dum);

    XtVaSetValues(w,
		  XmNtitleString, string,
		  XmNtraversalOn, False,
		  XmNvalue, 360,
		  XmNminimum, 0,
		  XmNmaximum, 360*5,
		  XmNscaleMultiple, 10,
		  XmNshowValue, True,
		  NULL);
    XmStringFree(string);
    XtAddCallback(w, XmNdragCallback,
		  (XtCallbackProc) change_bounds, NULL);
    
    XtAddCallback(w, XmNvalueChangedCallback,
		  (XtCallbackProc) change_bounds, NULL);
  }

  else if (strcmp(XtName(w), "MYLIST") == 0) {
    scrolled_list = w;

    get_luts(w);
    
    XtAddCallback(w, XmNextendedSelectionCallback, 
		  (XtCallbackProc) item_selection, NULL);

    XtAddCallback(w, XmNdefaultActionCallback, 
		  (XtCallbackProc) item_selection, NULL);
  }

  else if (strcmp(XtName(w), "WEDGE") == 0) 
    XtVaSetValues(w,
		  XmNwidth, 3*L,
		  XmNheight, 30,
		  NULL);

  else if (strcmp(XtName(w), "LUTCOL") == 0) {
    lutcol = w;
  }

  else if (strcmp(XtName(w), "RETURN_TO_HSV_CONTROL") == 0) {
    return_to_hsv_control = w;
  }

  else {
    switch(*w_code) {
    case k_hdraw: hdraw = w; break;
    case k_sdraw: sdraw = w; break;
    case k_vdraw: vdraw = w; break;
    case k_single_draw_a: single_draw_a = w; break;
    }

    XtVaSetValues(w,
		  XmNwidth, L,
		  XmNheight, L,
		  XmNtranslations,
		  XtParseTranslationTable(color_translations),
		  NULL);


  }
}

void expose_hsvcontrol(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  int i;
  XSetForeground(display, gc, WhitePixel(display, screen));

  switch(*w_code) {
  case k_hdraw:
    XDrawLines(display, XtWindow(w), gc, huepoints, ncolors, CoordModeOrigin);
      /*
    DRAW(w, h);
    */
    break;

  case k_sdraw:
    XDrawLines(display, XtWindow(w), gc, satpoints, ncolors, CoordModeOrigin);
       /*
    DRAW(w, s);
    */
    break;

  case k_vdraw:
    XDrawLines(display, XtWindow(w), gc, valpoints, ncolors, CoordModeOrigin);
       /*
    DRAW(w, v);
    */
    break;


  case k_wedge:
    for (i = 0; i<ncolors; i++) {
      XSetForeground(display, gc, exact_defs[i].pixel);
      XFillRectangle(display, XtWindow(w), gc, 3*(i+1), 0, 3, 30);
    }
    XFillRectangle(display, XtWindow(w), gc, 3*(ncolors+1), 0, 3, 30);
    break;

  case k_single_draw_a:
    XDrawLines(display, XtWindow(w), gc, lutpoints, ncolors, CoordModeOrigin); 
    break;
  }
}

void init_colors()
{
  int i, status, uid = getuid();
  float t;
  
  ncolors = MAXCOL;
  cmap = DefaultColormapOfScreen(ecran);

  status = XAllocColorCells(display, cmap, NULL, NULL, NULL, colors, ncolors);

  if (!status) {
    default_cmap = DefaultColormapOfScreen(ecran);

    cmap = XCopyColormapAndFree(display, default_cmap);

    if(!XAllocColorCells(display, cmap, NULL,NULL,NULL, 
			 firstcolors, nfirstcol)) {
    
      fprintf(stderr, "%s\n", "Can't allocate colors");
      exit(1);
    }
    
    for (i = 0; i < nfirstcol; i++)
      first_defs[i].pixel = firstcolors[i];

    XQueryColors(display, default_cmap, first_defs, nfirstcol);

    XStoreColors(display, cmap, first_defs, nfirstcol);

    if (!XAllocColorCells(display, cmap, NULL, NULL, NULL, colors, ncolors)) {
      fprintf(stderr, "%s\n", "Can't allocate colors");
      exit(1);
    }
    /*
    XInstallColormap(display, cmap);
    */
  }
  /*
  fprintf(stderr, "allocated %d color cells\n", ncolors);
  */
  blackpix = BlackPixel(display, screen);

  if (!XParseColor(display, cmap, "Gray", &cdef) ||
      !XAllocColor(display, cmap, &cdef))
    graypix = BlackPixel(display, screen);
  else
    graypix = cdef.pixel;
  
  if (!XParseColor(display, cmap, "Red", &rdef) ||
      !XAllocColor(display, cmap, &rdef))
    redpix = BlackPixel(display, screen);
  else
    redpix = rdef.pixel;

  for (i = 0; i < ncolors; i++) {
    exact_defs[i].pixel = colors[i];
    colmap[i] = (unsigned char) exact_defs[i].pixel;
    namec[i] = (char *) malloc(8);
  }
  colmap[ncolors] = (unsigned char) BlackPixel(display, screen);
}

void reset(Widget w, XEvent *event)
{
  int k;
  float t;

  for (k = 0; k<ncolors; k++) {
    if (w == single_draw_a) {
      t = (float) k/(ncolors - 1);
      lutpoints[k].y = (L-1)*(1-t);
      lp[k] = t*(ncolors-1);
    }
    else {
      if (w == hdraw) {
	t = (float) k/(ncolors - 1);
	huepoints[k].y = (L-1)*(1-t);
	hp[k] = t;
	hue[k] = (float) (lowbound) + hp[k]*(highbound-lowbound);
      }
      else if (w == sdraw) {
	satpoints[k].y = 0;
	sat[k] = 1.;
      }
      else {
	valpoints[k].y = 0;
	val[k] = 1.;
      }
      hsv_to_rgb(&hue[k], &sat[k], &val[k], &red[k], &green[k], &blue[k]);
    }
  }

  if (w == single_draw_a)
    cmap_transfert_function();
  else 
    transfert_function();
  
  XSetForeground(display, gc, BlackPixel(display, screen));
  XFillRectangle (display, XtWindow(w), gc, 0, 0, L+1, L+1);
  XSetForeground(display, gc, WhitePixel(display, screen));
  if (w == hdraw)
    XDrawLines(display, XtWindow(w), gc, huepoints, ncolors, CoordModeOrigin);
  else if(w == sdraw)
    XDrawLines(display, XtWindow(w), gc, satpoints, ncolors, CoordModeOrigin);
  else if (w == vdraw)
    XDrawLines(display, XtWindow(w), gc, valpoints, ncolors, CoordModeOrigin);
  else 
    XDrawLines(display, XtWindow(w), gc, lutpoints, ncolors, CoordModeOrigin);
}

static int reverseon=0;

void color_input(Widget w, XEvent *event, String *params, Cardinal *num)
{
  int x, y, k;
  float i, j, orig, f;
  float t, offset;
  
  if (event->type == ButtonPress) {
    if (event->xbutton.button == Button1) reverseon = 0;
    else reverseon = 1;
  }

  x = event->xmotion.x;
  y = event->xmotion.y;
  
  if (!CTRLZONE(x, y)) return;

  i = (float) x/ncolors;

  if (!reverseon)
    j = 1. - i;
  else 
    j = -1. + i;

  /* orig par pente */
  orig= (1. - i/j)*0.5;		  

  for (k=0; k<ncolors; k++) {
    t = (float) k/(ncolors-1);
    
    if (!reverseon)
      offset = ((i/j) + 1.)*((float) (ncolors - 1 - y)/(ncolors - 1))
	- ((i/j) + orig);
    else
      offset = (1. - (i/j))*((float) (ncolors - 1 - y)/(ncolors - 1)) 
	- orig;

    f = (i/j)*t + orig + offset;

    if (f < 0.) f = 0.;
    else if (f > 1.) f = 1.;

    if (w == single_draw_a) {
      lutpoints[k].y = (L-1)*(1.-f);
      lp[k] = f*(ncolors - 1);
    }
    else {
      if (w == hdraw) {
	huepoints[k].y = (L-1)*(1.-f);
	hp[k] = f;
	hue[k] = (float) (lowbound) + hp[k]*(highbound-lowbound);
      }
      else if (w == sdraw) {
	satpoints[k].y = (L-1)*(1.-f);
	sat[k] = f;
      }
      else {
	valpoints[k].y = (L-1)*(1.-f);
	val[k] = f;
      }
      
      hsv_to_rgb(&hue[k], &sat[k], &val[k], &red[k], &green[k], &blue[k]);
    }
  }

  if (w == single_draw_a)
    cmap_transfert_function();
  else
    transfert_function();

  XSetForeground(display, gc, BlackPixel(display, screen));
  XFillRectangle (display, XtWindow(w), gc, 0, 0, L+1, L+1);
  XSetForeground(display, gc, WhitePixel(display, screen));
  if (w == hdraw)
    XDrawLines(display, XtWindow(w), gc, huepoints, ncolors, CoordModeOrigin);
  else if(w == sdraw)
    XDrawLines(display, XtWindow(w), gc, satpoints, ncolors, CoordModeOrigin);
  else if (w == vdraw)
    XDrawLines(display, XtWindow(w), gc, valpoints, ncolors, CoordModeOrigin);
  else 
    XDrawLines(display, XtWindow(w), gc, lutpoints, ncolors, CoordModeOrigin);
}


void dismiss_hsv(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  XtUnmapWidget(hsvshell);
}

void change_lut(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  int i, ind=*w_code;

  for (i = 0; i < MAXCOL; i++) {
    red[i] = lutr[(ind - 1)*MAXCOL + i];
    green[i] = lutg[(ind - 1)*MAXCOL + i];
    blue[i] = lutb[(ind - 1)*MAXCOL + i];
  }
  transfert_function();

  for (i=0; i<MAXPOINT; i++) {
     h[i].x = luth[(ind - 1)*MAXPOINT + i].x;
     h[i].y = luth[(ind - 1)*MAXPOINT + i].y;
     s[i].x = luts[(ind - 1)*MAXPOINT + i].x;
     s[i].y = luts[(ind - 1)*MAXPOINT + i].y;
     v[i].x = lutv[(ind - 1)*MAXPOINT + i].x; 
     v[i].y = lutv[(ind - 1)*MAXPOINT + i].y; 
  }

  for (i=0; i<MAXPOINT-1; i++) {
     AH[i] = lutAH[(ind - 1)*(MAXPOINT - 1) + i];
     AS[i] = lutAS[(ind - 1)*(MAXPOINT - 1) + i];
     AV[i] = lutAV[(ind - 1)*(MAXPOINT - 1) + i];
          					   
     BH[i] = lutBH[(ind - 1)*(MAXPOINT - 1) + i];
     BS[i] = lutBS[(ind - 1)*(MAXPOINT - 1) + i];
     BV[i] = lutBV[(ind - 1)*(MAXPOINT - 1) + i];
  }

  DRAW(hdraw, h);
  DRAW(sdraw, s);
  DRAW(vdraw, v);
}


void hardsave_lut(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  FILE *lut_id;
  char lutname[128];
  int i, j, n;
  char *dum, works[80];
  XmString lutstring;

  dum = XmTextGetString(w);
  
  n=strlen(dum);
  j = 0;
  for (i = 0; i<n; i++) {
    if (dum[i] != ' ') {
      works[j] = dum[i];
      j++;
    }
  }
  works[j] = 0;
  
  XtFree(dum);
  
  if (strlen(works) != 0) {
    sprintf(lutname, "%s/%s", tmppath, works);

    if (strstr(lutname, ".") == NULL) 
      strcat(lutname, ".lut");
    
    lut_id  = fopen(lutname, "w");
    
    if (lut_id != NULL) {
      for (i=0; i<ncolors; i++)
	fprintf(lut_id, "%f %f %f\n", red[i], green[i], blue[i]);
      
      fclose(lut_id);
    }

    sprintf(lutname, "%s", works);
    
    if (strstr(lutname, ".") == NULL) 
      strcat(lutname, ".lut");
    
    lutstring = XmStringCreateLocalized(lutname);

    if (XmListItemExists(scrolled_list, lutstring))
      XmListDeleteItem(scrolled_list, lutstring);

    XmListAddItem(scrolled_list, lutstring, 1);
    
    XmListSelectItem(scrolled_list, lutstring, False);
    
    XmStringFree(lutstring);

    XmTextSetString(w, NULL);
  }
  
}