file: stacktool.c


/* util.c - utility routines for XmdvTool */

/* Copyright 1994, Matthew O. Ward
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without fee
 * is granted provided that the above copyright notice appears in all copies.
 * It is provided "as is" without express or implied warranty.
*/

/* callbacks for canvas processing, some currently empty callbacks for the
   keys (later will provide more details on dimensions?), and some useful
   utilities. */

#include <X11/Xatom.h>
#include "XmdvTool.h"
#include "hierarchy.h"
#include "stacktool.h"
#include "util.h"
#include "brush.h"

extern Widget       appShell;
extern int dims;
extern char names[MAXDIM][MAXLABEL];
extern double *br_pos, *br_size;
extern double dim_min[MAXDIM], dim_max[MAXDIM];
extern unsigned long color_cells[NUM_COLOR_CELLS];
extern XColor outline_col;
extern GC gc;

/* is this a color display? */
extern int COLOR;
extern int X_SIZE, Y_SIZE;

Arg wargs[10];
int n;

/* stack brush tool brush variables */
int sbt_open = FALSE;
double sbt_br_pos[MAXDIM], sbt_br_size[MAXDIM];
Dimension sbt_x, sbt_y;		/* Stack Brush Tool X/Y dims */
int sbt_left_offset,		/* offsets from edge of brush tool */
    sbt_bottom_offset;


/* button defines */
#define BUTTON_DOWN   1
#define BUTTON_DRAG   2
#define BUTTON_UP     3
#define BUTTON_CANCEL 4

void StackBToolRedrawCanvas(Widget w, caddr_t client_data, 
    XawDrawingAreaCallbackStruct *call_data)
{
  StackBToolDoRedraw();
}

void StackBToolDoRedraw(void)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas */
  int i,j;
  int dpy_xmin,			/* display min/max vars */
      dpy_xmax,
      dpy_ymin,
      dpy_ymax;
  XFontStruct *font;		/* the font to draw text with */
  unsigned long font_height;	/* the height of the font */
  int dummy;			/* dummy var passed to XTextExtents() */
  XCharStruct overall;		/* for finding extents */
  int label_len;		/* the length of a label */
  int x,y;

  sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas");
  if(!sbt_canvas_w)
    {
      fprintf(stderr, "Error finding *stack_btool_canvas\n");
      return;
    }

  /* if brush tool is not open, do nothing */
  if(!sbt_open)
    return;

  /* get the new x/y dimensions of the brush tool */
  n = 0;
  XtSetArg(wargs[n],XtNwidth,&sbt_x);                      n++;
  XtSetArg(wargs[n],XtNheight,&sbt_y);                     n++;
  XtGetValues(sbt_canvas_w,wargs,n);

  /* set the min/max vars */
  dpy_xmin = sbt_left_offset;
  dpy_xmax = sbt_x - SBT_SLIDER_WIDTH;
  dpy_ymin = sbt_y/2 + SBT_SLIDER_WIDTH;
  dpy_ymax = sbt_y - sbt_bottom_offset;

  /* clear the canvas */
  XClearWindow(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w));
  
  /* set the brush color */
  if(COLOR==1)
    XSetForeground(XtDisplay(sbt_canvas_w), gc, outline_col.pixel);
  
  for(i=0; i<dims; i++)
    StackBToolDrawAxis(i);
  
  /* set the foreground color for drawing outlines */
  if(COLOR==1)
    XSetForeground(XtDisplay(sbt_canvas_w), gc, color_cells[CCELL_DATA]);


  XSetForeground(XtDisplay(sbt_canvas_w),gc, color_cells[CCELL_TEXT]);

  /* draw the divider line */
  XDrawLine(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
	    0, sbt_y/2, sbt_x, sbt_y/2);


  /* draw the slider outlines */
  for(i=0; i<dims; i++)
    {
      /* if odd, draw on the upper half */
      if(i%2)
	{
	  XDrawRectangle(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
			 dpy_xmin - 1, i*SBT_SLIDER_WIDTH - 1,
			 dpy_xmax - dpy_xmin + 1, SBT_SLIDER_WIDTH + 1);
	}
      /* if even, draw on lower half */
      else
	{
	  XDrawRectangle(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
			 (i+1)*SBT_SLIDER_WIDTH - 1, dpy_ymin - 1,
			 SBT_SLIDER_WIDTH + 1, dpy_ymax - dpy_ymin + 1);
	}
    }

  /* draw the labels */

  /* get the font */
  font = XQueryFont(XtDisplay(sbt_canvas_w), XGContextFromGC(gc));

