#include <Mrm/MrmAppl.h>
#include <Xm/MwmUtil.h>
#include <Xm/RowColumn.h>
#include <Xm/TextF.h>
#include <Xm/Text.h>
#include <Xm/PushB.h>
#include <Xm/Scale.h>
#include <Xm/DrawingA.h>
#include <Xm/MainW.h>

#include "mview_misc.h"
#include "mview_macros.h"

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
/*
#define max(a,b) ((int)(a)>(int)(b)?(int)(a):(int)(b))
#define min(a,b) ((int)(a)<(int)(b)?(int)(a):(int)(b))
*/
static char dumstr[80];

static int ERROR;
extern int veloleft;

static int gesterreurs(Display *canal_aff, XErrorEvent *errev)
{
  XGetErrorText(canal_aff, errev->error_code, dumstr, 80);
  fprintf(stderr, "%s\n", dumstr);
  ERROR  = 1;
}

int cursor_mode;


MrmHierarchy Hierarchie; 
XtAppContext app;
Display *display;
int screen;
Screen *ecran;
Window fenrac;
Visual *visual;
unsigned int depth;
int pixmapdim[2], cpixmapdim[2];

Pixmap testpixmap;
Pixmap pixmap;       /* Pixmap for mosaic */
Pixmap cpixmap;      /* Pixmap for wedge */
Pixmap spixmap;      /* Pixmap for slice */
Pixmap ipixmap;      /* Pixmap for integ spec along slice */
Pixmap mpixmap=0;    /* Pixmap for mean */
Pixmap vpixmap=0;    /* Pixmap for velocity */
Pixmap wpixmap=0;    /* Pixmap for width */

GC gc, gcx;
XGCValues xgcvl;

int slicewidth; /* Maximum width for slice */
int slice_zoomx, slice_zoomy;
int maxspectrumwidth; /* Maximum width for spectrum pixmap */
int maxspectrumheight;
int specwidth; /* width for spectrum draw */
int specheight; /* height for spectrum draw */

Dimension disp_w, disp_h;

#define REGISTERCALLBACKS
#define REGISTERACTIONS

#include "mview_callbacks.h"
#include "mview_actions.h"

#define WIDGET_STORAGE
#include "mview_widgets.h"

extern int show_posy;


static char mom_translations[] = 
                "<EnterNotify>: mom_input()\n\
                 <LeaveNotify>: mom_input()\n\
                 <MotionNotify>: mom_input()\n";

void dismiss_zoom(w, w_code, cbs)
Widget w;
int *w_code;
XmAnyCallbackStruct *cbs;
{
  XtUnmapWidget(XtParent(XtParent(w)));
}

void
redraw(window)
Window window;
{
  XCopyArea(display, pixmap, window, gc, 0, voffset,
            pixmapdim[0], pixmapdim[1], 0, 0);

  
  if (cursor_mode == SUBAREA) {
    redraws_box();
    
  }
  if (cursor_mode == SLICE) {
    redraws_slice();
  }

  redraw_cross();
}

void
scrolled(scrollbar, data, cbs)
Widget scrollbar;
XtPointer data;
XmScrollBarCallbackStruct *cbs;
{
  int pos[2], newoffset;

  newoffset = cbs->value * sizey;

  show_posy = show_posy + (voffset - newoffset);

  voffset = cbs->value * sizey;

  redraw(XtWindow(radec));
}

static XPoint sticks[2];
int stick1, stick2, prev_stick1, prev_stick2;

extern int firstsub;

void draw_sticks(Widget w)
{
  char dum[80];

  XSetForeground(display, gc, BlackPixelOfScreen(ecran));
  XFillRectangle(display, XtWindow(w), gc, 0, 0,
		 50, Nsubs*slice_zoomy);
  XSetForeground(display, gc, WhitePixelOfScreen(ecran));
  XFillRectangle(display, XtWindow(w), gc,
		 0, sticks[0].y, 50, slice_zoomy);
  XFillRectangle(display, XtWindow(w), gc,
		 0, sticks[1].y, 50, slice_zoomy);

  sprintf(dum, "%d%c%d", 
	  Nsubs - 1 - sticks[0].y/slice_zoomy + firstsub,'-',
	  Nsubs - 1 - sticks[1].y/slice_zoomy + firstsub);
  XmTextSetString(slicelab, dum);
}


void new_sticks(Widget w, int x, int y)
{
  int d, D, n, N;
  int s1, s2;

  D = 1E+05;
  for (n=0; n<2; n++) {
    if (y > slice_zoomy*Nsubs/2)
      d = sqrt((float) ((sticks[n].y + slice_zoomy - y)*
			(sticks[n].y + slice_zoomy - y)));
    else 
      d = sqrt((float) ((sticks[n].y - y)*
			(sticks[n].y - y)));
    if (d < D) {
      D = d;
      N = n;
    }
  }
  
  switch(N) {
  case 0:
    sticks[0].y = (min(max(0, y), 
		       slice_zoomy*(Nsubs-1))/slice_zoomy)*slice_zoomy;
    break;
  case 1:
    sticks[1].y = (min(max(0, y), 
		       slice_zoomy*(Nsubs-1))/slice_zoomy)*slice_zoomy;
    break;
  }
  
  s1 = sticks[0].y;
  s2 = sticks[1].y;
  sticks[0].y = max(s1, s2);
  sticks[1].y = min(s1, s2);
  
  draw_sticks(w);
  return;
}

void set_sticks(Widget w, XEvent* event, String *params, Cardinal num_params)
{
  int ret, x, y;

  switch(event->type) {
  case ButtonPress:
    switch (event->xbutton.button) {
    case Button1:
      x = event->xbutton.y;
      y = event->xbutton.y;
      kill_movie();
      new_sticks(w, x, y);
      break;
    }
    break;


  case MotionNotify:
    x = event->xmotion.x;
    y = event->xmotion.y;
    
    new_sticks(w, x, y);
    break;

  case ButtonRelease:
    stick1 = Nsubs - 1 - sticks[0].y/slice_zoomy;
    stick2 = Nsubs - 1 - sticks[1].y/slice_zoomy;

    if ((prev_stick1 != stick1) || (prev_stick2 != stick2)) {
      prev_stick1 = stick1;
      prev_stick2 = stick2;
      new_profile();
    }
    
    break;
  }
}