#define SBT_TEXT_MAX_LETTERS 3

  for(i=0; i<dims; i++)
    {
      /* determine the string length */
      label_len = MIN(SBT_TEXT_MAX_LETTERS, strlen(names[i]));

      /* find the extents of the string */
      XTextExtents(font, names[i], label_len, &dummy, &dummy, &dummy,
		   &overall);

      font_height = overall.ascent + overall.descent;

      /* if odd, draw on the upper half */
      if(i%2)
	{
	  x = dpy_xmin - overall.width - font_height/3.;
	  y = i*SBT_SLIDER_WIDTH + SBT_SLIDER_WIDTH/2. + font_height/2.;

	  XDrawString(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
		      x, y,
		      names[i], MIN(SBT_TEXT_MAX_LETTERS, strlen(names[i])));
	}
      /* if even, draw on lower half */
      else
	{
	  y = sbt_y - sbt_bottom_offset;
	  
	  for(j=0; j<strlen(names[i]); j++)
	    {
	      XTextExtents(font, &names[i][j], 1, &dummy, &dummy, &dummy,
			   &overall);
	      
	      x = SBT_SLIDER_WIDTH + SBT_SLIDER_WIDTH*i + overall.width/2;
	      y += overall.ascent + font_height * 0.2;

	      /* if about to go off the bottom border, stop */
	      if(y + overall.descent > sbt_y)
		break;

	      XDrawString(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
			  x, y,
			  &names[i][j], 1);

	      y += overall.descent;
	    }
	}
    }
  
}

/* stack brush tool button flags */

int sbt_button_one_down = FALSE;
int sbt_button_two_down = FALSE;
int sbt_button_three_down = FALSE;



void StackBToolMotionCanvas(Widget w, caddr_t client_data, 
    XawDrawingAreaCallbackStruct *call_data)
{
  if(sbt_button_one_down)
    {
      StackBToolInteractiveResize(call_data->event->xmotion.x,
				  call_data->event->xmotion.y,
				  BUTTON_DRAG);        //OVERLOAD CALL: BUTTON_DRAG: glyphtool.c(?), stacktool.c(?), util.c(?)
    }
  else if(sbt_button_two_down)
    {
      StackBToolInteractiveMove(call_data->event->xmotion.x,
				call_data->event->xmotion.y,
				BUTTON_DRAG);        //OVERLOAD CALL: BUTTON_DRAG: glyphtool.c(?), stacktool.c(?), util.c(?)
    }
  else if(sbt_button_three_down)
    {
    }
}

void StackBToolInputCanvas(Widget w, caddr_t client_data, 
    XawDrawingAreaCallbackStruct *call_data)
{
  int x, y;

  switch (call_data->event->type)
    {
      /* Process mouse button events */
    case ButtonPress:
      x = call_data->event->xbutton.x;
      y = call_data->event->xbutton.y;

      switch (call_data->event->xbutton.button) 
	{
	case 1:			/* the resize button */
	  if(sbt_button_two_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      StackBToolInteractiveMove(x, y, BUTTON_CANCEL);         //OVERLOAD CALL: BUTTON_CANCEL: glyphtool.c(?), stacktool.c(?), util.c(?)
	      break;
	    }
	  else if(sbt_button_three_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      break;
	    }
	  
	  sbt_button_one_down = TRUE;

	  StackBToolInteractiveResize(x, y, BUTTON_DOWN);        //OVERLOAD CALL: BUTTON_DOWN: glyphtool.c(?), stacktool.c(?), util.c(?)

	  break;
	case 2:			/* the move button */
	  if(sbt_button_one_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      StackBToolInteractiveResize(x, y, BUTTON_CANCEL);        //OVERLOAD CALL: BUTTON_CANCEL: glyphtool.c(?), stacktool.c(?), util.c(?)
	      break;
	    }
	  else if(sbt_button_three_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      break;
	    }
	  
	  sbt_button_two_down = TRUE;

	  StackBToolInteractiveMove(x, y, BUTTON_DOWN);        //OVERLOAD CALL: BUTTON_DOWN: glyphtool.c(?), stacktool.c(?), util.c(?)

	  break;
	case 3:  
	  if(sbt_button_one_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      StackBToolInteractiveResize(x, y, BUTTON_CANCEL);        //OVERLOAD CALL: BUTTON_CANCEL: glyphtool.c(?), stacktool.c(?), util.c(?)
	      break;
	    }
	  else if(sbt_button_two_down)
	    {
	      XBell(XtDisplay(w), 0);
	      sbt_button_one_down = sbt_button_two_down = sbt_button_three_down = FALSE;
	      StackBToolInteractiveMove(x, y, BUTTON_CANCEL);        //OVERLOAD CALL: BUTTON_CANCEL: glyphtool.c(?), stacktool.c(?), util.c(?)
	      break;
	    }
	    
	  sbt_button_three_down = TRUE;
	  break;
	}
      break;
      
    case ButtonRelease:
      x = call_data->event->xbutton.x;
      y = call_data->event->xbutton.y;

      switch (call_data->event->xbutton.button) 
	{
	case 1:
	  if(!sbt_button_one_down)
	    break;
	  
	  StackBToolInteractiveResize(x, y, BUTTON_UP);        //OVERLOAD CALL: BUTTON_UP: glyphtool.c(?), stacktool.c(?), util.c(?)

	  sbt_button_one_down = FALSE;
	  break;
	case 2:  
	  if(!sbt_button_two_down)
	    break;

	  StackBToolInteractiveMove(x, y, BUTTON_UP);        //OVERLOAD CALL: BUTTON_UP: glyphtool.c(?), stacktool.c(?), util.c(?)
	  
	  sbt_button_two_down = FALSE;
	  break;
	case 3:  
	  if(!sbt_button_three_down)
	    break;

	  sbt_button_three_down = FALSE;
	  break;
	}
      break;
    }
}


void StackBToolApply(Widget w, caddr_t client_data, caddr_t call_data)
{
  int i;

  /* copy the stack btool brush to the real brush */
  for(i=0; i<dims; i++)
    {
      br_pos[i] = sbt_br_pos[i];
      br_size[i] = sbt_br_size[i];
    }
  do_redraw();
}

void StackBToolInit(Widget w, caddr_t client_data, caddr_t call_data)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas widget */
  int i;
  XFontStruct *font;		/* the font to draw text with */
  int dummy;			/* dummy var passed to XTextExtents() */
  XCharStruct overall;		/* for finding extents */


  /* set the global tool open flag */
  sbt_open = TRUE;

  /* copy the real brush to the stack btool brush */
  for(i=0; i<dims; i++)
    {
      sbt_br_pos[i] = br_pos[i];
      sbt_br_size[i] = br_size[i];
    }

  /* resize the canvas */
  if(!(sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas")))
    {
      fprintf(stderr,
	      "Error finding  *stack_btool_canvas in StackBToolInit()\n");
      return;
    }

  /* calculate the needed canvas size */
  if(dims%2)
    sbt_x = (dims/2 + 1)*SBT_SLIDER_WIDTH*2 + SBT_SLIDER_WIDTH;
  else
    sbt_x = dims/2*SBT_SLIDER_WIDTH*2 + SBT_SLIDER_WIDTH;
  sbt_y = (dims/2*SBT_SLIDER_WIDTH*2 + SBT_SLIDER_WIDTH)*2;


  n = 0;
  XtSetArg(wargs[n],XtNwidth,sbt_x);                      n++;
  XtSetArg(wargs[n],XtNheight,sbt_y);                     n++;
  XtSetValues(sbt_canvas_w,wargs,n);


  /* calculate the offsets */

  /* left offset should be large enough for three letters horizontally */
  font = XQueryFont(XtDisplay(sbt_canvas_w), XGContextFromGC(gc));
  XTextExtents(font, "XXX", 3, &dummy, &dummy, &dummy, &overall);

  /* scale width up by 30% */
  sbt_left_offset = overall.width * 1.3;
  
  /* bottom offset should be large enough for three letters vertically */
    
  /* scale up by 30% */
  sbt_bottom_offset = (3.0 * (overall.ascent + overall.descent)) * 1.3;
}

/*
 * StackBToolPopDown() - Callback when brush tool is popped down.
 */
void StackBToolPopDown(Widget w, caddr_t client_data, caddr_t call_data)
{
  /* reset global tool open flag */
  sbt_open = FALSE;
}


/*
 * StackBToolUpdate() - Update the stack brush tool so that it matches
 *                      the real brush.
 */
void StackBToolUpdate(void)
{
  int i;
  /* if brush tool is not open, do nothing */
  if(!sbt_open)
    return;

  for(i = 0;i < dims;i++)	{
    sbt_br_pos[i] = br_pos[i];
    sbt_br_size[i] = br_size[i];
    }

/*
  StackBToolInit(NULL, NULL, NULL);
*/
  StackBToolDoRedraw();
}

  
void StackBToolInteractiveMove(int mouse_x, int mouse_y, int button)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas widget */
  static int axis;		/* axis for resize */
  double new_pos;		/* new brush position */
  int h_axes, v_axes;		/* horizontal and vertical axes */

  sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas");
  if(!sbt_canvas_w)
    {
      fprintf(stderr, "Error finding *stack_btool_canvas\n");
      return;
    }


  /* if this is a button down, determine axis */
  if(button == BUTTON_DOWN)        //OVERLOAD CALL: BUTTON_DOWN: glyphtool.c(?), stacktool.c(?), util.c(?)
    {
      v_axes = dims/2;
      h_axes = dims/2 + dims%2;
      
      /* check if on top half or bottom half */
      if(mouse_y < sbt_y/2)
	{
	  if(mouse_y < SBT_SLIDER_WIDTH)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	    
	  axis = (mouse_y - SBT_SLIDER_WIDTH) * (2*v_axes - 1) /
	    ((2*v_axes - 1)*SBT_SLIDER_WIDTH);
	  if(axis%2)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	  axis++;
	}
      else
	{
	  if(mouse_x < SBT_SLIDER_WIDTH)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	    
	  axis = (mouse_x - SBT_SLIDER_WIDTH) * (2*h_axes - 1) /
	    ((2*h_axes - 1)*SBT_SLIDER_WIDTH);
	  if(axis%2)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	}
      
      /* sanity check */
      if(axis < 0 || axis >= dims)
	{
	  XBell(XtDisplay(sbt_canvas_w), 0);
	  return;
	}

      /* store old brush position for later retrieval on cancel */
    }
  else
    {
      /* sanity check */
      if(axis < 0 || axis >= dims)
	return;
    }
  
  /* erase the old axis */
  StackBToolEraseAxis(axis);

  /* calculate new position and bound it */
  if(mouse_y < sbt_y/2)
    {
      new_pos = (mouse_x - sbt_left_offset) * (dim_max[axis] - dim_min[axis]) /
	(sbt_x - sbt_left_offset - SBT_SLIDER_WIDTH);
      new_pos += dim_min[axis];
    }
  else
    {
      new_pos = (sbt_y - sbt_bottom_offset - mouse_y) * (dim_max[axis] - dim_min[axis]) /
	(sbt_y/2 - SBT_SLIDER_WIDTH - sbt_bottom_offset);
      new_pos += dim_min[axis];
    }
    
  new_pos = MIN(new_pos, dim_max[axis]-sbt_br_size[axis]/2.);
  new_pos = MAX(new_pos, dim_min[axis]+sbt_br_size[axis]/2.);

  /* move brush to new location */
  sbt_br_pos[axis] = new_pos;
  
  /* set the brush color */
  if(COLOR==1)
    XSetForeground(XtDisplay(sbt_canvas_w), gc, outline_col.pixel);
  
  /* draw the new axis */
  StackBToolDrawAxis(axis);
}