static char set_sticks_translations [] =
                     "Button1<Motion>: set_sticks()\n\
                      <Btn1Down>: set_sticks()\n\
                      <Btn1Up>: set_sticks()\n";
void draw_axes()
{
  XSetForeground(display, gc, BlackPixelOfScreen(ecran));
  XFillRectangle(display, XtWindow(axedraw), gc, 0, 0,
		 slicewidth*slice_zoomx, 30);
  XFillRectangle(display, XtWindow(raxedraw), gc, 0, 0,
		 30, Nsubs*slice_zoomy+30);
  XFillRectangle(display, XtWindow(laxedraw), gc, 0, 0,
		 30, Nsubs*slice_zoomy+30);
  
  XSetForeground(display, gc, WhitePixelOfScreen(ecran));
  XDrawLine(display, XtWindow(axedraw), gc, 
	    0, 5, slicewidth*slice_zoomx, 5);
  if (veloleft) {
    XDrawLine(display, XtWindow(axedraw), gc, 
	      slicewidth*slice_zoomx - 5, 0, slicewidth*slice_zoomx, 5);
    XDrawLine(display, XtWindow(axedraw), gc, 
	      slicewidth*slice_zoomx - 5, 10, slicewidth*slice_zoomx, 5);
    
    XDrawString(display, XtWindow(axedraw), gc,
		slicewidth*slice_zoomx - 20, 20, "Pos", 3);

    XDrawLine(display, XtWindow(laxedraw), gc, 
	      25, 0, 25, Nsubs*slice_zoomy+5);
    XDrawLine(display, XtWindow(laxedraw), gc, 
	      20, 10, 25, 0);
    XDrawLine(display, XtWindow(laxedraw), gc, 
	      25, 0, 30, 10);
    XDrawLine(display, XtWindow(laxedraw), gc, 
	      25, Nsubs*slice_zoomy+5, 30, Nsubs*slice_zoomy+5);
    XDrawString(display, XtWindow(laxedraw), gc,
		0, 20, "Vel", 3);
  }
  else {
    XDrawLine(display, XtWindow(axedraw), gc, 
	      0, 5, 10, 0);
    XDrawLine(display, XtWindow(axedraw), gc, 
	      0, 5, 10, 10);
    
    XDrawString(display, XtWindow(axedraw), gc,
		0, 20, "Pos", 3);

    XDrawLine(display, XtWindow(raxedraw), gc, 
	      5, 0, 5, Nsubs*slice_zoomy+5);
    XDrawLine(display, XtWindow(raxedraw), gc, 
	      0, 10, 5, 0);
    XDrawLine(display, XtWindow(raxedraw), gc, 
	      5, 0, 10, 10);
    XDrawLine(display, XtWindow(raxedraw), gc, 
	      0, Nsubs*slice_zoomy+5, 5, Nsubs*slice_zoomy+5);
    XDrawString(display, XtWindow(raxedraw), gc,
		10, 20, "Vel", 3);
  }
  draw_angle();

  XFlush(display);
}

void create(w, w_code, cbs)
Widget w;
int *w_code;
XmAnyCallbackStruct *cbs;
{
  XmString label;

  switch (*w_code) {

  case k_vsb:
    vsb = w;
    XtVaSetValues(w,
		  XmNorientation, XmVERTICAL,
		  XmNmaximum,     rows,
		  XmNsliderSize,  
		  min(pixmapdim[1]/sizey, rows),
		  NULL);  
    break;

  case k_small_w:
    small_w = w;
    break;

  case k_scrolled_w:
    scrolled_w = w;
    break;

  case k_radec:
    radec = w;

    XtVaSetValues(w,
		  XmNwidth, pixmapdim[0],
		  XmNheight, pixmapdim[1],
		  NULL);
    break;

  case k_cliparea:
    cliparea = w;

    cpixmap = XCreatePixmap(display, fenrac,
			    cpixmapdim[0], cpixmapdim[1], depth);

    

    XSetForeground(display, gc, BlackPixelOfScreen(ecran));

    XFillRectangle(display, cpixmap, gc, 0, 0,
		   cpixmapdim[0], cpixmapdim[1]);

    XtVaSetValues(w,
		  XmNwidth, cpixmapdim[0],
		  XmNheight, cpixmapdim[1],
		  NULL);

    break;

  case k_sliceticks:
    sliceticks = w;
    XtVaSetValues(sliceticks,
		  XmNwidth, 50,
		  XmNheight, Nsubs*slice_zoomy,
		  XmNtranslations, 
		  XtParseTranslationTable(set_sticks_translations),
		  NULL);

    sticks[0].x = 0; sticks[0].y = Nsubs*slice_zoomy  - slice_zoomy;
    sticks[1].x = 0; sticks[1].y = 0;
    stick1 = 0;
    stick2 = Nsubs - 1;
    prev_stick1 = 0;
    prev_stick2 = Nsubs - 1;
    break;

  case k_slicelab:
    slicelab = w;
    XtVaSetValues(w,
		  XmNwidth, 50,
		  XmNheight, 30,
		  NULL);
    break;

  case k_drawaxes:
    axedraw = w;
    XtVaSetValues(w, XmNwidth, slicewidth*slice_zoomx, NULL);
    break;
  case k_ldrawaxes:
    laxedraw = w;
    XtVaSetValues(w, XmNheight, Nsubs*slice_zoomy+30, NULL);
    break;
  case k_rdrawaxes:
    raxedraw = w;
    XtVaSetValues(w, XmNheight, Nsubs*slice_zoomy+30, NULL);
    break;
 
  case k_coupe:
    coupe = w;

    

    XtVaSetValues(coupe,
		  XmNwidth, slicewidth*slice_zoomx,
		  XmNheight, Nsubs*slice_zoomy,
		  NULL);

    spixmap = XCreatePixmap(display, fenrac,
			    slicewidth*slice_zoomx, Nsubs*slice_zoomy,
			    depth);

    XSetForeground(display, gc, BlackPixelOfScreen(ecran));
    XFillRectangle(display, spixmap, gc, 0, 0,
		   slicewidth*slice_zoomx,
		   Nsubs*slice_zoomy);
    break;

  case k_coupe_integ:
    coupe_integ = w;

    XtVaSetValues(coupe_integ,
		  XmNwidth, slicewidth*slice_zoomx,
		  XmNheight, Nsubs*slice_zoomy,
		  NULL);


    ipixmap = XCreatePixmap(display, fenrac,
			    slicewidth*slice_zoomx, Nsubs*slice_zoomy,
			    depth);

    XSetForeground(display, gc, BlackPixelOfScreen(ecran));
    XFillRectangle(display, ipixmap, gc, 0, 0,
		   slicewidth*slice_zoomx,
		   Nsubs*slice_zoomy);
    break;

  case k_text: slice_sav = w; break;
  case k_name: fieldname = w; break;
  case k_pixelvalue: 
    pixelvalue = w; 
    XtVaSetValues(w,
		  XmNwidth, (pixmapdim[0]+cpixmapdim[0])/2,
		  NULL);
    break;
  case k_gridcoord : 
    gridcoord = w;
    XtVaSetValues(w,
		  XmNwidth, (pixmapdim[0]+cpixmapdim[0])/2-64,
		  NULL);
    break;

  case k_axis1: 
    axis1 = w; 
    XtVaSetValues(w,
		  XmNwidth, (pixmapdim[0]+cpixmapdim[0])/3,
		  NULL);

    break;
  case k_axis2: 
    axis2 = w; 
    XtVaSetValues(w,
		  XmNwidth, (pixmapdim[0]+cpixmapdim[0])/3,
		  NULL);

    break;

  case k_axis3: 
    axis3 = w; 
    XtVaSetValues(w,
		  XmNwidth, (pixmapdim[0]+cpixmapdim[0])/3-64,
		  NULL);

    break;

  case k_spixelvalue: 
    spixelvalue = w; 
    XtVaSetValues(w,
		  XmNwidth, (zsizex+specwidth)/2,
		  NULL);
    break;

  case k_sgridcoord : 
    sgridcoord = w;
    XtVaSetValues(w,
		  XmNwidth, (zsizex+specwidth)/2,
		  NULL);
    break;

  case k_saxis1: 
    saxis1 = w; 
    XtVaSetValues(w,
		  XmNwidth, (zsizex+specwidth)/3,
		  NULL);
    break;

  case k_saxis2: 
    saxis2 = w; 
    XtVaSetValues(w,
		  XmNwidth, (zsizex+specwidth)/3,
		  NULL);
    break;
  case k_saxis3: 
    saxis3 = w; 
    XtVaSetValues(w,
		  XmNwidth, (zsizex+specwidth)/3,
		  NULL);
    break;

  case k_clip: clipbutton = w; break;

  case k_slice: slicebutton = w; break;
  case k_cursor: 
    cursorbutton = w; 
    if (Nsubs < 2) {
      label = XmStringCreateLocalized("2D box");
      XtVaSetValues(w, XmNlabelString, label, NULL);
      XmStringFree(label);
    }
    break;
    
  case k_moments:
     if (Nsubs < 2) {
       /*       fprintf(stderr, "%s\n", XtName(w));*/
       XtDestroyWidget(w);
     }
     
     break;
  case k_zoom: zoombutton = w; break;

  case k_highscale: highscale = w; break;
  case k_highcut: highcut = w; break;
  case k_lowscale: lowscale = w; break;
  case k_lowcut: lowcut = w; break;
  case k_ok: 
    comput = w; 
    XmTextSetString(w, "Press OK to validate");
    break;
  }

}

void expose(w, area, cbs)
Widget w;
int *area;
XmDrawingAreaCallbackStruct *cbs;
{
  unsigned long selectcursor, selectslice;

  switch(*area) {
  case k_radec:
    if (cbs->event->xexpose.count == 0)
      redraw(cbs->window);

    break;
  case k_cliparea:
    if (cbs->event->xexpose.count == 0)

      XCopyArea(cbs->event->xexpose.display,
		cpixmap,
		cbs->window,
		gc,
		0, 0,
		cpixmapdim[0], cpixmapdim[1],
		0, 0);
    break;
    
  case k_sliceticks:
    draw_sticks(w);
    break;


  case k_coupe:
    if (cbs->event->xexpose.count == 0)
      XCopyArea(cbs->event->xexpose.display,
		spixmap,
		cbs->window,
		gc,
		0, 0,
	        slicewidth*slice_zoomx, Nsubs*slice_zoomy,
		0, 0);
    
    break;
  case k_coupe_integ:
    if (cbs->event->xexpose.count == 0)
      XCopyArea(cbs->event->xexpose.display,
		ipixmap,
		cbs->window,
		gc,
		0, 0,
		slicewidth*slice_zoomx, Nsubs*slice_zoomy,
		0, 0);
    break;
  case k_drawaxes:
    XSetForeground(display, gc, WhitePixelOfScreen(ecran));
    XDrawLine(display, XtWindow(w), gc, 
	      0, 5, slicewidth*slice_zoomx, 5);
    if (veloleft) {
      XDrawLine(display, XtWindow(w), gc, 
		slicewidth*slice_zoomx - 5, 0, slicewidth*slice_zoomx, 5);
      XDrawLine(display, XtWindow(w), gc, 
		slicewidth*slice_zoomx - 5, 10, slicewidth*slice_zoomx, 5);
   
      XDrawString(display, XtWindow(w), gc,
		  slicewidth*slice_zoomx - 20, 20, "Pos", 3);
    }
    else {
      XDrawLine(display, XtWindow(w), gc, 
		0, 5, 10, 0);
      XDrawLine(display, XtWindow(w), gc, 
		0, 5, 10, 10);
   
      XDrawString(display, XtWindow(w), gc,
		  0, 20, "Pos", 3);
    }
    draw_angle();
    break;
  case k_ldrawaxes:
    if (veloleft) {
      XSetForeground(display, gc, WhitePixelOfScreen(ecran));
      XDrawLine(display, XtWindow(w), gc, 
		25, 0, 25, Nsubs*slice_zoomy+5);
      XDrawLine(display, XtWindow(w), gc, 
		20, 10, 25, 0);
      XDrawLine(display, XtWindow(w), gc, 
		25, 0, 30, 10);
      XDrawLine(display, XtWindow(w), gc, 
		25, Nsubs*slice_zoomy+5, 30, Nsubs*slice_zoomy+5);
      XDrawString(display, XtWindow(w), gc,
		  0, 20, "Vel", 3);
    }
    break;
  case k_rdrawaxes:
    if (!veloleft) {
      XSetForeground(display, gc, WhitePixelOfScreen(ecran));
      XDrawLine(display, XtWindow(w), gc, 
		5, 0, 5, Nsubs*slice_zoomy+5);
      XDrawLine(display, XtWindow(w), gc, 
		0, 10, 5, 0);
      XDrawLine(display, XtWindow(w), gc, 
		5, 0, 10, 10);
      XDrawLine(display, XtWindow(w), gc, 
		0, Nsubs*slice_zoomy+5, 5, Nsubs*slice_zoomy+5);
      XDrawString(display, XtWindow(w), gc,
		  10, 20, "Vel", 3);
    }
    break;
  }
}