/*
 * StackBToolDrawAxis() - Draws the stack brush tool representation
 *                        for a single axis on the stack brush tool.
 *
 * PARAMETERS
 *   axis           The axis to draw
 *
 * RETURNS
 *   void
 */
void StackBToolDrawAxis(int axis)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas */
  int dpy_xmin,			/* display min/max vars */
      dpy_xmax,
      dpy_ymin,
      dpy_ymax;
  int rect_min, rect_max;	/* min/max rectangle display values */

  sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas");
  if(!sbt_canvas_w)
    {
      fprintf(stderr, "Error finding *stack_btool_canvas\n");
      return;
    }

  /* set the min/max vars */
  dpy_xmin = sbt_left_offset;
  dpy_xmax = sbt_x - SBT_SLIDER_WIDTH;
  dpy_ymin = sbt_y/2 + SBT_SLIDER_WIDTH;
  dpy_ymax = sbt_y - sbt_bottom_offset;

  
  /* if odd, draw on the upper half */
  if(axis%2)
    {
      rect_min = (sbt_br_pos[axis] - sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_xmax - dpy_xmin);
      rect_min += dpy_xmin;
      
      rect_max = (sbt_br_pos[axis] + sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_xmax - dpy_xmin);
      rect_max += dpy_xmin;
      
      /* check lower bound on width */
      if(rect_max <= rect_min)
	{
	  if(rect_max == dpy_xmax)
	    rect_min = dpy_xmax-1;
	  else
	    rect_max = rect_min+1;
	}

      XFillRectangle(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
		     rect_min, axis*SBT_SLIDER_WIDTH,
		     rect_max - rect_min, SBT_SLIDER_WIDTH);
    }
  /* if even, draw on lower half */
  else
    {
      rect_min = (sbt_br_pos[axis] - sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_ymax - dpy_ymin);
      rect_min = dpy_ymax - rect_min;
      
      rect_max = (sbt_br_pos[axis] + sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_ymax - dpy_ymin);
      rect_max = dpy_ymax - rect_max;
      
      /* check lower bound on height */
      if(rect_max >= rect_min)
	{
	  if(rect_max == dpy_ymin)
	    rect_min = dpy_ymin+1;
	  else
	    rect_max = rect_min-1;
	}

      XFillRectangle(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), gc,
		     (axis+1)*SBT_SLIDER_WIDTH, rect_max,
		     SBT_SLIDER_WIDTH, rect_min - rect_max);
    }
}