void inidisplay()
{
  MrmCode code;
  char *db_filename_vec[2];
  char uidname[128], hsvname[128];
  Widget main_w;
  Font fonte;
  int narg=0;
  char *name[10];
  

  name[0] = (char *) malloc(80*sizeof(char));

  strcpy(name[0], "mview");

  cursor_mode = 0;

  MrmInitialize();

  if (!(toplevel = XtVaAppInitialize(&app,
				     NULL,
                                     NULL,
				     0,
				     &narg, name,
				     NULL,
				     XmNtitle, "mview",
				     XmNmwmDecorations, 
				     MWM_DECOR_TITLE |
				     MWM_DECOR_BORDER | MWM_DECOR_MINIMIZE,
				     NULL))) {
    printf("Failed to start X Window\n"); exit(0);
  }

  display = XtDisplay(toplevel);
  ecran = XtScreen(toplevel);
  screen = DefaultScreen(display);
  fenrac = RootWindowOfScreen(ecran);
  visual = DefaultVisual(display, screen);
  depth = DefaultDepthOfScreen(ecran);


  xgcvl.function = GXxor;
  xgcvl.line_width = 2;
  if (!(gcx = XCreateGC(display, fenrac, GCForeground | GCFunction |
			GCLineWidth, &xgcvl))) {
    printf("creates_itt : could not get a graphic context. Aborting !\n");
    exit(0);
  }
  
  
  if (!(gc = XCreateGC(display, fenrac, (unsigned long int) 0, NULL))) {
    printf("creates_itt : could not get a graphic context. Aborting !\n");
    exit(0);
  }
  fonte = XLoadFont(display, "6x10");
  XSetFont(display, gc, fonte);


  disp_w = DisplayWidth(display, screen);
  disp_h = DisplayHeight(display, screen);

  cols = 1;
  rows = 1;
  zoom = 1;

  while (1) {
    if (cols*rows >= Nsubs) break;
    cols++;
    if (cols*rows >= Nsubs) break;
    rows++;
  }

  cpixmapdim[0] = 102;
  
  while (1) {
    if ((cols*npix[0]*(zoom + 1) + cpixmapdim[0] > disp_w) ||
	(rows*npix[1]*(zoom + 1) + 200 > disp_h)) break;
    zoom++;
  }

  while(1) {
    incr++;

    sizex = (zoom*npix[0])/incr;
    sizey = (zoom*npix[1])/incr;

    pixmapdim[0] = sizex*cols;
    pixmapdim[1] = sizey*rows;
    /*
    fprintf(stderr,  "Nsubs %d cols %d rows %d", Nsubs, cols, rows);
    
    fprintf(stderr, "sizex %d sizey %d", sizex, sizey);
    
    fprintf(stderr, "view_width %d view_height %d", 
	    pixmapdim[0], pixmapdim[1]);
    
	    */

    if ((rows > 1) && ((pixmapdim[0] + cpixmapdim[0] > disp_w) || 
		       (pixmapdim[1] + 200 > disp_h))) {
      cols = max(1, (disp_w-cpixmapdim[0])/sizex - 1);
      cols = min(cols, Nsubs);
      rows = (Nsubs + cols-1)/cols;

      pixmapdim[0] = sizex*cols;
      
      pixmapdim[1] = min(sizey*rows, max(sizey * ((disp_h-200)/sizey), sizey));
      /*
      pixmapdim[1] = sizey*rows;
      */
    }
    /*    
    fprintf(stderr, "Nsubs %d cols %d rows %d", Nsubs, cols, rows);
    fprintf(stderr, "subset_width %d subset_height%d", sizex, sizey);
    
    fprintf(stderr, "view_width %d view_height %d", 
	    pixmapdim[0], pixmapdim[1]);
	    
    fprintf(stderr, "Create Pixmap %d %d", cols*sizex, 
	    rows*sizey);
	    */
    

    XSetErrorHandler(gesterreurs);

    ERROR = 0;
    pixmap = XCreatePixmap(display, fenrac,
			   cols*sizex, rows*sizey, depth);
    
    XSync(display, False);

    
    if (!ERROR) {
      /*
      fprintf(stderr, "%s\n", "Pixmap OK");
      */
      break;
    }
    /*  
    fprintf(stderr, "decimation %d", incr);
    fprintf(stderr, "Zoom %d\n", zoom);
    */
  }    

  XSetErrorHandler(NULL);

  XSetForeground(display, gc, WhitePixelOfScreen(ecran));
  XFillRectangle(display, pixmap, gc, 0, 0,
		 cols*sizex, rows*sizey);

  /*
  if (Nsubs < 16)
    specwidth = Nsubs*16 + 40;
  else if (Nsubs < 32)
    specwidth = Nsubs*8 + 40;
  else if (Nsubs < 64)
    specwidth = Nsubs*4 + 40;
  else 
    specwidth = Nsubs*2 + 40;
    */

  if (disp_h > 1000) {
    maxspectrumwidth = 512;
    maxspectrumheight = 384;
  }
  else {
    maxspectrumwidth = 256;
    maxspectrumheight = 256;
  }

  specwidth = Nsubs*(max(1, 256/Nsubs))+40;

  localzoom = 1;
  while ((npix[0]*(localzoom + 1) <= maxspectrumwidth) 
	 && (npix[1]*(localzoom + 1) <= maxspectrumheight))
    localzoom++;

  /*
  fprintf(stderr, "%s %d\n", "spectrum zoom =", localzoom);
  */
  zsizex = localzoom*npix[0];
  zsizey = localzoom*npix[1];


  if (disp_h > 1000)
    slice_zoomy = max(1, zsizey/Nsubs);
  else 
    slice_zoomy = max(1, zsizey/(2*Nsubs));

  slicewidth = sqrt((float) (npix[0]*npix[0])/(incr*incr) + 
		    (float) (npix[1]*npix[1])/(incr*incr));


  if (slicewidth <= 64)
    slice_zoomx = 8;
  else if (slicewidth <= 128)
    slice_zoomx = 4;
  else if (slicewidth <= 256)
    slice_zoomx = 2;
  else 
    slice_zoomx = 1;

  if (npix[0] > maxspectrumwidth) {
    slice_zoomx = 1;
    maxspectrumwidth=npix[0];
  }
  if (npix[1] > maxspectrumwidth) {
    slice_zoomx = 1;
    maxspectrumwidth=npix[1];
  }
  /*
  fprintf(stderr, "%s\n", "Open hierarchy");
  */
  cpixmapdim[1] = pixmapdim[1];

  sprintf(uidname, "%s%s", uidlocation, "mview.uid");
  db_filename_vec[0] = &uidname[0];
  sprintf(hsvname, "%s%s", uidlocation, "hsvcontrol.uid");
  db_filename_vec[1] = &hsvname[0];  

  if (MrmOpenHierarchy (2,
			db_filename_vec,
			NULL,
			&Hierarchie)
      !=MrmSUCCESS) {
    printf("Can't open uid files.\n"); exit(0);
  }

  /* Regi[<stering callbacks before fetching */ 
  MrmRegisterNames(reglist, sizeof(reglist)/sizeof(reglist[0]));
  /*
  fprintf(stderr, "%s\n", "fetch widget");
  */
  if (MrmFetchWidget(Hierarchie,
		     "MAIN_W",
		     toplevel,
		     &main_w,
		     &code)
      != MrmSUCCESS ){
    printf("Can't fetch widget.\n"); exit(0);
  }

  XtManageChild(main_w);
  /*
  fprintf(stderr, "%s\n", "manage OK");
  */
  XtAppAddActions(app, actions, XtNumber(actions));
  

  
}