/*
 * StackBToolEraseAxis() - Erases the stack brush tool representation
 *                         for a single axis on the stack brush tool.
 *
 * PARAMETERS
 *   axis           The axis to erase
 *
 * RETURNS
 *   void
 */
void StackBToolEraseAxis(int axis)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas */
  int dpy_xmin,			/* display min/max vars */
      dpy_xmax,
      dpy_ymin,
      dpy_ymax;
  int rect_min, rect_max;	/* min/max rectangle display values */

  sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas");
  if(!sbt_canvas_w)
    {
      fprintf(stderr, "Error finding *stack_btool_canvas\n");
      return;
    }

  /* set the min/max vars */
  dpy_xmin = sbt_left_offset;
  dpy_xmax = sbt_x - SBT_SLIDER_WIDTH;
  dpy_ymin = sbt_y/2 + SBT_SLIDER_WIDTH;
  dpy_ymax = sbt_y - sbt_bottom_offset;

  
  /* if odd, erase upper half */
  if(axis%2)
    {
      rect_min = (sbt_br_pos[axis] - sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_xmax - dpy_xmin);
      rect_min += dpy_xmin;
      
      rect_max = (sbt_br_pos[axis] + sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_xmax - dpy_xmin);
      rect_max += dpy_xmin;
      
      /* check lower bound on width */
      if(rect_max <= rect_min)
	{
	  if(rect_max == dpy_xmax)
	    rect_min = dpy_xmax-1;
	  else
	    rect_max = rect_min+1;
	}
      
      XClearArea(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), 
		 rect_min, axis*SBT_SLIDER_WIDTH,
		 rect_max - rect_min, SBT_SLIDER_WIDTH, False);
    }
  /* if even, erase lower half */
  else
    {
      rect_min = (sbt_br_pos[axis] - sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_ymax - dpy_ymin);
      rect_min = dpy_ymax - rect_min;
      
      rect_max = (sbt_br_pos[axis] + sbt_br_size[axis]/2. - dim_min[axis]) /
	(dim_max[axis] - dim_min[axis]) * (dpy_ymax - dpy_ymin);
      rect_max = dpy_ymax - rect_max;
      
      /* check lower bound on height */
      if(rect_max >= rect_min)
	{
	  if(rect_max == dpy_ymin)
	    rect_min = dpy_ymin+1;
	  else
	    rect_max = rect_min-1;
	}

      XClearArea(XtDisplay(sbt_canvas_w), XtWindow(sbt_canvas_w), 
		 (axis+1)*SBT_SLIDER_WIDTH, rect_max,
		 SBT_SLIDER_WIDTH, rect_min - rect_max,
		 False);
    }
}



/*
 * StackBToolInteractiveResize() - Interactively resize the brush
 *                                 using the stack brush tool
 */