void realize_top()
{

  /* Allow the ScrolledWindow to initialize itself accordingly...*/
  XmScrolledWindowSetAreas(scrolled_w, NULL, vsb, radec);

  if ((cols*sizex == pixmapdim[0]) &&
      (rows*sizey == pixmapdim[1]))
    
    XtUnmanageChild(vsb);
  
  /* Actually map the window */
  
  XtRealizeWidget(toplevel);

  spectrum();
  
  slice();
  
  /* loop on X-Window events */

  set_colormap(toplevel);

  XtAppMainLoop(app);
}



void dismiss(w, code, cbs)
Widget w;
int *code;
XmDrawingAreaCallbackStruct *cbs;
{

  XtUnmapWidget(XtParent(XtParent(w)));
}

extern void view_mean();
extern void view_velo();
extern void view_width();
extern void create_momwidgets();

static Widget momshell=NULL, meanshell=NULL, veloshell=NULL, widthshell=NULL;
static Widget mean_w, velo_w, width_w;

static Widget seuil_w;
static float seuil;

void change_seuil(w, tag, cbs)
Widget w;
int *tag;
XmScaleCallbackStruct *cbs;
{

  char dum[80];

  seuil = clip[0] + ((float) (cbs->value)/100.)*(clip[1] - clip[0]);

  sprintf(dum, "%10.2g", seuil);

  XmTextFieldSetString(seuil_w, dum);
}

void get_seuil(float *s)
{
  *s = seuil;
}

static float vel[512];
static float *fmean=NULL, *fvelo=NULL, *fwidth=NULL;

void compute_moments(w, w_code, cbs)
Widget w;
XmAnyCallbackStruct *cbs;
int *w_code;
{
  int i, x, y, z, k;
  float t, f;
  double uc[3];
  char chainx[80], chainy[80], chainz[80], chainv[80];
  int sub[2];

  if (fmean == NULL) {
    x = 1; y = 1;
    for (i = 0; i < Nsubs; i++) {
      z = i+1;
      phys_coord(&x, &y, &z, uc,
		 chainx, chainy, chainz, chainv,
		 strlen(chainx), strlen(chainy), strlen(chainz), 
		 strlen(chainv));
      vel[i] = (float) atof(chainz);
    }

      fmean = (float *) malloc(npix[0]*npix[1]*sizeof(float));

      fvelo = (float *) malloc(npix[0]*npix[1]*sizeof(float));

      fwidth = (float *) malloc(npix[0]*npix[1]*sizeof(float));
  }
  
  /* Calcul des moments */
  for (k = 0; k < npix[0]*npix[1]; k++) {
    fmean[k] = 0.0;
    fvelo[k] = 0.0;
    fwidth[k] = 0.0;
  }
  /*
  k = 0;
  for (y = 0; y<npix[1]; y++) {
    for (x = 0; x<npix[0]; x++) {

      for (z = 0; z <Nsubs; z++) {
	t = vel[z];

	f = *(F_ADDR(x, y, z));
	if (((float)fabs((double)(f - Blank)) <= Tolerance) ||
	(f < seuil)) 
	f = 0.;

	fmean[k] = fmean[k] + f;
	fvelo[k] = fvelo[k] + t*f;
	fwidth[k] = fwidth[k] + t*t*f;
      } 
      k++;
    }
  }
  */

  get_relative_sub(sub);

  if (sub[0] > sub[1]) {
    z = sub[1];
    sub[1] = sub[0];
    sub[0] = z;
  }

  for (z = sub[0]; z <= sub[1]; z++) {
    k = 0;
    t = vel[z];
    for (y = 0; y<npix[1]; y++) {
      for (x = 0; x<npix[0]; x++) {
	f = *(F_ADDR(x, y, z));
	if (((float)fabs((double)(f - Blank)) <= Tolerance) ||
	    (f < seuil)) 
	  f = 0.;

	fmean[k] = fmean[k] + f;
	fvelo[k] = fvelo[k] + t*f;
	fwidth[k] = fwidth[k] + t*t*f;
	k++;
      }
    }
  }

  for (k = 0; k < npix[0]*npix[1]; k++) {
    if (fmean[k] != 0.) {
      fvelo[k] = fvelo[k]/fmean[k];
      fwidth[k] = fwidth[k]/fmean[k];
      if (fwidth[k] - fvelo[k]*fvelo[k] < 0.) {
	fwidth[k] = 0.;
      }
      else 
	fwidth[k] = (float)sqrt((double)(fwidth[k] - fvelo[k]*fvelo[k]));
    }
    else {
      fvelo[k] = 0.;
      fwidth[k] = 0.;
    }
  }
  view_mean();
  view_velo();
  view_width();

  create_momwidgets();
}

void destroy_momshell(w, area, cbs)
Widget w;
Pixmap *area;
XmAnyCallbackStruct *cbs;
{
  momshell = NULL;
}

void make_moments(w, code, cbs)
Widget w;
int *code;
XmAnyCallbackStruct *cbs;
{

  Widget rowcol, scale_w, button;
  XmString string;
  char dum[80];

  if (Nsubs < 2) return;

  if (momshell == NULL) {
    
    momshell = XtVaAppCreateShell("Moments",
				  "momshell",
				  topLevelShellWidgetClass,
				  display,
				  XmNmwmDecorations, MWM_DECOR_MENU |
				  MWM_DECOR_TITLE |
				  MWM_DECOR_BORDER | MWM_DECOR_MINIMIZE,
				  NULL);
    
    XtAddCallback(momshell, XtNdestroyCallback,
		  (XtCallbackProc) destroy_momshell, NULL);
		  

    rowcol = XtVaCreateManagedWidget("rowcol",
				     xmRowColumnWidgetClass,

				     momshell,
				     XmNbackground, blackpix,
				     XmNorientation, XmHORIZONTAL,
				     NULL);

    seuil_w = XtVaCreateManagedWidget("seuil_w",
				      xmTextFieldWidgetClass,
				      rowcol,
				      XmNbackground, blackpix,
				      NULL);
    seuil = clip[0];
    sprintf(dum, "%10.2g", seuil);
    XmTextFieldSetString(seuil_w, dum);

    
    string = XmStringCreateLocalized("Seuil");

    scale_w = 
      XtVaCreateManagedWidget("scale_w",
			      xmScaleWidgetClass,
			      rowcol,
			      XmNbackground, blackpix,
			      XmNorientation, XmHORIZONTAL,
			      XmNwidth, 512,
			      XmNtitleString, string,
			      NULL);
    XmStringFree(string);
    XtAddCallback(scale_w, XmNdragCallback,
		  (XtCallbackProc) change_seuil, NULL);
    
    XtAddCallback(scale_w, XmNvalueChangedCallback,
		  (XtCallbackProc) change_seuil, NULL);

    button = XtVaCreateManagedWidget("OK",
				     xmPushButtonWidgetClass,
				     rowcol,
				     XmNbackground, blackpix,
				     NULL);

    XtAddCallback(button,
		  XmNactivateCallback, 
		  (XtCallbackProc) compute_moments, NULL);

    XtRealizeWidget(momshell);
    set_colormap(momshell);
  }


}

static mom_gesterreurs(Display *canal_aff, XErrorEvent *errev)
{
  XGetErrorText(canal_aff, errev->error_code, dumstr, 80);
  
  fprintf(stderr, "%s\n", dumstr);
}

void view_mean()
{
  int i;
  float mclip[2];
  char *pixels;
  XImage *image;
  Window fen_rac;
  int x, y;
  unsigned int larg, haut, ep_bord, prof;
  Status ret;
  
  XSetErrorHandler(mom_gesterreurs);

  if (mpixmap == 0) {

    mpixmap = XCreatePixmap(display, fenrac, zsizex, zsizey, depth);

    ret = XGetGeometry(display, mpixmap, &fen_rac, &x, &y, &larg, &haut,
		       &ep_bord, &prof);
    if (ret == 0) {
      fprintf(stderr, "%s\n", "not enough mem");
      mpixmap = 0;
      return;
    }
  }


  pixels = (char *) malloc(zsizex*zsizey*sizeof(char));
  
  mclip[1] = 0.;
  for(i = 0; i<npix[0]*npix[1]; i++)
    if (fmean[i] > mclip[1]) mclip[1] = fmean[i];
  mclip[0] = mclip[1];
  for(i = 0; i<npix[0]*npix[1]; i++)
    if ((fmean[i] < mclip[0]) && (fmean[i] != 0)) mclip[0] = fmean[i];
  /*
  fprintf(stderr, "mean clips %f %f\n", mclip[0], mclip[1]);
  */
  _2DfloatTo2Dbyte(fmean,
		   1, npix[0],
		   1, npix[1],
		   pixels,
		   localzoom, localzoom,
		   mclip[0], mclip[1],
		   1);
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, zsizex, zsizey, 8, 0);
  
  XPutImage(display, mpixmap, gc, image, 0, 0,
	    0, 0,
	    zsizex, zsizey);
  
  XFree(image);
  free(pixels);
}

void view_velo()
{
  
  int i;
  float vclip[2];
  char *pixels;
  XImage *image;
  Window fen_rac;
  int x, y;
  unsigned int larg, haut, ep_bord, prof;
  Status ret;

  if (vpixmap == 0) {
    vpixmap =  XCreatePixmap(display, fenrac, zsizex, zsizey, depth);

    ret = XGetGeometry(display, vpixmap, &fen_rac, &x, &y, &larg, &haut,
		       &ep_bord, &prof);
    if (ret == 0) {
      fprintf(stderr, "%s\n", "not enough mem");
      vpixmap = 0;
      return;
    }
  }

  pixels = (char *) malloc(zsizex*zsizey*sizeof(char));
  
  vclip[1] = 0.;
  for(i = 0; i<npix[0]*npix[1]; i++)
    if (fvelo[i] > vclip[1]) vclip[1] = fvelo[i];
  vclip[0] = vclip[1];
  for(i = 0; i<npix[0]*npix[1]; i++)
    if ((fvelo[i] < vclip[0]) && (fvelo[i] != 0)) vclip[0] = fvelo[i];
  /*
  fprintf(stderr, "velo clips %f %f\n", vclip[0], vclip[1]);
  */
  _2DfloatTo2Dbyte(fvelo,
		   1, npix[0],
		   1, npix[1],
		   pixels,
		   localzoom, localzoom,
		   vclip[0], vclip[1],
		   1);
  
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, zsizex, zsizey, 8, 0);
  
  XPutImage(display, vpixmap, gc, image, 0, 0,
	    0, 0,
	    zsizex, zsizey);
  
  XFree(image);
  free(pixels);

}