void StackBToolInteractiveResize(int mouse_x, int mouse_y, int button)
{
  Widget sbt_canvas_w;		/* the stack brush tool canvas widget */
  static int axis;		/* axis for resize */
  double new_min, new_max;	/* new brush min/max */
  double mouse_data;		/* mouse in data coords */
  static int resize_min,	/* resize min/max flags */
             resize_max;
  int h_axes, v_axes;		/* horizontal and vertical axes */

  sbt_canvas_w = WcFullNameToWidget(appShell,"*stack_btool_canvas");
  if(!sbt_canvas_w)
    {
      fprintf(stderr, "Error finding *stack_btool_canvas\n");
      return;
    }

  /* if this is a button down, determine axis */
  if(button == BUTTON_DOWN)        //OVERLOAD CALL: BUTTON_DOWN: glyphtool.c(?), stacktool.c(?), util.c(?)
    {
      v_axes = dims/2;
      h_axes = dims/2 + dims%2;
      
      /* check if on top half or bottom half */
      if(mouse_y < sbt_y/2)
	{
	  if(mouse_y < SBT_SLIDER_WIDTH)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	    
	  axis = (mouse_y - SBT_SLIDER_WIDTH) * (2*v_axes - 1) /
	    ((2*v_axes - 1)*SBT_SLIDER_WIDTH);
	  if(axis%2)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	  axis++;
	}
      else
	{
	  if(mouse_x < SBT_SLIDER_WIDTH)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	  
	  axis = (mouse_x - SBT_SLIDER_WIDTH) * (2*h_axes - 1) /
	    ((2*h_axes - 1)*SBT_SLIDER_WIDTH);
	  if(axis%2)
	    {
	      axis = -1;
	      XBell(XtDisplay(sbt_canvas_w), 0);
	      return;
	    }
	}
      
      /* sanity check */
      if(axis < 0 || axis >= dims)
	{
	  XBell(XtDisplay(sbt_canvas_w), 0);
	  return;
	}

      /* calculate position in data space and bound it */
      if(mouse_y < sbt_y/2)
	{
	  mouse_data = (mouse_x - sbt_left_offset) *
	    (dim_max[axis] - dim_min[axis]) /
	      (sbt_x - sbt_left_offset - SBT_SLIDER_WIDTH);
	  mouse_data += dim_min[axis];
	}
      else
	{
	  mouse_data = (sbt_y - sbt_bottom_offset - mouse_y) *
	    (dim_max[axis] - dim_min[axis]) /
	      (sbt_y/2 - SBT_SLIDER_WIDTH - sbt_bottom_offset);
	  mouse_data += dim_min[axis];
	}

      mouse_data = MIN(mouse_data, dim_max[axis]);
      mouse_data = MAX(mouse_data, dim_min[axis]);
    
      /* now determine if min or max is being resized */
      resize_min = resize_max = FALSE;
      if(mouse_data < sbt_br_pos[axis])
	resize_min = TRUE;
      else
	resize_max = TRUE;

      /* store old brush position for later retrieval on cancel */
    }
  else
    {
      /* sanity check */
      if(axis < 0 || axis >= dims)
	return;

      /* calculate position in data space and bound it */
      if(mouse_y < sbt_y/2)
	{
	  mouse_data = (mouse_x - sbt_left_offset) *
	    (dim_max[axis] - dim_min[axis]) /
	      (sbt_x - sbt_left_offset - SBT_SLIDER_WIDTH);
	  mouse_data += dim_min[axis];
	}
      else
	{
	  mouse_data = (sbt_y - sbt_bottom_offset - mouse_y) *
	    (dim_max[axis] - dim_min[axis]) /
	      (sbt_y/2 - SBT_SLIDER_WIDTH - sbt_bottom_offset);
	  mouse_data += dim_min[axis];
	}
      mouse_data = MIN(mouse_data, dim_max[axis]);
      mouse_data = MAX(mouse_data, dim_min[axis]);
    }
  
  /* resize min or max */
  if(resize_min)
    {
      new_min = mouse_data;
      new_max = sbt_br_pos[axis]+sbt_br_size[axis]/2.;
    }
  else
    {
      new_min = sbt_br_pos[axis]-sbt_br_size[axis]/2.;
      new_max = mouse_data;
    }
  
  /* check if min>max */
  if(resize_min && new_min > new_max)
    new_max = new_min;
  if(resize_max && new_min > new_max)
    new_min = new_max;

  /* erase the old axis */
  StackBToolEraseAxis(axis);

  /* assign the new brush */
  sbt_br_pos[axis] = (new_min + new_max)/2.;
  sbt_br_size[axis] = new_max - new_min;

  /* set the brush color */
  if(COLOR==1)
    XSetForeground(XtDisplay(sbt_canvas_w), gc, outline_col.pixel);
  
  /* draw the new axis */
  StackBToolDrawAxis(axis);
}



Back to Source File Index


C++ to HTML Conversion by ctoohtml