void view_width()
{
  int i;
  float wclip[2];
  char *pixels;
  XImage *image;
  Window fen_rac;
  int x, y;
  unsigned int larg, haut, ep_bord, prof;
  Status ret;

  if (wpixmap == 0) {
    wpixmap =  XCreatePixmap(display, fenrac, zsizex, zsizey, depth);

    ret = XGetGeometry(display, wpixmap, &fen_rac, &x, &y, &larg, &haut,
		       &ep_bord, &prof);
    if (ret == 0) {
      fprintf(stderr, "%s\n", "not enough mem");
      wpixmap = 0;
      return;
    }

  }

  pixels = (char *) malloc(zsizex*zsizey*sizeof(char));

  wclip[1] = 0.;
  for(i = 0; i<npix[0]*npix[1]; i++)
    if (fwidth[i] > wclip[1]) wclip[1] = fwidth[i];
  wclip[0] = wclip[1];
  for(i = 0; i<npix[0]*npix[1]; i++)
    if ((fwidth[i] < wclip[0]) && (fwidth[i] != 0)) wclip[0] = fwidth[i];
  /*
  fprintf(stderr, "width clips %f %f\n", wclip[0], wclip[1]);
  */
  _2DfloatTo2Dbyte(fwidth,
		   1, npix[0],
		   1, npix[1],
		   pixels,
		   localzoom, localzoom,
		   wclip[0], wclip[1],
		   1);
  
  image = XCreateImage(display, visual, depth,
		       ZPixmap, 0, pixels, zsizex, zsizey, 8, 0);
  
  XPutImage(display, wpixmap, gc, image, 0, 0,
	    0, 0,
	    zsizex, zsizey);
  
  XFree(image);
  free(pixels);

  XSetErrorHandler(NULL);
}

void expose_moment(w, area, cbs)
Widget w;
Pixmap *area;
XmDrawingAreaCallbackStruct *cbs;
{

  XCopyArea(cbs->event->xexpose.display,
	    *area,
	    cbs->window,
	    gc,
	    0, 0,
	    zsizex, zsizey,
	    0, 0);
}

void destroy_moment(w, area, cbs)
Widget w;
Pixmap *area;
XmAnyCallbackStruct *cbs;
{
  
  if (*area == mpixmap) meanshell = NULL;
  if (*area == vpixmap) veloshell = NULL;
  if (*area == wpixmap) widthshell = NULL;
  
}

void mom_input(w, event)
Widget w;
XEvent *event;
{
  static int prev_x, prev_y;
  static prev_xm=-1, prev_ym, prev_sub, prev_sub1, prev_sub2;
  int x, y, z, xm, ym, rang, sub, sub1, sub2, do_it;
  float ecart;
  char dum[80];
  static char *preval;

  if (event->type == EnterNotify) {
    preval = XmTextGetString(axis3);
    prev_xm = -1;
    return;
  }

  if (event->type  == LeaveNotify) {
    XmTextSetString(axis3, preval);
    XtFree(preval);
  }

  if ((event->type  == LeaveNotify) && (prev_xm != -1)) {
    if (w == velo_w) {
      DRAWCIRC(radec, POSX(prev_xm,prev_sub), POSY(prev_ym,prev_sub));
    }
    if (w == width_w) {
      for (z=min(prev_sub1,prev_sub2); z<=max(prev_sub1, prev_sub2); z++) {
	DRAWCIRC(radec, POSX(prev_xm,z), POSY(prev_ym,z));
      }
    }

    DRAWCIRC(w, prev_x, prev_y);
    return;
  }
  
  x = event->xmotion.x;
  y = event->xmotion.y;

  do_it = 1;

  if ((x < 0) || (x >= zsizex) || (y < 0) || (y >= zsizey))
    do_it = 0;

  if (do_it) {
    rang = ((zsizey - 1 - y)/localzoom)*npix[0] + x/localzoom;
    if (fvelo[rang] == 0) do_it = 0;
  }

  if (do_it == 0) { 
    if (prev_xm != -1) {
      if (w == velo_w) {
	DRAWCIRC(radec, POSX(prev_xm,prev_sub), POSY(prev_ym,prev_sub));
      }
      if (w == width_w) {
	for (z=min(prev_sub1,prev_sub2); z<=max(prev_sub1, prev_sub2); z++) {
	  DRAWCIRC(radec, POSX(prev_xm,z), POSY(prev_ym,z));
	}
      }
      DRAWCIRC(w, prev_x, prev_y);
      XmTextSetString(axis3, NULL);
    }
    prev_xm = -1;
    return;
  }

  sprintf(dum, "%g", fvelo[rang]);

  XmTextSetString(axis3, dum);

  if (prev_xm != -1) {
    DRAWCIRC(w, prev_x, prev_y);
  }
  DRAWCIRC(w, x, y);
  prev_x = x;
  prev_y = y;
  

  ecart = ((float) (Nsubs-1))/(vel[Nsubs-1] - vel[0]);
  
  xm = zoom*((float) x/localzoom)/incr;
  ym = zoom*((float) y/localzoom)/incr;

  if (w == velo_w) {
    sub = (fvelo[rang] - vel[0])*ecart;

    if (prev_xm != -1) {
      DRAWCIRC(radec, POSX(prev_xm,prev_sub), POSY(prev_ym,prev_sub));
    }
    DRAWCIRC(radec, POSX(xm,sub), POSY(ym,sub));
    prev_xm = xm;
    prev_ym = ym;
    prev_sub = sub;
  }
  
  if (w == width_w) {
    sub1 = (fvelo[rang] - fwidth[rang] - vel[0])*ecart;
    sub2 = (fvelo[rang] + fwidth[rang] - vel[0])*ecart;

    if (prev_xm != -1) {
      for (z=min(prev_sub1,prev_sub2); z<=max(prev_sub1, prev_sub2); z++) {
	DRAWCIRC(radec, POSX(prev_xm,z), POSY(prev_ym,z));
      }
    }
    for (z=min(sub1,sub2); z<=max(sub1, sub2); z++) {
      DRAWCIRC(radec, POSX(xm,z), POSY(ym,z));
    }

    prev_xm = xm;
    prev_ym = ym;
    prev_sub1 = sub1;
    prev_sub2 = sub2;
  }

}

#if 0
void mom_input(w, event)
Widget w;
XEvent *event;
{
  static int prev_x, prev_y;
  static prev_xm=-1, prev_ym, prev_sub, prev_sub1, prev_sub2;
  int x, y, z, xm, ym, rang, sub, sub1, sub2;
  float ecart;
  char dum[80];


  if (event->type == EnterNotify)
    prev_xm = -1;
  
  if ((event->type  == LeaveNotify) && (prev_xm != -1)) {
    if (w == velo_w) {
      DRAWCIRC(radec, POSX(prev_xm,prev_sub), POSY(prev_ym,prev_sub));
    }
    if (w == width_w) {
      for (z=min(prev_sub1,prev_sub2); z<=max(prev_sub1, prev_sub2); z++) {
	DRAWCIRC(radec, POSX(prev_xm,z), POSY(prev_ym,z));
      }
    }
    DRAWCIRC(w, prev_x, prev_y);
    return;
  }
  

  x = event->xmotion.x;
  y = event->xmotion.y;

  if (prev_xm != -1) {
    DRAWCIRC(w, prev_x, prev_y);
  }
  DRAWCIRC(w, x, y);
  prev_x = x;
  prev_y = y;
    
  if ((x < 0) || (x >= zsizex) || (y < 0) || (y >= zsizey))
    return;
  
  rang = ((zsizey - 1 - y)/localzoom)*npix[0] + x/localzoom;
  ecart = ((float) (Nsubs-1))/(vel[Nsubs-1] - vel[0]);
  
  xm = zoom*((float) x/localzoom)/incr;
  ym = zoom*((float) y/localzoom)/incr;

  if (w == velo_w) {
    sub = (fvelo[rang] - vel[0])*ecart;
    /*
    fprintf(stderr, "%f %d\n", fvelo[rang], sub);

    sprintf(dum, "%g", vel[sub]);
    XmTextSetString(axis3, dum); 
    */
    if (prev_xm != -1) {
      DRAWCIRC(radec, POSX(prev_xm,prev_sub), POSY(prev_ym,prev_sub));
    }
    DRAWCIRC(radec, POSX(xm,sub), POSY(ym,sub));
    prev_xm = xm;
    prev_ym = ym;
    prev_sub = sub;
  }
  
  if (w == width_w) {
    sub1 = (fvelo[rang] - fwidth[rang] - vel[0])*ecart;
    sub2 = (fvelo[rang] + fwidth[rang] - vel[0])*ecart;
    /*
    fprintf(stderr, "%f %d %d\n", fwidth[rang], sub1, sub2);
    */
    if (prev_xm != -1) {
      for (z=min(prev_sub1,prev_sub2); z<=max(prev_sub1, prev_sub2); z++) {
	DRAWCIRC(radec, POSX(prev_xm,z), POSY(prev_ym,z));
      }
    }
    for (z=min(sub1,sub2); z<=max(sub1, sub2); z++) {
      DRAWCIRC(radec, POSX(xm,z), POSY(ym,z));
    }

    prev_xm = xm;
    prev_ym = ym;
    prev_sub1 = sub1;
    prev_sub2 = sub2;
  }

}
#endif

void create_momwidgets()
{
  if (meanshell == NULL) {
    
    meanshell = XtVaAppCreateShell("Mean",
				   "meanshell",
				   topLevelShellWidgetClass,
				   display,
				   NULL);
    XtAddCallback(meanshell, XtNdestroyCallback,
		  (XtCallbackProc) destroy_moment, &mpixmap);

    mean_w = 
      XtVaCreateManagedWidget("mean_w",
			      xmDrawingAreaWidgetClass,
			      meanshell,
			      XmNbackground, blackpix,
			      XmNwidth, zsizex,
			      XmNheight, zsizey,
			      NULL);

    XtAddCallback(mean_w, XmNexposeCallback, (XtCallbackProc) expose_moment,
		  &mpixmap);
    XtRealizeWidget(meanshell);
    set_colormap(meanshell);
  }
  XCopyArea(display,
	      mpixmap,
	      XtWindow(mean_w),
	      gc,
	      0, 0,
	      zsizex, zsizey,
	      0, 0);
  XFlush(display);

  if (veloshell == NULL) {
    
    veloshell = XtVaAppCreateShell("Velocity",
				   "veloshell",
				   topLevelShellWidgetClass,
				   display,
				   NULL);
    XtAddCallback(veloshell, XtNdestroyCallback,
		  (XtCallbackProc) destroy_moment, &vpixmap);

    velo_w = 
      XtVaCreateManagedWidget("velo_w",
			      xmDrawingAreaWidgetClass,
			      veloshell,
			      XmNbackground, blackpix,
			      XmNwidth, zsizex,
			      XmNheight, zsizey,
			      /*
			      XmNtranslations, 
			      XtParseTranslationTable(mom_translations),
			      */
			      NULL);
    XtVaSetValues(velo_w, XmNtranslations, 
		  XtParseTranslationTable(mom_translations),
		  NULL);

    XtAddCallback(velo_w, XmNexposeCallback, (XtCallbackProc) expose_moment,
		  &vpixmap);
    XtRealizeWidget(veloshell);
    set_colormap(veloshell);
  }
  XCopyArea(display,
	    vpixmap,
	    XtWindow(velo_w),
	    gc,
	    0, 0,
	    zsizex, zsizey,
	    0, 0);
  XFlush(display);
  
  if (widthshell == NULL) {
    
    widthshell = XtVaAppCreateShell("Width",
				    "widthshell",
				    topLevelShellWidgetClass,
				    display,
				    NULL);
    XtAddCallback(widthshell, XtNdestroyCallback,
		  (XtCallbackProc) destroy_moment, &wpixmap);

    width_w = 
      XtVaCreateManagedWidget("width_w",
			      xmDrawingAreaWidgetClass,
			      widthshell,
			      XmNbackground, blackpix,
			      XmNwidth, zsizex,
			      XmNheight, zsizey,
			      /*
			      XmNtranslations, 
			      XtParseTranslationTable(mom_translations),
			      */
			      NULL);

    XtVaSetValues(width_w, XmNtranslations, 
		  XtParseTranslationTable(mom_translations),
		  NULL);

    XtAddCallback(width_w, XmNexposeCallback, (XtCallbackProc) expose_moment,
		  &wpixmap);
    
    XtRealizeWidget(widthshell);
    set_colormap(widthshell);
  }
  XCopyArea(display,
	    wpixmap,
	    XtWindow(width_w),
	    gc,
	    0, 0,
	    zsizex, zsizey,
	    0, 0);
  XFlush(display);

}