Changeset 13479

trunk/Ohana/Makefile.in

-              r12859
+              r13479
 imclean     \
 imregister  \
+kapa        \
+kii         \
+kapa2       \
 misc        \
 mosastro    \
 …
 mana:
         make libs
+        make kii.install
+        make kapa.install
+        make kapa2.install
         cd src/opihi; make mana.install && exit
 dvoshell:
         make libs
+        make kii.install
+        make kapa.install
+        make kapa2.install
         cd src/opihi; make dvo.install && exit

trunk/Ohana/src/addstar/src/SEDops.c

-              r8361
+              r13479
   graphdata.style = 2;
   graphdata.ptype = 2;
   KapaClear (Xgraph, TRUE);
+  KapaClearSections (Xgraph);
   magSection.name = strcreate ("mag");
   magSection.x  = 0;
 …
   int j, minRow, Nfilter;
   double X, Y;
+  double X, Y, Z, RA, DEC;
   char line[1024], key[20];
 …
   SWAP (graphdata.ymin, graphdata.ymax);
   KapaClear (Xgraph, TRUE);
+  KapaClearSections (Xgraph);
   KapaSetSection (Xgraph, &magSection);
   KapaSetLimits (Xgraph, &graphdata);
 …
   graphdata.ptype = 7;
   KapaPrepPlot (Xgraph, Nfilter, &graphdata);
   KapaPlotVector (Xgraph, Nfilter, table[0].wavecode);
   KapaPlotVector (Xgraph, Nfilter, fitmags);
+  KapaPlotVector (Xgraph, Nfilter, table[0].wavecode, "x");
+  KapaPlotVector (Xgraph, Nfilter, fitmags, "y");
   graphdata.color = KapaColorByName ("red");
 …
+  }
   KapaPrepPlot (Xgraph, Nfilter, &graphdata);
   KapaPlotVector (Xgraph, Nfilter, table[0].wavecode);
   KapaPlotVector (Xgraph, Nfilter, fitmags);
   KapaPlotVector (Xgraph, Nfilter, fiterrs);
   KapaPlotVector (Xgraph, Nfilter, fiterrs);
+  KapaPlotVector (Xgraph, Nfilter, table[0].wavecode, "x");
+  KapaPlotVector (Xgraph, Nfilter, fitmags, "x");
+  KapaPlotVector (Xgraph, Nfilter, fiterrs, "dym");
+  KapaPlotVector (Xgraph, Nfilter, fiterrs, "dyp");
   KapaSendLabel (Xgraph, "model,fit (mags)", 1);
 …
+  }
   KapaPrepPlot (Xgraph, Nfilter, &graphdata);
   KapaPlotVector (Xgraph, Nfilter, table[0].wavecode);
   KapaPlotVector (Xgraph, Nfilter, fitmags);
   KapaPlotVector (Xgraph, Nfilter, fiterrs);
   KapaPlotVector (Xgraph, Nfilter, fiterrs);
+  KapaPlotVector (Xgraph, Nfilter, table[0].wavecode, "x");
+  KapaPlotVector (Xgraph, Nfilter, fitmags, "y");
+  KapaPlotVector (Xgraph, Nfilter, fiterrs, "dym");
+  KapaPlotVector (Xgraph, Nfilter, fiterrs, "dyp");
   KapaSendLabel (Xgraph, "wavelength (nm)", 0);
   KapaSendLabel (Xgraph, "resid (mags)", 1);
   KiiCursorOn (Xgraph);
   while (KiiCursorRead (Xgraph, &X, &Y, key)) {
+  while (KiiCursorRead (Xgraph, &X, &Y, &Z, &RA, &DEC, key)) {
     // fprintf (stderr, "window: %f %f (%s)\n", X, Y, key);
     if (!strcasecmp (key, "Q")) {

trunk/Ohana/src/gastro/Makefile

r12842	r13479
15	15	FULL_CFLAGS = $(BASE_CFLAGS)
16	16	FULL_CPPFLAGS = $(BASE_CPPFLAGS)
17		FULL_LDFLAGS = -ldvo -lFITS -lohana $(BASE_LDFLAGS)
	17	FULL_LDFLAGS = -lkapa -ldvo -lFITS -lohana $(BASE_LDFLAGS)
18	18
19	19	gastro: $(BIN)/gastro.$(ARCH)

trunk/Ohana/src/gastro/src/plotstuff.c

-              r12332
+              r13479
 int open_graph (int N) {
+# ifdef ANSI
+#   define F_SETFL      4
+#   define O_NONBLOCK 0200000
+#   define       AF_UNIX         1
+#   define       SOCK_STREAM     1
+#define ENOENT          2       /* No such file or directory    */
+# endif /* ANSI */
+  int InitSocket, status;
+  socklen_t addreslen;
+  struct sockaddr_un Address;
+  char temp[100];
+  char socket_name[100];
+  char name[100];
   active = N;
+  sprintf (socket_name, "/tmp/kapa%d", N);
+  sprintf (temp, "rm -f %s", socket_name);
+  system (temp);
+  strcpy (Address.sun_path, socket_name);
+  Address.sun_family = AF_UNIX;
+  InitSocket = socket (AF_UNIX, SOCK_STREAM, 0);
+  status = bind (InitSocket, (struct sockaddr *) &Address, sizeof (Address));
+  status = listen (InitSocket, 1);
+  sprintf (temp, "kapa %s &", socket_name);
+# ifndef DEBUG
+  system (temp);
+# else
+  fprintf (stderr, "start kapa, press return: %s\n", temp);
+  fscanf (stdin, "%d", &i);
+# endif
+  addreslen =  sizeof (Address);
+  Xgraph[N] = accept (InitSocket, (struct sockaddr *) &Address, &addreslen);
+  sprintf (name, "gastro [%d]", N);
+  Xgraph[N] = KapaOpen ("kapa", name);
   if (Xgraph[N] < 0) {
     fprintf (stderr, "error starting kapa\n");
     return (FALSE);
+  }
+  else {
+    return (TRUE);
+  }
+  return (TRUE);
+}
 void DonePlotting (Graphdata *graphmode, int N) {
-  char buffer[65], buffer2[65];
+  write (Xgraph[N], "DBOX", 4);
+  sprintf (buffer, "%f %f %f %f ", graphmode[0].xmin, graphmode[0].xmax, graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d ", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%s %s %s", "2222", "2222", "2222");
+  sprintf (buffer2, "NBYTES: %6d ", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  if (Xgraph[N] == 0) return;
+  KapaBox (Xgraph[N], graphmode);
+  return;
+}
 void PrepPlotting (int Npts, Graphdata *graphmode, int N) {
+  int i, status;
+  char buffer[128], buffer2[128];
+  if (Xgraph[N] == 0) return;
   active = N;
   if (Npts < 1) return;
+  /* test Xgraph[N], flush junk from pipe */
+  signal (SIGPIPE, XDead);
+  fcntl (Xgraph[N], F_SETFL,  O_NONBLOCK);
+  for (i = 0; (read (Xgraph[N], buffer, 64) > 0) && (i < 20); i++);
+  fcntl (Xgraph[N], F_SETFL, !O_NONBLOCK);
+  if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  /* tell kapa to look for the incoming image */
+  status = write (Xgraph[N], "PLOT", 4);
+  /* send Xgraph[N] the plot details */
+  sprintf (buffer, "%8d %8d %d %d %d %d %f %f ",
+           Npts, graphmode[0].style,
+           graphmode[0].ptype, graphmode[0].ltype,
+           graphmode[0].etype, graphmode[0].color,
+           graphmode[0].lweight, graphmode[0].size);
+  sprintf (buffer2, "NBYTES: %6d ", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%f %f %f %f ",
+           graphmode[0].xmin, graphmode[0].xmax,
+           graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d ", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  KapaPrepPlot (Xgraph[N], Npts, graphmode);
+}
 …
   if (Npts < 1) return;
   active = N;
+  Nbytes = Npts * sizeof (float);
+  write (Xgraph[N], vect, Nbytes);
+  KapaPlotVector (Xgraph[N], Npts, vect);
+}
 …
   if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  write (Xgraph[N], "ERAS", 4);
+  KapaClearSections (Xgraph[N]);
+}
+}
 /* include these lines to plot a pair of vectors:

trunk/Ohana/src/gastro2/Makefile

r12842	r13479
15	15	FULL_CFLAGS = $(BASE_CFLAGS)
16	16	FULL_CPPFLAGS = $(BASE_CPPFLAGS)
17		FULL_LDFLAGS = -ldvo -lFITS -lohana $(BASE_LDFLAGS)
	17	FULL_LDFLAGS = -lkapa -ldvo -lFITS -lohana $(BASE_LDFLAGS)
18	18
19	19	gastro2: $(BIN)/gastro2.$(ARCH)

trunk/Ohana/src/gastro2/src/plotstuff.c

-              r12332
+              r13479
 int open_graph (int N) {
+# ifdef ANSI
+#   define F_SETFL      4
+#   define O_NONBLOCK 0200000
+#   define       AF_UNIX         1
+#   define       SOCK_STREAM     1
+#define ENOENT          2       /* No such file or directory    */
+# endif /* ANSI */
+  int InitSocket, status;
+  socklen_t addreslen;
+  struct sockaddr_un Address;
+  char temp[100];
+  char socket_name[100];
+  char name[100];
   active = N;
+  sprintf (socket_name, "/tmp/kapa%d", N);
+  sprintf (temp, "rm -f %s", socket_name);
+  system (temp);
+  strcpy (Address.sun_path, socket_name);
+  Address.sun_family = AF_UNIX;
+  InitSocket = socket (AF_UNIX, SOCK_STREAM, 0);
+  status = bind (InitSocket, (struct sockaddr *) &Address, sizeof (Address));
+  status = listen (InitSocket, 1);
+  sprintf (temp, "kapa %s -name %d &", socket_name, N);
+# ifndef DEBUG
+  system (temp);
+# else
+  fprintf (stderr, "start kapa, press return: %s\n", temp);
+  fscanf (stdin, "%d", &i);
+# endif
+  addreslen =  sizeof (Address);
+  Xgraph[N] = accept (InitSocket, (struct sockaddr *) &Address, &addreslen);
+  sprintf (name, "gastro [%d]", N);
+  Xgraph[N] = KapaOpen ("kapa", name);
   if (Xgraph[N] < 0) {
     fprintf (stderr, "error starting kapa\n");
     return (FALSE);
+  }
+  else {
+    return (TRUE);
+  }
+  return (TRUE);
+}
 void DonePlotting (Graphdata *graphmode, int N) {
-  char buffer[65], buffer2[65];
+  write (Xgraph[N], "DBOX", 4);
+  sprintf (buffer, "%f %f %f %f", graphmode[0].xmin, graphmode[0].xmax, graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%s %s %s", "2222", "2222", "2222");
+  sprintf (buffer2, "NBYTES: %6d", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  if (Xgraph[N] == 0) return;
+  KapaBox (Xgraph[N], graphmode);
+  return;
+}
 void PrepPlotting (int Npts, Graphdata *graphmode, int N) {
+  int i, status;
+  char buffer[128], buffer2[128];
+  if (Xgraph[N] == 0) return;
   active = N;
   if (Npts < 1) return;
+  /* test Xgraph[N], flush junk from pipe */
+  signal (SIGPIPE, XDead);
+  fcntl (Xgraph[N], F_SETFL,  O_NONBLOCK);
+  for (i = 0; (read (Xgraph[N], buffer, 64) > 0) && (i < 20); i++);
+  fcntl (Xgraph[N], F_SETFL, !O_NONBLOCK);
+  if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  /* tell kapa to look for the incoming image */
+  status = write (Xgraph[N], "PLOT", 4);
+  /* send Xgraph[N] the plot details */
+  sprintf (buffer, "%8d %8d %d %d %d %d %d %f %f",
+           Npts, graphmode[0].style,
+           graphmode[0].ptype, graphmode[0].ltype,
+           graphmode[0].etype, graphmode[0].ebar, graphmode[0].color,
+           graphmode[0].lweight, graphmode[0].size);
+  sprintf (buffer2, "NBYTES: %6d", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%f %f %f %f",
+           graphmode[0].xmin, graphmode[0].xmax,
+           graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d", (unsigned int) strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  KapaPrepPlot (Xgraph[N], Npts, graphmode);
+}
 …
   if (Npts < 1) return;
   active = N;
+  Nbytes = Npts * sizeof (float);
+  write (Xgraph[N], vect, Nbytes);
+  KapaPlotVector (Xgraph[N], Npts, vect);
+}
 …
   if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  write (Xgraph[N], "ERAS", 4);
+  KapaClearSections (Xgraph[N]);
+}
+}
 /* include these lines to plot a pair of vectors:

trunk/Ohana/src/kapa2/Makefile

-              r13333
+              r13479
 default: kapa2
+default: kapa
 help:
         @echo "make options: kapa (default)"
 …
 INDEPS  = $(DESTINC)/kapa.h $(DESTINC)/dvo.h $(DESTINC)/gfitsio.h $(DESTINC)/ohana.h
 kapa2: $(BIN)/kapa2.$(ARCH)
 install: $(DESTBIN)/kapa2
+kapa2: $(BIN)/kapa.$(ARCH)
+install: $(DESTBIN)/kapa
 KAPA = \
 …
 $(SRC)/Graphs.$(ARCH).o                   $(SRC)/SetGraphSize.$(ARCH).o       \
 $(SRC)/Resize.$(ARCH).o                   $(SRC)/ErasePlots.$(ARCH).o         \
+$(SRC)/EraseImage.$(ARCH).o               $(SRC)/SetToolbox.$(ARCH).o         \
 $(SRC)/EraseCurrentPlot.$(ARCH).o         $(SRC)/EraseSections.$(ARCH).o      \
 $(SRC)/SetSection.$(ARCH).o               $(SRC)/DefineSection.$(ARCH).o      \
 …
 $(SRC)/CreatePicture.$(ARCH).o            $(SRC)/CreateColorbar.$(ARCH).o     \
 $(SRC)/MakeColormap.$(ARCH).o             $(SRC)/SetColormap.$(ARCH).o        \
 $(SRC)/PaintOverlay.$(ARCH).o             $(SRC)/PaintTickmarks.$(ARCH).o     \
+$(SRC)/PaintOverlay.$(ARCH).o             $(SRC)/SetGraphData.$(ARCH).o       \
 $(SRC)/LoadOverlay.$(ARCH).o              $(SRC)/EraseOverlay.$(ARCH).o       \
 $(SRC)/LoadTickmarks.$(ARCH).o            $(SRC)/SaveOverlay.$(ARCH).o        \
+$(SRC)/SaveOverlay.$(ARCH).o              $(SRC)/SetImageData.$(ARCH).o       \
 $(SRC)/CSaveOverlay.$(ARCH).o             $(SRC)/EraseOverlay.$(ARCH).o       \
 $(SRC)/CheckVisual.$(ARCH).o              $(SRC)/CursorOps.$(ARCH).o          \
 …
 $(OBJ): $(INDEPS) $(LDDEPS)
 $(BIN)/kapa2.$(ARCH): $(OBJ)
+$(BIN)/kapa.$(ARCH): $(OBJ)

trunk/Ohana/src/kapa2/include/constants.h

-              r13320
+              r13479
  | PointerMotionMask)
 # define PAD1  5
 # define PAD2  3
+# define PAD1  3
+# define PAD2  5
 # define TEXTPAD 25
 # define COLORPAD 10
 # define TEXT_Y 15
 # define ZOOM_X 170
 # define ZOOM_Y 170
+# define ZOOM_X 152
+# define ZOOM_Y 152
 # define NOVERLAYS 4
 # define BUTTON_WIDTH 28

trunk/Ohana/src/kapa2/include/globals.h

r13333	r13479
15	15
16	16	/* file descriptor for socket connection to mana */
17		int sock;
	17	// int sock;
18	18
19	19	/* each layout / section defines one of the active portions of the graphics window

trunk/Ohana/src/kapa2/include/prototypes.h

-              r13333
+              r13479
 /* EventLoop */
 int           PScommand           PROTO(());
+int           PScommand           PROTO((int sock));
 int           CheckPipe           PROTO(());
 int           Reconfig            PROTO((XEvent *event));
 …
 /* CheckPipe */
+int           PNGit               PROTO(());
+int           PPMit               PROTO(());
+int           LoadFrame           PROTO(());
+int           LoadObject          PROTO(());
+int           LoadLabels          PROTO(());
+int           LoadTextlines       PROTO(());
+int           LoadVectorData      PROTO(());
+int           Resize              PROTO(());
+int           GetLimits           PROTO(());
+int           SetLimits           PROTO(());
+int           SetSection          PROTO(());
+int           ListSection         PROTO(());
+int           DefineSection       PROTO(());
+int           SetFont             PROTO(());
+int           EraseCurrentPlot    PROTO(());
+int           ErasePlots          PROTO(());
+int           EraseSections       PROTO(());
+int           PNGit               PROTO((int sock));
+int           PPMit               PROTO((int sock));
+int           LoadFrame           PROTO((int sock));
+int           LoadObject          PROTO((int sock));
+int           LoadLabels          PROTO((int sock));
+int           LoadTextlines       PROTO((int sock));
+int           Resize              PROTO((int sock));
+int           GetLimits           PROTO((int sock));
+int           SetLimits           PROTO((int sock));
+int           SetSection          PROTO((int sock));
+int           ListSection         PROTO((int sock));
+int           MoveSection         PROTO((int sock));
+int           DefineSection       PROTO((int sock));
+int           SetFont             PROTO((int sock));
+int           EraseCurrentPlot    PROTO((void));
+int           ErasePlots          PROTO((void));
+int           EraseSections       PROTO((void));
+int           EraseImage          PROTO((void));
+int           SetGraphData        PROTO((int sock));
+int           GetGraphData        PROTO((int sock));
+int           SetImageData        PROTO((int sock));
+int           GetImageData        PROTO((int sock));
+int           LoadVectorData      PROTO((int sock, KapaGraphWidget *graph, int N, char *type));
 /* Section Utilities */
 …
 Section      *GetActiveSection    PROTO(());
 int           SetActiveSectionByNumber PROTO((int N));
 int           ListSection         PROTO(());
+int           ListSection         PROTO((int sock));
 KapaGraphWidget *InitGraph        PROTO(());
 void          DrawGraph           PROTO((KapaGraphWidget *graph));
 void          SetGraphSize        PROTO((Section *section));
+void          FreeGraph           PROTO((KapaGraphWidget *graph));
 void          InitLayout          PROTO((int argc, char **argv));
 …
 void          QuitX               PROTO((Display *display, char *message));
 Graphic      *GetGraphic          PROTO(());
+int           GetPixelCount       PROTO((int sock));
 int           Center              PROTO(());
 …
 void          Remap24             PROTO((Graphic *graphic, KapaImageWidget *image, Matrix *matrix));
 void          Remap32             PROTO((Graphic *graphic, KapaImageWidget *image, Matrix *matrix));
+int           LoadPicture         PROTO(());
+int           LoadPicture         PROTO((int sock));
 KapaImageWidget *InitImage        PROTO(());
+void          FreeImage           PROTO((KapaImageWidget *image));
 void          SetImageSize        PROTO((Section *section));
+int           GetPixelCount       PROTO(());
 void          InitButtonSize      PROTO((Button *button, int width, int height, char *bitmap));
 void          InitButtonFunc      PROTO((Button *button, int (*function)()));

trunk/Ohana/src/kapa2/include/structures.h

-              r13320
+              r13479
   int Nobjects;
   unsigned long color;
   Object *objects;
+  KiiOverlay *objects;
 } Overlay;
 …
   Axis      axis[4];    /* coordinate axes */
   Label     label[8];   /* fixed axis labels */
+  Graphdata data;       /* current graph data */
   Gobjects *objects;    /* graphic objects */
 …
   Button   grey_button;
   Button   rainbow_button;
   Button   puns_button;
+  Button    puns_button;
   Button   overlay_button[NOVERLAYS];
   // location of the status box
   int      text_x, text_y;
+  int      text_dx, text_dy;
   int      location;          // position of the zoom/status widgets (0 = none, 1-4 = bottom,left,top,right)
   int      MovePointer;
 …
   Coords   coords;
   char     file[1024];     /* name of file */
   char     buffer_name[1024];  /* name of buffer */
+  char     name[1024];  /* name of buffer */
 } KapaImageWidget;

trunk/Ohana/src/kapa2/src/CSaveOverlay.c

-              r13320
+              r13479
 # include "Ximage.h"
 int CSaveOverlay () {
+int CSaveOverlay (int sock) {
   char filename[256];
+  char filename[256], *type;
   int i, N;
   double ra, dec, ra1, dec1, x1, y1, dra, ddec;
 …
   KapaImageWidget *image;
+  KiiScanMessage (sock, "%*s %d %s", &N, filename);
   section = GetActiveSection();
   image   = section->image;
+  if (image == NULL) return (TRUE);
-  KiiScanMessage (sock, "%*s %d %s", &N, filename);
   f = fopen (filename, "w");
   if (f == NULL) {
 …
   for (i = 0; i < image[0].overlay[N].Nobjects; i++) {
     if (!strcmp (image[0].overlay[N].objects[i].type, "LINE")) {
+    if (image[0].overlay[N].objects[i].type == KII_OVERLAY_LINE) {
       XY_to_RD (&ra, &dec, image[0].overlay[N].objects[i].x, image[0].overlay[N].objects[i].y, &image[0].coords);
       x1 = image[0].overlay[N].objects[i].x + image[0].overlay[N].objects[i].dx;
 …
       dra = cos (dec*RAD_DEG) * fabs (ra1 - ra);
+    }
+    fprintf (f, "%s %lf %lf %lf %lf\n", image[0].overlay[N].objects[i].type, ra, dec, dra, ddec);
+    type = KiiOverlayTypeByNumber (image[0].overlay[N].objects[i].type);
+    if (type == NULL) continue;
+    fprintf (f, "%s %lf %lf %lf %lf\n", type, ra, dec, dra, ddec);
+   }
   fclose (f);

trunk/Ohana/src/kapa2/src/Center.c

-              r13320
+              r13479
 # include "Ximage.h"
 int Center () {
+int Center (int sock) {
   int zoom;
 …
   KapaImageWidget *image;
+  KiiScanMessage (sock, "%lf %lf %d", &X,  &Y, &zoom);
   graphic = GetGraphic();
   section = GetActiveSection();
   image = section->image;
+  KiiScanMessage (sock, "%lf %lf %d", &X,  &Y, &zoom);
+  if (image == NULL) return (TRUE);
   image[0].X = 0.5*image[0].matrix.Naxis[0] - X;

trunk/Ohana/src/kapa2/src/CheckPipe.c

-              r13333
+              r13479
 # define STRCONST(A) ((int)(0x1000000*A[0] + 0x10000*A[1] + 0x100*A[2] + 0x1*A[3]))
+static KapaSockAddress Address;
+static int InitSocket = -1;
+static int sock = -1;
+// we can supply a port here, with only small changes
+void InitPipe () {
+  InitSocket = KapaServerInit (&Address);
+  return;
+}
+int GetActiveSocket () {
+  return (sock);
+}
+// after we have processed the command, we unblock the socket
+# define FINISHED(A) { fcntl (sock, F_SETFL, O_NONBLOCK); return (A); }
 int CheckPipe () {
   int status;
+  char buffer[32];
+  char word[5];
+  // check if we have a valid connection. if not, see if we can get one
+  if (sock == -1) {
+    sock = KapaServerWait (InitSocket, &Address);
+    if (sock == -1) return (TRUE);
+    close (InitSocket); /* stop listening for new connections */
+    fcntl (sock, F_SETFL, O_NONBLOCK);
+  }
   /***** read (4 byte) message word from socket ****/
   status = read (sock, buffer, 4);
   buffer[4] = 0;
+  status = read (sock, word, 4);
+  word[4] = 0;
   switch (status) {
   case -1:                          /* no input from pipe: continue */
 …
+  }
+  /* once we get a command, we block to ensure we get complete messages */
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
   /***** handle different messages ****/
   if (ACTIVE_CURSOR) {
+    if (strcmp (buffer, "NCUR")) {
+      fprintf (stderr, "wrong end message %s\n", buffer);
+      return (TRUE);
+    if (strcmp (word, "NCUR")) {
+      fprintf (stderr, "wrong end message %s\n", word);
+      KiiSendCommand (sock, 4, "DONE");
+      FINISHED (TRUE);
+    }
     ACTIVE_CURSOR = FALSE;
+    return (TRUE);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
   if (!strcmp (buffer, "QUIT")) return (FALSE);
   if (!strcmp (buffer, "CURS")) {
+  if (!strcmp (word, "QUIT")) FINISHED (FALSE);
+  if (!strcmp (word, "CURS")) {
     ACTIVE_CURSOR = TRUE;
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "PSIT")) {
+    status = PScommand ();
+    write (sock, "DONE", 4);
+    return (status);
+  }
+  if (!strcmp (buffer, "PNGF")) {
+    status = PNGit ();
+    write (sock, "DONE", 4);
+    return (status);
+  }
+  if (!strcmp (buffer, "PPMF")) {
+    status = PPMit ();
+    write (sock, "DONE", 4);
+    return (status);
+  }
+  if (!strcmp (buffer, "DBOX")) {
+    status = LoadFrame ();
+    return (status);
+  }
+  if (!strcmp (buffer, "PLOT")) {
+    status = LoadObject ();
+    return (status);
+  }
+  if (!strcmp (buffer, "LABL")) {
+    status = LoadLabels ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "PTXT")) {
+    status = LoadTextlines ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "RSIZ")) {
+    status = Resize ();
+    return (status);
+  }
+  if (!strcmp (buffer, "LIMS")) {
+    GetLimits ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "SLIM")) {
+    status = SetLimits ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "SSEC")) {
+    status = SetSection ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "LSEC")) {
+    status = ListSection ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "DSEC")) {
+    status = DefineSection ();
+    return (TRUE);
+  }
+  if (!strcmp (buffer, "FONT")) {
+    status = SetFont ();
+    return (TRUE);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "PSIT")) {
+    status = PScommand (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "PNGF")) {
+    status = PNGit (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "PPMF")) {
+    status = PPMit (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "DBOX")) {
+    status = LoadFrame (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "PLOT")) {
+    status = LoadObject (sock);
+    // LoadObject sends its own handshake
+    // KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "LABL")) {
+    status = LoadLabels (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "PTXT")) {
+    status = LoadTextlines (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "RSIZ")) {
+    status = Resize (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "GLIM")) {
+    GetLimits (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "SLIM")) {
+    status = SetLimits (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "GSTY")) {
+    GetGraphData (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "SSTY")) {
+    status = SetGraphData (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "GIMD")) {
+    GetImageData (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "SIMD")) {
+    status = SetImageData (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "TOOL")) {
+    status = SetToolbox (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "SSEC")) {
+    status = SetSection (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "LSEC")) {
+    status = ListSection (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "DSEC")) {
+    status = DefineSection (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "MSEC")) {
+    status = MoveSection (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "FONT")) {
+    status = SetFont (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
   /* Erase Section */
+  if (!strcmp (buffer, "ERSC")) {
+    status = EraseCurrentPlot (TRUE);
+    return (status);
+  }
+  /* Erase Section */
+  if (!strcmp (buffer, "ERAS")) {
+    status = ErasePlots (TRUE);
+    return (status);
+  }
+  /* Don't Erase Section */
+  if (!strcmp (buffer, "ERSS")) {
+    status = EraseSections (FALSE);
+    return (status);
+  }
+  if (!strcmp (buffer, "READ")) {
+    status = LoadPicture ();
+    return (status);
+  }
+  // XXX duplicate Command word
+  if (!strcmp (buffer, "ERAS")) {
+    status = EraseOverlay ();
+    return (status);
+  }
+  if (!strcmp (buffer, "LOAD")) {
+    status = LoadOverlay ();
+    return (status);
+  }
+  if (!strcmp (buffer, "TICK")) {
+    status = LoadTickmarks ();
+    return (status);
+  }
+  if (!strcmp (buffer, "SAVE")) {
+    status = SaveOverlay ();
+    return (status);
+  }
+  if (!strcmp (buffer, "CSVE")) {
+    status = CSaveOverlay ();
+    return (status);
+  }
+  if (!strcmp (buffer, "JPEG")) {
+    status = JPEGit24 ();
+    write (sock, "DONE", 4);
+    return (status);
+  }
+  if (!strcmp (buffer, "CENT")) {
+    status = Center ();
+    return (status);
+  }
+  if (!strcmp (buffer, "NPIX")) {
+    GetPixelCount ();
+    return (TRUE);
+  }
+  fprintf (stderr, "unknown signal %s\n", buffer);
+  return (TRUE);
+  if (!strcmp (word, "ERSC")) {
+    status = EraseCurrentPlot ();
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  /* Erase Plots */
+  if (!strcmp (word, "ERSP")) {
+    status = ErasePlots ();
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  /* Erase Sections */
+  if (!strcmp (word, "ERSS")) {
+    status = EraseSections ();
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  /* Erase Image */
+  if (!strcmp (word, "ERSI")) {
+    status = EraseImage ();
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  /* Erase Overlay for this section */
+  if (!strcmp (word, "ERSO")) {
+    status = EraseOverlay (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "READ")) {
+    status = LoadPicture (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "LOAD")) {
+    status = LoadOverlay (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "SAVE")) {
+    status = SaveOverlay (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "CSVE")) {
+    status = CSaveOverlay (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "JPEG")) {
+    status = JPEGit24 (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "CENT")) {
+    status = Center (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "NPIX")) {
+    GetPixelCount (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  fprintf (stderr, "unknown signal %s\n", word);
+  KiiSendCommand (sock, 4, "DONE");
+  FINISHED (TRUE);
+}

trunk/Ohana/src/kapa2/src/CheckVisual.c

-              r13320
+              r13479
     /* make private colormap  */
     if (graphic[0].Npixels < 16) {
       fprintf (stderr, "can't allocate enough cells, using private colormap\n");
+      // fprintf (stderr, "can't allocate enough cells, using private colormap\n");
       graphic[0].colormap = XCreateColormap (graphic[0].display, RootWindow (graphic[0].display, graphic[0].screen), graphic[0].visual, AllocNone);
       for (graphic[0].Npixels = NPIXELS;
 …
   if (!dyn) {
     graphic[0].Npixels = 256;
     fprintf (stderr, "can't use dynamic colors, color scrollbar inactive\n");
     fprintf (stderr, " this can be avoided by using a dynamic visual class\n");
     fprintf (stderr, " (see Kii help page for details)\n");
+    // fprintf (stderr, "can't use dynamic colors, color scrollbar inactive\n");
+    // fprintf (stderr, " this can be avoided by using a dynamic visual class\n");
+    // fprintf (stderr, " (see Kii help page for details)\n");
+  }

trunk/Ohana/src/kapa2/src/CreatePicture.c

r13320	r13479
56	56	case 32:
57	57	REALLOCATE (image[0].picture.data, char, (4image[0].picture.dximage[0].picture.dy + 32));
58		~~fprintf (stderr, "allocating %d for picture data\n", (4image[0].picture.dximage[0].picture.dy + 32));~~
59	58	memset (image[0].picture.data, 0xbd, 4image[0].picture.dximage[0].picture.dy + 30);
60	59	l = (unsigned int *) image[0].picture.data;

trunk/Ohana/src/kapa2/src/CreateZoom16.c

-              r13320
+              r13479
 # include "Ximage.h"
-# define XPIX(x,Rx,S) (x*S + Rx)
-# define ZPIX(value,Rz1,Rz2) (value*Rz1 - Rz2)
 # define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void CreateZoom16 (KapaImageWidget *image, Graphic *graphic, double x, double y) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, zoomscale, Rx, Ry;
   int expand_in, expand_out;
   unsigned char *out_pix, *out_pix2, *data;
   unsigned char *in_pix,  *in_pix2;
+  float *imdata, *in_pix,  *in_pix2;
   unsigned char pixel1[256], pixel2[256];
   unsigned char pixvalue1, pixvalue2;
 …
   back1 = 0x0000ff & back;
   back2 = 0x0000ff & (back >> 8);
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
   zoomscale = MAX (5, image[0].expand + 5);
 …
   data = out_pix = (unsigned char *) image[0].zoom.data;
+  in_pix  = (unsigned char *) (image[0].matrix.buffer) + DX*(int)MAX(Ry,0) + (int)MAX(Rx,0);
+  imdata  = (float *) image[0].matrix.buffer;
+  in_pix  = &imdata[DX*(int)MAX(Ry,0) + (int)MAX(Rx,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix+=2) {
+        out_pix[0] = pixel1[*in_pix2];
+        out_pix[1] = pixel2[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        out_pix[0] = pixel1[pixelN];
+        out_pix[1] = pixel2[pixelN];
+      }
+    }
+    else {
+    } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= 2*expand_out) {
+        pixvalue1 = pixel1[*in_pix2];
+        pixvalue2 = pixel2[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        pixvalue1 = pixel1[pixelN];
+        pixvalue2 = pixel2[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=2*(dx-expand_out)) {
 …
+  }
   image[0].zoom.pix = XCreateImage (graphic[0].display, graphic[0].visual, 16, ZPixmap, 0,
                                         image[0].zoom.data, image[0].zoom.dx, image[0].zoom.dy, 32, 0);
+  image[0].zoom.pix = XCreateImage (graphic[0].display, graphic[0].visual, graphic[0].depth, ZPixmap, 0,
+                                        image[0].zoom.data, image[0].zoom.dx, image[0].zoom.dy, 16, 0);
+}

trunk/Ohana/src/kapa2/src/CreateZoom24.c

-              r13320
+              r13479
 # include "Ximage.h"
-# define XPIX(x,Rx,S) (x*S + Rx)
-# define ZPIX(value,Rz1,Rz2) (value*Rz1 - Rz2)
 # define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void CreateZoom24 (KapaImageWidget *image, Graphic *graphic, double x, double y) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, zoomscale, Rx, Ry;
   int expand_in, expand_out;
   unsigned char *out_pix, *out_pix2, *data;
   unsigned char *in_pix,  *in_pix2;
+  float *imdata, *in_pix, *in_pix2;
   unsigned char pixel1[256], pixel2[256], pixel3[256];
   unsigned char pixvalue1, pixvalue2, pixvalue3;
 …
   back3 = 0x0000ff & (back >> 16);
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
   zoomscale = MAX (5, image[0].expand + 5);
   expand = 1 / zoomscale;
 …
   data = out_pix = (unsigned char *) image[0].zoom.data;
+  in_pix  = (unsigned char *) (image[0].matrix.buffer) + DX*(int)MAX(Ry,0) + (int)MAX(Rx,0);
+  imdata  = (float *) image[0].matrix.buffer;
+  in_pix  = &imdata[DX*(int)MAX(Ry,0) + (int)MAX(Rx,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix+=3) {
+        out_pix[0] = pixel1[*in_pix2];
+        out_pix[1] = pixel2[*in_pix2];
+        out_pix[2] = pixel3[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        out_pix[0] = pixel1[pixelN];
+        out_pix[1] = pixel2[pixelN];
+        out_pix[2] = pixel3[pixelN];
+      }
+    }
+    else {
+    } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= 3*expand_out) {
+        pixvalue1 = pixel1[*in_pix2];
+        pixvalue2 = pixel2[*in_pix2];
+        pixvalue3 = pixel3[*in_pix2];
+        pixelN   = PixelLookup(*in_pix2);
+        pixvalue1 = pixel1[pixelN];
+        pixvalue2 = pixel2[pixelN];
+        pixvalue3 = pixel3[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=3*(dx-expand_out)+extra) {

trunk/Ohana/src/kapa2/src/CreateZoom32.c

-              r13320
+              r13479
 # include "Ximage.h"
-# define XPIX(x,Rx,S) (x*S + Rx)
-# define ZPIX(value,Rz1,Rz2) (value*Rz1 - Rz2)
 # define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void CreateZoom32 (KapaImageWidget *image, Graphic *graphic, double x, double y) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, zoomscale, Rx, Ry;
   int expand_in, expand_out;
   unsigned int *out_pix, *out_pix2, *data;
   unsigned char  *in_pix,  *in_pix2;
+  unsigned int *out_pix, *out_pix2;
+  float *imdata, *in_pix, *in_pix2;
   unsigned long pixel[256], pixvalue;
   unsigned long back;
 …
+  }
   back = graphic[0].back;
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
   zoomscale = MAX (5, image[0].expand + 5);
 …
   out_pix = (unsigned int *) image[0].zoom.data;
   data = (unsigned int *) image[0].zoom.data;
   in_pix  = (unsigned char *) (image[0].matrix.buffer) + DX*(int)MAX(Ry,0) + (int)MAX(Rx,0);
+  imdata  = (float *) image[0].matrix.buffer;
+  in_pix  = &imdata[DX*(int)MAX(Ry,0) + (int)MAX(Rx,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix++) {
+        out_pix[0] = pixel[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        out_pix[0] = pixel[pixelN];
+      }
+    }
     else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= expand_out) {
+        pixvalue = *(pixel + *in_pix2);
+        pixelN   = PixelLookup(*in_pix2);
+        pixvalue = pixel[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=(dx-expand_out)) {

trunk/Ohana/src/kapa2/src/CreateZoom8.c

-              r13320
+              r13479
 # include "Ximage.h"
-# define XPIX(x,Rx,S) (x*S + Rx)
-# define ZPIX(value,Rz1,Rz2) (value*Rz1 - Rz2)
 # define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void CreateZoom8 (KapaImageWidget *image, Graphic *graphic, double x, double y) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, zoomscale, Rx, Ry;
   int expand_in, expand_out;
   char  *out_pix, *out_pix2;
   char  *in_pix,  *in_pix2;
+  unsigned char *out_pix, *out_pix2;
+  float *imdata, *in_pix, *in_pix2;
   unsigned long pixel[256], pixvalue;
   unsigned long back;
 …
   back = graphic[0].back;
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
   zoomscale = MAX (5, image[0].expand + 5);
   expand = 1 / zoomscale;
   expand_out = (int) zoomscale;
   expand_in  = 1;
-  /*
-  dx = image[0].zoom.dx;
-  dy = image[0].zoom.dy;
-  DX = image[0].matrix.Naxis[0];
-  DY = image[0].matrix.Naxis[1];
-  Rx = 0.5*(DX - (dx - 1)*expand) - x;
-  Ry = 0.5*(DY - (dy - 1)*expand) - y;
-  data coords of 0,0 point in pic array
-  X = 0.5*image[0].matrix.Naxis[0] - expand*((int)(0.5*image[0].zoom.dx + 0.5) - 0.0) - image[0].X;
-  Y = 0.5*image[0].matrix.Naxis[1] - expand*((int)(0.5*image[0].zoom.dy + 0.5) - 0.0) - image[0].Y;
-  i_start = MIN (MAX (-Rx / expand, 0), dx - expand_out + 1);
-  j_start = MIN (MAX (-Ry / expand, 0), dy - expand_out + 1);
-  i_end   = MAX (MIN ((DX-Rx) / expand, dx - expand_out + 1), 0);
-  j_end   = MAX (MIN ((DY-Ry) / expand, dy - expand_out + 1), 0);
-  dropback = expand_out - (i_end - i_start) % expand_out;
-  if ((i_end - i_start) % expand_out == 0) dropback = 0;
-  out_pix = image[0].zoom.data;
-  in_pix  = (char *) (image[0].matrix.buffer) + DX*(int)MAX(Y,0) + (int)MAX(X,0);
-  */
   dx = image[0].zoom.dx;
 …
   out_pix = (char *) image[0].zoom.data;
+  in_pix  = (char *) (image[0].matrix.buffer) + DX*(int)MAX(Ry,0) + (int)MAX(Rx,0);
+  imdata  = (float *) image[0].matrix.buffer;
+  in_pix  = &imdata[DX*(int)MAX(Ry,0) + (int)MAX(Rx,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     in_pix2 = in_pix;
     if (expand_out == 1) {
+      for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix++)
+        *out_pix = *(pixel + *in_pix2);
+    }
+    else {
+      for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix++) {
+        pixelN = PixelLookup(*in_pix2);
+        *out_pix = pixel[pixelN];
+      }
+    } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= expand_out) {
+        pixvalue = *(pixel + *in_pix2);
+        pixelN   = PixelLookup(*in_pix2);
+        pixvalue = pixel[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=(dx-expand_out)) {
 …
   /**** fill in top area ****/
   for (j = 0; (j < dx*(dy - j_end)) && (out_pix - image[0].zoom.data < dx*dy); j++, out_pix++) {
+  for (j = 0; (j < dx*(dy - j_end)) && (out_pix - (unsigned char *) image[0].zoom.data < dx*dy); j++, out_pix++) {
     *out_pix = back;
+  }

trunk/Ohana/src/kapa2/src/DefineSection.c

-              r13320
+              r13479
 # include "Ximage.h"
+int DefineSection () {
+// define the section, but do not create a graph or image
+int DefineSection (int sock) {
   int i, N, MoveSection;
 …
   if (N < 0) {
     section = AddSection (name, x, y, dx, dy);
-    section->graph = InitGraph ();
     MoveSection = TRUE;
   } else {
 …
   if (MoveSection) {
     SetGraphSize (section);
+    SetSectionSizes (section);
     Refresh (1);
+  }

trunk/Ohana/src/kapa2/src/EraseCurrentPlot.c

r13320	r13479
11	11	section = GetActiveSection();
12	12	if (section->graph == NULL) return (TRUE);
	13
13	14	EraseGraph (section->graph);
14	15

trunk/Ohana/src/kapa2/src/EraseOverlay.c

-              r13331
+              r13479
 # include "Ximage.h"
 int EraseOverlay () {
+int EraseOverlay (int sock) {
   char buffer[256];
 …
   section = GetActiveSection();
   image = section->image;
+  if (image == NULL) return (TRUE);
   KiiScanCommand (sock, 16, "%*s %d", &N);
   if (N > NOVERLAYS) {
     REALLOCATE (image[0].tickmarks.objects, Object, 1);
+    REALLOCATE (image[0].tickmarks.objects, KiiOverlay, 1);
     image[0].tickmarks.Nobjects = 0;
   } else {
     for (i = 0; i < image[0].overlay[N].Nobjects; i++) {
       if (!strcmp (image[0].overlay[N].objects[i].type, "TEXT")) {
+      if (image[0].overlay[N].objects[i].type == KII_OVERLAY_TEXT) {
         free (image[0].overlay[N].objects[i].text);
+      }
+    }
     REALLOCATE (image[0].overlay[N].objects, Object, 1);
+    REALLOCATE (image[0].overlay[N].objects, KiiOverlay, 1);
     image[0].overlay[N].Nobjects = 0;
     image[0].overlay[N].active = FALSE;

trunk/Ohana/src/kapa2/src/GetPixelCount.c

r13320	r13479
1	1	# include "Ximage.h"
2	2
3		int GetPixelCount () {
	3	int GetPixelCount (int sock) {
4	4
5	5	int i;

trunk/Ohana/src/kapa2/src/Graphs.c

-              r13320
+              r13479
     strcpy (graph[0].label[i].text, "");
+  }
+  graph[0].data.xmin = 0.0;
+  graph[0].data.xmax = 1.0;
+  graph[0].data.ymin = 0.0;
+  graph[0].data.ymax = 1.0;
   graph[0].Nobjects = 0;
 …
   FREE (graph[0].objects);
   FREE (graph[0].textline);
+  free (graph);
   return;
+}

trunk/Ohana/src/kapa2/src/Image.c

-              r13331
+              r13479
   image[0].start = 0;
   image[0].slope = 1;
+  image[0].location = 4;
   image[0].coords.Npolyterms = 0;
   for (i = 0; i < NOVERLAYS; i++) {
     image[0].overlay[i].Nobjects = 0;
     ALLOCATE (image[0].overlay[i].objects, Object, 1);  /* allocate so later free will not crash! */
+    ALLOCATE (image[0].overlay[i].objects, KiiOverlay, 1);  /* allocate so later free will not crash! */
     image[0].overlay[i].active = FALSE;
     image[0].overlay[i].color = graphic[0].overlay_color[i];
 …
   graphic = GetGraphic ();
   XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
   XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc,
                   image[0].picture.x, image[0].picture.y,
                   image[0].picture.dx + 1, image[0].picture.dy + 1);
+  XSetForeground (graphic[0].display,  graphic[0].gc, graphic[0].fore);
+  XDrawRectangle (graphic[0].display,  graphic[0].window, graphic[0].gc,
+                  image[0].picture.x,  image[0].picture.y,
+                  image[0].picture.dx+1, image[0].picture.dy+1);
   XPutImage (graphic[0].display, graphic[0].window, graphic[0].gc,
 …
              image[0].picture.dx, image[0].picture.dy);
-  XPutImage (graphic[0].display, graphic[0].window, graphic[0].gc,
-             image[0].cmapbar.pix, 0, 0,
-             image[0].cmapbar.x, image[0].cmapbar.y,
-             image[0].cmapbar.dx, image[0].cmapbar.dy);
-  CrossHairs (graphic, image);
   for (i = 0; i < NOVERLAYS; i++) {
     if (image[0].overlay[i].active) {
 …
+    }
+  }
-# if (0)
-  PaintTickmarks (graphic, image);
-# endif
+  // XXX make this optional?a
+  if (1) {
+  if (image[0].location) {
+    XPutImage (graphic[0].display, graphic[0].window, graphic[0].gc,
+               image[0].cmapbar.pix, 0, 0,
+               image[0].cmapbar.x, image[0].cmapbar.y,
+               image[0].cmapbar.dx, image[0].cmapbar.dy);
+    CrossHairs (graphic, image);
     /* erase everything below zoom box, then draw */
+    /*
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
     XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc,
                     image[0].text_x, image[0].text_x, image[0].zoom.dx, graphic[0].dy);
+                    image[0].text_x, image[0].text_x, image[0].text_dx, image[0].text_dy);
+    */
     DrawButton (graphic, &image[0].PS_button);
     DrawButton (graphic, &image[0].recenter_button);
 …
       DrawButton (graphic, &image[0].overlay_button[i]);
+    }
+    StatusBox (graphic, image);
+  }
-  StatusBox (graphic, image);
   FlushDisplay (graphic[0].display);
+}
+void FreeImage (KapaImageWidget *image) {
+  int i;
+  if (image == NULL) return;
+  for (i = 0; i < NOVERLAYS; i++) {
+    free (image[0].overlay[i].objects);
+  }
+  free (image[0].matrix.buffer);
+  free (image[0].picture.data);
+  free (image[0].cmapbar.data);
+  free (image[0].zoom.data);
+  free (image);
+}

trunk/Ohana/src/kapa2/src/InterpretKeys.c

-              r13333
+              r13479
 int InterpretKeys (Graphic *graphic, XKeyEvent *event) {
+  double           X, Y, offset;
+  int              modstate;
+  float           *imdata;
+  double           X, Y, Z, R, D, offset;
+  int              sock, DX, DY, modstate;
   char            *name, string[16], line[40];
   KeySym           keysym;
 …
   // XXX allow user to choose graph or image coords
   if (ACTIVE_CURSOR) {
+    sock = GetActiveSocket ();
+    if (sock == -1) goto skip_cursor;
     name = XKeysymToString (keysym);
 …
     if (!strcmp (name, "(null)")) goto skip_cursor;
+    Z = -1;
     if (graph) {
       X = (event[0].x - graph[0].axis[0].fx)*(graph[0].axis[0].max - graph[0].axis[0].min)/graph[0].axis[0].dfx + graph[0].axis[0].min;
       Y = (event[0].y - graph[0].axis[1].fy)*(graph[0].axis[1].max - graph[0].axis[1].min)/graph[0].axis[1].dfy + graph[0].axis[1].min;
+      XY_to_RD (&R, &D, X, Y, &graph[0].data.coords);
+    }
     if (image && !graph) {
 …
       if (event[0].y > image[0].picture.y + image[0].picture.dy) goto skip_cursor;
       Screen_to_Image (&X, &Y, (double)event[0].x, (double)event[0].y, image);
+      XY_to_RD (&R, &D, X, Y, &image[0].coords);
+      DX = image[0].matrix.Naxis[0];
+      DY = image[0].matrix.Naxis[1];
+      if (X < 0) goto off_image;
+      if (Y < 0) goto off_image;
+      if (X >= DX) goto off_image;
+      if (Y >= DY) goto off_image;
+      imdata = (float *) image[0].matrix.buffer;
+      Z      = imdata[DX*(int)(Y) + (int)(X)];
+    }
     snprintf (line, 40, "%12s %12.6f %12.6f ", name, X, Y);
     write (sock, line, 40);
+  off_image:
+    KiiSendMessage (sock, "%12s %12.6f %12.6f %12.6f %12.6f %12.6f", name, X, Y, Z, R, D);
+  }
 skip_cursor:
+  if (image == NULL) return (TRUE);
   // offset is in image pixels:
   // 0.5 image pixels is 1 screen pixel for expand == +2

trunk/Ohana/src/kapa2/src/InterpretPresses.c

-              r13333
+              r13479
 int InterpretPresses (Graphic *graphic, XButtonEvent *event) {
   int              status, done, this_button, old_cursor;
+  int              sock, DX, DY, status, done, this_button, old_cursor;
   char             name[16], line[40];
+  double           X, Y;
+  double           X, Y, Z, R, D;
+  float           *imdata;
   KeySym           keysym;
   Button          *button;
 …
   // XXX allow user to choose graph or image coords
   if (ACTIVE_CURSOR) {
+    sock = GetActiveSocket ();
+    if (sock == -1) goto skip_cursor;
     sprintf (name, "Button%d", event[0].button);
     if (graph) {
       X = (event[0].x - graph[0].axis[0].fx)*(graph[0].axis[0].max - graph[0].axis[0].min)/graph[0].axis[0].dfx + graph[0].axis[0].min;
       Y = (event[0].y - graph[0].axis[1].fy)*(graph[0].axis[1].max - graph[0].axis[1].min)/graph[0].axis[1].dfy + graph[0].axis[1].min;
+      XY_to_RD (&R, &D, X, Y, &graph[0].data.coords);
+    }
     if (image && !graph) {
 …
       if (event[0].x > image[0].picture.x + image[0].picture.dx) goto skip_cursor;
       if (event[0].y > image[0].picture.y + image[0].picture.dy) goto skip_cursor;
       Screen_to_Image (&X, &Y, (double)event[0].x, (double)event[0].y, image);
+      XY_to_RD (&R, &D, X, Y, &image[0].coords);
+      DX = image[0].matrix.Naxis[0];
+      DY = image[0].matrix.Naxis[1];
+      if (X < 0) goto off_image;
+      if (Y < 0) goto off_image;
+      if (X >= DX) goto off_image;
+      if (Y >= DY) goto off_image;
+      imdata = (float *) image[0].matrix.buffer;
+      Z      = imdata[DX*(int)(Y) + (int)(X)];
+    }
     snprintf (line, 40, "%12s %12.6f %12.6f ", name, X, Y);
     write (sock, line, 40);
+  off_image:
+    KiiSendMessage (sock, "%12s %12.6f %12.6f %12.6f %12.6f %12.6f", name, X, Y, Z, R, D);
+  }
 …
   status = TRUE;
   this_button = event[0].button;
+  // XXX add graph buttons here
+  if (image == NULL) return (TRUE);
   if ((event[0].type == ButtonPress) && InPicture (event, &image[0].picture)) {

trunk/Ohana/src/kapa2/src/JPEGit24.c

-              r13320
+              r13479
 # define WHITE_B 255
+// XXX this currently writes out the jpeg for the active image
+int JPEGit24 () {
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
+// XXX this currently writes out the jpeg for just the active image
+int JPEGit24 (int sock) {
   struct jpeg_compress_struct cinfo;
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   int status, Nbytes, quality;
   int expand_in, expand_out;
   double expand, Rx, Ry, X, Y;
+  unsigned char *out_pix, *in_pix, *in_pix_ref;
+  unsigned char *out_pix;
+  float *imdata, *in_pix, *in_pix_ref;
   unsigned char pixel1[256], pixel2[256], pixel3[256];
   char filename[1024];
   FILE *f;
+  /* expect a line telling the number of bytes and a filename */
+  KiiScanMessage (sock, "%s", filename);
   graphic = GetGraphic();
   section = GetActiveSection();
   image   = section->image;
+  /* expect a line telling the number of bytes and a filename */
+  KiiScanMessage (sock, "%s", filename);
+  if (image == NULL) return (TRUE);
   /***** JPEG init calls */
 …
+  }
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
   expand = expand_in = expand_out = 1.0;
   if (image[0].expand == 0) /* set up expansions */
 …
   ALLOCATE (line_buffer, JSAMPLE, 3*dx);
+  in_pix_ref  = (unsigned char *) (image[0].matrix.buffer) + DX*(int)MAX(Y,0) + (int)MAX(X,0);
+  imdata = (float *) image[0].matrix.buffer;
+  in_pix_ref = &imdata[DX*(int)MAX(Y,0) + (int)MAX(X,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     /*** fill in the picture region ***/
     for (i = i_start; i < i_end; i+=expand_out, in_pix+=expand_in) {
+      pixelN = PixelLookup(*in_pix);
       for (ii = 0; ii < expand_out; ii++, out_pix+=3) {
         out_pix[0] = pixel1[*in_pix];
         out_pix[1] = pixel2[*in_pix];
         out_pix[2] = pixel3[*in_pix];
+        out_pix[0] = pixel1[pixelN];
+        out_pix[1] = pixel2[pixelN];
+        out_pix[2] = pixel3[pixelN];
+      }
+    }

trunk/Ohana/src/kapa2/src/Layout.c

-              r13333
+              r13479
 void InitLayout (int argc, char **argv) {
   int N, UseGraph;
+  int N;
   Section *section;
+  UseGraph = FALSE;
+  if ((N = get_argument (argc, argv, "-image"))) {
+    remove_argument(N, &argc, argv);
+    UseGraph = FALSE;
+  }
+  /** initiate connection with server **/
+  if (!FOREGROUND) {
+    if (argc < 2) {
+      fprintf (stderr, "socket path not specified\n");
+      exit (0);
+    }
+    sock = KiiWait (argv[1]);
+  }
+  InitPipe();
   ACTIVE_CURSOR = FALSE;
 …
+  }
+  /* move this out of here... */
+  if (argc != 1) {
+    fprintf (stderr, "USAGE: kapa\n");
+    exit (0);
+  }
   InitRotFonts ();
   /* create basic section */
+  /* create basic section, empty of image or graph */
   section = AddSection ("default", 0.0, 0.0, 1.0, 1.0);
-  if (UseGraph) {
-    section->graph = InitGraph ();
-    SetGraphSize (section);
-  } else {
-    section->image = InitImage ();
-    SetImageSize (section);
+  }
+}

trunk/Ohana/src/kapa2/src/LoadFrame.c

-              r13320
+              r13479
 # include "Ximage.h"
 int LoadFrame () {
+int LoadFrame (int sock) {
   int i, status;
 …
   section = GetActiveSection();
+  if (section->graph == NULL) {
+    section->graph = InitGraph ();
+    SetSectionSizes (section);
+  }
   graph = section->graph;
-  // XXX what to do if graph is NULL?
   KiiScanMessage (sock, "%lf %lf %lf %lf",
                   &graph[0].axis[0].min, &graph[0].axis[0].max,
 …
+  }
+  SetSectionSizes (section);
   if (USE_XWINDOW) DrawFrame (graph);
   FlushDisplay ();

trunk/Ohana/src/kapa2/src/LoadLabels.c

-              r13320
+              r13479
 # include "Ximage.h"
 int LoadLabels () {
+int LoadLabels (int sock) {
   char *c, *label;
 …
   section = GetActiveSection();
+  if (section->graph == NULL) {
+    section->graph = InitGraph ();
+    SetSectionSizes (section);
+  }
   graph = section->graph;
-  fcntl (sock, F_SETFL, !O_NONBLOCK);
   KiiScanMessage (sock, "%d", &mode);
 …
   strncpy (graph[0].label[mode].text, label, Nbytes);
   label[Nbytes] = 0;
-  fcntl (sock, F_SETFL, O_NONBLOCK);
   c = GetRotFont (&size);

trunk/Ohana/src/kapa2/src/LoadObject.c

-              r13320
+              r13479
 # include "Ximage.h"
 # include <errno.h>
+int LoadObject () {
+# define DEBUG 0
+int LoadObject (int sock) {
   int N;
 …
   section = GetActiveSection();
+  if (section->graph == NULL) {
+    section->graph = InitGraph ();
+    SetSectionSizes (section);
+  }
   graph = section->graph;
-  fcntl (sock, F_SETFL, !O_NONBLOCK);
   N = graph[0].Nobjects;
 …
                   &graph[0].objects[N].x0, &graph[0].objects[N].x1,
                   &graph[0].objects[N].y0, &graph[0].objects[N].y1);
+  fcntl (sock, F_SETFL, O_NONBLOCK);
+  if (!LoadVectorData (graph, N, "x")) {
+  // acknowledge receipt of the metadata
+  KiiSendCommand (sock, 4, "DONE");
+  // XXX Currently, I require these in a special order.  The data includes a message defining the
+  // object type.  This could be made more flexible by using the information (though we still need
+  // to know how many items will be sent)
+  if (!LoadVectorData (sock, graph, N, "x")) {
     FreeObjectData (&graph[0].objects[N]);
     graph[0].Nobjects --;
 …
+  }
   if (!LoadVectorData (graph, N, "y")) {
+  if (!LoadVectorData (sock, graph, N, "y")) {
     FreeObjectData (&graph[0].objects[N]);
     graph[0].Nobjects --;
 …
+  }
   if (graph[0].objects[N].size < 0.0) {
     if (!LoadVectorData (graph, N, "z")) {
+    if (!LoadVectorData (sock, graph, N, "z")) {
       FreeObjectData (&graph[0].objects[N]);
       graph[0].Nobjects --;
 …
+  }
   if (graph[0].objects[N].etype & 0x01) {
     if (!LoadVectorData (graph, N, "dym")) {
       FreeObjectData (&graph[0].objects[N]);
       graph[0].Nobjects --;
       REALLOCATE (graph[0].objects, Gobjects, MAX (1, graph[0].Nobjects));
+    }
     if (!LoadVectorData (graph, N, "dyp")) {
+    if (!LoadVectorData (sock, graph, N, "dym")) {
+      FreeObjectData (&graph[0].objects[N]);
+      graph[0].Nobjects --;
+      REALLOCATE (graph[0].objects, Gobjects, MAX (1, graph[0].Nobjects));
+    }
+    if (!LoadVectorData (sock, graph, N, "dyp")) {
       FreeObjectData (&graph[0].objects[N]);
       graph[0].Nobjects --;
 …
+  }
   if (graph[0].objects[N].etype & 0x02) {
     if (!LoadVectorData (graph, N, "dxm")) {
       FreeObjectData (&graph[0].objects[N]);
       graph[0].Nobjects --;
       REALLOCATE (graph[0].objects, Gobjects, MAX (1, graph[0].Nobjects));
+    }
     if (!LoadVectorData (graph, N, "dxp")) {
+    if (!LoadVectorData (sock, graph, N, "dxm")) {
+      FreeObjectData (&graph[0].objects[N]);
+      graph[0].Nobjects --;
+      REALLOCATE (graph[0].objects, Gobjects, MAX (1, graph[0].Nobjects));
+    }
+    if (!LoadVectorData (sock, graph, N, "dxp")) {
       FreeObjectData (&graph[0].objects[N]);
       graph[0].Nobjects --;
 …
+}
+/* load data for the named component */
+int LoadVectorData (KapaGraphWidget *graph, int N, char *type) {
+  int Npts, Ninpts, status, Ntry;
+int LoadVectorData (int sock, KapaGraphWidget *graph, int N, char *type) {
+  int i, Npts, Ninpts, status, Ntry;
   int bytes_left;
+  char *buff;
+  buff = NULL;
+  char *byte, *buffer, type_send[16], tmp;
+  int Npts_send, Nbytes_send, swap_client, swap_host;
+  buffer = NULL;
   Npts = graph[0].objects[N].Npts;
+  KiiWaitAnswer (sock, "PLOB");
+  KiiScanMessage (sock, "%s %d %d %d", type_send, &Npts_send, &Nbytes_send, &swap_client);
+  if (strcmp (type, type_send)) {
+    fprintf (stderr, "Kapa Communication error: unexpected data type %s vs %s\n", type_send, type);
+  }
+  if (Npts_send != Npts) {
+    fprintf (stderr, "Kapa Communication error: unexpected number of points %d vs %d\n", Npts_send, Npts);
+  }
+  if (Nbytes_send != Npts_send*sizeof(float)) {
+    fprintf (stderr, "Kapa Communication error: unexpected data size %d vs %d\n", Nbytes_send, Npts_send*sizeof(float));
+  }
   status = 1;
   if (!strcmp (type, "x")) {
     ALLOCATE (graph[0].objects[N].x, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].x;
+    buffer = (char *) graph[0].objects[N].x;
+  }
   if (!strcmp (type, "y")) {
     ALLOCATE (graph[0].objects[N].y, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].y;
+    buffer = (char *) graph[0].objects[N].y;
+  }
   if (!strcmp (type, "z")) {
     ALLOCATE (graph[0].objects[N].z, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].z;
+    buffer = (char *) graph[0].objects[N].z;
+  }
   if (!strcmp (type, "dxm")) {
     ALLOCATE (graph[0].objects[N].dxm, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].dxm;
+    buffer = (char *) graph[0].objects[N].dxm;
+  }
   if (!strcmp (type, "dxp")) {
     ALLOCATE (graph[0].objects[N].dxp, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].dxp;
+    buffer = (char *) graph[0].objects[N].dxp;
+  }
   if (!strcmp (type, "dym")) {
     ALLOCATE (graph[0].objects[N].dym, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].dym;
+    buffer = (char *) graph[0].objects[N].dym;
+  }
   if (!strcmp (type, "dyp")) {
     ALLOCATE (graph[0].objects[N].dyp, float, MAX (1, Npts));
     buff = (char *) graph[0].objects[N].dyp;
+    buffer = (char *) graph[0].objects[N].dyp;
+  }
   bytes_left = Npts*sizeof (float);
+  fcntl (sock, F_SETFL, O_NONBLOCK);
+  // read the vector data as raw binary in client machine byte order (floats)
   Ntry = 0;
   if (DEBUG) fprintf (stderr, "starting vector load\n");
   Ninpts = 0;
+  byte = buffer;
   while (bytes_left > 0) {
     status = read (sock, buff, bytes_left);
+    status = read (sock, byte, bytes_left);
     if (DEBUG) fprintf (stderr, "status: %d, %d\n", status, bytes_left);
     if (status == 0) {  /* No more pipe */
 …
       Ninpts += status;
       bytes_left -= status;
       buff = (char *)(buff + status);
+      byte = (char *)(byte + status);
       Ntry = 0;
       continue;
 …
     perror ("kapa load");
+  }
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
+  KiiSendCommand (sock, 4, "DONE");
+# ifdef BYTE_SWAP
+  swap_host = 1;
+# else
+  swap_host = 0;
+# endif
+  // if host and client have opposite swap parities, word swap the incoming data
+  // SWAP_WORD is strangely defined... it takes the number of the start byte in a
+  // buffer called 'byte'
+  if ((swap_host && !swap_client) || (!swap_host && swap_client)) {
+    byte = buffer;
+    for (i = 0; i < Nbytes_send; i+=4) {
+      SWAP_WORD (i);
+    }
+  }
   if (Ninpts != Npts*sizeof(float)) {
     fprintf (stderr, "error: expected %d bytes, but got only %d\n", Ninpts, (unsigned int)(Npts*sizeof(float)));
 …
   if (object[0].dyp != (float *) NULL) free (object[0].dyp);
+}

trunk/Ohana/src/kapa2/src/LoadOverlay.c

-              r13331
+              r13479
 # include "Ximage.h"
+// XXX this is a very inefficient method to send the data: binary would be better
+int LoadOverlay () {
+int LoadOverlay (int sock) {
+  char word[17], type[16], string[128];
+  char *buffer, *buff;
+  double x, y, dx, dy;
+  int Nin, bytes, status;
+  int i, N, NOBJECTS, Nobjects, Nstart;
+  int i, j, Ntotal, Nbytes, Nread, Nfound, Ntext, Nobjects, overnum;
+  int Noverlay, NOVERLAY, Ntextdata;
+  char *textdata, *buffer, *p, *q;
   Section *section;
   KapaImageWidget *image;
   Graphic *graphic;
+  KiiOverlayBase *overlay;
   graphic = GetGraphic ();
   section = GetActiveSection();
+  image   = section->image;
+  if (section->image == NULL) {
+    section->image = InitImage ();
+    SetSectionSizes (section);
+  }
+  image = section->image;
+  ALLOCATE (buffer, char, 65536);  /* space for 512 lines of 128 bytes */
+  bzero (buffer, 65536);
+  KiiScanMessage (sock, "%d %d %d %d", &overnum, &Noverlay, &Ntext, &Ntextdata);
   KiiScanCommand (sock, 16, "%*s %d", &N);
   Nstart = image[0].overlay[N].Nobjects;
+  // XXX need to validate overnum
+  if ((overnum < 0) || (overnum >= NOVERLAYS)) overnum = 0;
+  while (1) {
+    KiiScanCommand (sock, 16, "%s %d", word, &Nin);
+    if (!strcmp (word, "DONE")) break;
+    if (strcmp (word, "NLINES")) abort();
+  // read the overlay data as binary
+  Ntotal = 0;
+  Nbytes = Noverlay*sizeof(KiiOverlayBase);
+  fcntl (sock, F_SETFL, O_NONBLOCK);
+  ALLOCATE (overlay, KiiOverlayBase, Noverlay);
+  buffer = (char *) overlay;
+  while (Nbytes > 0) {
+    Nread = read (sock, &buffer[Ntotal], Nbytes);
+    // fprintf (stderr, "read: %d of %d remaining, %d so far, %d expected\n", Nread, Nbytes, Ntotal, Noverlay*sizeof(KiiOverlayBase));
+    if (Nread == 0) {  /* No more pipe */
+      fprintf (stderr, "error: pipe closed\n");
+      free (overlay);
+      fcntl (sock, F_SETFL, !O_NONBLOCK);
+      return (FALSE);
+    }
+    if (Nread != -1) { /* pipe has data */
+      Nbytes -= Nread;
+      Ntotal += Nread;
+    }
+  }
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
+  KiiSendCommand (sock,  4, "DONE");
+    buff = buffer;
+    bytes = 128*Nin;
+  // read the textdata as binary
+  Ntotal = 0;
+  Nbytes = Ntextdata;
+  fcntl (sock, F_SETFL, O_NONBLOCK);
+  ALLOCATE (textdata, char, Ntextdata);
+  while (Nbytes > 0) {
+    Nread = read (sock, &textdata[Ntotal], Nbytes);
+    if (Nread == 0) {  /* No more pipe */
+      fprintf (stderr, "error: pipe closed\n");
+      free (textdata);
+      free (overlay);
+      fcntl (sock, F_SETFL, !O_NONBLOCK);
+      return (FALSE);
+    }
+    if (Nread != -1) { /* pipe has data */
+      Nbytes -= Nread;
+      Ntotal += Nread;
+    }
+  }
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
+  KiiSendCommand (sock,  4, "DONE");
+    /* accept data from the socket until we have all of the bytes */
+    fcntl (sock, F_SETFL, O_NONBLOCK);
+    while (bytes > 0) {
+      status = read (sock, buff, bytes);
+      if (status == 0) {  /* No more pipe */
+        fprintf (stderr, "error: pipe closed\n");
+        free (buffer);
+        fcntl (sock, F_SETFL, O_NONBLOCK);
+        return (FALSE);
+      }
+      if (status != -1) { /* pipe has data */
+        bytes -= status;
+        buff = (char *)(buff + status);
+      }
+    }
+    fcntl (sock, F_SETFL, !O_NONBLOCK);
+  // add new overlay objects to existing data
+  Nobjects = image[0].overlay[overnum].Nobjects + Noverlay;
+  REALLOCATE (image[0].overlay[overnum].objects, KiiOverlay, Nobjects);
+    /* parse buffer data */
+    NOBJECTS = image[0].overlay[N].Nobjects + Nin;
+    Nobjects = image[0].overlay[N].Nobjects;
+    REALLOCATE (image[0].overlay[N].objects, Object, NOBJECTS);
+    for (i = 0; i < Nin; i++) {
+      sscanf (&buffer[i*128], "%s %lf %lf %lf %lf\n", type, &x, &y, &dx, &dy);
+      if (strcasecmp (type, "TEXT") && strcasecmp (type, "LINE") && strcasecmp (type, "BOX") && strcasecmp (type, "CIRCLE")) {  /* skip */
+        fprintf (stderr, "don't know %s, skipping\n", type);
+        continue;
+      }
+      if (!strcasecmp (type, "TEXT")) { /* end of objects */
+        sscanf (&buffer[i*128], "%s %lf %lf %s\n", type, &x, &y, string);
+      }
+      strcpy (image[0].overlay[N].objects[Nobjects].type, type);
+      image[0].overlay[N].objects[Nobjects].x = x;
+      image[0].overlay[N].objects[Nobjects].y = y;
+      if (!strcmp (type, "TEXT")) {
+        image[0].overlay[N].objects[Nobjects].dx = 0;
+        image[0].overlay[N].objects[Nobjects].dy = 0;
+        image[0].overlay[N].objects[Nobjects].text = strcreate (string);
+      } else {
+        image[0].overlay[N].objects[Nobjects].dx = dx;
+        image[0].overlay[N].objects[Nobjects].dy = dy;
+      }
+      Nobjects++;
+    }
+    REALLOCATE (image[0].overlay[N].objects, Object, MAX(Nobjects, 1));
+    image[0].overlay[N].Nobjects = Nobjects;
+  j = image[0].overlay[overnum].Nobjects;
+  for (i = 0; i < Noverlay; i++, j++) {
+    image[0].overlay[overnum].objects[j].x = overlay[i].x;
+    image[0].overlay[overnum].objects[j].y = overlay[i].y;
+    image[0].overlay[overnum].objects[j].dx = overlay[i].dx;
+    image[0].overlay[overnum].objects[j].dy = overlay[i].dy;
+    image[0].overlay[overnum].objects[j].type = overlay[i].type;
+    image[0].overlay[overnum].objects[j].text = NULL;
+  }
+  /* cleanup */
+  free (buffer);
+  REALLOCATE (image[0].overlay[N].objects, Object, MAX (1, image[0].overlay[N].Nobjects));
+  image[0].overlay[N].active = TRUE;
+  fcntl (sock, F_SETFL, O_NONBLOCK);
+  // parse the text data : text lines are separated by '\n', one per text entry
+  p = textdata;
+  Nfound = 0;
+  for (i = 0; i < Noverlay; i++) {
+    if (overlay[i].type != KII_OVERLAY_TEXT) continue;
+    if (Nfound >= Ntext) {
+      fprintf (stderr, "inconsistent number of text lines\n");
+      break;
+    }
+    if (! *p) {
+      fprintf (stderr, "inconsistent number of text lines\n");
+      break;
+    }
+    q = strchr (p, '\n');
+    if (q == NULL) {
+      fprintf (stderr, "inconsistent text line\n");
+      break;
+    }
+    j = image[0].overlay[overnum].Nobjects + i;
+    image[0].overlay[overnum].objects[j].text = strncreate (p, q-p);
+    p = q + 1;
+    Nfound ++;
+  }
+  if (Nfound != Ntext) {
+    fprintf (stderr, "read %d text lines, expected %d\n", Nfound, Ntext);
+  }
+  free (textdata);
+  free (overlay);
+  image[0].overlay[overnum].Nobjects = Nobjects;
+  image[0].overlay[overnum].active = TRUE;
   if (USE_XWINDOW) {
 …
+      }
+    }
-    PaintTickmarks (graphic, image);
     XFlush (graphic[0].display);
+  }

trunk/Ohana/src/kapa2/src/LoadPicture.c

-              r13320
+              r13479
 # include "Ximage.h"
 int LoadPicture () {
+int LoadPicture (int sock) {
   Header header;
 …
   graphic = GetGraphic ();
   section = GetActiveSection();
+  image   = section->image;
+  if (section->image == NULL) {
+    section->image = InitImage ();
+    SetSectionSizes (section);
+  }
+  image = section->image;
   KiiSendMessage (sock, "%d", graphic->Npixels);
-  fcntl (sock, F_SETFL, !O_NONBLOCK);
   header.Naxes = 2;
   KiiScanMessage (sock, "%d %d %d %d %lf %lf", &header.Naxis[0], &header.Naxis[1]);
   KiiScanMessage (sock, "%d %d %d %d %lf %lf", &header.bitpix, &header.unsign, &header.bzero, &header.bscale);
   KiiScanMessage (sock, "%lf %lf",  &image[0].zero, &image[0].range);
+  KiiScanMessage (sock, "%lf %lf %s",  &image[0].zero, &image[0].range, image[0].name, image[0].file);
   KiiScanMessage (sock, "%lf %lf %d", &image[0].min,  &image[0].max, &header.size);
   KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].coords.crval1, &image[0].coords.crpix1, &image[0].coords.cdelt1, &image[0].coords.pc1_1, &image[0].coords.pc1_2);
   KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].coords.crval2, &image[0].coords.crpix2, &image[0].coords.cdelt2, &image[0].coords.pc2_1, &image[0].coords.pc2_2);
+  KiiScanMessage (sock, "%s %s %s", image[0].coords.ctype, image[0].file, image[0].buffer_name);
+  KiiScanMessage (sock, "%s", image[0].coords.ctype);
   gfits_free_matrix (&image[0].matrix);
 …
+  }
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
   if (DEBUG) fprintf (stderr, "read %d bytes\n", image[0].matrix.size);
   /* it it not obvious this condition should kill kii, but ... */

trunk/Ohana/src/kapa2/src/LoadTextlines.c

-              r13320
+              r13479
 # include "Ximage.h"
 int LoadTextlines () {
+int LoadTextlines (int sock) {
   char *string;
 …
   section = GetActiveSection();
   graph = section->graph;
+  fcntl (sock, F_SETFL, !O_NONBLOCK);
+    if (section->graph == NULL) {
+    section->graph = InitGraph ();
+    SetSectionSizes (section);
+  }
   graph[0].Ntextline = MAX (graph[0].Ntextline, 0);
   N = graph[0].Ntextline;
 …
   strcpy (graph[0].textline[N].text, string);
   free (string);
-  fcntl (sock, F_SETFL, O_NONBLOCK);
   string = GetRotFont (&size);

trunk/Ohana/src/kapa2/src/LoadTickmarks.c

-              r13320
+              r13479
 # include "Ximage.h"
 int LoadTickmarks () {
+int LoadTickmarks (int sock) {
   char line[129], type[16];
 …
   section = GetActiveSection();
+  if (section->image == NULL) {
+    section->image = InitImage ();
+    SetSectionSizes (section);
+  }
   image   = section->image;
-  fcntl (sock, F_SETFL, !O_NONBLOCK);
   Nobjects = image[0].tickmarks.Nobjects;
   NOBJECTS = Nobjects + 100;
   REALLOCATE (image[0].tickmarks.objects, Object, NOBJECTS);
+  REALLOCATE (image[0].tickmarks.objects, KiiOverlay, NOBJECTS);
   done = FALSE;
 …
     if (Nobjects >= NOBJECTS) {
       NOBJECTS = Nobjects + 100;
       REALLOCATE (image[0].tickmarks.objects, Object, NOBJECTS);
+      REALLOCATE (image[0].tickmarks.objects, KiiOverlay, NOBJECTS);
+    }
+  }
   REALLOCATE (image[0].tickmarks.objects, Object, MAX(Nobjects, 1));
+  REALLOCATE (image[0].tickmarks.objects, KiiOverlay, MAX(Nobjects, 1));
   image[0].tickmarks.Nobjects = Nobjects;
   if (USE_XWINDOW) Refresh ();
-  fcntl (sock, F_SETFL, O_NONBLOCK);
   return (TRUE);
+}

trunk/Ohana/src/kapa2/src/PNGit.c

r13320	r13479
1	1	# include "Ximage.h"
2	2
3		int PNGit () {
	3	int PNGit (int sock) {
4	4
5	5	FILE *f;

trunk/Ohana/src/kapa2/src/PPMit.c

r13320	r13479
1	1	# include "Ximage.h"
2	2
3		int PPMit () {
	3	int PPMit (int sock) {
4	4
5	5	FILE *f;

trunk/Ohana/src/kapa2/src/PSOverlay.c

-              r13331
+              r13479
     dY = (image[0].overlay[N].objects[i].dy)/expand;
+    if (!strcmp (image[0].overlay[N].objects[i].type, "LINE")) {
+      if (((X < Xmin) && (X + dX < Xmin)) || ((X > Xmax) && (X + dX > Xmax)) ||
+          ((Y < Ymin) && (Y + dY < Ymin)) || ((Y > Ymax) && (Y + dY > Ymax))) {
+        continue;
+      }
+      fprintf (f, " %6.1f %6.1f %6.1f %6.1f L\n", X + extra, Y + extra, (X+dX + extra), (Y-dY + extra));
+      continue;
+    switch (image[0].overlay[N].objects[i].type) {
+      case KII_OVERLAY_LINE:
+        if (((X < Xmin) && (X + dX < Xmin)) || ((X > Xmax) && (X + dX > Xmax)) ||
+            ((Y < Ymin) && (Y + dY < Ymin)) || ((Y > Ymax) && (Y + dY > Ymax))) {
+          break;
+        }
+        fprintf (f, " %6.1f %6.1f %6.1f %6.1f L\n", X + extra, Y + extra, (X+dX + extra), (Y-dY + extra));
+        break;
+      case KII_OVERLAY_TEXT:
+        if (((X < Xmin) && (X + dX < Xmin)) || ((X > Xmax) && (X + dX > Xmax)) ||
+            ((Y < Ymin) && (Y + dY < Ymin)) || ((Y > Ymax) && (Y + dY > Ymax))) {
+          break;
+        }
+        fprintf (f, "(%s) %6.1f %6.1f T\n", image[0].overlay[N].objects[i].text, X + extra, Y + extra);
+        break;
+      case KII_OVERLAY_BOX:
+        if (((X - 0.5*dX < Xmin) && (X + 0.5*dX < Xmin)) || ((X - 0.5*dX > Xmax) && (X + 0.5*dX > Xmax)) ||
+            ((Y - 0.5*dY < Ymin) && (Y + 0.5*dY < Ymin)) || ((Y - 0.5*dY > Ymax) && (Y + 0.5*dY > Ymax))) {
+          break;
+        }
+        fprintf (f, " %6.1f %6.1f %6.1f %6.1f B\n", (dX + 2*extra), (dY + 2*extra), (X - 0.5*dX - extra), (Y - 0.5*dY - extra));
+        break;
+      case KII_OVERLAY_CIRCLE:
+        if (((X - dX < Xmin) && (X + dX < Xmin)) || ((X - dX > Xmax) && (X + dX > Xmax)) ||
+            ((Y - dY < Ymin) && (Y + dY < Ymin)) || ((Y - dY > Ymax) && (Y + dY > Ymax))) {
+          break;
+        }
+        fprintf (f, " %6.1f %6.1f %6.1f C\n", X, Y, fabs(dX + extra));
+        break;
+      default:
+        fprintf (stderr, "skipping unknown object\n");
+        break;
+    }
-    if (!strcmp (image[0].overlay[N].objects[i].type, "TEXT")) {
-      if (((X < Xmin) && (X + dX < Xmin)) || ((X > Xmax) && (X + dX > Xmax)) ||
-          ((Y < Ymin) && (Y + dY < Ymin)) || ((Y > Ymax) && (Y + dY > Ymax))) {
-        continue;
+      }
-      fprintf (f, "(%s) %6.1f %6.1f T\n", image[0].overlay[N].objects[i].text, X + extra, Y + extra);
-      continue;
+    }
-    if (!strcmp (image[0].overlay[N].objects[i].type, "BOX")) {
-      if (((X - 0.5*dX < Xmin) && (X + 0.5*dX < Xmin)) || ((X - 0.5*dX > Xmax) && (X + 0.5*dX > Xmax)) ||
-          ((Y - 0.5*dY < Ymin) && (Y + 0.5*dY < Ymin)) || ((Y - 0.5*dY > Ymax) && (Y + 0.5*dY > Ymax))) {
-        continue;
+      }
-      fprintf (f, " %6.1f %6.1f %6.1f %6.1f B\n", (dX + 2*extra), (dY + 2*extra), (X - 0.5*dX - extra), (Y - 0.5*dY - extra));
-      continue;
+    }
-    if (!strcmp (image[0].overlay[N].objects[i].type, "CIRCLE")) {
-      if (((X - dX < Xmin) && (X + dX < Xmin)) || ((X - dX > Xmax) && (X + dX > Xmax)) ||
-          ((Y - dY < Ymin) && (Y + dY < Ymin)) || ((Y - dY > Ymax) && (Y + dY > Ymax))) {
-        continue;
+      }
-      fprintf (f, " %6.1f %6.1f %6.1f C\n", X, Y, fabs(dX + extra));
-      continue;
+    }
-    fprintf (stderr, "don't know %s, skipping\n", image[0].overlay[N].objects[i].type);
+  }
+}

trunk/Ohana/src/kapa2/src/PSit.c

r13331	r13479
6	6	static Graphic *graphic;
7	7
8		int PScommand () {
	8	int PScommand (int sock) {
9	9
10	10	int status, scaleMode, pageMode;

trunk/Ohana/src/kapa2/src/PaintOverlay.c

-              r13320
+              r13479
        for a BOX (x, y) is the center, (dx, dy) is the width */
+    if (!strcasecmp (image[0].overlay[N].objects[i].type, "LINE")) {
+      XDrawLine (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, (X+dX), (Y+dY));
+      continue;
+    switch (image[0].overlay[N].objects[i].type) {
+      case KII_OVERLAY_LINE:
+        XDrawLine (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, (X+dX), (Y+dY));
+        break;
+      case KII_OVERLAY_TEXT:
+        XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].overlay[N].objects[i].text, strlen(image[0].overlay[N].objects[i].text));
+        break;
+      case KII_OVERLAY_BOX:
+        dx = MAX (abs(dX),2) / 2;
+        dy = MAX (abs(dY),2) / 2;
+        XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, (X - dx), (Y - dy), 2*dx, 2*dy);
+        break;
+      case KII_OVERLAY_CIRCLE:
+        dx = MAX (abs(dX),2);
+        dy = MAX (abs(dY),2);
+        XDrawArc (graphic[0].display, graphic[0].window, graphic[0].gc, (X - dx), (Y - dy), 2*dx, 2*dy, 0, 23040);
+        break;
+      default:
+        fprintf (stderr, "skipping unknown object\n");
+        break;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "TEXT")) {
-      XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].overlay[N].objects[i].text, strlen(image[0].overlay[N].objects[i].text));
-      continue;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "BOX")) {
-      dx = MAX (abs(dX),2) / 2;
-      dy = MAX (abs(dY),2) / 2;
-      XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, (X - dx), (Y - dy), 2*dx, 2*dy);
-       continue;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "CIRCLE")) {
-      dx = MAX (abs(dX),2);
-      dy = MAX (abs(dY),2);
-      XDrawArc (graphic[0].display, graphic[0].window, graphic[0].gc, (X - dx), (Y - dy), 2*dx, 2*dy, 0, 23040);
-      continue;
+    }
-    fprintf (stderr, "don't know %s, skipping (PO)\n", image[0].overlay[N].objects[i].type);
+  }

trunk/Ohana/src/kapa2/src/PaintTickmarks.c

-              r13320
+              r13479
     dY = image[0].tickmarks.objects[i].dy * Yrange;
+    if (!strcmp (image[0].tickmarks.objects[i].type, "LINE")) {
+      XDrawLine (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, (X+dX), (Y+dY));
+      continue;
+    switch (image[0].overlay[0].objects[i].type) {
+      case KII_OVERLAY_LINE:
+        XDrawLine (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, (X+dX), (Y+dY));
+        break;
+      case KII_OVERLAY_TEXT:
+        if (image[0].tickmarks.objects[i].dy == 0) {
+            XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
+            XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y-11, 6*strlen(image[0].tickmarks.objects[i].text), 11);
+            XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
+            XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].tickmarks.objects[i].text, strlen(image[0].tickmarks.objects[i].text));
+        }
+        if (image[0].tickmarks.objects[i].dy == 90) {
+            XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
+            XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y-6*strlen(image[0].tickmarks.objects[i].text), 11, 6*strlen(image[0].tickmarks.objects[i].text));
+            XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
+            /* XDrawRotString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].tickmarks.objects[i].text, strlen(image[0].tickmarks.objects[i].text)); */
+        }
+        break;
+      case KII_OVERLAY_BOX:
+        XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, (int)(X - 0.5*dX), (int)(Y - 0.5*dY), abs(dX), abs(dY));
+        break;
+      case KII_OVERLAY_CIRCLE:
+        XDrawArc (graphic[0].display, graphic[0].window, graphic[0].gc, X - dX, Y - dY, abs(2*dX), abs(2*dY), 0, 23040);
+        break;
+      default:
+        fprintf (stderr, "skipping unknown object\n");
+        break;
+    }
-    if (!strcmp (image[0].tickmarks.objects[i].type, "TEXT")) {
-      if (image[0].tickmarks.objects[i].dy == 0) {
-        XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
-        XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y-11, 6*strlen(image[0].tickmarks.objects[i].text), 11);
-        XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
-        XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].tickmarks.objects[i].text, strlen(image[0].tickmarks.objects[i].text));
+      }
-      if (image[0].tickmarks.objects[i].dy == 90) {
-        XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
-        XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y-6*strlen(image[0].tickmarks.objects[i].text), 11, 6*strlen(image[0].tickmarks.objects[i].text));
-        XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
-        /* XDrawRotString (graphic[0].display, graphic[0].window, graphic[0].gc, X, Y, image[0].tickmarks.objects[i].text, strlen(image[0].tickmarks.objects[i].text)); */
+      }
-      continue;
+    }
-    if (!strcmp (image[0].tickmarks.objects[i].type, "BOX")) {
-      XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, (int)(X - 0.5*dX), (int)(Y - 0.5*dY), abs(dX), abs(dY));
-       continue;
+    }
-    if (!strcmp (image[0].tickmarks.objects[i].type, "CIRCLE")) {
-      XDrawArc (graphic[0].display, graphic[0].window, graphic[0].gc, X - dX, Y - dY, abs(2*dX), abs(2*dY), 0, 23040);
-      continue;
+    }
-    fprintf (stderr, "don't know %s, skipping (PO)\n", image[0].tickmarks.objects[i].type);
+  }
   XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
+}

trunk/Ohana/src/kapa2/src/Reconfig.c

-              r13320
+              r13479
   for (i = 0; i < Nsection; i++) {
       section = GetSectionByNumber (i);
+      SetGraphSize (section);
+      SetImageSize (section);
+      SetSectionSizes (section);
+  }

trunk/Ohana/src/kapa2/src/Refresh.c

-              r13320
+              r13479
   for (i = 0; i < Nsection; i++) {
       section = GetSectionByNumber (i);
+      DrawImage (section->image);
       DrawGraph (section->graph);
-      DrawImage (section->image);
+  }

trunk/Ohana/src/kapa2/src/Remap16.c

-              r13320
+              r13479
 # include "Ximage.h"
+# define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void Remap16 (Graphic *graphic, KapaImageWidget *image, Matrix *matrix) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, Rx, Ry, X, Y;
   int expand_in, expand_out;
   unsigned char *out_pix, *out_pix2, *data;
   unsigned char *in_pix,  *in_pix2;
   unsigned char pixel1[256], pixel2[256], pixel3[256];
+  float *imdata, *in_pix, *in_pix2;
+  unsigned char pixel1[256], pixel2[256];
   unsigned char pixvalue1, pixvalue2;
   unsigned long back;
   unsigned char back1, back2;
+  // local array for pixel values (is this working??)
   for (i = 0; i < 256; i++) { /* set up pixel array */
+    pixel1[i] = 0x0000ff &  graphic[0].cmap[i].pixel;
+    pixel2[i] = 0x0000ff & (graphic[0].cmap[i].pixel >> 8);
+    pixel3[i] = 0x0000ff & (graphic[0].cmap[i].pixel >> 16);
+    pixel1[i] = 0x00ff &  graphic[0].cmap[i].pixel;
+    pixel2[i] = 0x00ff & (graphic[0].cmap[i].pixel >> 8);
+  }
   back = graphic[0].back;
 …
   back2 = 0x00ff & (back >> 8);
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
+  // set up expansions
   expand = expand_in = expand_out = 1.0;
   if (image[0].expand == 0) /* set up expansions */
 …
+  }
+  // define the image boundaries
   dx = image[0].picture.dx;
   dy = image[0].picture.dy;
 …
   data = out_pix = (unsigned char *) image[0].picture.data;
+  in_pix  = (unsigned char *) (matrix[0].buffer) + DX*(int)MAX(Y,0) + (int)MAX(X,0);
+  imdata  = (float *) matrix[0].buffer;
+  in_pix  = &imdata[DX*(int)MAX(Y,0) + (int)MAX(X,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix+=2) {
+        out_pix[0] = pixel1[*in_pix2];
+        out_pix[1] = pixel2[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        out_pix[0] = pixel1[pixelN];
+        out_pix[1] = pixel2[pixelN];
+      }
+    }
     else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= 2*expand_out) {
+        pixvalue1 = pixel1[*in_pix2];
+        pixvalue2 = pixel2[*in_pix2];
+        pixelN    = PixelLookup(*in_pix2);
+        pixvalue1 = pixel1[pixelN];
+        pixvalue2 = pixel2[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=2*(dx-expand_out)) {

trunk/Ohana/src/kapa2/src/Remap24.c

-              r13320
+              r13479
 # include "Ximage.h"
+# define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void Remap24 (Graphic *graphic, KapaImageWidget *image, Matrix *matrix) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback, extra;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, Rx, Ry, X, Y;
   int expand_in, expand_out;
   unsigned char *out_pix, *out_pix2, *data;
   unsigned char *in_pix,  *in_pix2;
+  float *imdata, *in_pix, *in_pix2;
   unsigned char pixel1[256], pixel2[256], pixel3[256];
   unsigned char pixvalue1, pixvalue2, pixvalue3;
 …
   unsigned char back1, back2, back3;
+  // local arrays for pixel values
   for (i = 0; i < 256; i++) { /* set up pixel array */
     pixel1[i] = 0x0000ff &  graphic[0].cmap[i].pixel;
 …
   back3 = 0x0000ff & (back >> 16);
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
+  // set up expansions
   expand = expand_in = expand_out = 1.0;
   if (image[0].expand == 0) /* set up expansions */
 …
   data = out_pix = (unsigned char *) image[0].picture.data;
+  in_pix  = (unsigned char *) (matrix[0].buffer) + DX*(int)MAX(Y,0) + (int)MAX(X,0);
+  imdata  = (float *) matrix[0].buffer;
+  in_pix  = &imdata[DX*(int)MAX(Y,0) + (int)MAX(X,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix+=3) {
+        out_pix[0] = pixel1[*in_pix2];
+        out_pix[1] = pixel2[*in_pix2];
+        out_pix[2] = pixel3[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        out_pix[0] = pixel1[pixelN];
+        out_pix[1] = pixel2[pixelN];
+        out_pix[2] = pixel3[pixelN];
+      }
+    }
+    else {
+    } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= 3*expand_out) {
+        pixvalue1 = pixel1[*in_pix2];
+        pixvalue2 = pixel2[*in_pix2];
+        pixvalue3 = pixel3[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        pixvalue1 = pixel1[pixelN];
+        pixvalue2 = pixel2[pixelN];
+        pixvalue3 = pixel3[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=3*(dx-expand_out)+extra) {

trunk/Ohana/src/kapa2/src/Remap32.c

-              r13320
+              r13479
 # include "Ximage.h"
+# define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void Remap32 (Graphic *graphic, KapaImageWidget *image, Matrix *matrix) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, Rx, Ry, X, Y;
   int expand_in, expand_out;
   unsigned int *out_pix, *out_pix2;
   unsigned char *in_pix,  *in_pix2;
+  float *imdata, *in_pix, *in_pix2;
   unsigned long pixel[256], pixvalue;
   unsigned long back;
+  for (i = 0; i < 256; i++) { /* set up pixel array */
+  // local array for pixel values
+  for (i = 0; i < 256; i++) {
     pixel[i] = graphic[0].cmap[i].pixel;
+  }
   back = graphic[0].back;
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
+  // set up expansions
   expand = expand_in = expand_out = 1.0;
   if (image[0].expand == 0) /* set up expansions */
+  if (image[0].expand == 0)
     image[0].expand = 1;
   if (image[0].expand > 0) {
 …
+  }
+  // define the image boundaries
   dx = image[0].picture.dx;
   dy = image[0].picture.dy;
 …
   out_pix = (unsigned int *) image[0].picture.data;
+  in_pix  = (unsigned char *) (matrix[0].buffer) + DX*(int)MAX(Y,0) + (int)MAX(X,0);
+  imdata  = (float *) matrix[0].buffer;
+  in_pix  = &imdata[DX*(int)MAX(Y,0) + (int)MAX(X,0)];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix++) {
+        *out_pix = pixel[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        *out_pix = pixel[pixelN];
+      }
-      /* *out_pix = *(pixel + *in_pix2);  */
+    }
     else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= expand_out) {
+        pixvalue = pixel[*in_pix2];
+        pixelN   = PixelLookup(*in_pix2);
+        pixvalue = pixel[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=(dx-expand_out)) {

trunk/Ohana/src/kapa2/src/Remap8.c

-              r13320
+              r13479
 # include "Ximage.h"
+# define FRAC(a) ((a) - (int)(a))
+static float slope = 1.0;
+static float start = 0.0;
+static int MaxValue = 255;
+// XXX inline this if needed
+static int PixelLookup(float value) {
+  int out;
+  out = MIN (MAX (slope * value - start, 0), MaxValue);
+  return (out);
+}
 void Remap8 (Graphic *graphic, KapaImageWidget *image, Matrix *matrix) {
 …
   int i_start, i_end, j_start, j_end;
   int dropback;  /* this is a bit of a kludge... */
   int dx, dy, DX, DY;
+  int dx, dy, DX, DY, pixelN;
   double expand, Rx, Ry, X, Y;
   int expand_in, expand_out;
   unsigned char *out_pix, *out_pix2;
   unsigned char *in_pix,  *in_pix2;
+  float *imdata, *in_pix,  *in_pix2;
   unsigned long pixel[256], pixvalue;
   unsigned long back;
+  for (i = 0; i < 256; i++) { /* set up pixel array */
+  // local array for pixel values
+  for (i = 0; i < 256; i++) {
     pixel[i] = graphic[0].cmap[i].pixel;
+  }
   back = graphic[0].back;
+  // define the color transform parameters
+  MaxValue = graphic[0].Npixels - 1;
+  if (image[0].range != 0.0) {
+    slope = graphic[0].Npixels / image[0].range;
+    start = graphic[0].Npixels * image[0].zero / image[0].range;
+  } else {
+    slope = 1.0;
+    start = image[0].zero;
+  }
+  // set up expansions
   expand = expand_in = expand_out = 1.0;
   if (image[0].expand == 0) /* set up expansions */
 …
+  }
+  // define the image boundaries
   dx = image[0].picture.dx;
   dy = image[0].picture.dy;
   DX = matrix[0].Naxis[0];
   DY = matrix[0].Naxis[1];
   /* X,Y are the image coordinates of the first image pixel */
   X = MAX(0.5*(DX - dx*expand) - image[0].X, 0);
 …
   out_pix = (unsigned char *) image[0].picture.data;
+  in_pix  = (unsigned char *) matrix[0].buffer + DX*(int)MAX(Y,0) + (int)MAX(X,0);
+  imdata  = (float *) matrix[0].buffer;
+  in_pix  = &imdata[(int)(DX*(int)MAX(Y,0) + (int)MAX(X,0))];
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2+= expand_in, out_pix++) {
+        *out_pix = pixel[*in_pix2];
+        pixelN = PixelLookup(*in_pix2);
+        *out_pix = pixel[pixelN];
+      }
+      /* *out_pix = *(pixel + *in_pix2);  */
+    }
+    else {
+    } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2++, out_pix+= expand_out) {
+        pixvalue = pixel[*in_pix2];
+        pixelN   = PixelLookup(*in_pix2);
+        pixvalue = pixel[pixelN];
         out_pix2 = out_pix;
         for (jj = 0; jj < expand_out; jj++, out_pix2+=(dx-expand_out)) {

trunk/Ohana/src/kapa2/src/Resize.c

-              r13320
+              r13479
 // XXX Should there be a base command + KiiMessage command?
 int Resize () {
+int Resize (int sock) {
   int i, Nsection;
 …
   for (i = 0; i < Nsection; i++) {
       section = GetSectionByNumber (i);
+      SetGraphSize (section);
+      SetImageSize (section);
+      SetSectionSizes (section);
+  }

trunk/Ohana/src/kapa2/src/SaveOverlay.c

-              r13320
+              r13479
 # include "Ximage.h"
 int SaveOverlay () {
+int SaveOverlay (int sock) {
   int i, N;
   char filename[256];
+  char filename[256], *type;
   FILE *f;
   Section *section;
 …
   section = GetActiveSection();
   image   = section->image;
+  if (image == NULL) return (TRUE);
   KiiScanMessage (sock, "%*s %d %s", &N, filename);
 …
   for (i = 0; i < image[0].overlay[N].Nobjects; i++) {
+    type = KiiOverlayTypeByNumber (image[0].overlay[N].objects[i].type);
+    if (type == NULL) continue;
     fprintf (f, "%s %lf %lf %lf %lf\n",
              image[0].overlay[N].objects[i].type,
+             type,
              image[0].overlay[N].objects[i].x,
              image[0].overlay[N].objects[i].y,
 …
   return (TRUE);
+}
+/* this is asymmetric with LoadOverlay.c.  In that case, the client reads the file and sends
+ * the overlay objects to kapa.  In this case, kapa writes the file directly...
+ */

trunk/Ohana/src/kapa2/src/Sections.c

-              r13320
+              r13479
   if (section == NULL) return;
   if (section[0].graph != NULL) FreeGraph (section[0].graph);
   // if (section[0].image != NULL) FreeImage (section[0].image);
   if (section[0].name  != NULL) free (section[0].name);
+  FreeGraph (section[0].graph);
+  FreeImage (section[0].image);
+  FREE (section[0].name);
   free (section);
+}
 …
+}
-// XXX how to set the section type?
-// XXX set active section on Add?
 Section *AddSection (char *name, float x, float y, float dx, float dy) {
 …
+}
 int ListSection () {
+int ListSection (int sock) {
   int i, ThisSection;
 …
   return (TRUE);
+}
+void SetSectionSizes (Section *section) {
+    SetGraphSize (section);
+    SetImageSize (section);
+    return;
+}
+// return TRUE even for nonsense cases to avoid quitting kapa
+int MoveSection (int sock) {
+  int i, N;
+  char name[128];
+  char direction[16];
+  Section *tmpSection = NULL;
+  KiiScanMessage (sock, "%s %s", name, direction);
+  N = GetSectionByName (name);
+  if (N < 0) {
+    fprintf (stderr, "section %s not found\n", name);
+    return (TRUE);
+  }
+  if (!strcasecmp (direction, "up")) {
+      if (N < 0) return (TRUE);
+      if (N > Nsections - 2) return (TRUE);
+      tmpSection = sections[N];
+      sections[N] = sections[N+1];
+      sections[N+1] = tmpSection;
+      Refresh (1);
+      return (TRUE);
+  }
+  if (!strcasecmp (direction, "down")) {
+      if (N < 1) return (TRUE);
+      if (N > Nsections - 1) return (TRUE);
+      tmpSection = sections[N];
+      sections[N] = sections[N-1];
+      sections[N-1] = tmpSection;
+      Refresh (1);
+      return (TRUE);
+  }
+  if (!strcasecmp (direction, "top")) {
+      if (N < 0) return (TRUE);
+      if (N > Nsections - 2) return (TRUE);
+      tmpSection = sections[N];
+      for (i = N; i < Nsections - 1; i++) {
+        sections[i] = sections[i+1];
+      }
+      sections[i] = tmpSection;
+      Refresh (1);
+      return (TRUE);
+  }
+  if (!strcasecmp (direction, "bottom")) {
+      if (N < 1) return (TRUE);
+      if (N > Nsections - 1) return (TRUE);
+      tmpSection = sections[N];
+      for (i = N; i >= 1; i--) {
+        sections[i] = sections[i-1];
+      }
+      sections[i] = tmpSection;
+      Refresh (1);
+      return (TRUE);
+  }
+  fprintf (stderr, "unknown direction %s for MoveSection\n", direction);
+  return (TRUE);
+}

trunk/Ohana/src/kapa2/src/SetFont.c

r13320	r13479
1	1	# include "Ximage.h"
2	2
3		int SetFont () {
	3	int SetFont (int sock) {
4	4
5	5	char name[64];

trunk/Ohana/src/kapa2/src/SetGraphSize.c

-              r13320
+              r13479
   int fontsize, bump, Nc;
+  int textpad, textdY, WdY;
   double PADx, PADy, Dx, Dy;
   double PXm, PXp, PYm, PYp;
 …
   PYp = (graph[0].axis[2].islabel) ? 4*fontsize : 0;
   /* size of the graph in Xwindow coordinates */
+  /* basic size of the graph in Xwindow coordinates */
   X0 = PADx + PXm + (Dx * section[0].x);
   Y0 = PADy + PYm + (Dy * section[0].y);
   dX = (Dx * section[0].dx) - PXp - PXm;
   dY = (Dy * section[0].dy) - PYp - PYm;
+  // if we are tied to an image, make mods as needed
+  if (section->image) {
+    textpad = graphic[0].font[0].ascent;
+    textdY = 6*textpad + 7*PAD1;
+    WdY = MAX (ZOOM_Y, textdY + 2*BUTTON_HEIGHT + PAD1);
+    switch (section->image->location) {
+      case 1:
+        Y0 = graphic[0].dy * section[0].y + 2*PAD1 + WdY + 2; // tied to image in Y
+        dY = graphic[0].dy * section[0].dy - 5*PAD1 - WdY - COLORPAD + 1;
+        break;
+      case 3:
+        dY = graphic[0].dy * section[0].dy - 5*PAD1 - WdY - COLORPAD - PADy - PYm;
+        break;
+      case 2:
+        X0 = graphic[0].dx * section[0].x  + 2*PAD1 + ZOOM_X;
+        dX = graphic[0].dx * section[0].dx - 3*PAD1 - ZOOM_X;
+        break;
+      case 4:
+        dX = graphic[0].dx * section[0].dx - 3*PAD1 - ZOOM_X - PADx - PXm;
+        break;
+    }
+  }
   /* define locations of coordinate axes */

trunk/Ohana/src/kapa2/src/SetImageSize.c

-              r13320
+              r13479
 void SetImageSize (Section *section) {
+  int Xs, Ys, Xe, Ye, dX, dY;
+  int textpad, textdY, WdY;
   KapaImageWidget *image;
+  KapaGraphWidget *graph;
   Graphic *graphic;
 …
   image = section->image;
   if (image == NULL) return;
+  graph = section->graph;
   graphic = GetGraphic ();
+  image[0].cmapbar.dx = graphic[0].dx - 2*PAD1;
+  image[0].cmapbar.dy = COLORPAD;
+  image[0].cmapbar.x = PAD1;
+  image[0].cmapbar.y = PAD1;
+  image[0].zoom.dx = ZOOM_X;
+  image[0].zoom.dy = ZOOM_Y;
+  image[0].zoom.x = graphic[0].dx - PAD1 - ZOOM_X;
+  image[0].zoom.y = image[0].cmapbar.y + image[0].cmapbar.dy + PAD2;
+  image[0].picture.dx = image[0].zoom.x - 2*PAD1 - 25;
+  image[0].picture.dy = graphic[0].dy - 2*PAD1 - PAD2 - COLORPAD - 25;
+  image[0].picture.x = PAD1 + 25;
+  image[0].picture.y = PAD1 + PAD2 + COLORPAD;
+  /** everything below is tied in x-dir to the zoom box **/
+  image[0].text_x = image[0].zoom.x;
+  image[0].text_y = image[0].zoom.y + image[0].zoom.dy + PAD2;
+  /*  image[0].PS_button.y = graphic[0].dy - BUTTON_HEIGHT - PAD1; */
+  image[0].PS_button.x = image[0].zoom.x + 5;
+  image[0].PS_button.y = 2*ZOOM_Y;
+  /** everything below is tied to the PS_button in y-dir **/
+  image[0].grey_button.x = image[0].PS_button.x + image[0].PS_button.dx + PAD1;
+  image[0].grey_button.y = image[0].PS_button.y;
+  image[0].rainbow_button.x = image[0].grey_button.x + image[0].grey_button.dx + PAD1;
+  image[0].rainbow_button.y = image[0].PS_button.y;
+  image[0].puns_button.x = image[0].rainbow_button.x + image[0].rainbow_button.dx + PAD1;
+  image[0].puns_button.y = image[0].PS_button.y;
+  image[0].recenter_button.x = image[0].puns_button.x + image[0].puns_button.dx + PAD1;
+  image[0].recenter_button.y = image[0].PS_button.y;
+  image[0].overlay_button[0].x = image[0].zoom.x + 5;
+  image[0].overlay_button[0].y = image[0].PS_button.y - BUTTON_HEIGHT - PAD1;
+  /* the image is placed within the graphic window in region specified by section */
+  Xs = graphic[0].dx * section[0].x;
+  Ys = graphic[0].dy * (1 - section[0].y - section[0].dy);
+  dX = graphic[0].dx * section[0].dx;
+  dY = graphic[0].dy * section[0].dy;
+  switch (image[0].location) {
+    case 0:
+      if (section->graph) {
+          image[0].picture.x  = graph[0].axis[0].fx;
+          image[0].picture.y  = graph[0].axis[1].fy + graph[0].axis[1].dfy;
+          image[0].picture.dx = MAX(graph[0].axis[0].dfx + 1, 1);
+          image[0].picture.dy = MAX(fabs(graph[0].axis[1].dfy) - 1, 1);
+      } else {
+          image[0].picture.x  = Xs + PAD1;
+          image[0].picture.y  = Ys + PAD1;
+          image[0].picture.dx = dX - 2*PAD1;
+          image[0].picture.dy = dY - 2*PAD1;
+      }
+      if (USE_XWINDOW) CreatePicture (image, graphic);
+      Remap (graphic, image, &image[0].matrix);
+      return;
+    case 1:
+      textpad = graphic[0].font[0].ascent;
+      textdY = 6*textpad + 7*PAD1;
+      WdY = MAX (ZOOM_Y, textdY + 2*BUTTON_HEIGHT + PAD1);
+      if (section->graph) {
+          image[0].picture.x = graph[0].axis[0].fx;
+          image[0].picture.y = Ys + 2*PAD1 + COLORPAD;
+          image[0].picture.dx = graph[0].axis[0].dfx;
+          image[0].picture.dy = dY - 5*PAD1 - WdY - COLORPAD;
+      } else {
+          image[0].picture.x  = Xs + PAD1;
+          image[0].picture.y  = Ys + 2*PAD1 + COLORPAD;
+          image[0].picture.dx = dX - 2*PAD1;
+          image[0].picture.dy = dY - 5*PAD1 - WdY - COLORPAD;
+      }
+      image[0].cmapbar.dx = dX - 2*PAD1;
+      image[0].cmapbar.dy = COLORPAD;
+      image[0].cmapbar.x = Xs + PAD1;
+      image[0].cmapbar.y = Ys + PAD1;
+      // XXX zoom should scale somewhat with the image? (with a min and a max)
+      // XXX actually, it is limited by the buttons and status region
+      image[0].zoom.dx = ZOOM_X;
+      image[0].zoom.dy = ZOOM_Y;
+      image[0].zoom.x = Xs + PAD1;
+      image[0].zoom.y = image[0].picture.y + image[0].picture.dy + PAD1;
+      /** everything below is tied in x-dir to the zoom box **/
+      image[0].text_x = image[0].zoom.x + image[0].zoom.dx + PAD1;
+      image[0].text_y = image[0].zoom.y;
+      image[0].text_dx = ZOOM_X;
+      image[0].text_dy = 6*textpad + 7*PAD1;
+      image[0].overlay_button[0].x = image[0].text_x;
+      image[0].overlay_button[0].y = image[0].text_y + image[0].text_dy + PAD1;
+  image[0].overlay_button[1].x = image[0].overlay_button[0].x + image[0].overlay_button[0].dx + PAD1;
+  image[0].overlay_button[1].y = image[0].PS_button.y - BUTTON_HEIGHT - PAD1;
+  image[0].overlay_button[2].x = image[0].overlay_button[1].x + image[0].overlay_button[1].dx + PAD1;
+  image[0].overlay_button[2].y = image[0].PS_button.y - BUTTON_HEIGHT - PAD1;
+  image[0].overlay_button[3].x = image[0].overlay_button[2].x + image[0].overlay_button[2].dx + PAD1;
+  image[0].overlay_button[3].y = image[0].PS_button.y - BUTTON_HEIGHT - PAD1;
+  image[0].hms_button.x = image[0].overlay_button[3].x + image[0].overlay_button[3].dx + PAD1;
+  image[0].hms_button.y = image[0].PS_button.y - BUTTON_HEIGHT - PAD1;
+      image[0].overlay_button[1].x = image[0].overlay_button[0].x + image[0].overlay_button[0].dx + PAD1;
+      image[0].overlay_button[1].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[2].x = image[0].overlay_button[1].x + image[0].overlay_button[1].dx + PAD1;
+      image[0].overlay_button[2].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[3].x = image[0].overlay_button[2].x + image[0].overlay_button[2].dx + PAD1;
+      image[0].overlay_button[3].y = image[0].overlay_button[0].y;
+      image[0].hms_button.x = image[0].overlay_button[3].x + image[0].overlay_button[3].dx + PAD1;
+      image[0].hms_button.y = image[0].overlay_button[0].y;
+      image[0].PS_button.x = image[0].text_x;
+      image[0].PS_button.y = image[0].overlay_button[0].y + BUTTON_HEIGHT + PAD1;
+      /** everything below is tied to the PS_button in y-dir + the neighbor in x-dir **/
+      image[0].grey_button.x = image[0].PS_button.x + image[0].PS_button.dx + PAD1;
+      image[0].grey_button.y = image[0].PS_button.y;
+      image[0].rainbow_button.x = image[0].grey_button.x + image[0].grey_button.dx + PAD1;
+      image[0].rainbow_button.y = image[0].PS_button.y;
+      image[0].puns_button.x = image[0].rainbow_button.x + image[0].rainbow_button.dx + PAD1;
+      image[0].puns_button.y = image[0].PS_button.y;
+      image[0].recenter_button.x = image[0].puns_button.x + image[0].puns_button.dx + PAD1;
+      image[0].recenter_button.y = image[0].PS_button.y;
+      break;
+    case 3:
+      textpad = graphic[0].font[0].ascent;
+      textdY = 6*textpad + 7*PAD1;
+      WdY = MAX (ZOOM_Y, textdY + 2*BUTTON_HEIGHT + PAD1);
+      if (section->graph) {
+        image[0].picture.x = graph[0].axis[0].fx;
+        image[0].picture.y = graph[0].axis[1].fy + graph[0].axis[1].dfy;
+        image[0].picture.dx = MAX(graph[0].axis[0].dfx, 1);
+        image[0].picture.dy = MAX(fabs(graph[0].axis[1].dfy) - 1, 1);
+      } else {
+        image[0].picture.dx = dX - 2*PAD1;
+        image[0].picture.dy = dY - 5*PAD1 - WdY - COLORPAD;
+        image[0].picture.x = Xs + PAD1;
+        image[0].picture.y = Ys + 4*PAD1 + COLORPAD + WdY;
+      }
+      image[0].cmapbar.dx = dX - 2*PAD1;
+      image[0].cmapbar.dy = COLORPAD;
+      image[0].cmapbar.x = Xs + PAD1;
+      image[0].cmapbar.y = Ys + PAD1;
+      // XXX zoom should scale somewhat with the image? (with a min and a max)
+      // XXX actually, it is limited by the buttons and status region
+      image[0].zoom.dx = ZOOM_X;
+      image[0].zoom.dy = ZOOM_Y;
+      image[0].zoom.x = Xs + PAD1;
+      image[0].zoom.y = Ys + 2*PAD1 + COLORPAD;
+      /** everything below is tied in x-dir to the zoom box **/
+      image[0].text_x = image[0].zoom.x + image[0].zoom.dx + PAD1;
+      image[0].text_y = image[0].zoom.y;
+      image[0].text_dx = ZOOM_X;
+      image[0].text_dy = 6*textpad + 7*PAD1;
+      image[0].overlay_button[0].x = image[0].text_x;
+      image[0].overlay_button[0].y = image[0].text_y + image[0].text_dy + PAD1;
+      image[0].overlay_button[1].x = image[0].overlay_button[0].x + image[0].overlay_button[0].dx + PAD1;
+      image[0].overlay_button[1].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[2].x = image[0].overlay_button[1].x + image[0].overlay_button[1].dx + PAD1;
+      image[0].overlay_button[2].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[3].x = image[0].overlay_button[2].x + image[0].overlay_button[2].dx + PAD1;
+      image[0].overlay_button[3].y = image[0].overlay_button[0].y;
+      image[0].hms_button.x = image[0].overlay_button[3].x + image[0].overlay_button[3].dx + PAD1;
+      image[0].hms_button.y = image[0].overlay_button[0].y;
+      image[0].PS_button.x = image[0].text_x;
+      image[0].PS_button.y = image[0].overlay_button[0].y + BUTTON_HEIGHT + PAD1;
+      /** everything below is tied to the PS_button in y-dir + the neighbor in x-dir **/
+      image[0].grey_button.x = image[0].PS_button.x + image[0].PS_button.dx + PAD1;
+      image[0].grey_button.y = image[0].PS_button.y;
+      image[0].rainbow_button.x = image[0].grey_button.x + image[0].grey_button.dx + PAD1;
+      image[0].rainbow_button.y = image[0].PS_button.y;
+      image[0].puns_button.x = image[0].rainbow_button.x + image[0].rainbow_button.dx + PAD1;
+      image[0].puns_button.y = image[0].PS_button.y;
+      image[0].recenter_button.x = image[0].puns_button.x + image[0].puns_button.dx + PAD1;
+      image[0].recenter_button.y = image[0].PS_button.y;
+      break;
+    case 2:
+      if (section->graph) {
+        image[0].picture.x = Xs + 2*PAD1 + ZOOM_X;
+        image[0].picture.y = graph[0].axis[1].fy + graph[0].axis[1].dfy;
+        image[0].picture.dx = dX - 3*PAD1 - ZOOM_X;
+        image[0].picture.dy = MAX(fabs(graph[0].axis[1].dfy) - 1, 1);
+      } else {
+        image[0].picture.dx = dX - 3*PAD1 - ZOOM_X;
+        image[0].picture.dy = dY - 3*PAD1 - COLORPAD;
+        image[0].picture.x = Xs + 2*PAD1 + ZOOM_X;
+        image[0].picture.y = Ys + 2*PAD1 + COLORPAD;
+      }
+      image[0].cmapbar.dx = dX - 2*PAD1;
+      image[0].cmapbar.dy = COLORPAD;
+      image[0].cmapbar.x = Xs + PAD1;
+      image[0].cmapbar.y = Ys + PAD1;
+      // XXX zoom should scale somewhat with the image? (with a min and a max)
+      // XXX actually, it is limited by the buttons and status region
+      image[0].zoom.dx = ZOOM_X;
+      image[0].zoom.dy = ZOOM_Y;
+      image[0].zoom.x = Xs + PAD1;
+      image[0].zoom.y = image[0].picture.y;
+      /** everything below is tied in x-dir to the zoom box **/
+      textpad = graphic[0].font[0].ascent;
+      image[0].text_x = image[0].zoom.x;
+      image[0].text_y = image[0].zoom.y + image[0].zoom.dy + PAD1;
+      image[0].text_dx = ZOOM_X;
+      image[0].text_dy = 6*textpad + 7*PAD1;
+      image[0].overlay_button[0].x = image[0].text_x;
+      image[0].overlay_button[0].y = image[0].text_y + image[0].text_dy + PAD1;
+      image[0].overlay_button[1].x = image[0].overlay_button[0].x + image[0].overlay_button[0].dx + PAD1;
+      image[0].overlay_button[1].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[2].x = image[0].overlay_button[1].x + image[0].overlay_button[1].dx + PAD1;
+      image[0].overlay_button[2].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[3].x = image[0].overlay_button[2].x + image[0].overlay_button[2].dx + PAD1;
+      image[0].overlay_button[3].y = image[0].overlay_button[0].y;
+      image[0].hms_button.x = image[0].overlay_button[3].x + image[0].overlay_button[3].dx + PAD1;
+      image[0].hms_button.y = image[0].overlay_button[0].y;
+      image[0].PS_button.x = image[0].zoom.x;
+      image[0].PS_button.y = image[0].overlay_button[0].y + BUTTON_HEIGHT + PAD1;
+      /** everything below is tied to the PS_button in y-dir + the neighbor in x-dir **/
+      image[0].grey_button.x = image[0].PS_button.x + image[0].PS_button.dx + PAD1;
+      image[0].grey_button.y = image[0].PS_button.y;
+      image[0].rainbow_button.x = image[0].grey_button.x + image[0].grey_button.dx + PAD1;
+      image[0].rainbow_button.y = image[0].PS_button.y;
+      image[0].puns_button.x = image[0].rainbow_button.x + image[0].rainbow_button.dx + PAD1;
+      image[0].puns_button.y = image[0].PS_button.y;
+      image[0].recenter_button.x = image[0].puns_button.x + image[0].puns_button.dx + PAD1;
+      image[0].recenter_button.y = image[0].PS_button.y;
+      break;
+    case 4:
+      if (section->graph) {
+        image[0].picture.x = graph[0].axis[0].fx;
+        image[0].picture.y = graph[0].axis[1].fy + graph[0].axis[1].dfy;
+        image[0].picture.dx = dX - 3*PAD1 - ZOOM_X - graph[0].axis[0].fx;
+        image[0].picture.dy = MAX(fabs(graph[0].axis[1].dfy) - 1, 1);
+      } else {
+        image[0].picture.dx = dX - 3*PAD1 - ZOOM_X;
+        image[0].picture.dy = dY - 3*PAD1 - COLORPAD;
+        image[0].picture.x = Xs + PAD1;
+        image[0].picture.y = Ys + 2*PAD1 + COLORPAD;
+      }
+      image[0].cmapbar.dx = dX - 2*PAD1;
+      image[0].cmapbar.dy = COLORPAD;
+      image[0].cmapbar.x = Xs + PAD1;
+      image[0].cmapbar.y = Ys + PAD1;
+      // XXX zoom should scale somewhat with the image? (with a min and a max)
+      // XXX actually, it is limited by the buttons and status region
+      image[0].zoom.dx = ZOOM_X;
+      image[0].zoom.dy = ZOOM_Y;
+      image[0].zoom.x = image[0].picture.x + image[0].picture.dx + PAD1;
+      image[0].zoom.y = image[0].picture.y;
+      /** everything below is tied in x-dir to the zoom box **/
+      textpad = graphic[0].font[0].ascent;
+      image[0].text_x = image[0].zoom.x;
+      image[0].text_y = image[0].zoom.y + image[0].zoom.dy + PAD1;
+      image[0].text_dx = ZOOM_X;
+      image[0].text_dy = 6*textpad + 7*PAD1;
+      image[0].overlay_button[0].x = image[0].text_x;
+      image[0].overlay_button[0].y = image[0].text_y + image[0].text_dy + PAD1;
+      image[0].overlay_button[1].x = image[0].overlay_button[0].x + image[0].overlay_button[0].dx + PAD1;
+      image[0].overlay_button[1].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[2].x = image[0].overlay_button[1].x + image[0].overlay_button[1].dx + PAD1;
+      image[0].overlay_button[2].y = image[0].overlay_button[0].y;
+      image[0].overlay_button[3].x = image[0].overlay_button[2].x + image[0].overlay_button[2].dx + PAD1;
+      image[0].overlay_button[3].y = image[0].overlay_button[0].y;
+      image[0].hms_button.x = image[0].overlay_button[3].x + image[0].overlay_button[3].dx + PAD1;
+      image[0].hms_button.y = image[0].overlay_button[0].y;
+      image[0].PS_button.x = image[0].zoom.x;
+      image[0].PS_button.y = image[0].overlay_button[0].y + BUTTON_HEIGHT + PAD1;
+      /** everything below is tied to the PS_button in y-dir + the neighbor in x-dir **/
+      image[0].grey_button.x = image[0].PS_button.x + image[0].PS_button.dx + PAD1;
+      image[0].grey_button.y = image[0].PS_button.y;
+      image[0].rainbow_button.x = image[0].grey_button.x + image[0].grey_button.dx + PAD1;
+      image[0].rainbow_button.y = image[0].PS_button.y;
+      image[0].puns_button.x = image[0].rainbow_button.x + image[0].rainbow_button.dx + PAD1;
+      image[0].puns_button.y = image[0].PS_button.y;
+      image[0].recenter_button.x = image[0].puns_button.x + image[0].puns_button.dx + PAD1;
+      image[0].recenter_button.y = image[0].PS_button.y;
+      break;
+    default:
+      abort ();
+      break;
+  }
   if (USE_XWINDOW) {

trunk/Ohana/src/kapa2/src/SetLimits.c

-              r13320
+              r13479
 # include "Ximage.h"
 int SetLimits () {
+int SetLimits (int sock) {
   int i;
 …
   section = GetActiveSection();
+  if (section->graph == NULL) return (TRUE);
+  if (section->graph == NULL) {
+    section->graph = InitGraph ();
+    SetSectionSizes (section);
+  }
   graph = section->graph;
   graph[0].axis[2].min = graph[0].axis[0].min = xmin;
   graph[0].axis[2].max = graph[0].axis[0].max = xmax;
 …
   Refresh (1);
+  return (TRUE);
+  return (TRUE);
+}
 int GetLimits () {
+int GetLimits (int sock) {
   double dX, dY;

trunk/Ohana/src/kapa2/src/SetNormalHints.c

-              r13320
+              r13479
   // XXX : can we drop the position flag
+  sizehints[0].flags = USPosition | USSize | PMinSize;
+  // sizehints[0].flags = USPosition | USSize | PMinSize;
+  sizehints[0].flags = USSize | PMinSize;
   sizehints[0].base_width = graphic->dx;

trunk/Ohana/src/kapa2/src/SetSection.c

r13320	r13479
2	2
3	3	// set active section
4		int SetSection () {
	4	int SetSection (int sock) {
5	5
6	6	int N;

trunk/Ohana/src/kapa2/src/UpdatePointer.c

-              r13320
+              r13479
   int textpad;
   double  x, y, z;
+  float *data;
   char line[100];
   Section *section;
 …
   section = GetActiveSection();
   image   = section->image;
+  if (image == NULL) return (TRUE);
+  if (!image[0].location) return (TRUE);
   if (image[0].MovePointer && InPicture ((XButtonEvent *)event, &image[0].picture)) {
+    data = (float *) image[0].matrix.buffer;
     Screen_to_Image (&x, &y, (double)event[0].x, (double)event[0].y, image);
+    if ((x >= 0) && (x < image[0].matrix.Naxis[0]) && (y >= 0) && (y < image[0].matrix.Naxis[1])) {
+      /*
+      X = event[0].x - image[0].picture.x;
+      Y = event[0].y - image[0].picture.y;
+      pix = MIN (MAX (X + Y*image[0].picture.dx, 0), image[0].picture.dx*image[0].picture.dy - 1);
+      z = image[0].range * image[0].picture.data[pix] / image[0].Npixels + image[0].zero;
+      */
+      z = -1;
+    }
+    else
+      z = -1;
+    z = -1;
+    if (x < 0) goto skip;
+    if (x >= image[0].matrix.Naxis[0]) goto skip;
+    if (y < 0) goto skip;
+    if (y >= image[0].matrix.Naxis[1]) goto skip;
+    z = data[(int)(y)*image[0].matrix.Naxis[0] + (int)(x)];
+  skip:
     image[0].x = x;
     image[0].y = y;
 …
     CrossHairs (graphic, image);
     XFlush (graphic[0].display);
+  }
 …
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
     bzero (line, 100);
     sprintf (line, "%25.2f", z);
+    sprintf (line, "%22.3f", z);
     XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc,
                  image[0].text_x + PAD1, image[0].text_y + textpad + PAD1,

trunk/Ohana/src/kapa2/src/UpdateStatusBox.c

-              r13320
+              r13479
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
     XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc,
                     image[0].text_x, image[0].text_y, ZOOM_X, 6*textpad+7*PAD1);
+                    image[0].text_x, image[0].text_y, image[0].text_dx, image[0].text_dy);
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
     XDrawRectangle (graphic[0].display, graphic[0].window, graphic[0].gc,
                     image[0].text_x, image[0].text_y, ZOOM_X, 6*textpad+7*PAD1);
+                    image[0].text_x, image[0].text_y, image[0].text_dx, image[0].text_dy);
     bzero (line, 100);
 …
     bzero (line, 100);
     sprintf (line, "(%s)                                          ", image[0].buffer_name);
+    sprintf (line, "(%s)                                          ", image[0].name);
     XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc,
                  image[0].text_x + PAD1, image[0].text_y + 6*textpad + 6*PAD1, line, 25);
 …
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].back);
     XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc,
                     image[0].text_x + 1, image[0].text_y + 1, ZOOM_X - 2, 3*textpad+3*PAD1 +1);
+                    image[0].text_x+1, image[0].text_y+1, image[0].text_dx-2, image[0].text_dy-2);
     XSetForeground (graphic[0].display, graphic[0].gc, graphic[0].fore);
+  }
   bzero (line, 100);
   sprintf (line, "%25.3f", z);
+  sprintf (line, "%22.3f", z);
   XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc,
                image[0].text_x + PAD1, image[0].text_y + textpad + PAD1, line, strlen(line));
   bzero (line, 100);
   sprintf (line, "%12.1f %12.1f", x, y);
+  sprintf (line, "%10.1f %10.1f", x, y);
   XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc,
                image[0].text_x + PAD1, image[0].text_y + 2*textpad + 2*PAD1, line, strlen(line));
 …
   bzero (line, 100);
   if (image[0].DecimalDegrees) {
     sprintf (line, "%12.6f %12.6f", ra, dec);
+    sprintf (line, "%10.6f %10.6f", ra, dec);
   } else {
     hh_hms (line, ra, dec, ':');

trunk/Ohana/src/kapa2/src/bDrawIt.c

r13320	r13479
22	22	section = GetSectionByNumber (i);
23	23	bDrawGraph (section->graph);
24		// bDrawImage (section->~~graph~~);
	24	// bDrawImage (section->image);
25	25	}
26	26

trunk/Ohana/src/kapa2/src/bDrawOverlay.c

-              r13320
+              r13479
     expand = fabs((double)image[0].expand);
+  }
-  /*
-  X = 0.5*image[0].matrix.Naxis[0] - expand*((int)(0.5*image[0].picture.dx + 0.5) - 0.0) - image[0].X;
-  Y = 0.5*image[0].matrix.Naxis[1] - expand*((int)(0.5*image[0].picture.dy + 0.5) - 0.0) - image[0].Y;
-  X0 =  (image[0].X + 1 - (int)(0.5*image[0].matrix.Naxis[0] + 0.5) - X + (int)X)/expand + image[0].picture.x + 0.5*image[0].picture.dx;
-  Y0 =  (image[0].Y + 1 - (int)(0.5*image[0].matrix.Naxis[1] + 0.5) - Y + (int)Y)/expand + image[0].picture.y + 0.5*image[0].picture.dy;
-  */
   Image_to_Screen (&X0, &Y0, 0.0, 0.0, image);
 …
        for a BOX (x, y) is the center, (dx, dy) is the width */
+    if (!strcasecmp (image[0].overlay[N].objects[i].type, "LINE")) {
+      bDrawLine (X, Y, (X+dX), (Y+dY));
+      continue;
+    switch (image[0].overlay[N].objects[i].type) {
+      case KII_OVERLAY_LINE:
+        bDrawLine (X, Y, (X+dX), (Y+dY));
+        break;
+      case KII_OVERLAY_TEXT:
+        bDrawRotText (X, Y, image[0].overlay[N].objects[i].text, 8, 0.0);
+        break;
+      case KII_OVERLAY_BOX:
+        dx = MAX (abs(dX),2) / 2;
+        dy = MAX (abs(dY),2) / 2;
+        bDrawRectOpen ((X-dx), (Y-dy), (X+dx), (Y+dy));
+        // bDrawRectOpen ((X-dx), (Y-dy), (X), (Y));
+        break;
+      case KII_OVERLAY_CIRCLE:
+        dx = MAX (abs(dX),2);
+        dy = MAX (abs(dY),2);
+        bDrawArc (X, Y, dx, dy, 0, 360);
+        break;
+      default:
+        fprintf (stderr, "skipping unknown object\n");
+        break;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "TEXT")) {
-      bDrawRotText (X, Y, image[0].overlay[N].objects[i].text, 8, 0.0);
-      continue;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "BOX")) {
-      dx = MAX (abs(dX),2) / 2;
-      dy = MAX (abs(dY),2) / 2;
-      bDrawRectOpen ((X-dx), (Y-dy), (X+dx), (Y+dy));
-      // bDrawRectOpen ((X-dx), (Y-dy), (X), (Y));
-       continue;
+    }
-    if (!strcasecmp (image[0].overlay[N].objects[i].type, "CIRCLE")) {
-      dx = MAX (abs(dX),2);
-      dy = MAX (abs(dY),2);
-      bDrawArc (X, Y, dx, dy, 0, 360);
-      continue;
+    }
-    fprintf (stderr, "don't know %s, skipping (PO)\n", image[0].overlay[N].objects[i].type);
+  }

trunk/Ohana/src/kapa2/src/kapa.c

r13320	r13479
7	7	SetUpGraphic (&argc, argv);
8	8
9		~~// XXX get socket connection here?~~
10
11	9	InitLayout (argc, argv);
12	10	EventLoop ();

trunk/Ohana/src/kii/event/CheckPipe.c

-              r5700
+              r13479
+  }
+  /* is this no longer used ?
   if (!strcmp (buffer, "NPIX")) {
     sprintf (buffer, "NPIX:   %8d", layout[0].Npixels);
 …
     return (TRUE);
+  }
+  */
   fprintf (stderr, "unknown signal %s\n", buffer);

trunk/Ohana/src/libkapa/Makefile

-              r12879
+              r13479
 $(SRC)/KiiConvert.$(ARCH).o \
 $(SRC)/KapaWindow.$(ARCH).o \
+$(SRC)/KapaColors.$(ARCH).o
+$(SRC)/KapaColors.$(ARCH).o \
+$(SRC)/KapaOpen.$(ARCH).o
 DRAW = \

trunk/Ohana/src/libkapa/include/kapa.h

-              r13326
+              r13479
 # define KAPA_H
+/* linux is happy with this, not solaris */
+# include <netinet/ip.h>
+# include <netdb.h>
+# include <arpa/inet.h>
+# include <sys/types.h>
+# include <sys/socket.h>
 # include <X11/Xlib.h>
 # include <png.h>
 # include <dvo.h>
+typedef struct sockaddr_in KapaSockAddress;
 typedef struct {
 …
   int Nx;
   int Ny;
-  char *file;
-  char *name;
 } KiiImage;
 typedef struct {
+  double zero;
+  double range;
+  int logflux;
+} KiiDisplayMode;
+  float x;
+  float y;
+  float dx;
+  float dy;
+  int type;
+} KiiOverlayBase;
 typedef struct {
 …
 typedef struct {
+  int logflux;
+  double zero, range;
+  char name[1024];
+  char file[1024];
+} KapaImageData;
+typedef struct {
   int dx, dy, ascent;
   unsigned char *bits;
 …
 int KiiSendData (int device, char *data, int Nbytes);
 char *KiiRecvData (int device);
+int KiiWaitAnswer (int device, char *expect);
 /* KiiOpen.c */
 …
 /* KiiPicture.c */
 int KiiNewPicture1D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords);
 int KiiNewPicture2D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords);
+int KiiNewPicture1D (int fd, KiiImage *image, KapaImageData *data, Coords *coords);
+int KiiNewPicture2D (int fd, KiiImage *image, KapaImageData *data, Coords *coords);
 /* KiiOverlay.c */
 …
 int KiiCursorOn (int fd);
 int KiiCursorOff (int fd);
 int KiiCursorRead (int fd, double *x, double *y, char *key);
+int KiiCursorRead (int fd, double *x, double *y, double *z, double *r, double *d, char *key);
 /* KapaWindow.c */
 …
 int KiiCenter (int fd, double x, double y, int zoom);
 int KapaBox (int fd, Graphdata *graphdata);
+int KapaClear (int fd, int ClearSection);
+int KapaClearCurrentPlot (int fd);
+int KapaClearPlots (int fd);
+int KapaClearSections (int fd);
+int KapaClearImage (int fd);
 int KapaInitGraph (Graphdata *graphdata);
 int KapaPrepPlot (int fd, int Npts, Graphdata *graphmode);
 int KapaPlotVector (int fd, int Npts, float *values);
+int KapaPlotVector (int fd, int Npts, float *values, char *type);
 int KapaSetFont (int fd, char *name, int size);
 int KapaSendLabel (int fd, char *string, int mode);
 …
 int KapaSelectSection (int fd, char *name);
 int KapaGetSection (int fd, char *name);
+int KapaMoveSection (int fd, char *name, char *direction);
+int KapaSetGraphData (int fd, Graphdata *graphmode);
+int KapaGetGraphData (int fd, Graphdata *graphmode);
+int KapaSetImageData (int fd, KapaImageData *graphmode);
+int KapaGetImageData (int fd, KapaImageData *graphmode);
 /* KapaColors */
 …
 int bDrawRotBitmap (int x, int y, int dx, int dy, unsigned char *bitmap, int mode, double angle, double scale);
+/* Kapa Socket functions */
+int KapaOpen (char *kapa_exec, char *kapa_name);
+int KapaServerInit (KapaSockAddress *Address);
+int KapaServerWait (int InitSocket, KapaSockAddress *Address);
+int KapaDefineValidIP (char *ipstring);
+int KapaClientSocket (char *hostname);
 /* define Kapa names for shared functions */
 # define KapaOpen(p,n) KiiOpen(p,n)
+// # define KapaOpen(p,n) KiiOpen(p,n)
 # define KapaResize(fd,Nx,Ny) KiiResize(fd,Nx,Ny)
 # define KapaCenter(fd,x,y,z) KiiResize(fd,x,y,z)

trunk/Ohana/src/libkapa/src/IOfuncs.c

-              r13326
+              r13479
 # include <kapa_internal.h>
+/** these function expect to operate with a BLOCKing socket **/
 /* why is this not defined in stdarg.h for linux/x64? */
 …
   status = read (device, buffer, 16);
   buffer[16] = 0;
+  if (status != 16) fprintf (stderr, "dropped message length\n");
   /* find the message length, allocate space */
 …
   message[status] = 0;
   /* make the string easy to parse */
+  // fprintf (stderr, "recv: %s\n", message);
   /* scan the incoming message */
 …
   write (device, string, length);
+  // fprintf (stderr, "send: %s\n", string);
   free (string);
   return (TRUE);
 …
 int KiiScanCommand (int device, int length, char *format, ...) {
   int Nbytes, status;
   char *buffer, *message;
+  int status;
+  char *message;
   va_list argp;
 …
   /* read Nbytes from the device */
+  status = read (device, message, Nbytes);
+  if (status != Nbytes) fprintf (stderr, "Kii/Kapa comm error\n");
+  message[status] = 0;
+  /* make the string easy to parse */
+  status = read (device, message, length);
+  if (status != length) {
+      fprintf (stderr, "Kii/Kapa comm error\n");
+      return (0);
+  }
+  message[status] = 0; // make the string easy to parse
   /* scan the incoming message */
   va_start (argp, format);
   Nbytes = vsscanf (message, format, argp);
+  vsscanf (message, format, argp);
   va_end (argp);
   return (status);
+  return (1);
+}
+int KiiWaitAnswer (int device, char *expect) {
+  int Nbytes;
+  char *answer;
+  Nbytes = strlen (expect);
+  ALLOCATE (answer, char, Nbytes + 1);
+  KiiScanCommand (device, Nbytes, "%s", answer);
+  if (strcmp (answer, expect)) {
+      fprintf (stderr, "unexpected response %s, expected %s\n", answer, expect);
+      REALLOCATE (answer, char, 128);
+      Nbytes = read (device, answer, 127);
+      answer[Nbytes] = 0;
+      fprintf (stderr, "extra data in buffer: %d bytes\n", Nbytes);
+      fprintf (stderr, "garbage: %s\n", answer);
+      return (FALSE);
+  }
+  return (TRUE);
+}

trunk/Ohana/src/libkapa/src/KapaOpen.c

-              r13344
+              r13479
   if (status == -1) {
     if (errno == EADDRINUSE) {
+        close (InitSocket);
         Address[0].sin_port ++;
         if (Address[0].sin_port > MY_PORT + 10) exit (2);
 …
+  }
   if (!status) return (-1);
-  /* this is a blocking wait; use in a separate thread */
-  // fcntl (InitSocket, F_SETFL, !O_NONBLOCK);
   if (DEBUG) fprintf (stderr, "init sock: %d, len: %d\n", InitSocket, length);
 …
 accepted:
   if (DEBUG) fprintf (stderr, "connection accepted\n");
-  // fcntl (BindSocket, F_SETFL, O_NONBLOCK);
   return (BindSocket);
+}
 …
     if (DEBUG) fprintf (stderr, "error connecting: %d\n", errno);
     if (errno == ECONNREFUSED) {
+      close (InitSocket);
       Address.sin_port ++;
       if (Address.sin_port > MY_PORT + 10) return (-1);
 …
   if (DEBUG) fprintf (stderr, "connected on port: %d\n", Address.sin_port);
   if (DEBUG) fprintf (stderr, "connected\n");
+  fcntl (InitSocket, F_SETFL, O_NONBLOCK);
+  // the client uses a BLOCKing socket by default
+  fcntl (InitSocket, F_SETFL, !O_NONBLOCK);
   return (InitSocket);
+}
 …
     sprintf (line, "%s &", kapa_exec);
   } else {
     sprintf (line, "%s -name %s &", kapa_exec, kapa_name);
+    sprintf (line, "%s -name '%s' &", kapa_exec, kapa_name);
+  }
   system (line);

trunk/Ohana/src/libkapa/src/KapaWindow.c

-              r10923
+              r13479
 # include <kapa_internal.h>
+int KiiCenter (int fd, double x, double y, int zoom) {
+  KiiSendCommand (fd, 4, "CENT");
+  KiiSendMessage (fd, "%8.3f %8.3f %8d ", x, y, zoom);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
 int KiiResize (int fd, int Nx, int Ny) {
 …
   KiiSendCommand (fd, 4, "RSIZ");
   KiiSendMessage (fd, "%d %d", Nx, Ny);
+  return (TRUE);
+}
+int KiiCenter (int fd, double x, double y, int zoom) {
+  KiiSendCommand (fd, 4, "CENT");
+  KiiSendMessage (fd, "%8.3f %8.3f %8d ", x, y, zoom);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendCommand (fd, 4, "DBOX");
   KiiSendMessage (fd, "%12.6g %12.6g %12.6g %12.6g",
                     graphdata[0].xmin, graphdata[0].xmax, graphdata[0].ymin, graphdata[0].ymax);
   KiiSendMessage (fd, "%s %s %s", graphdata[0].axis, graphdata[0].labels, graphdata[0].ticks);
+  return (TRUE);
+}
+int KapaClear (int fd, int ClearSection) {
+  if (ClearSection) {
+    KiiSendCommand (fd, 4, "ERAS");
+  } else {
+    KiiSendCommand (fd, 4, "ERSS");
+  }
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaClearCurrentPlot (int fd) {
+  KiiSendCommand (fd, 4, "ERSC");
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaClearPlots (int fd) {
+  KiiSendCommand (fd, 4, "ERSP");
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaClearSections (int fd) {
+  KiiSendCommand (fd, 4, "ERSS");
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaClearImage (int fd) {
+  KiiSendCommand (fd, 4, "ERSI");
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaSetToolbox (int fd, int location) {
+  KiiSendCommand (fd, 4, "TOOL");
+  KiiSendMessage (fd, "%d", location);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
+}
 int KapaPrepPlot (int fd, int Npts, Graphdata *graphmode) {
+int KapaPrepPlot (int fd, int Npts, Graphdata *data) {
   /* tell kapa to look for the incoming image */
   KiiSendCommand (fd, 4, "PLOT");
   /* send Xgraph the plot details */
+  /* send kapa the plot details */
   KiiSendMessage (fd, "%8d %8d %d %d %d %d %d %f %f",
                   Npts, graphmode[0].style,
                   graphmode[0].ptype, graphmode[0].ltype,
                   graphmode[0].etype, graphmode[0].ebar, graphmode[0].color,
                   graphmode[0].lweight, graphmode[0].size);
+                  Npts, data[0].style,
+                  data[0].ptype, data[0].ltype,
+                  data[0].etype, data[0].ebar, data[0].color,
+                  data[0].lweight, data[0].size);
   KiiSendMessage (fd, "%g %g %g %g",
+                  graphmode[0].xmin, graphmode[0].xmax,
+                  graphmode[0].ymin, graphmode[0].ymax);
+  return (TRUE);
+}
+int KapaPlotVector (int fd, int Npts, float *values) {
+                  data[0].xmin, data[0].xmax,
+                  data[0].ymin, data[0].ymax);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaSetGraphData (int fd, Graphdata *data) {
+  /* tell kapa to look for the incoming image */
+  KiiSendCommand (fd, 4, "SSTY");
+  /* send kapa the plot details */
+  KiiSendMessage (fd, "%8d %d %d %d %d %d %f %f",
+                  data[0].style,
+                  data[0].ptype, data[0].ltype,
+                  data[0].etype, data[0].ebar, data[0].color,
+                  data[0].lweight, data[0].size);
+  KiiSendMessage (fd, "%g %g %g %g",
+                  data[0].xmin, data[0].xmax,
+                  data[0].ymin, data[0].ymax);
+  KiiSendMessage (fd, "%g %g %g %g",
+                  data[0].coords.pc1_1, data[0].coords.pc2_2,
+                  data[0].coords.pc1_2, data[0].coords.pc2_1);
+  KiiSendMessage (fd, "%d %d %s",
+                  data[0].flipeast, data[0].flipnorth,
+                  data[0].coords.ctype);
+  KiiSendMessage (fd, "%g %g %g %g %g %g",
+                  data[0].coords.crval1,
+                  data[0].coords.crval2,
+                  data[0].coords.crpix1,
+                  data[0].coords.crpix2,
+                  data[0].coords.cdelt1,
+                  data[0].coords.cdelt2);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaGetGraphData (int fd, Graphdata *data) {
+  /* tell kapa to look for the incoming image */
+  KiiSendCommand (fd, 4, "GSTY");
+  /* send kapa the plot details */
+  KiiScanMessage (fd, "%d %d %d %d %d %d %lf %lf",
+                  &data[0].style,
+                  &data[0].ptype, &data[0].ltype,
+                  &data[0].etype, &data[0].ebar, &data[0].color,
+                  &data[0].lweight, &data[0].size);
+  KiiScanMessage (fd, "%lf %lf %lf %lf",
+                  &data[0].xmin, &data[0].xmax,
+                  &data[0].ymin, &data[0].ymax);
+  KiiScanMessage (fd, "%f %f %f %f",
+                  &data[0].coords.pc1_1, &data[0].coords.pc2_2,
+                  &data[0].coords.pc1_2, &data[0].coords.pc2_1);
+  KiiScanMessage (fd, "%d %d %s",
+                  &data[0].flipeast, &data[0].flipnorth,
+                  data[0].coords.ctype);
+  KiiScanMessage (fd, "%lf %lf %f %f %f %f",
+                  &data[0].coords.crval1,
+                  &data[0].coords.crval2,
+                  &data[0].coords.crpix1,
+                  &data[0].coords.crpix2,
+                  &data[0].coords.cdelt1,
+                  &data[0].coords.cdelt2);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaSetImageData (int fd, KapaImageData *data) {
+  /* tell kapa to look for the incoming image */
+  KiiSendCommand (fd, 4, "SIMD");
+  /* send kapa the plot details */
+  KiiSendMessage (fd, "%g %g %s %s",
+                  data[0].zero, data[0].range, data[0].name, data[0].file);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaGetImageData (int fd, KapaImageData *data) {
+  /* tell kapa to look for the incoming image */
+  KiiSendCommand (fd, 4, "GIMD");
+  KiiScanMessage (fd, "%lf %lf %s %s",
+                  &data[0].zero, &data[0].range, data[0].name, data[0].file);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaPlotVector (int fd, int Npts, float *values, char *type) {
   int Nbytes;
+  int swap;
+# ifdef BYTE_SWAP
+  swap = 1;
+# else
+  swap = 0;
+# endif
   Nbytes = Npts * sizeof (float);
+  if (!strcmp(type, "x")) goto valid;
+  if (!strcmp(type, "y")) goto valid;
+  if (!strcmp(type, "z")) goto valid;
+  if (!strcmp(type, "dym")) goto valid;
+  if (!strcmp(type, "dyp")) goto valid;
+  if (!strcmp(type, "dxm")) goto valid;
+  if (!strcmp(type, "dxp")) goto valid;
+  return (FALSE);
+valid:
+  KiiSendCommand (fd, 4, "PLOB");
+  KiiSendMessage (fd, "%s %d %d %d", type, Npts, Nbytes, swap);
   write (fd, values, Nbytes);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendCommand (fd, 16, "%s", name);
   KiiSendCommand (fd, 16, "%d", size);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 int KapaSendLabel (int fd, char *string, int mode) {
   KiiSendCommand (fd, 4, "LABL");
   KiiSendMessage (fd, "%6d", mode);
   KiiSendData (fd, string, strlen(string));
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendMessage (fd, "%f %f %f", x, y, angle);
   KiiSendData (fd, string, strlen(string));
+  return (TRUE);
+}
+int KapaSetLimits (int fd, Graphdata *graphmode) {
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaSetLimits (int fd, Graphdata *data) {
   KiiSendCommand (fd, 4, "SLIM");
+  KiiSendMessage (fd, "%g %g %g %g ", graphmode[0].xmin, graphmode[0].xmax, graphmode[0].ymin, graphmode[0].ymax);
+  KiiSendMessage (fd, "%g %g %g %g ", data[0].xmin, data[0].xmax, data[0].ymin, data[0].ymax);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+// for now, this just gets the dimensions
+int KapaGetLimits (int fd, float *dx, float *dy) {
+  KiiSendCommand (fd, 4, "GLIM");
+  KiiScanMessage (fd, "%f %f", dx, dy);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
                   section[0].dx,
                   section[0].dy);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KapaMoveSection (int fd, char *name, char *direction) {
+  if (!strcasecmp(direction, "up")) goto valid;
+  if (!strcasecmp(direction, "down")) goto valid;
+  if (!strcasecmp(direction, "top")) goto valid;
+  if (!strcasecmp(direction, "bottom")) goto valid;
+  fprintf (stderr, "unexpected direction %s\n", direction);
+  return (FALSE);
+valid:
+  KiiSendCommand (fd, 4, "MSEC");
+  KiiSendMessage (fd, "%s %s", name, direction);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendCommand (fd, 4, "SSEC");
   KiiSendMessage (fd, "%s", name);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendCommand (fd, 4, "LSEC");
   KiiSendMessage (fd, "%s", name);
+  return (TRUE);
+}
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}

trunk/Ohana/src/libkapa/src/KiiConvert.c

-              r12892
+              r13479
 int KiiJPEG (int fd, const char *filename) {
-  char buffer[20];
   KiiSendCommand (fd, 4, "JPEG");
   KiiSendMessage (fd, "%s", filename);
+  /* block for the response, which says the operation completed */
+  read (fd, buffer, 4);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
 int KapaPNG (int fd, const char *filename) {
-  char buffer[20];
   KiiSendCommand (fd, 4, "PNGF");
   KiiSendMessage (fd, "%s", filename);
+  /* block for the response, which says the operation completed */
+  read (fd, buffer, 4);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
 int KapaPPM (int fd, const char *filename) {
-  char buffer[20];
   KiiSendCommand (fd, 4, "PPMF");
   KiiSendMessage (fd, "%s", filename);
+  /* block for the response, which says the operation completed */
+  read (fd, buffer, 4);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
 int KiiPS (int fd, const char *filename, int scaleMode, int pageMode, char *pagename) {
-  char buffer[20];
-  /* the default operation */
   KiiSendCommand (fd, 4, "PSIT");
   KiiSendMessage (fd, "%s %s %d %d", filename, pagename, scaleMode, pageMode);
+  /* block for the response, which says the operation completed */
+  read (fd, buffer, 4);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}

trunk/Ohana/src/libkapa/src/KiiCursor.c

-              r5848
+              r13479
 int KiiCursorOn (int fd) {
+  write (fd, "CURS", 4); /* ask Source to look for the keystrokes */
+  KiiSendCommand (fd, 4, "CURS");
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 int KiiCursorOff (int fd) {
+  write (fd, "NCUR", 4); /* ask Source to look for the keystrokes */
+  KiiSendCommand (fd, 4, "NCUR");
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 int KiiCursorRead (int fd, double *x, double *y, char *key) {
+int KiiCursorRead (int fd, double *x, double *y, double *z, double *r, double *d, char *key) {
+  char buffer[40];
+  bzero (buffer, 40);
+  read (fd, buffer, 40);
+  buffer[39] = 0;
+  sscanf (buffer, "%s %lf %lf", key, x, y);
+  KiiScanMessage (fd, "%s %lf %lf %lf %lf %lf", key, x, y, z, r, d);
   if (ispunct(key[0])) strcpy (key, "_");
   return (TRUE);
+}

trunk/Ohana/src/libkapa/src/KiiOverlay.c

-              r13327
+              r13479
+}
 int KiiLoadOverlay (int fd, KiiOverlay *overlay, int Noverlay, char *overname) {
+int KiiLoadOverlayOld (int fd, KiiOverlay *overlay, int Noverlay, char *overname) {
   int i, n, Nline;
 …
   free (buffer);
+  KiiWaitAnswer (fd, "DONE");
   /* this is very inefficient: 128 bytes per object vs 17 as binary, plus the
      conversions back and forth
   */
+  return (TRUE);
+}
+int KiiLoadOverlay (int fd, KiiOverlay *overlay, int Noverlay, char *overname) {
+  int i, overnum, Ntextdata, NTEXTDATA, Ntext, Nchar;
+  char *textdata;
+  KiiOverlayBase *buffer;
+  Ntext = 0;
+  KiiSelectOverlay (overname, &overnum);
+  Ntextdata = 0;
+  NTEXTDATA = 1024;
+  ALLOCATE (textdata, char, 1024);
+  // we send the position information as a binary block
+  ALLOCATE (buffer, KiiOverlayBase, Noverlay);
+  for (i = 0; i < Noverlay; i++) {
+    buffer[i].x    = overlay[i].x;
+    buffer[i].y    = overlay[i].y;
+    buffer[i].dx   = overlay[i].dx;
+    buffer[i].dy   = overlay[i].dy;
+    buffer[i].type = overlay[i].type;
+    if (buffer[i].type == KII_OVERLAY_TEXT) {
+      Ntext ++;
+      Nchar = strlen(overlay[i].text) + 1;
+      if (Ntextdata + Nchar >= NTEXTDATA) {
+        NTEXTDATA += 1024;
+        REALLOCATE (textdata, char, NTEXTDATA);
+      }
+      sprintf (&textdata[Ntextdata], "%s\n", overlay[i].text);
+      Ntextdata += Nchar;
+    }
+  }
+  KiiSendCommand (fd,  4, "LOAD");
+  KiiSendMessage (fd, "%d %d %d %d", overnum, Noverlay, Ntext, Ntextdata);
+  // we could break this into segments if we want to trap an interrupt, but why bother?
+  Nchar = write (fd, buffer, Noverlay*sizeof(KiiOverlayBase));
+  fprintf (stderr, "sent %d of %d bytes\n", Nchar, Noverlay*sizeof(KiiOverlayBase));
+  KiiWaitAnswer (fd, "DONE");
+  write (fd, textdata, Ntextdata);
+  KiiWaitAnswer (fd, "DONE");
+  free (buffer);
+  free (textdata);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSelectOverlay (overname, &n);
   KiiSendCommand (fd, 4, "ERAS");
+  KiiSendCommand (fd, 4, "ERSO");
   KiiSendCommand (fd, 16, "OVERLAY %7d ", n);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 …
   KiiSendMessage (fd, "FILE: %d %s", n, file);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}

trunk/Ohana/src/libkapa/src/KiiPicture.c

-              r5852
+              r13479
 # include <kapa_internal.h>
 int KiiNewPicture1D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords) {
+int KiiNewPicture1D (int fd, KiiImage *image, KapaImageData *data, Coords *coords) {
   int i;
   int Npix, Ncolors, NNcolors, size;
   float *in, min, max;
   char *out, *outbuffer, *root;
+  char *out, *outbuffer;
   double a1, a2;
   Npix = image[0].Nx*image[0].Ny;
+  KiiSendCommand (fd, 4, "READ"); /* tell Ximage to look for the incoming image */
+  KiiSendCommand (fd, 4, "READ"); /* tell kapa to look for the incoming image */
+  KiiScanMessage (fd, "%d", &Ncolors);
+  in = image[0].data1d;
+  /* these are for a future upgrade */
+  min = max = 0.0;
+  size = Npix*sizeof(float);
+  /* done with the conversion, now send kapa the converted picture */
+  KiiSendMessage (fd, "%8d %8d", image[0].Nx, image[0].Ny);
+  KiiSendMessage (fd, "-32 1 0.0 1.0");
+  KiiSendMessage (fd, "%f %f %s %s", data[0].zero, data[0].range, data[0].name, data[0].file);
+  KiiSendMessage (fd, "%f %f %d ", min, max, size);
+  KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2);
+  KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2);
+  KiiSendMessage (fd, "%s", coords[0].ctype);
+  /* send the image data */
+  write (fd, image[0].data1d, size);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KiiNewPicture1D_8bit (int fd, KiiImage *image, KapaImageData *data, Coords *coords) {
+  int i;
+  int Npix, Ncolors, NNcolors, size;
+  float *in, min, max;
+  char *out, *outbuffer;
+  double a1, a2;
+  Npix = image[0].Nx*image[0].Ny;
+  KiiSendCommand (fd, 4, "READ"); /* tell kapa to look for the incoming image */
   KiiScanMessage (fd, "%d", &Ncolors);
 …
   /* define color table, */
   NNcolors = Ncolors - 1;
   if (mode[0].logflux) {
     mode[0].range = MAX (2, mode[0].range);
     a1 = Ncolors / log10 (mode[0].range);
     a2 = mode[0].zero;
+  if (data[0].logflux) {
+    data[0].range = MAX (2, data[0].range);
+    a1 = Ncolors / log10 (data[0].range);
+    a2 = data[0].zero;
     for (i = 0; i < Npix; i++, in++, out++) {
       *out = (char) MIN (a1 * log10 (MAX (*in - a2, 1.0)), NNcolors);
+    }
   } else {
     a1 = Ncolors / mode[0].range;
     a2 = Ncolors * mode[0].zero / mode[0].range;
+    a1 = Ncolors / data[0].range;
+    a2 = Ncolors * data[0].zero / data[0].range;
     for (i = 0; i < Npix; i++, in++, out++) {
       *out = (char) MIN (MAX (a1 * *in - a2, 0), NNcolors);
 …
   size = Npix*sizeof(char);
   /* done with the conversion, now send Ximage the converted picture */
+  /* done with the conversion, now send kapa the converted picture */
   KiiSendMessage (fd, "%8d %8d", image[0].Nx, image[0].Ny);
   KiiSendMessage (fd, "8 1 0.0 1.0");
   KiiSendMessage (fd, "%f %f ", mode[0].zero, mode[0].range);
+  KiiSendMessage (fd, "%f %f %s %s", data[0].zero, data[0].range, data[0].name, data[0].file);
   KiiSendMessage (fd, "%f %f %d ", min, max, size);
   KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2);
   KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2);
+  /* send the filename */
+  root = filerootname (image[0].file);
+  KiiSendMessage (fd, "%s %s %s ", coords[0].ctype, root, image[0].name);
+  free (root);
+  KiiSendMessage (fd, "%s", coords[0].ctype);
   /* send the image data */
 …
   free (outbuffer);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}
 int KiiNewPicture2D (int fd, KiiImage *image, KiiDisplayMode *mode, Coords *coords) {
+int KiiNewPicture2D (int fd, KiiImage *image, KapaImageData *data, Coords *coords) {
   int i, j;
   int Npix, Ncolors, NNcolors, size;
   float *in, min, max;
+  char *out, *outbuffer, *root;
+  char buffer[1024];
+  char *out, *outbuffer;
   double a1, a2;
   Npix = image[0].Nx*image[0].Ny;
+  KiiSendCommand (fd, 4, "READ"); /* tell Ximage to look for the incoming image */
+  /* convert from (float *) to 1 byte chars -- depends on how many colors Kii owns */
+  /* use this response as a handshake test */
+  read (fd, buffer, 16);
+  sscanf (buffer, "%*s %d", &Ncolors);
+  KiiSendCommand (fd, 4, "READ"); /* tell kapa to look for the incoming image */
+  KiiScanMessage (fd, "%d", &Ncolors);
   ALLOCATE (outbuffer, char, Npix);
 …
   /* define color table, */
   NNcolors = Ncolors - 1;
   if (mode[0].logflux) {
     mode[0].range = MAX (2, mode[0].range);
     a1 = Ncolors / log10 (mode[0].range);
     a2 = mode[0].zero;
+  if (data[0].logflux) {
+    data[0].range = MAX (2, data[0].range);
+    a1 = Ncolors / log10 (data[0].range);
+    a2 = data[0].zero;
     for (j = 0; j < image[0].Ny; j++) {
       in = image[0].data2d[j];
 …
+    }
   } else {
     a1 = Ncolors / mode[0].range;
     a2 = Ncolors * mode[0].zero / mode[0].range;
+    a1 = Ncolors / data[0].range;
+    a2 = Ncolors * data[0].zero / data[0].range;
     for (j = 0; j < image[0].Ny; j++) {
       in = image[0].data2d[j];
 …
   size = Npix*sizeof(char);
+  /* done with the conversion, now send Ximage the converted picture */
+  KiiSendMessage (fd, "%8d %8d 8 1 %f %f", image[0].Nx, image[0].Ny, 0.0, 1.0);
+  KiiSendMessage (fd, "%f %f %f %f %d ", mode[0].zero, mode[0].range, min, max, size);
+  /* done with the conversion, now send kapa the converted picture */
+  KiiSendMessage (fd, "%8d %8d", image[0].Nx, image[0].Ny);
+  KiiSendMessage (fd, "8 1 0.0 1.0");
+  KiiSendMessage (fd, "%f %f %s %s", data[0].zero, data[0].range, data[0].name, data[0].file);
+  KiiSendMessage (fd, "%f %f %d ", min, max, size);
   KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2);
   KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2);
+  /* send the filename */
+  root = filerootname (image[0].file);
+  KiiSendMessage (fd, "%s %s %s ", coords[0].ctype, root, image[0].name);
+  KiiSendMessage (fd, "%s", coords[0].ctype);
   /* send the image data */
 …
   free (outbuffer);
+  KiiWaitAnswer (fd, "DONE");
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.astro/cgrid.c

-              r7917
+              r13479
   double x, y;
   Vector Xvec, Yvec;
   int NorthPole, SouthPole, N, OnPic, LOnPic, status, NELEMENTS, First;
+  int kapa, NorthPole, SouthPole, N, OnPic, LOnPic, status, NELEMENTS, First;
   Graphdata graphmode;
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 1) {
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   /* are we plotting one of the poles? */
 …
   graphmode.ptype = 100; /* connect a pair */
   graphmode.etype = 0;
+  PrepPlotting (N, &graphmode);
+  PlotVector (N, Xvec.elements);
+  PlotVector (N, Yvec.elements);
+  PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/cmd.astro/cplot.c

-              r7917
+              r13479
 int cplot (int argc, char **argv) {
   int i, Npts, status;
+  int i, kapa, Npts, status;
   float *x, *y, *r, *d, Rmin, Rmax;
   Vector Xvec, Yvec, *xvec, *yvec;
   Graphdata graphmode;
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 3) {
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   Rmin = graphmode.coords.crval1 - 182.0;
 …
   graphmode.etype = 0;
+  PrepPlotting (Npts, &graphmode);
+  PlotVector (Npts, Xvec.elements);
+  PlotVector (Npts, Yvec.elements);
+  PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/cmd.astro/czplot.c

-              r7917
+              r13479
 int czplot (int argc, char **argv) {
   int i, Npts;
+  int i, kapa, Npts;
   double min, range, Rmin, Rmax;
   float *in, *out, *r, *d, *x, *y;
 …
   Graphdata graphmode;
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 6) {
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   min = atof(argv[4]);
 …
   graphmode.etype = 0;
   Npts = Xvec.Nelements;
+  PrepPlotting (Npts, &graphmode);
+  PlotVector (Npts, Xvec.elements);
+  PlotVector (Npts, Yvec.elements);
+  PlotVector (Npts, Zvec.elements);
+  PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/cmd.astro/gauss.c

-              r7917
+              r13479
   char key[20];
   int i, N, Npix, Nborder, Nspot;
+  double X, Y, Z, max;
+  int Ximage, Nimage;
+  double X, Y, Z, ZP, RA, DEC, max;
+  int kapa;
+  char *name;
   Buffer *buf;
+  KapaImageData data;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImageData (&data, &kapa, name)) return (FALSE);
+  FREE (name);
   Nborder = 3;
 …
+  }
   if (Ximage < 1) {
+  if (kapa < 1) {
     gprint (GP_ERR, "no active TV\n");
     return (FALSE);
 …
+  }
   if ((buf = SelectBuffer (GetImageName(), OLDBUFFER, TRUE)) == NULL) return (FALSE);
+  if ((buf = SelectBuffer (data.name, OLDBUFFER, TRUE)) == NULL) return (FALSE);
   KiiCursorOn (Ximage);
+  KiiCursorOn (kapa);
   for (i = 0; (i < Nspot) || (Nspot == 0); i++) {
     KiiCursorRead (Ximage, &X, &Y, key);
+    KiiCursorRead (kapa, &X, &Y, &ZP, &RA, &DEC, key);
     if (!strcasecmp (key, "Q")) break;
     Z = get_aperture_stats (&buf[0].matrix, (int)(X+0.5), (int)(Y+0.5), Npix, Nborder, max);
+  }
   KiiCursorOff (Ximage);
+  KiiCursorOff (kapa);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.astro/objload.c

-              r7917
+              r13479
   int i, N, Objtype, type, Nline, status;
   FILE *f;
   char *buffer, *line;
   int Ximage, Nimage, Noverlay, NOVERLAY;
+  char *buffer, *line, *name;
+  int kapa, Noverlay, NOVERLAY;
   KiiOverlay *overlay;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   Objtype = 0;
 …
   free (buffer);
   KiiLoadOverlay (Ximage, overlay, Noverlay, argv[1]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[1]);
   free (overlay);

trunk/Ohana/src/opihi/cmd.astro/outline.c

-              r7917
+              r13479
     /* code to draw dots on Ximage */
+    {
       int Nimage, Ximage;
+      int kapa;
       float xp, yp, x, y;
       float dx, dy, theta, t, dt;
 …
       KiiOverlay *overlay;
+      Nimage = -1;
+      if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+      if (!GetImage (NULL, &kapa, NULL)) return (FALSE);
       Noverlay = 0;
 …
         CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 1000);
+      }
       KiiLoadOverlay (Ximage, overlay, Noverlay, "red");
+      KiiLoadOverlay (kapa, overlay, Noverlay, "red");
       free (overlay);
+    }

trunk/Ohana/src/opihi/cmd.astro/outline2.c

-              r7917
+              r13479
 int plot_outline () {
   int Nimage, Ximage;
+  int kapa;
   float xp, yp, x, y;
   float dx, dy, theta, t, dt;
 …
   KiiOverlay *overlay;
+  Nimage = -1;
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, NULL)) return (FALSE);
   Noverlay = 0;
 …
     CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 1000);
+  }
   KiiLoadOverlay (Ximage, overlay, Noverlay, "red");
+  KiiLoadOverlay (kapa, overlay, Noverlay, "red");
   free (overlay);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.astro/region.c

-              r10928
+              r13479
   char string[256];
   double Ra, Dec, Radius;
+  double dx, dy;
+  int N, Ngraph, Xgraph;
+  float dx, dy;
+  int N, kapa;
+  char *name;
   Graphdata graphmode;
+  Ngraph = 0;
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  name = NULL;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    name = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &kapa, name)) return (FALSE);
+  FREE (name);
   if ((N = get_argument (argc, argv, "-ew"))) {
 …
   /* ask kapa for coordinate limits, so get the right aspect ratio */
+  KiiSendCommand (Xgraph, 4, "LIMS");
+  KiiScanMessage (Xgraph, "%lf %lf", &dx, &dy);
+  KapaGetLimits (kapa, &dx, &dy);
   dx = fabs (dx);
   dy = fabs (dy);
 …
   graphmode.coords.cdelt1 = graphmode.coords.cdelt2 = 1.0;
   KapaClear (Xgraph, TRUE);
   KapaSetLimits (Xgraph, &graphmode);
+  KapaClearSections (kapa);
+  KapaSetLimits (kapa, &graphmode);
   /* drop this? */
   sprintf (string, "%8.4f %8.4f (%f)", Ra, Dec, Radius);
   KapaSendLabel (Xgraph, string, 2);
+  KapaSendLabel (kapa, string, 2);
+  SetGraph (graphmode);
+  // XXX is this the right thing to be doing?
+  SetGraph (&graphmode);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/box.c

-              r7917
+              r13479
 int box (int argc, char **argv) {
+  int i, N, Ngraph, Xgraph;
+  int i, N, kapa;
+  char *name;
   Graphdata graphmode;
   Ngraph = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Ngraph = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, name)) return (FALSE);
+  FREE (name);
   strcpy (graphmode.ticks, "2222");
 …
   if (argc != 1) goto usage;
   KapaBox (Xgraph, &graphmode);
+  KapaBox (kapa, &graphmode);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/center.c

-              r7917
+              r13479
   double x, y;
   int zoom;
+  int Ximage, Nimage, N;
+  int kapa, N;
+  char *name;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   if ((argc != 3) && (argc != 4)) {
 …
   if (argc == 4) zoom = atof (argv[3]);
   KiiCenter (Ximage, x, y, zoom);
+  KiiCenter (kapa, x, y, zoom);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/clear.c

-              r7917
+              r13479
 # include "data.h"
+// default is to clear all plots, but not the sections or the images
 int clear (int argc, char **argv) {
+  int N, ClearSection;
+  int Ngraph, Xgraph;
+  int N;
+  int kapa;
+  char *name;
   Ngraph = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Ngraph = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (NULL, &Xgraph, &Ngraph)) return (FALSE);
+  if (!GetGraph (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
+  ClearSection = FALSE;
+  if ((N = get_argument (argc, argv, "-s"))) {
+    remove_argument (N, &argc, argv);
+    ClearSection = TRUE;
+  // clear all sections
+  if ((N = get_argument (argc, argv, "-s")) ||
+      (N = get_argument (argc, argv, "-section"))) {
+      KapaClearSections (kapa);
+      return (TRUE);
+  }
+  // clear all sections
+  if ((N = get_argument (argc, argv, "-graph"))) {
+      KapaClearCurrentPlot (kapa);
+      return (TRUE);
+  }
+  // clear image
+  if ((N = get_argument (argc, argv, "-image"))) {
+      KapaClearImage (kapa);
+      return (TRUE);
+  }
   if (argc != 1) {
+    gprint (GP_ERR, "USAGE: clear [-n Xgraph]\n");
+    gprint (GP_ERR, "USAGE: clear [-n Xgraph] [-s|-section] [-image] [-graph]\n");
+    gprint (GP_ERR, "       [-s|-section] : clear all sections\n");
+    gprint (GP_ERR, "       [-graph]      : clear current graph\n");
+    gprint (GP_ERR, "       [-image]      : clear current image\n");
     return (FALSE);
+  }
   KapaClear (Xgraph, ClearSection);
+  KapaClearPlots (kapa);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/close.c

-              r6686
+              r13479
 int close_device (int argc, char **argv) {
+  int N, Source, Nsource, IsImage;
+  int N, kapa, IsImage;
+  char *name;
   /* close current graphics device */
   Nsource = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
-  if ((N = get_argument (argc, argv, "-g"))) {
-    remove_argument (N, &argc, argv);
-    SetImageDevice (FALSE);
+  }
-  if ((N = get_argument (argc, argv, "-i"))) {
-    remove_argument (N, &argc, argv);
-    SetImageDevice (TRUE);
+  }
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+    close_image (Nsource);
+  } else {
+    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
+    close_graph (Nsource);
+  }
+  if (!GetGraph (NULL, &kapa, name)) return (FALSE);
+  close_kapa (name);
+  FREE (name);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/cursor.c

-              r7917
+              r13479
 int cursor (int argc, char **argv) {
   char string[20], key[20];
   int i, N, Nsource, Source, IsImage;
+  char string[20], key[20], *name;
+  int i, N, kapa;
   double X, Y, R, D, Z;
   void *oldsignal;
-  Graphdata graphmode;
-  Buffer *buf;
+  Nsource = -1;
+  // XXX need to be able to specify graph vs image coords
+  // currently, if only one exists, that frame will be used
+  // if both exist, defaults to ??
+  // if ((N = get_argument (argc, argv, "-g"))) {
+  // if ((N = get_argument (argc, argv, "-i"))) {
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-g"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (FALSE);
+  }
+  if ((N = get_argument (argc, argv, "-i"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (TRUE);
+  }
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+  } else {
+    if (!GetGraph (&graphmode, &Source, &Nsource)) return (FALSE);
+  }
+  if (!GetGraphData (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   N = 0;
 …
+  }
+  buf = NULL;
+  if (IsImage) buf = SelectBuffer (GetImageName(), OLDBUFFER, FALSE);
+  KiiCursorOn (Source);
+  KiiCursorOn (kapa);
   oldsignal = signal (SIGINT, handle_interrupt);
   interrupt = FALSE;
+  Z = -1.0;
   for (i = 0; ((i < N) || (N == 0)) && !interrupt; i++) {
+    KiiCursorRead (Source, &X, &Y, key);
+    KiiCursorRead (kapa, &X, &Y, &Z, &R, &D, key);
     sprintf (string, "X%s", key);
 …
     sprintf (string, "Y%s", key);
     set_variable (string, Y);
+    sprintf (string, "Z%s", key);
+    set_variable (string, Z);
+    sprintf (string, "R%s", key);
+    set_variable (string, R);
+    sprintf (string, "D%s", key);
+    set_variable (string, D);
     set_str_variable ("KEY", key);
+    if (IsImage) {
+      if (buf != NULL) {
+        Z = gfits_get_matrix_value (&buf[0].matrix, (int) X, (int) Y);
+      }
+      gprint (GP_LOG, "%s %f %f  %f\n", key, X, Y, Z);
+    } else {
+      XY_to_RD (&R, &D, X, Y, &graphmode.coords);
+      sprintf (string, "R%s", key);
+      set_variable (string, R);
+      sprintf (string, "D%s", key);
+      set_variable (string, D);
+      gprint (GP_LOG, "%s %f %f\n", key, X, Y);
+    }
+    gprint (GP_LOG, "%s %f %f %f %f %f\n", key, X, Y, Z, R, D);
     if (!strcasecmp (key, "Q")) break;
+  }
   signal (SIGINT, oldsignal);
   KiiCursorOff (Source);
+  KiiCursorOff (kapa);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/device.c

-              r7917
+              r13479
 int device (int argc, char **argv) {
+  int N, Source, Nsource, IsImage;
+  int N, kapa, IsImage;
+  char *name;;
   /* set / get current graphics device */
   Nsource = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
-  if ((N = get_argument (argc, argv, "-g"))) {
-    remove_argument (N, &argc, argv);
-    SetImageDevice (FALSE);
+  }
-  if ((N = get_argument (argc, argv, "-i"))) {
-    remove_argument (N, &argc, argv);
-    SetImageDevice (TRUE);
+  }
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+    gprint (GP_ERR, "kii %d\n", Nsource);
+  if (name == NULL) {
+    name = GetKapaName ();
+    if (name == NULL) {
+      gprint (GP_ERR, "no device defined\n");
+      return (NULL);
+    }
   } else {
+    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
+    gprint (GP_ERR, "kapa %d\n", Nsource);
+    if (!GetGraph (NULL, &kapa, name)) return (FALSE);
+  }
+  gprint (GP_ERR, "kapa %s\n", name);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/dot.c

-              r7917
+              r13479
 int dot (int argc, char **argv) {
+  int kapa;
   Graphdata graphmode;
   float x, y;
   if (!style_args (&graphmode, &argc, argv, -1)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 3) {
 …
   y = atof(argv[2]);
-  /* set plotting options (these are sticky) */
-  SetGraph (graphmode);
   /* set point style and errorbar mode (these are NOT sticky) */
   graphmode.style = 2;
   graphmode.etype = 0;
+  if (!PrepPlotting (1, &graphmode)) return (FALSE);
+  PlotVector (1, &x);
+  PlotVector (1, &y);
+  if (!KapaPrepPlot (kapa, 1, &graphmode)) return (FALSE);
+  KapaPlotVector (kapa, 1, &x, "x");
+  KapaPlotVector (kapa, 1, &y, "y");
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/erase.c

-              r7917
+              r13479
   int i, N;
+  int Ximage, Nimage;
+  int kapa;
+  char *name;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   if (argc < 2) {
 …
   for (i = 1; i < argc; i++) {
     if (!(strcasecmp (argv[i], "all"))) {
       KiiEraseOverlay (Ximage, "red");
       KiiEraseOverlay (Ximage, "green");
       KiiEraseOverlay (Ximage, "blue");
       KiiEraseOverlay (Ximage, "yellow");
+      KiiEraseOverlay (kapa, "red");
+      KiiEraseOverlay (kapa, "green");
+      KiiEraseOverlay (kapa, "blue");
+      KiiEraseOverlay (kapa, "yellow");
       continue;
+    }
 …
       return (FALSE);
+    }
     KiiEraseOverlay (Ximage, argv[i]);
+    KiiEraseOverlay (kapa, argv[i]);
+  }
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/grid.c

-              r7917
+              r13479
 int grid (int argc, char **argv) {
   int j, N, MinorTick, MajorTick;
+  int j, kapa, N, MinorTick, MajorTick;
   Vector Xvec, Yvec;
   double range, lrange, factor, mantis, fmantis, power, major, minor, first, next;
   Graphdata graphmode;
+  int Ngraph;
+  Ngraph = -1;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    Ngraph = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return (FALSE);
   MajorTick = TRUE;
 …
   graphmode.ptype = 100; /* connect a pair */
   graphmode.etype = 0;
+  PrepPlotting (N, &graphmode);
+  PlotVector (N, Xvec.elements);
+  PlotVector (N, Yvec.elements);
+  PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/cmd.data/init.c

-              r10997
+              r13479
   int i;
+  InitGraph ();
+  InitImage ();
+  InitKapa ();
   InitQueues ();

trunk/Ohana/src/opihi/cmd.data/jpeg.c

-              r7917
+              r13479
   char filename[1024];
+  int N, Source, Nsource, IsImage, IsPNG;
+  int N, kapa, IsImage, IsPNG, IsPPM;
+  char *name;
   if ((N = get_argument (argc, argv, "--help"))) {
 …
   /* image type */
   IsPNG = TRUE;
+  IsPPM = IsPNG = FALSE;
   if ((N = get_argument (argc, argv, "-ppm"))) {
     remove_argument (N, &argc, argv);
     IsPNG = FALSE;
+    IsPPM = TRUE;
+  }
+  if ((N = get_argument (argc, argv, "-png"))) {
+    remove_argument (N, &argc, argv);
+    IsPNG = TRUE;
+  }
+  if (!strcmp (argv[0], "png")) IsPNG = TRUE;
+  if (!strcmp (argv[0], "ppm")) IsPPM = TRUE;
   /* file name */
 …
   /* display source */
   Nsource = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  /* XXX output png / jpeg needs to include both graph and image
+     if available.  this is a poor mix of data representations
+     (png for image / jpeg for plots)
   if ((N = get_argument (argc, argv, "-g"))) {
-    remove_argument (N, &argc, argv);
-    SetImageDevice (FALSE);
+  }
   if ((N = get_argument (argc, argv, "-i"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (TRUE);
+  }
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+    if (!filename[0]) strcpy (filename, "Ximage.jpg");
+    KiiJPEG (Source, filename);
+  } else {
+    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
+    if (!filename[0]) strcpy (filename, "Xgraph.png");
+    if (IsPNG) {
+      KapaPNG (Source, filename);
+    } else {
+      KapaPPM (Source, filename);
+    }
+  */
+  if (!GetGraph (NULL, &kapa, name)) return (FALSE);
+  if (!IsPNG && !IsPPM) {
+    if (!filename[0]) strcpy (filename, "kapa.jpg");
+    KiiJPEG (kapa, filename);
+  }
+  if (IsPNG) {
+    if (!filename[0]) strcpy (filename, "kapa.png");
+    KapaPNG (kapa, filename);
+  }
+  if (IsPPM) {
+    if (!filename[0]) strcpy (filename, "kapa.ppm");
+    KapaPPM (kapa, filename);
+  }
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/labels.c

-              r7917
+              r13479
   char name[64];
   int N, size, Xgraph;
+  int N, size, kapa;
   if (!GetGraph (NULL, &Xgraph, NULL)) return (FALSE);
+  if (!GetGraph (NULL, &kapa, NULL)) return (FALSE);
   if (get_argument (argc, argv, "-h")) {
 …
     size = atof (argv[N]);
     remove_argument (N, &argc, argv);
     KapaSetFont (Xgraph, name, size);
+    KapaSetFont (kapa, name, size);
+  }
   if ((N = get_argument (argc, argv, "-x"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 0);
+    KapaSendLabel (kapa, argv[N], 0);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "-y"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 1);
+    KapaSendLabel (kapa, argv[N], 1);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "+x"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 2);
+    KapaSendLabel (kapa, argv[N], 2);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "+y"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 3);
+    KapaSendLabel (kapa, argv[N], 3);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "-ul"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 4);
+    KapaSendLabel (kapa, argv[N], 4);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "-ur"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 5);
+    KapaSendLabel (kapa, argv[N], 5);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "-ll"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 6);
+    KapaSendLabel (kapa, argv[N], 6);
     remove_argument (N, &argc, argv);
+  }
 …
   if ((N = get_argument (argc, argv, "-lr"))) {
     remove_argument (N, &argc, argv);
     KapaSendLabel (Xgraph, argv[N], 7);
+    KapaSendLabel (kapa, argv[N], 7);
     remove_argument (N, &argc, argv);
+  }

trunk/Ohana/src/opihi/cmd.data/limits.c

-              r7917
+              r13479
   int N, APPLY;
+  int Ngraph, Xgraph;
+  int kapa;
+  char *name;
   Graphdata graphmode;
   Vector *xvec, *yvec;
 …
     APPLY = TRUE;
+  }
+  Ngraph = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Ngraph = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, name)) return (FALSE);
+  FREE (name);
   if (argc == 1) {
     gprint (GP_ERR, "limits: %f %f %f %f [-a] [-n Xgraph]\n",
+    gprint (GP_ERR, "limits: %f %f %f %f [-a] [-n device]\n",
              graphmode.xmin, graphmode.xmax,
              graphmode.ymin, graphmode.ymax);
 …
  success:
   SetLimits (xvec, yvec, &graphmode);
   if (APPLY) KapaSetLimits (Xgraph, &graphmode);
+  if (APPLY) KapaSetLimits (kapa, &graphmode);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/line.c

-              r12332
+              r13479
 int line (int argc, char **argv) {
+  int kapa;
   Graphdata graphmode;
   float x[2], y[2];
   if (!style_args (&graphmode, &argc, argv, -1)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 6) {
 …
   y[1] = atof(argv[5]);
-  SetGraph (graphmode);
   /* set point style and errorbar mode (these are NOT sticky) */
   graphmode.style = 0;
   graphmode.etype = 0;
+  if (!PrepPlotting (2, &graphmode)) return (FALSE);
+  PlotVector (2, x);
+  PlotVector (2, y);
+  if (!KapaPrepPlot (kapa, 2, &graphmode)) return (FALSE);
+  KapaPlotVector (kapa, 2, x, "x");
+  KapaPlotVector (kapa, 2, y, "y");
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/load.c

-              r7917
+              r13479
   int i, N, n, ISCEL;
   int Ximage, Nimage, Noverlay, NOVERLAY;
+  int kapa, Noverlay, NOVERLAY;
   char *c, type[10], string[128], line[1024];
   double x, y, dx, dy, x1, y1;
   double dra, ddec, ra1, dec1, ra, dec;
   FILE *f;
   char *buffer;
+  char *buffer, *name;
   Coords coords;
   Buffer *buf;
   KiiOverlay *overlay;
+  KapaImageData data;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImageData (&data, &kapa, name)) return (FALSE);
+  FREE (name);
   ISCEL = FALSE;
 …
   if (ISCEL) {
     if ((buf = SelectBuffer (GetImageName(), OLDBUFFER, TRUE)) == NULL) return (FALSE);
+    if ((buf = SelectBuffer (data.name, OLDBUFFER, TRUE)) == NULL) return (FALSE);
     GetCoords (&coords, &buf[0].header);
+  }
 …
+  }
   KiiLoadOverlay (Ximage, overlay, Noverlay, argv[1]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[1]);
   for (i = 0; i < Noverlay; i++) {

trunk/Ohana/src/opihi/cmd.data/plot.c

-              r7917
+              r13479
 int plot (int argc, char **argv) {
   int N, Npts;
+  int kapa, N, Npts;
   Graphdata graphmode;
   Vector *xvec, *yvec, *dxmvec, *dxpvec, *dymvec, *dypvec;
   if (!style_args (&graphmode, &argc, argv, -1)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   /* decide on error bars */
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   /* set errorbar mode (these are NOT sticky) */
 …
   if (Npts == 0) return (TRUE);
   if (!PrepPlotting (Npts, &graphmode)) return (FALSE);
+  if (!KapaPrepPlot (kapa, Npts, &graphmode)) return (FALSE);
   PlotVector (Npts, xvec[0].elements);
   PlotVector (Npts, yvec[0].elements);
+  KapaPlotVector (kapa, Npts, xvec[0].elements, "x");
+  KapaPlotVector (kapa, Npts, yvec[0].elements, "y");
   if (graphmode.etype & 0x01) {
     PlotVector (Npts, dymvec[0].elements);
     PlotVector (Npts, dypvec[0].elements);
+    KapaPlotVector (kapa, Npts, dymvec[0].elements, "dym");
+    KapaPlotVector (kapa, Npts, dypvec[0].elements, "dyp");
+  }
   if (graphmode.etype & 0x02) {
     PlotVector (Npts, dxmvec[0].elements);
     PlotVector (Npts, dxpvec[0].elements);
+    KapaPlotVector (kapa, Npts, dxmvec[0].elements, "dxm");
+    KapaPlotVector (kapa, Npts, dxpvec[0].elements, "dxp");
+  }
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/point.c

-              r7917
+              r13479
   int N, celestial, pixscale;
   int Ximage, Nimage;
+  int kapa;
   double ra, dec, dra, ddec;
   double x1, y1, ra1, dec1;
+  char *name;
   Coords coords;
   Buffer *buf;
   KiiOverlay overlay;
+  KapaImageData data;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImageData (&data, &kapa, name)) return (FALSE);
+  FREE (name);
   celestial = FALSE;
   if ((N = get_argument (argc, argv, "-c"))) {
 …
   if (celestial) {
     if ((buf = SelectBuffer (GetImageName(), OLDBUFFER, TRUE)) == NULL) return (FALSE);
+    if ((buf = SelectBuffer (data.name, OLDBUFFER, TRUE)) == NULL) return (FALSE);
     GetCoords (&coords, &buf[0].header);
+  }
 …
+  }
   overlay.type = KiiOverlayTypeByName (argv[2]);
   KiiLoadOverlay (Ximage, &overlay, 1, argv[1]);
+  KiiLoadOverlay (kapa, &overlay, 1, argv[1]);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/ps.c

-              r12892
+              r13479
 int ps (int argc, char **argv) {
   char filename[1024], pagename[1024];
   int N, Source, Nsource, scaleMode, pageMode, IsImage;
+  char filename[1024], pagename[1024], *name;
+  int N, kapa, scaleMode, pageMode, IsImage;
   if ((N = get_argument (argc, argv, "--help"))) goto help;
 …
   /* which tool */
   Nsource = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  /* which device */
+  if ((N = get_argument (argc, argv, "-g"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (FALSE);
+  }
+  if ((N = get_argument (argc, argv, "-i"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (TRUE);
+  }
   if ((argc > 1) && filename[0]) goto help;
   if (argc > 1) strcpy (filename, argv[1]);
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+    if (!filename[0]) strcpy (filename, "Ximage.ps");
+  } else {
+    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
+    if (!filename[0]) strcpy (filename, "Xgraph.ps");
+  }
+  // get the connection to kapa, false if none available
+  if (!GetGraphData (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
+  if (!filename[0]) strcpy (filename, "kapa.ps");
   /* tell Ximage/Xgraph to ps the image */
   KiiPS (Source, filename, scaleMode, pageMode, pagename);
+  KiiPS (kapa, filename, scaleMode, pageMode, pagename);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/rd.c

-              r13107
+              r13479
   /* find matrix, free old data */
+  if ((buf = SelectBuffer (argv[1], ANYBUFFER, TRUE)) == NULL) return (FALSE);
+  if ((buf = SelectBuffer (argv[1], ANYBUFFER, TRUE)) == NULL) {
+      fclose (f);
+      return (FALSE);
+  }
   gfits_free_matrix (&buf[0].matrix);
   gfits_free_header (&buf[0].header);
 …
       gprint (GP_ERR, "entry in %s not found\n", argv[2]);
       DeleteBuffer (buf);
+      fclose (f);
       return (FALSE);
+    }
 …
         DeleteBuffer (buf);
         free (CCDKeyword);
+        fclose (f);
         return (FALSE);
+      }
 …
         DeleteBuffer (buf);
         free (CCDKeyword);
+        fclose (f);
         return (FALSE);
+      }
 …
     buf[0].header.bzero = 0;
     buf[0].header.bscale = 1;
+    fclose (f);
     return (TRUE);
+  }
 …
     gprint (GP_ERR, "-plane is too large: %d total planes\n", Nplane);
     DeleteBuffer (buf);
+    fclose (f);
     return (FALSE);
+  }

trunk/Ohana/src/opihi/cmd.data/resize.c

-              r7917
+              r13479
   char *end;
   double NX, NY;
+  int N, Source, Nsource, IsImage;
+  int N, kapa;
+  char *name;
   /* display source */
   Nsource = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nsource = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-g"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (FALSE);
+  }
+  if ((N = get_argument (argc, argv, "-i"))) {
+    remove_argument (N, &argc, argv);
+    SetImageDevice (TRUE);
+  }
+  IsImage = GetCurrentDevice ();
+  if (IsImage) {
+    if (!GetImage (&Source, &Nsource)) return (FALSE);
+  } else {
+    if (!GetGraph (NULL, &Source, &Nsource)) return (FALSE);
+  }
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   if (argc != 3) {
 …
   if (!strcmp (end, "cm")) { NY *= 38; }
   KiiResize (Source, NX, NY);
+  KiiResize (kapa, NX, NY);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/save.c

-              r7917
+              r13479
   int N, celestial;
+  int Ximage, Nimage;
+  int kapa;
+  char *name;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   celestial = FALSE;
 …
+  }
   KiiSaveOverlay (Ximage, celestial, argv[1], argv[2]);
+  KiiSaveOverlay (kapa, celestial, argv[1], argv[2]);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/section.c

-              r7917
+              r13479
 # include "data.h"
+enum {NONE, LIST, UP, DOWN, TOP, BOTTOM, TOOL};
 int section (int argc, char **argv) {
   int N, List;
   int Ngraph, Xgraph;
+  int N, action, kapa;
+  char *name, *location;
   Graphdata graphmode;
   KapaSection section;
   List = FALSE;
+  action = NONE;
   if ((N = get_argument (argc, argv, "-list"))) {
+    action = LIST;
     remove_argument (N, &argc, argv);
+    List = TRUE;
+  }
+  if ((N = get_argument (argc, argv, "-up"))) {
+    action = UP;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-down"))) {
+    action = DOWN;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-top"))) {
+    action = TOP;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-bottom"))) {
+    action = BOTTOM;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-imtool"))) {
+    action = TOOL;
+    remove_argument (N, &argc, argv);
+    location = argv[N];
+    remove_argument (N, &argc, argv);
+  }
   Ngraph = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Ngraph = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, name)) return (FALSE);
+  FREE (name);
   /* list sections */
+  if (argc == 1) {
+    KapaGetSection (Xgraph, "*");
+    gprint (GP_ERR, "USAGE: section name [x y dx dy]\n");
+  if ((argc == 1) && (action == NONE)) {
+    KapaGetSection (kapa, "*");
+    gprint (GP_ERR, "USAGE: section name [x y dx dy] [options]\n");
+    gprint (GP_ERR, "OPTIONS: -list   : show properties of all sections\n");
+    gprint (GP_ERR, "         -up     : move section up in display stack\n");
+    gprint (GP_ERR, "         -down   : move section down in display stack\n");
+    gprint (GP_ERR, "         -top    : move section to top of display stack\n");
+    gprint (GP_ERR, "         -bottom : move section to bottom of display stack\n");
+    gprint (GP_ERR, "         -imtool (position) : set location of image zoom / status box\n");
+    gprint (GP_ERR, "                 (position may be: -x, +x, -y, +y, none)\n");
     return (TRUE);
+  }
 …
   if (argc == 2) {
     /* select / show section */
+    if (List) {
+      KapaGetSection (Xgraph, argv[1]);
+    } else {
+      KapaSelectSection (Xgraph, argv[1]);
+    switch (action) {
+      case NONE:
+        KapaSelectSection (kapa, argv[1]);
+        break;
+      case UP:
+        KapaMoveSection (kapa, argv[1], "up");
+        break;
+      case DOWN:
+        KapaMoveSection (kapa, argv[1], "down");
+        break;
+      case TOP:
+        KapaMoveSection (kapa, argv[1], "top");
+        break;
+      case BOTTOM:
+        KapaMoveSection (kapa, argv[1], "bottom");
+        break;
+      case TOOL:
+        if (!strcmp(location, "-x")) {
+          KapaSetToolbox (kapa, 1);
+          break;
+        }
+        if (!strcmp(location, "+x")) {
+          KapaSetToolbox (kapa, 3);
+          break;
+        }
+        if (!strcmp(location, "-y")) {
+          KapaSetToolbox (kapa, 2);
+          break;
+        }
+        if (!strcmp(location, "+y")) {
+          KapaSetToolbox (kapa, 4);
+          break;
+        }
+        if (!strcmp(location, "none")) {
+          KapaSetToolbox (kapa, 0);
+          break;
+        }
+        gprint (GP_ERR, "unknown toolbox location %s\n", location);
+        gprint (GP_ERR, "valid values: -x, +x, -y, +y, none\n");
+        return (FALSE);
+      case LIST:
+        KapaGetSection (kapa, argv[1]);
+        break;
+    }
     return (TRUE);
 …
     section.dx = atof (argv[4]);
     section.dy = atof (argv[5]);
     KapaSetSection (Xgraph, &section);
+    KapaSetSection (kapa, &section);
     return (TRUE);
+  }
   gprint (GP_ERR, "USAGE: section name [x y dx dy]\n");
+  gprint (GP_ERR, "USAGE: section name [-list] [-up] [-down] [-top] [-bottom]\n");
   return (FALSE);
+}

trunk/Ohana/src/opihi/cmd.data/style.c

-              r7917
+              r13479
 int style (int argc, char **argv) {
+  Graphdata graphmode;
+  int kapa;
+  Graphdata data;
   if (!style_args (&graphmode, &argc, argv, -1)) return FALSE;
+  if (!style_args (&data, &argc, argv, &kapa)) return FALSE;
   if (argc > 1) {
 …
     return (FALSE);
+  }
   SetGraph (graphmode);
+  KapaSetGraphData (kapa, &data);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/textline.c

-              r7917
+              r13479
   char name[64];
   double x, y, angle;
   int Ngraph, Xgraph;
+  int kapa;
   Graphdata graphmode;
+  Ngraph = -1;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    Ngraph = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return (FALSE);
   if ((N = get_argument (argc, argv, "-fn"))) {
 …
     size = atof (argv[N]);
     remove_argument (N, &argc, argv);
     KapaSetFont (Xgraph, name, size);
+    KapaSetFont (kapa, name, size);
+  }
 …
+  }
   KapaSendTextline (Xgraph, argv[3], x, y, angle);
+  KapaSendTextline (kapa, argv[3], x, y, angle);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.data/tv.c

-              r7917
+              r13479
 int tv (int argc, char **argv) {
+  int N, Ximage, Nimage;
+  int N, kapa;
+  char *name, *file;
   Coords coords;
   Buffer *buf;
   KiiImage image;
   KiiDisplayMode mode;
+  KapaImageData data;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (&data, &kapa, name)) return (FALSE);
+  FREE (name);
   /* shell exits on pipe close, FIX */
   if ((N = get_argument (argc, argv, "-kill"))) {
+    KiiClose (Ximage);
+    Ximage = 0;
+    KiiClose (kapa);
     return (TRUE);
+  }
   mode.logflux = FALSE;
+  data.logflux = FALSE;
   if ((N = get_argument (argc, argv, "-log"))) {
     remove_argument (N, &argc, argv);
     mode.logflux = TRUE;
+    data.logflux = TRUE;
+  }
+  // use the currently-set zero,range values if not supplied
   if ((argc != 2) && (argc != 4)) {
     gprint (GP_ERR, "USAGE: tv <buffer> [zero range] [-n Nimage] [-log] [-kill]\n");
 …
+  }
-  GetImageScale (&mode.zero, &mode.range);
   if (argc == 4) {
+    mode.zero = atof (argv[2]);
+    mode.range = atof (argv[3]);
+    if (mode.range == 0.0) mode.range = 0.001;
+    SetImageScale (mode.zero, mode.range);
+    data.zero = atof (argv[2]);
+    data.range = atof (argv[3]);
+    if (data.range == 0.0) data.range = 0.001;
+  }
 …
   image.Nx = buf[0].matrix.Naxis[0];
   image.Ny = buf[0].matrix.Naxis[1];
-  image.file = buf[0].file;
-  image.name = buf[0].name;
+  KiiNewPicture1D (Ximage, &image, &mode, &coords);
+  // send only the root of the file, not the full path
+  file = filerootname (buf[0].file);
+  strcpy (data.file, file);
+  free (file);
+  SetImageName (argv[1]);
+  strcpy (data.name, argv[1]);
+  KiiNewPicture1D (kapa, &image, &data, &coords);
   set_str_variable ("TV", argv[1]);
   return (TRUE);
+}
-/*
-projections and coordinates:
-IRAS:
-CTYPE1  = 'LL      '                    /TANGENT PLANE (L)
-CRVAL1  =         0.100000D+02          /R.A. OF MAP CENTER  *** SEE COMMENT
-CDELT1  =        -0.133333D-01          /SEPARATION IN L (DEG)
-CRPIX1  =                  128          /MAPCENTER IN L
-CROTA1  =         0.000000E+00          /NO ROTATION
-CTYPE2  = 'MM      '                    /TANGENT PLANE (M)
-CRVAL2  =         0.410000D+02          /DEC. OF MAP CENTER  *** SEE COMMENT
-CDELT2  =         0.133333D-01          /SEPARATION IN M (DEG)
-CRPIX2  =                  128          /MAP CENTER IN M
-CROTA2  =         0.000000E+00          /NO ROTATION
-HIRAS:
-CTYPE1  = 'RA---TAN          ' / PRIMARY AXIS NAME
-CRVAL1  =   1.000000000000E+01 / PRIMARY REFERENCE VALUE
-CDELT1  =  -5.555555555556E-03 / PRIMARY PIXEL SEPARATION
-CRPIX1  =   2.560000000000E+02 / PRIMARY REFERENCE PIXEL
-CUNIT1  = 'DEGREE            ' / PRIMARY AXIS UNITS
-CDELT2  =   5.555555555556E-03 / PRIMARY PIXEL SEPARATION
-CRPIX2  =   2.560000000000E+02 / PRIMARY REFERENCE PIXEL
-CRVAL2  =   4.100000000000E+01 / PRIMARY REFERENCE VALUE
-CTYPE2  = 'DEC--TAN          ' / PRIMARY AXIS NAME
-CUNIT2  = 'DEGREE            ' / PRIMARY AXIS UNITS
-PROJTYPE= 'GNOMON    '
-COORDSYS= 'EQUATORIAL     '
-gene (small FOV linear):
-RA_O
-RA_X
-RA_Y
-DEC_O
-DEC_X
-DEC_Y
-*/
-# ifdef NEWTVMODE
+  {
-    double *pixvalues, slope;
-    ALLOCATE (pixvalues, double, Ncolors + 1);
-    range = fabs (range);
-    for (i = 0; i < Ncolors + 1; i++) {
-      if (ISLOG) {
-        pixvalues[i] = i*range / NNcol + zero;
+      }
-      if (!ISLOG) {
-        pixvalues[i] = pow (10.0, i*log10(range - 1.0) / NNcol) + zero - 1.0;
+      }
+    }
-    for (j = 0; j < Npix; j++, in++, out++) {
-      if (*in < pixvalues[0]) {
-        i = 0;
-      } else {
-        if (*in > pixvalues[NNcol]) {
-          i = NNcol;
-        } else {
-          for (i = 0; (*in < pixvalues[i]) || (*in > pixvalues[i+1]); ) {
-            slope = 1.0 / (pixvalues[i+1] - pixvalues[i]);
-            i = MIN (MAX (0, i + (*in - pixvalues[i]) * slope), NNcol);
+          }
+        }
+      }
-      /* for (i = 0; (i < Ncolors - 1) && (pixvalues[i] < *in); i++); */
-      *out = i;
+    }
-    free (pixvalues);
+  }
-# endif

trunk/Ohana/src/opihi/cmd.data/tvcontour.c

-              r7917
+              r13479
   float *v00, *v01, *v10, *v11;
   float *Vout, *Vin, *matrix;
+  int Ximage, Nimage, N, Noverlay, NOVERLAY;
+  char *name;
+  int kapa, N, Noverlay, NOVERLAY;
   Buffer *buf;
   KiiOverlay *overlay;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   if ((argc != 4) && (argc != 5)) {
 …
+  }
   KiiLoadOverlay (Ximage, overlay, Noverlay, argv[2]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[2]);
   free (overlay);

trunk/Ohana/src/opihi/cmd.data/tvgrid.c

-              r7917
+              r13479
   char format[16];
   Coords coords;
+  int Ximage, Nimage, N, Noverlay, NOVERLAY;
+  int kapa, N, Noverlay, NOVERLAY;
+  char *name;
   Buffer *buf;
   KiiOverlay *overlay;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   if (argc != 3) {
     gprint (GP_ERR, "USAGE: tvgrid (overlay) (buffer)\n");
 …
+  }
+  # if (0)
+  /* write the labels on the axes */
+  dDEC = fabs(dec1 - dec0) / 100;
+  for (ra = dRA * ((int)(MIN(ra0, ra1)/dRA) + 1); ra < MAX(ra0, ra1); ra += dRA) {
+    RD_to_XY (&x0, &y0, ra + 0.1*dRA, MIN(dec0, dec1), &coords);
+    sprintf (label, format, ra);
+    sprintf (buffer, "%15s %20.10f %20.10f %20.10f %20.10f ", "TEXT", x0, y0, (double)(strlen(label) + 1), 0.0);
+    write (Ximage, buffer, 128);
+    write (Ximage, label, strlen(label) + 1);
+    RD_to_XY (&x0, &y0, ra, MIN(dec0, dec1), &coords);
+    for (dec = MIN(dec0, dec1) + dDEC; dec < MAX(dec0,dec1); dec += dDEC) {
+      RD_to_XY (&x1, &y1, ra, dec, &coords);
+      sprintf (buffer, "%15s %20.10f %20.10f %20.10f %20.10f ", "LINE", x0, y0, (x1 - x0), (y1 - y0));
+      write (Ximage, buffer, 128);
+      x0 = x1;
+      y0 = y1;
+    }
+  }
+  # endif
+  KiiLoadOverlay (Ximage, overlay, Noverlay, argv[1]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[1]);
   free (overlay);

trunk/Ohana/src/opihi/cmd.data/vload.c

-              r7917
+              r13479
   int i, N, Noverlay;
+  int Ximage, Nimage, type;
+  int kapa, type;
+  char *name;
   double dx, dy, size;
   KiiOverlay *overlay;
   Vector *vecx, *vecy;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   type = KII_OVERLAY_BOX;
 …
+  }
   KiiLoadOverlay (Ximage, overlay, Noverlay, argv[1]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[1]);
   free (overlay);
   return (TRUE);

trunk/Ohana/src/opihi/cmd.data/zplot.c

-              r7917
+              r13479
 int zplot (int argc, char **argv) {
   int i, N, Npts, Ngraph;
+  int i, kapa, N, Npts;
   float *in, *out;
   double min, range;
 …
   Vector *xvec, *yvec, *zvec, Zvec;
+  Ngraph = -1;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    Ngraph = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return (FALSE);
   if (argc != 6) {
 …
   graphmode.etype = 0; /* no errorbars */
   Npts = xvec[0].Nelements;
+  PrepPlotting (Npts, &graphmode);
+  PlotVector (Npts, xvec[0].elements);
+  PlotVector (Npts, yvec[0].elements);
+  PlotVector (Npts, Zvec.elements);
+  PlotVectorTriplet (kapa, Npts, xvec[0].elements, yvec[0].elements, Zvec.elements, &graphmode);
   free (Zvec.elements);

trunk/Ohana/src/opihi/dimm/dimm.c.in

-              r12280
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  QuitImage ();
+  QuitGraph ();
+  QuitKapa ();
   return;
+}

trunk/Ohana/src/opihi/dvo/ImageSelection.c

-              r7917
+              r13479
   if (RegionSelect) {
     Ngraph = 0;
     if (!GetGraphData (&graphsky, NULL, &Ngraph)) {
+    // how does this know which sky plot to use?
+    if (!GetGraphData (&graphsky, NULL, NULL)) {
       gprint (GP_ERR, "region display not available\n");
       return (FALSE);

trunk/Ohana/src/opihi/dvo/Makefile

-              r12842
+              r13479
 $(SRC)/init.$(ARCH).o                   \
 $(SRC)/ImageOps.$(ARCH).o               \
 $(SRC)/ImageSelection.$(ARCH).o \
+$(SRC)/ImageSelection.$(ARCH).o         \
 $(SRC)/LoadImages.$(ARCH).o             \
 $(SRC)/cmpReadFile.$(ARCH).o            \
 $(SRC)/compare.$(ARCH).o               \
+$(SRC)/compare.$(ARCH).o                \
 $(SRC)/match_image.$(ARCH).o            \
 $(SRC)/photometry.$(ARCH).o            \
+$(SRC)/photometry.$(ARCH).o             \
 $(SRC)/dvomisc.$(ARCH).o                \
 $(SRC)/region_list.$(ARCH).o            \
+$(SRC)/dvomisc.$(ARCH).o                \
+$(SRC)/dbBooleanCond.$(ARCH).o          \
+$(SRC)/dbCheckStack.$(ARCH).o           \
+$(SRC)/dbCmdlineFields.$(ARCH).o        \
+$(SRC)/dbExtractAverages.$(ARCH).o      \
+$(SRC)/dbExtractMeasures.$(ARCH).o      \
+$(SRC)/dbFields.$(ARCH).o               \
+$(SRC)/dbRPN.$(ARCH).o                  \
+$(SRC)/dbStackMath.$(ARCH).o            \
+$(SRC)/dbStackOps.$(ARCH).o             \
 $(SRC)/dvo.$(ARCH).o

trunk/Ohana/src/opihi/dvo/avextract.c

-              r12332
+              r13479
 int avextract (int argc, char **argv) {
   int i, j, m, N, NPTS, param;
+  int i, j, n, m, Npts, NPTS, last, Nfields, Nreturn, Ncstack, Nstack;
   int Nsecfilt, mode;
   char *RegionName, *RegionList, *p;
+  char **cstack;
+  float *values;
   Catalog catalog;
   SkyList *skylist;
   PhotCode *code;
+  Vector *vec;
+  Vector **vec;
+  dbField *fields;
+  dbStack *stack;
   /* defaults */
 …
   Nsecfilt = GetPhotcodeNsecfilt ();
   /* interpret command-line options */
   SetSelectionParam (0);
+  // remove skyregion options
+  // XXX this needs to explicitly handle -qregion and -skyregion
   if (!SetRegionSelection (&argc, argv, &RegionName, &RegionList)) goto escape;
-  if (!SetPhotSelections (&argc, argv, 1)) goto usage;
+  /* interpret required command-line arguments: mextract (value) */
+  if (argc != 2) { goto usage; }
+  param = GetAverageParam (argv[1]);
+  if (param == AVE_ZERO) {
+    if (!GetPhotcodeInfo (argv[1], &code, &mode)) {
+      GetAverageParamHelp ();
+      goto escape;
+    }
+    param = AVE_MAG;
+    for (p = argv[1]; *p != 0; p++) {
+      if (*p == '.') *p = ':';
+    }
+  }
+  if (!TestPhotSelections (&code, &mode, param)) goto escape;
+  // command-line is of the form: avextract field,field, field [where (field op value)...]
+  // parse the fields to be extracted and returned
+  fields = dbCmdlineFields (argc, argv, DVO_TABLE_AVERAGE, &last, &Nfields);
+  if (fields == NULL) return (FALSE);
+  // parse the remainder of the line as a boolean math expression
+  cstack = isolate_elements (argc-last, &argv[last], &Ncstack);
+  // construct the db Boolean math stack (frees cstack)
+  stack = dbRPN (Ncstack, cstack, &Nstack);
+  Nreturn = Nfields;
+  dbCheckStack (stack, Nstack, DVO_TABLE_AVERAGE, &fields, &Nfields);
+  // XXX handle errors
   /* load region corresponding to selection above */
   if ((skylist = SelectRegions (RegionName, RegionList)) == NULL) goto escape;
+  /* create storage vector */
+  N = 0;
+  /* create output storage vectors */
+  ALLOCATE (values, float, Nfields);
+  ALLOCATE (vec, Vector *, Nreturn);
+  for (i = 0; i < Nreturn; i++) {
+    if ((vec[i] = SelectVector (fields[i].name, ANYVECTOR, TRUE)) == NULL) goto escape;
+  }
+  Npts = 0;
   NPTS = 1;
-  if ((vec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) goto escape;
   // XXX need to add interrupt test to this loop
 …
     for (j = 0; j < catalog.Naverage; j++) {
       m = catalog.average[j].offset;
+      vec[0].elements[N] = ExtractAverages (code, mode, &catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], param);
+      N++;
+      CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 2000);
+      // extract the relevant values
+      // XXX for measure values, this could be optimized for one loop over measures...
+      for (n = 0; n < Nfields; n++) {
+        values[n] = dbExtractAverages (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
+      }
+      // test the conditional statement
+      if (!dbBooleanCond (stack, Nstack, values)) continue;
+      for (n = 0; n < Nreturn; n++) {
+        vec[n][0].elements[Npts] = values[n];
+      }
+      Npts++;
+      if (Npts >= NPTS) {
+        NPTS += 2000;
+        for (n = 0; n < Nreturn; n++) {
+          REALLOCATE (vec[n][0].elements, float, NPTS);
+        }
+      }
+    }
     dvo_catalog_free (&catalog);
+  }
+  vec[0].Nelements = N;
+  REALLOCATE (vec[0].elements, float, MAX(1,N));
+  for (n = 0; n < Nreturn; n++) {
+    vec[n][0].Nelements = Npts;
+    REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
+  }
+  // XXX free fields and stack
   SkyListFree (skylist, ((RegionName != NULL) || (RegionList != NULL)));

trunk/Ohana/src/opihi/dvo/catalog.c

-              r12332
+              r13479
   int Ngraph;
+  Ngraph = 0;
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, NULL, NULL)) return (FALSE);
   VarConfig ("GSCDIR", "%s", gscdir);
 …
     PrepPlotting (N, &graphmode);
     PlotVector (N, Xvec.elements);
     PlotVector (N, Yvec.elements);
     PlotVector (N, Zvec.elements);
+    PlotVector (N, Xvec.elements, "x");
+    PlotVector (N, Yvec.elements, "y");
+    PlotVector (N, Zvec.elements, "z");
     free (Xvec.elements);

trunk/Ohana/src/opihi/dvo/cmpload.c

-              r7917
+              r13479
   int i, Noverlay, NOVERLAY, Nstar, N, Nin, Nextra, Objtype, type;
   int doneread, done, Nskip, Nbytes, nbytes, Ninstar;
   char *c, *c2;
+  char *c, *c2, *name;
   double dtmp;
   FILE *f;
   char *buffer;
   int Ximage, Nimage;
+  int kapa;
   Header header;
   KiiOverlay *overlay;
   Nimage = -1;
+  name = NULL;
   if ((N = get_argument (argc, argv, "-n"))) {
     remove_argument (N, &argc, argv);
     Nimage = atof (argv[N]);
+    name = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  if (!GetImage (&Ximage, &Nimage)) return (FALSE);
+  if (!GetImage (NULL, &kapa, name)) return (FALSE);
+  FREE (name);
   Objtype = 0;
 …
   fclose (f);
   KiiLoadOverlay (Ximage, overlay, Noverlay, argv[1]);
+  KiiLoadOverlay (kapa, overlay, Noverlay, argv[1]);
   free (overlay);

trunk/Ohana/src/opihi/dvo/dmt.c

-              r12332
+              r13479
 int dmt (int argc, char **argv) {
   int i, m, k, N, Ngraph, SaveVectors;
+  int i, m, k, N, kapa, SaveVectors;
   int Nsec, Nsecfilt, NPTS;
   double Radius;
 …
+  }
+  Ngraph = 0;
+  if (!GetGraphData (&graphsky, NULL, &Ngraph)) return (FALSE);
+  // XXX this needs to be fixed: how to access different graphs at once?
+  gprint (GP_ERR, "ERROR: this function is currently disabled\n");
+  return (FALSE);
+  if (!GetGraphData (&graphsky, &kapa, NULL)) return (FALSE);
   if (!GetGraph (&graphmode, NULL, NULL)) return (FALSE);
 …
   } else {
     graphmode.style = 2; /* set style to points */
+    PrepPlotting (N, &graphmode);
+    PlotVector (N, Xvec.elements);
+    PlotVector (N, Yvec.elements);
+    PlotVector (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     free (Xvec.elements);

trunk/Ohana/src/opihi/dvo/dvo.c.in

-              r12280
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  QuitImage ();
+  QuitGraph ();
+  QuitKapa ();
   return;
+}

trunk/Ohana/src/opihi/dvo/extract.c

-              r12332
+              r13479
   RegionFile *regions;
+  Ngraph = 0;
+  if (!GetGraphData (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraphData (&graphmode, NULL, NULL)) return (FALSE);
   if (!InitPhotcodes ()) return (FALSE);

trunk/Ohana/src/opihi/dvo/fitcolors.c

-              r12332
+              r13479
   float *out, *colorFit, *deltaFit, dColor, C0, C1;
   float minDelta, maxDelta, minColor, maxColor;
   int fd, Npx, Npy, NPX, NPY, Nplot, PLOT;
+  int kapa, Npx, Npy, NPX, NPY, Nplot, PLOT;
   Graphdata graphdata;
   KapaSection section;
 …
   if (PLOT) {
     if (!GetGraph (&graphdata, &fd, NULL)) return (FALSE);
+    if (!GetGraph (&graphdata, &kapa, NULL)) return (FALSE);
     Nplot = 0;
     Npx = Npy = 0;
 …
     graphdata.style = 2;
     graphdata.ptype = 2;
     KapaClear (fd, TRUE);
     KapaSetFont (fd, "helvetica", 14);
+    KapaClearSections (kapa);
+    KapaSetFont (kapa, "helvetica", 14);
     ALLOCATE (colorFit, float, 11);
 …
           strcpy (graphdata.labels, "1100");
+        }
         KapaSetSection (fd, &section);
         KapaSetLimits (fd, &graphdata);
         KapaBox (fd, &graphdata);
         KapaPrepPlot (fd, Npts, &graphdata);
         KapaPlotVector (fd, Npts, xvec[0].elements);
         KapaPlotVector (fd, Npts, yvec[0].elements);
+        KapaSetSection (kapa, &section);
+        KapaSetLimits (kapa, &graphdata);
+        KapaBox (kapa, &graphdata);
+        KapaPrepPlot (kapa, Npts, &graphdata);
+        KapaPlotVector (kapa, Npts, xvec[0].elements, "x");
+        KapaPlotVector (kapa, Npts, yvec[0].elements, "y");
         for (i = 0; i < 11; i++) {
 …
         graphdata.style = 0;
         graphdata.color = KapaColorByName ("red");
         KapaPrepPlot (fd, 11, &graphdata);
         KapaPlotVector (fd, 11, colorFit);
         KapaPlotVector (fd, 11, deltaFit);
         KapaSetFont (fd, "helvetica", 8);
+        KapaPrepPlot (kapa, 11, &graphdata);
+        KapaPlotVector (kapa, 11, colorFit, "x");
+        KapaPlotVector (kapa, 11, deltaFit, "y");
+        KapaSetFont (kapa, "helvetica", 8);
         sprintf (label, "%s", code[0][0].name);
         KapaSendTextline (fd, label, 0.2*maxColor + 0.8*minColor, 0.8*maxDelta + 0.2*minDelta, 0.0);
+        KapaSendTextline (kapa, label, 0.2*maxColor + 0.8*minColor, 0.8*maxDelta + 0.2*minDelta, 0.0);
         sprintf (label, "%s", code[1][0].name);
         KapaSendTextline (fd, label, 0.2*maxColor + 0.8*minColor, 0.2*maxDelta + 0.8*minDelta, 0.0);
         KapaSetFont (fd, "helvetica", 14);
+        KapaSendTextline (kapa, label, 0.2*maxColor + 0.8*minColor, 0.2*maxDelta + 0.8*minDelta, 0.0);
+        KapaSetFont (kapa, "helvetica", 14);
         graphdata.style = 2;
 …
             Npy = 0;
             sprintf (filename, "%s.%02d.png", plotname, Nplot);
             KapaPNG (fd, filename);
             KapaClear (fd, TRUE);
+            KapaPNG (kapa, filename);
+            KapaClearSections (kapa);
             Nplot++;
+          }

trunk/Ohana/src/opihi/dvo/fitsed.c

-              r12332
+              r13479
   float *fitmags, *fiterrs, *wavecode, *vegaToAB;
   float color;
   double X, Y;
   int fd, PLOT;
+  double X, Y, ZP, RA, DEC;
+  int kapa, PLOT;
   int Nrow, NROW, idx, Nfilter, start, row;
   unsigned short colorP, colorM, code, USNOred, USNOblu;
 …
   if (PLOT) {
     if (!GetGraph (&graphdata, &fd, NULL)) return (FALSE);
+    if (!GetGraph (&graphdata, &kapa, NULL)) return (FALSE);
     SetLimitsRaw (wavecode, NULL, Nfilter, &graphdata);
     graphdata.style = 2;
     graphdata.ptype = 2;
     KapaClear (fd, TRUE);
+    KapaClearSections (kapa);
     magSection.name = strcreate ("mag");
     magSection.x  = 0;
 …
     resSection.dy = 0.5;
     KapaSetFont (fd, "helvetica", 14);
+    KapaSetFont (kapa, "helvetica", 14);
     ALLOCATE (fitmags, float, Nfilter);
     ALLOCATE (fiterrs, float, Nfilter);
 …
         SWAP (graphdata.ymin, graphdata.ymax);
         KapaClear (fd, TRUE);
         KapaSetSection (fd, &magSection);
         KapaSetLimits (fd, &graphdata);
         KapaBox (fd, &graphdata);
+        KapaClearSections (kapa);
+        KapaSetSection (kapa, &magSection);
+        KapaSetLimits (kapa, &graphdata);
+        KapaBox (kapa, &graphdata);
         graphdata.color = KapaColorByName ("blue");
         graphdata.etype = 0;
         KapaPrepPlot (fd, Nfilter, &graphdata);
         KapaPlotVector (fd, Nfilter, wavecode);
         KapaPlotVector (fd, Nfilter, SEDtable[minFit.row][0].mags);
+        KapaPrepPlot (kapa, Nfilter, &graphdata);
+        KapaPlotVector (kapa, Nfilter, wavecode, "x");
+        KapaPlotVector (kapa, Nfilter, SEDtable[minFit.row][0].mags, "y");
         graphdata.color = KapaColorByName ("red");
         graphdata.etype = 1;
 …
           fiterrs[j] = sourceError.mags[j];
+        }
         KapaPrepPlot (fd, Nfilter, &graphdata);
         KapaPlotVector (fd, Nfilter, wavecode);
         KapaPlotVector (fd, Nfilter, fitmags);
         KapaPlotVector (fd, Nfilter, fiterrs);
         KapaPlotVector (fd, Nfilter, fiterrs);
         KapaSendLabel (fd, "model,fit (mags)", 1);
+        KapaPrepPlot (kapa, Nfilter, &graphdata);
+        KapaPlotVector (kapa, Nfilter, wavecode, "x");
+        KapaPlotVector (kapa, Nfilter, fitmags, "y");
+        KapaPlotVector (kapa, Nfilter, fiterrs, "dym");
+        KapaPlotVector (kapa, Nfilter, fiterrs, "dyp");
+        KapaSendLabel (kapa, "model,fit (mags)", 1);
         sprintf (line, "star: %10.6f %10.6f  T: %5.0fK  A_V|: %4.2f  M_D|: %5.2f  &sc&h^2|: %5.2f",
                  catalog.average[i].R, catalog.average[i].D,
                  SEDtable[minFit.row][0].Temp, SEDtable[minFit.row][0].Av, minFit.Md, minFit.chisq);
         KapaSendLabel (fd, line, 2);
         KapaSendLabel (fd, "model,fit (mags)", 1);
         KapaSetSection (fd, &resSection);
+        KapaSendLabel (kapa, line, 2);
+        KapaSendLabel (kapa, "model,fit (mags)", 1);
+        KapaSetSection (kapa, &resSection);
         graphdata.ymin = -1.0;
         graphdata.ymax = +1.0;
         KapaSetLimits (fd, &graphdata);
         KapaBox (fd, &graphdata);
+        KapaSetLimits (kapa, &graphdata);
+        KapaBox (kapa, &graphdata);
         graphdata.color = KapaColorByName ("red");
         graphdata.etype = 1;
 …
           fiterrs[j] = sourceError.mags[j];
+        }
         KapaPrepPlot (fd, Nfilter, &graphdata);
         KapaPlotVector (fd, Nfilter, wavecode);
         KapaPlotVector (fd, Nfilter, fitmags);
         KapaPlotVector (fd, Nfilter, fiterrs);
         KapaPlotVector (fd, Nfilter, fiterrs);
         KapaSendLabel (fd, "wavelength (nm)", 0);
         KapaSendLabel (fd, "resid (mags)", 1);
         KiiCursorOn (fd);
         while (KiiCursorRead (fd, &X, &Y, key)) {
+        KapaPrepPlot (kapa, Nfilter, &graphdata);
+        KapaPlotVector (kapa, Nfilter, wavecode, "x");
+        KapaPlotVector (kapa, Nfilter, fitmags, "y");
+        KapaPlotVector (kapa, Nfilter, fiterrs, "dym");
+        KapaPlotVector (kapa, Nfilter, fiterrs, "dyp");
+        KapaSendLabel (kapa, "wavelength (nm)", 0);
+        KapaSendLabel (kapa, "resid (mags)", 1);
+        KiiCursorOn (kapa);
+        while (KiiCursorRead (kapa, &X, &Y, &ZP, &RA, &DEC, key)) {
           gprint (GP_ERR, "window: %f %f (%s)\n", X, Y, key);
           if (!strcasecmp (key, "Q")) {
             KiiCursorOff (fd);
+            KiiCursorOff (kapa);
             break;
+          }
           if (!strcasecmp (key, "ESCAPE")) {
             KiiCursorOff (fd);
+            KiiCursorOff (kapa);
             goto escape;
+          }

trunk/Ohana/src/opihi/dvo/images.c

-              r12753
+              r13479
   int WITH_MOSAIC, SOLO_MOSAIC, HIDDEN;
   time_t tzero, tend;
   int N, NPTS, n, npts, Npts;
+  int N, NPTS, n, npts, Npts, kapa;
   Vector Xvec, Yvec;
   double r[8], d[8], x[8], y[8], Rmin, Rmax, Rmid, trange, Radius;
 …
   int typehash;
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   WITH_MOSAIC = FALSE;
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   /* it is not an error for the database not to have any images */
 …
     graphmode.ptype = 100; /* connect pairs of points */
     graphmode.etype = 0;
+    PrepPlotting (N, &graphmode);
+    PlotVector (N, Xvec.elements);
+    PlotVector (N, Yvec.elements);
+    PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
+  }

trunk/Ohana/src/opihi/dvo/imbox.c

-              r12332
+              r13479
 int imbox (int argc, char **argv) {
   int j, Nskip, status, InPic, flipped;
+  int j, kapa, Nskip, status, InPic, flipped;
   Vector Xvec, Yvec;
   double r, d, x[4], y[4], Rmin, Rmax, Rmid;
 …
   FILE *f;
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 2) {
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   f = fopen (argv[1], "r");
 …
       graphmode.ptype = 100; /* connect pairs of points */
       graphmode.etype = 0;
+      PrepPlotting (8, &graphmode);
+      PlotVector (8, Xvec.elements);
+      PlotVector (8, Yvec.elements);
+      PlotVectorPair (kapa, 8, Xvec.elements, Yvec.elements, &graphmode);
+    }
   skip:

trunk/Ohana/src/opihi/dvo/imdense.c

-              r7917
+              r13479
   long A, B;
   int i, N, Nimage, status, NPTS, Ngraph;
+  int i, kapa, N, Nimage, status, NPTS;
   double r, d, x, y, Rmin, Rmax;
   Vector Xvec, Yvec;
   Image *image;
   Graphdata graphmode;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   /* need options to list only images in region and only images in a time range */
 …
     return (FALSE);
+  }
-  Ngraph = 0;
-  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
   if ((image = LoadImages (&Nimage)) == NULL) return (FALSE);
 …
     graphmode.style = 2; /* points */
     graphmode.etype = 0;
+    PrepPlotting (N, &graphmode);
+    PlotVector (N, Xvec.elements);
+    PlotVector (N, Yvec.elements);
+    PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
+  }

trunk/Ohana/src/opihi/dvo/imextract.c

-              r12729
+              r13479
 int imextract (int argc, char **argv) {
   int i, j, Nimage, mode, N, Ngraph, PhotcodeSelect;
+  int i, j, Nimage, mode, N, PhotcodeSelect;
   int TimeSelect, RegionSelect, *subset, Nsubset, TimeFormat, FlagSelect, FlagValue;
   double x, y, ra, dec, t, trange;
 …
   Vector *vec;
+  Ngraph = 0;
+  if (!GetGraphData (&graphsky, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraphData (&graphsky, NULL, NULL)) return (FALSE);
   if (!InitPhotcodes ()) return (FALSE);

trunk/Ohana/src/opihi/dvo/imlist.c

-              r12332
+              r13479
   double r, d, trange, t;
   char *name;
-  int Ngraph;
   Image *image;
   Graphdata graphmode;
   PhotCode *PhotcodeValue;
+  Ngraph = 0;
+  if (!GetGraphData (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraphData (&graphmode, NULL, NULL)) return (FALSE);
   TimeSelect = FALSE;

trunk/Ohana/src/opihi/dvo/imstats.c

-              r12332
+              r13479
 int imstats (int argc, char **argv) {
   int i, Nimage, N;
   int Mcal, AutoLimits, Ngraph;
+  int i, kapa, Nimage, N;
+  int Mcal, AutoLimits;
   double r, d;
   Image *image;
 …
   Graphdata graphmode;
+  Ngraph = -1;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    Ngraph = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return (FALSE);
   Mcal = TRUE;
 …
   graphmode.style = 2;
   graphmode.etype = 0;
+  PrepPlotting (Nimage, &graphmode);
+  PlotVector (Nimage, Xvec.elements);
+  PlotVector (Nimage, Yvec.elements);
+  PlotVectorPair (kapa, Nimage, Xvec.elements, Yvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/dvo/lcat.c

-              r7917
+              r13479
   struct stat filestat;
   Graphdata graphmode;
-  int Ngraph;
   SkyTable *sky;
   SkyList *skylist;
+  Ngraph = 0;
+  if (!GetGraphData (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraphData (&graphmode, NULL, NULL)) return (FALSE);
   ShowAll = FALSE;

trunk/Ohana/src/opihi/dvo/lcurve.c

-              r12332
+              r13479
   double Ra, Dec, Radius, Radius2, r;
   float *RA, *DEC;
   int Ngraph, Xgraph, TimeFormat;
+  int kapa, TimeFormat;
   int Nstars, found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
   int i, j, m, N, NPTS, *N1;
 …
   if (!InitPhotcodes ()) return (FALSE);
+  Ngraph = -1;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    Ngraph = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!GetGraph (&graphmode, &Xgraph, &Ngraph)) return (FALSE);
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return (FALSE);
   AutoLimits = FALSE;
 …
     graphmode.etype = 0;
   PrepPlotting (N, &graphmode);
   PlotVector (N, Xvec.elements);
   PlotVector (N, Yvec.elements);
+  KapaPrepPlot (kapa, N, &graphmode);
+  KapaPlotVector (kapa, N, Xvec.elements, "x");
+  KapaPlotVector (kapa, N, Yvec.elements, "y");
   if (ErrorBars) {
     PlotVector (N, dYvec.elements);
     PlotVector (N, dYvec.elements);
+    KapaPlotVector (kapa, N, dYvec.elements, "dym");
+    KapaPlotVector (kapa, N, dYvec.elements, "dyp");
+  }
 …
            timeptr[0].tm_year, timeptr[0].tm_mon+1, timeptr[0].tm_mday);
   free (p);
   KapaSendLabel (Xgraph, string, 0);
+  KapaSendLabel (kapa, string, 0);
   free (RA);

trunk/Ohana/src/opihi/dvo/mextract.c

-              r12332
+              r13479
 int mextract (int argc, char **argv) {
   int i, j, k, m, N, N1, NPTS;
+  int i, j, k, m, n, N, N1, Npts, NPTS, last, Nfields, Nreturn, Ncstack, Nstack;
   int param, mode, Nsecfilt;
   char *RegionName, *RegionList, *p;
   double *M1;
+  char **cstack;
+  float *values;
-  PhotCode *code;
   Catalog catalog;
   SkyList *skylist;
+  Vector *vec;
+  PhotCode *code;
+  Vector **vec;
+  dbField *fields;
+  dbStack *stack;
   /* defaults */
 …
   if (!InitPhotcodes ()) goto escape;
   Nsecfilt = GetPhotcodeNsecfilt ();
+  // init locally static variables (time refs)
+  dbExtractMeasuresInit();
   /* interpret command-line options */
   SetSelectionParam (0);
+  // remove skyregion options
+  // XXX this needs to explicitly handle -qregion and -skyregion
   if (!SetRegionSelection (&argc, argv, &RegionName, &RegionList)) goto escape;
-  if (!SetPhotSelections (&argc, argv, 1)) goto usage;
+  /* interpret required command-line arguments: mextract (value) */
+  if (argc != 2) goto usage;
+  param = GetMeasureParam (argv[1]);
+  if (param == MEAS_ZERO) {
+    if (!GetPhotcodeInfo (argv[1], &code, &mode)) {
+      GetMeasureParam ("help");
+      goto escape;
+    }
+    param = MEAS_MAG;
+    for (p = argv[1]; *p != 0; p++) {
+      if (*p == '.') *p = ':';
+    }
+  }
+  if (!TestPhotSelections (&code, &mode, MEAS_ZERO)) goto escape;
+  // command-line is of the form: avextract field,field, field [where (field op value)...]
+  // parse the fields to be extracted and returned
+  fields = dbCmdlineFields (argc, argv, DVO_TABLE_MEASURE, &last, &Nfields);
+  if (fields == NULL) return (FALSE);
+  // parse the remainder of the line as a boolean math expression
+  cstack = isolate_elements (argc-last, &argv[last], &Ncstack);
+  // construct the db Boolean math stack (frees cstack)
+  stack = dbRPN (Ncstack, cstack, &Nstack);
+  Nreturn = Nfields;
+  dbCheckStack (stack, Nstack, DVO_TABLE_MEASURE, &fields, &Nfields);
+  // XXX handle errors
   /* load region corresponding to selection above */
   if ((skylist = SelectRegions (RegionName, RegionList)) == NULL) goto escape;
+  if (!SetImageSelection (param, ((RegionName == NULL) && (RegionList == NULL)))) goto escape;
+  // XXX is this still needed?
+  // if (!SetImageSelection (param, ((RegionName == NULL) && (RegionList == NULL)))) goto escape;
   /* create storage vector */
+  N = 0;
+  ALLOCATE (values, float, Nfields);
+  ALLOCATE (vec, Vector *, Nreturn);
+  for (i = 0; i < Nreturn; i++) {
+    if ((vec[i] = SelectVector (fields[i].name, ANYVECTOR, TRUE)) == NULL) goto escape;
+  }
+  Npts = 0;
   NPTS = 1;
-  if ((vec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) goto escape;
+  // XXX need to add interrupt test to this loop
   for (i = 0; i < skylist[0].Nregions; i++) {
+    /* lock, load, unlock catalog */
     catalog.filename = skylist[0].filename[i];
     catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_SECF;
 …
     for (j = 0; j < catalog.Naverage; j++) {
-      M1 = NULL;
       m = catalog.average[j].offset;
+      M1 = ExtractMeasures (code, mode, &catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &N1, param);
+      for (k = 0; k < N1; k++) {
+        vec[0].elements[N] = M1[k];
+        N++;
+        CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 2000);
+      for (k = 0; k < catalog.average[j].Nm; k++, m++) {
+        // extract the relevant values for this measurement
+        for (n = 0; n < Nfields; n++) {
+          values[n] = dbExtractMeasures (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
+        }
+        // test the conditional statement
+        if (!dbBooleanCond (stack, Nstack, values)) continue;
+        for (n = 0; n < Nreturn; n++) {
+          vec[n][0].elements[Npts] = values[n];
+        }
+        Npts++;
+        if (Npts >= NPTS) {
+          NPTS += 2000;
+          for (n = 0; n < Nreturn; n++) {
+            REALLOCATE (vec[n][0].elements, float, NPTS);
+          }
+        }
+      }
-      if (M1 != NULL) free (M1);
+    }
     dvo_catalog_free (&catalog);
+  }
+  vec[0].Nelements = N;
+  REALLOCATE (vec[0].elements, float, MAX(1,N));
+  for (n = 0; n < Nreturn; n++) {
+    vec[n][0].Nelements = Npts;
+    REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
+  }
+  // XXX free fields and stack
   FreeImageSelection ();

trunk/Ohana/src/opihi/dvo/paverage.c

-              r12332
+              r13479
   FILE *f;
   int i, j, Narg, Npts, NPTS, status, VERBOSE;
+  int i, j, kapa, Narg, Npts, NPTS, status, VERBOSE;
   int Nsecfilt, Nsec;
   double Mz, Mr, mag;
 …
   Nsecfilt = GetPhotcodeNsecfilt ();
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   f = (FILE *) NULL;
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   graphmode.style = 2; /* set style to points */
   graphmode.size = -1; /* point size determined by Zvec */
 …
+      }
       if (Npts > NCHUNK) {
           PlotVectorTriplet (Npts, Xvec, Yvec, Zvec, &graphmode);
+          PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
           Npts = 0;
+      }
 …
     dvo_catalog_free (&catalog);
+  }
   if (Npts > 0) PlotVectorTriplet (Npts, Xvec, Yvec, Zvec, &graphmode);
+  if (Npts > 0) PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
   free (Xvec);

trunk/Ohana/src/opihi/dvo/pcat.c

-              r7917
+              r13479
   double Radius;
   int i, j, N, Nregions, ShowAll, NPTS, Npts, leftside;
+  int i, j, kapa, N, Nregions, ShowAll, NPTS, Npts, leftside;
   RegionFile *regions;
   char filename[128];
 …
   double X[4], Y[4], Rmin, Rmax, Rmid;
   char catdir[256];
   int Ngraph, VERBOSE;
+  int VERBOSE;
   VarConfig ("CATDIR", "%s", catdir);
 …
     return (FALSE);
+  }
+  Ngraph = 0;
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, NULL)) return (FALSE);
   Radius = MAX (fabs(graphmode.xmax), fabs(graphmode.ymax));
 …
     graphmode.ptype = 100; /* connect pairs of points */
     graphmode.etype = 0;
+    PrepPlotting (Npts, &graphmode);
+    PlotVector (Npts, Xvec.elements);
+    PlotVector (Npts, Yvec.elements);
+    PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
+  }

trunk/Ohana/src/opihi/dvo/photometry.c

-              r12730
+              r13479
+}
+// XXX moved to dbFields
+# if (0)
 int GetMagMode (char *string) {
 …
   return (mode);
+}
+# endif
 int GetMeasureParam (char *parname) {

trunk/Ohana/src/opihi/dvo/pmeasure.c

-              r12332
+              r13479
   FILE *f;
   int i, j, k, m, Narg, Npts, NPTS, status, VERBOSE;
+  int i, j, k, m, kapa, Narg, Npts, NPTS, status, VERBOSE;
   double Mz, Mr, mag;
   double Radius, Rmin, Rmax, R, D;
 …
   if (!InitPhotcodes ()) return (FALSE);
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   f = (FILE *) NULL;
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   graphmode.style = 2; /* set style to points */
   graphmode.size = -1; /* point size determined by Zvec */
 …
+        }
         if (Npts > NCHUNK) {
             PlotVectorTriplet (Npts, Xvec, Yvec, Zvec, &graphmode);
+            PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
             Npts = 0;
+        }
 …
     dvo_catalog_free (&catalog);
+  }
   if (Npts > 0) PlotVectorTriplet (Npts, Xvec, Yvec, Zvec, &graphmode);
+  if (Npts > 0) PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
   free (Xvec);

trunk/Ohana/src/opihi/dvo/procks.c

-              r7917
+              r13479
   FILE *f;
   Vector Xvec, Yvec;
   int i, j, N, NROCKS;
+  int kapa, i, j, N, NROCKS;
   int N0, N1, SpeedClip, Reload;
   unsigned int t0, t1;
 …
   Graphdata graphmode;
   char rockcat[256];
-  int Ngraph;
-  Ngraph = 0;
   VarConfig ("ROCK_CATALOG", "%s", rockcat);
   if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, NULL)) return (FALSE);
   f = (FILE *) NULL;
 …
   graphmode.style = 2; /* set style to points */
   graphmode.etype = 0; /* no errorbars */
+  PrepPlotting (N, &graphmode);
+  PlotVector (N, Xvec.elements);
+  PlotVector (N, Yvec.elements);
+  PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
   /* now plot vectors between two extrema */
 …
   graphmode.ptype = 100; /* connect pairs */
   graphmode.etype = 0; /* no errorbars */
+  PrepPlotting (N, &graphmode);
+  PlotVector (N, Xvec.elements);
+  PlotVector (N, Yvec.elements);
+  PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/dvo/region_list.c

-              r7917
+              r13479
   double Radius;
-  int Ngraph;
   Graphdata graphsky;
   SkyList *skylist;
 …
+  }
+  Ngraph = 0;
+  if (!GetGraphData (&graphsky, NULL, &Ngraph)) {
+  if (!GetGraphData (&graphsky, NULL, NULL)) {
     gprint (GP_ERR, "region display not available\n");
     return (NULL);

trunk/Ohana/src/opihi/dvo/scripts/navigate

-              r10847
+              r13479
   $KEY = "none"
   while ("$KEY" != "q")
     cursor -g 1
+    cursor 1
     # help list
 …
       $ok = $KEY
       echo "type 'd' again at endpoint"
       cursor -g 1
+      cursor 1
       $r1 = $R$KEY
       $d1 = $D$KEY
 …
       $ok = $KEY
       echo "type 'z' again at radius"
       cursor -g 1
+      cursor 1
       $r1 = $R$KEY
       $d1 = $D$KEY
 …
     if ("$KEY" == "p")
       echo "P - new coords; p - old coords"
       cursor -g 1
+      cursor 1
       exec echo $Rp $Dp $RP $DP >> fix.coords
     end

trunk/Ohana/src/opihi/dvo/showtile.c

-              r7917
+              r13479
 int showtile (int argc, char **argv) {
   int Nd, N, NPTS, Ngraph, status, i, InPic;
+  int kapa, Nd, N, NPTS, status, i, InPic;
   Graphdata graphmode;
   Coords coords;
 …
   /* show tile pattern in viewed region */
+  Ngraph = 0;
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, NULL)) return (FALSE);
   if (argc != 1) {
 …
     graphmode.ptype = 100; /* connect pairs of points */
     graphmode.etype = 0;
+    PrepPlotting (N, &graphmode);
+    PlotVector (N, Xvec.elements);
+    PlotVector (N, Yvec.elements);
+    PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
+  }

trunk/Ohana/src/opihi/dvo/simage.c

-              r7917
+              r13479
   Header header;
   Coords coords;
   int i, j, Nstars, nstars, Nbytes, nbytes, Npts, N;
+  int i, j, kapa, Nstars, nstars, Nbytes, nbytes, Npts, N;
   Graphdata graphmode;
-  int Ngraph;
+  Ngraph = 0;
+  if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (&graphmode, &kapa, NULL)) return (FALSE);
   zero = 17.0;
 …
   graphmode.etype = 0;
   Npts = Xvec.Nelements;
-  PrepPlotting (Npts, &graphmode);
+  PlotVector (Npts, Xvec.elements);
+  PlotVector (Npts, Yvec.elements);
+  PlotVector (Npts, Zvec.elements);
+  PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
   free (Xvec.elements);

trunk/Ohana/src/opihi/dvo/skycat.c

-              r8328
+              r13479
   double Radius;
   int i, j, N, Nregions, ShowAll, NPTS, Npts, leftside, Depth, VERBOSE;
+  int i, j, N, Nregions, kapa, ShowAll, NPTS, Npts, leftside, Depth, VERBOSE;
   struct stat filestat;
   Vector Xvec, Yvec;
 …
+  }
   if (!style_args (&graphmode, &argc, argv, 0)) return FALSE;
+  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
   if (argc != 1) {
 …
     return (FALSE);
+  }
-  SetGraph (graphmode);
   Radius = MAX (fabs(graphmode.xmax), fabs(graphmode.ymax));
 …
     graphmode.ptype = 100; /* connect pairs of points */
     graphmode.etype = 0;
+    PrepPlotting (Npts, &graphmode);
+    PlotVector (Npts, Xvec.elements);
+    PlotVector (Npts, Yvec.elements);
+    PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
+  }

trunk/Ohana/src/opihi/include/data.h

r11007	r13479
162	162	void SetLimitsRaw PROTO((float xvec, float yvec, int Npts, Graphdata *graphmode));
163	163	void ApplyLimits PROTO((int Xgraph, Graphdata *graphmode, int apply));
164		int style_args PROTO((Graphdata graphmode, int argc, char **argv, int ~~Nforce~~));
	164	int style_args PROTO((Graphdata graphmode, int argc, char *argv, int kapa));
165	165
166	166	int read_table_vectors (int argc, char *argv, char extname);

trunk/Ohana/src/opihi/include/display.h

-              r12332
+              r13479
 # define DISPLAY_H
+# if (0)
+typedef struct {
+  double xmin, xmax, ymin, ymax;
+  int style, ptype, ltype, etype, ebar, color;
+  double lweight, size;
+  Coords coords;
+  int flipeast, flipnorth;
+  char axis[8], labels[8], ticks[8];
+} Graphdata;
+# endif
+/*** kapa graph functions ***/
+int           PlotVectorPair        PROTO((int kapa, int Npts, float *xValues, float *yValues, Graphdata *graphmode));
+int           PlotVectorTriplet     PROTO((int kapa, int Npts, float *xValues, float *yValues, float *zValues, Graphdata *graphmode));
+int           GetGraphData          PROTO((Graphdata *data, int *kapa, char *name));
+int           GetGraph              PROTO((Graphdata *data, int *kapa, char *name));
+int           SetGraph              PROTO((Graphdata *data));
+/*** plotting functions ***/
+int           GetCurrentDevice      PROTO((void));
+int           PrepPlotting          PROTO((int Npts, Graphdata *graphmode));
+int           PlotVector            PROTO((int, float *));
+int           PlotVectorTriplet     PROTO((int N, float *xValues, float *yValues, float *zValues, Graphdata *graphmode));
+int           GetGraphData          PROTO((Graphdata *data, int *sock, int *N));
+int           GetGraph              PROTO((Graphdata *data, int *socket, int *N));
+void          InitGraph             PROTO((void));
+int           open_graph            PROTO((int N));
+int           close_graph           PROTO((int N));
+void          QuitGraph             PROTO((void));
+void          SetGraph              PROTO((Graphdata data));
+void          XGraphDead            PROTO((int input));
+int           GetColor              PROTO((char *name));
+/*** kapa image functions */
+int           GetImageData          PROTO((KapaImageData *data, int *kapa, char *name));
+int           GetImage              PROTO((KapaImageData *data, int *kapa, char *name));
+int           SetImage              PROTO((KapaImageData *data));
+/* image (tv) functions */
+int           GetImage              PROTO((int *socket, int *N));
+char         *GetImageName          PROTO((void));
+void          GetImageScale         PROTO((double *zero, double *range));
+void          InitImage             PROTO((void));
+int           open_image            PROTO((int N));
+int           close_image           PROTO((int N));
+void          QuitImage             PROTO((void));
+void          SetImageDevice        PROTO((int state));
+void          SetImageName          PROTO((char *name));
+void          SetImageScale         PROTO((double zero, double range));
+void          XImageDead            PROTO((int input));
+int           SelectOverlay         PROTO((char *name, int *number));
+void          QuitKapa              PROTO(());
+void          InitKapa              PROTO(());
+int           open_kapa             PROTO((int entry));
+int           close_kapa            PROTO((char *name));
+int           AddKapaDevice         PROTO((char *name));
+int           DelKapaDevice         PROTO((char *name));
+int           FindKapaDevice        PROTO((char *name));
+char         *GetKapaName           PROTO(());
 /* calling program need to define a function 'get_variable' which

trunk/Ohana/src/opihi/include/dvoshell.h

-              r7960
+              r13479
 /* magnitude types */
 enum {MAG_NONE, MAG_INST, MAG_CAT, MAG_SYS, MAG_REL, MAG_CAL, MAG_AVE, MAG_REF};
+enum {MAG_NONE, MAG_INST, MAG_CAT, MAG_SYS, MAG_REL, MAG_CAL, MAG_AVE, MAG_REF, MAG_ERR, MAG_CHISQ};
 /* measure params */
+/* measure fields */
 enum {MEAS_ZERO, MEAS_RA, MEAS_DEC, MEAS_MAG, MEAS_dMAG, MEAS_MINST, MEAS_MCAT,
       MEAS_MSYS, MEAS_MREL, MEAS_MCAL, MEAS_PHOTCODE, MEAS_TIME, MEAS_dR, MEAS_dD,
       MEAS_FWHM, MEAS_DOPHOT, MEAS_XCCD, MEAS_YCCD, MEAS_XMOSAIC, MEAS_YMOSAIC, MEAS_FLAGS, MEAS_EXPTIME, MEAS_AIRMASS};
 /* average params */
+/* average fields */
 enum {AVE_ZERO, AVE_RA, AVE_DEC, AVE_RA_ERR, AVE_DEC_ERR, AVE_U_RA, AVE_U_DEC,
       AVE_U_RA_ERR, AVE_U_DEC_ERR, AVE_PAR, AVE_PAR_ERR, AVE_MAG, AVE_REF, AVE_dMAG,
       AVE_Xm, AVE_Xp, AVE_NMEAS, AVE_NMISS, AVE_TYPE, AVE_NPHOT, AVE_NCODE, AVE_NCRIT,
       AVE_FLAG, AVE_TYPEFRAC};
+enum {DVO_TABLE_AVERAGE, DVO_TABLE_MEASURE};
+// a single db field
+typedef struct {
+  char *name;
+  int extract;
+  int table;
+  int ID;
+  int magMode;
+  PhotCode *photcode;
+} dbField;
+// db boolean operations
+typedef struct {
+  char   *name;
+  char    type;
+  int     field;
+  float   Float;
+} dbStack;
 typedef struct {
 …
 int           RD_to_XYpic           PROTO((double *x, double *y, double r, double d, Coords *coords, double Rmin, double Rmax, double Rmid, int *leftside));
+// dvo DB field functions
+dbField     *dbCmdlineFields        PROTO((int argc, char **argv, int table, int *last, int *nfields));
+dbStack     *dbRPN                  PROTO((int argc, char **argv, int *nstack));
+int          dbCheckStack           PROTO((dbStack *stack, int Nstack, int table, dbField **inFields, int *Nfields));
+int          dbBooleanCond          PROTO((dbStack *inStack, int NinStack, float *fields));
+void         dbInitStack            PROTO((dbStack *stack));
+void         dbFreeStack            PROTO((dbStack *stack, int Nstack));
+void         dbFreeEntry            PROTO((dbStack *stack));
+dbStack     *dbBinary               PROTO((dbStack *V1, dbStack *V2, char *op, float *fields));
+dbStack     *dbUnary                PROTO((dbStack *V1, char *op, float *fields));
+int          GetMagMode             PROTO((char *string));
+PhotCode    *ParsePhotcodeField     PROTO((char *field, int *mode, int def));
+int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
+int          ParseAverageField      PROTO((dbField *field, char *fieldName));
+double       dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
+double       dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
+void         dbExtractMeasuresInit  PROTO(());
 # endif

trunk/Ohana/src/opihi/lib.data/Makefile

-              r12879
+              r13479
 $(SDIR)/gaussian.$(ARCH).o              \
 $(SDIR)/graphtools.$(ARCH).o            \
-$(SDIR)/open_graph.$(ARCH).o            \
-$(SDIR)/open_image.$(ARCH).o            \
 $(SDIR)/queues.$(ARCH).o                \
 $(SDIR)/PlotVectors.$(ARCH).o           \
+$(SDIR)/open_kapa.$(ARCH).o             \
 $(SDIR)/style_args.$(ARCH).o
+#$(SDIR)/open_graph.$(ARCH).o            \
+#$(SDIR)/open_image.$(ARCH).o            \
 # dependancy rules for include files ########################

trunk/Ohana/src/opihi/lib.data/PlotVectors.c

-              r10795
+              r13479
 # include "display.h"
+static int Xgraph;
+int PlotVectorPair (int kapa, int Npts, float *xValues, float *yValues, Graphdata *graphmode) {
+int PrepPlotting (int Npts, Graphdata *graphmode) {
+  KapaPrepPlot (kapa, Npts, graphmode);
+  KapaPlotVector (kapa, Npts, xValues, "x");
+  KapaPlotVector (kapa, Npts, yValues, "y");
-  if (!GetGraph (NULL, &Xgraph, NULL)) return (FALSE);
-  /* tell kapa to look for the incoming image */
-  KiiSendCommand (Xgraph, 4, "PLOT");
-  /* send Xgraph the plot details */
-  KiiSendMessage (Xgraph, "%8d %8d %d %d %d %d %d %f %f",
-                  Npts, graphmode[0].style,
-                  graphmode[0].ptype, graphmode[0].ltype,
-                  graphmode[0].etype, graphmode[0].ebar, graphmode[0].color,
-                  graphmode[0].lweight, graphmode[0].size);
-  KiiSendMessage (Xgraph, "%g %g %g %g",
-                  graphmode[0].xmin, graphmode[0].xmax,
-                  graphmode[0].ymin, graphmode[0].ymax);
   return (TRUE);
+}
 int PlotVector (int Npts, float *values) {
+int PlotVectorTriplet (int kapa, int Npts, float *xValues, float *yValues, float *zValues, Graphdata *graphmode) {
+  int Nbytes;
+  KapaPrepPlot   (kapa, Npts, graphmode);
+  KapaPlotVector (kapa, Npts, xValues, "x");
+  KapaPlotVector (kapa, Npts, yValues, "y");
+  KapaPlotVector (kapa, Npts, zValues, "z");
-  Nbytes = Npts * sizeof (float);
-  write (Xgraph, values, Nbytes);
   return (TRUE);
+}
-int PlotVectorPair (int N, float *xValues, float *yValues, Graphdata *graphmode) {
-    PrepPlotting (N, graphmode);
-    PlotVector (N, xValues);
-    PlotVector (N, yValues);
-    return (TRUE);
+}
-int PlotVectorTriplet (int N, float *xValues, float *yValues, float *zValues, Graphdata *graphmode) {
-    PrepPlotting (N, graphmode);
-    PlotVector (N, xValues);
-    PlotVector (N, yValues);
-    PlotVector (N, zValues);
-    return (TRUE);
+}
-/* we don't use GetGraph in PlotVector because it flushes the connection */

trunk/Ohana/src/opihi/lib.data/graphtools.c

-              r7680
+              r13479
     graphmode[0].ymax = maxY + 0.05*range;
+  }
   SetGraph (graphmode[0]);
+  SetGraph (graphmode);
   set_variable ("XMIN", graphmode[0].xmin);
 …
     graphmode[0].ymax = maxY + 0.05*range;
+  }
   SetGraph (graphmode[0]);
+  SetGraph (graphmode);
   set_variable ("XMIN", graphmode[0].xmin);

trunk/Ohana/src/opihi/lib.data/open_image.c

-              r7938
+              r13479
   return (Ximbuffer[Active]);
+}
+// leave this information on kapa, request when needed?
 void SetImageScale (double zero, double range) {
   Xzero[Active] = zero;

trunk/Ohana/src/opihi/lib.data/open_kapa.c

-              r13344
+              r13479
 # include "display.h"
 # include "shell.h"
+# include <assert.h>
 /* kapa support for the new version of kapa (v2.0), which has both graph and image
 …
 /* list of available socket connections */
 static int        Active;        // currently active socket (not device)
+static int        Active;        // currently active socket entry (index value, not socket value)
 static int       *Socket = NULL; // list of available sockets
 static int       *Device = NULL; // list of device numbers for each socked
 static int       Nsocket = 0;    // number of available sockets / devices
+static char     **Device = NULL; // list of device names for each socket
+static int       Ndevice = 0;    // number of available sockets / devices
 void InitKapa () {
+  Active  = -1;               // -1 is the INVALID entry
+  Nsocket = 0;                // number of defined sockets
+  ALLOCATE (Device, int, 1);
+  ALLOCATE (Socket, int, 1);
+  Device[Active] = 0;
+  Socket[Active] = 0;
+}
+// returns the number of the requested device, or -1 if not found
+int FindKapaDevice (int thisDevice) {
+  Active  = -1;                                   // -1 is the INVALID entry
+  Ndevice = 0;                                    // number of defined sockets
+  ALLOCATE (Device, char *, 1);                   // for future REALLOCATE calls
+  ALLOCATE (Socket, int, 1);                      // for future REALLOCATE calls
+}
+// add new device name if not found
+int AddKapaDevice (char *name) {
+  int N;
+  N = FindKapaDevice (name);
+  if (N != -1) return (N);
+  N = Ndevice;
+  Ndevice ++;
+  REALLOCATE (Device, char *, Ndevice);
+  REALLOCATE (Socket, int, Ndevice);
+  Device[N] = strcreate (name);
+  Socket[N] = -1;
+  return (N);
+}
+// delete device by name, close if not closed
+int DelKapaDevice (char *name) {
+  int i, N;
+  N = FindKapaDevice (name);
+  if (N == -1) return (FALSE);
+  if (Socket[N] != -1) close (Socket[N]);
+  free (Device[N]);
+  for (i = N; i < Ndevice - 1; i++) {
+    Device[i] = Device[i+1];
+    Socket[i] = Socket[i+1];
+  }
+  if (N == Active) {
+    Active = -1;
+  }
+  Ndevice --;
+  REALLOCATE (Device, char *, Ndevice);
+  REALLOCATE (Socket, int, Ndevice);
+  return (TRUE);
+}
+// returns the entry of the requested device, or -1 if not found
+int FindKapaDevice (char *name) {
   int i;
   for (i = 0; i < Nsocket; i++) {
+    if (Device[i] == thisDevice) {
       return (i);
+    }
+  if (name == NULL) return (-1);
+  for (i = 0; i < Ndevice; i++) {
+    if (!strcmp(Device[i], name)) return (i);
+  }
   return (-1);
+}
 // set the active device to the given device number, open if needed
 int open_kapa (int thisDevice) {
   int fd, entry;
   char *kapa_exec, name[16];
+// set the active device to the given device, open if needed
+int open_kapa (int entry) {
+  int fd;
+  char *kapa_exec, *kapa_name;
   // find the given device number, or create. set this to active
+  entry = FindKapaDevice (thisDevice);
+  if (entry < 0) {
+    Active = Nsocket;
+    Nsocket ++;
+    REALLOCATE (Device, int, Nsocket);
+    REALLOCATE (Socket, int, Nsocket);
+    Device[Active] = -1;
+    Socket[Active] = -1;
+  } else {
+    Active = entry;
+  }
+  assert (entry >= 0);
+  assert (entry <  Ndevice);
   // if the (now) active socket is not open, open it
   if (Socket[Active] < 0) {
+  if (Socket[entry] < 0) {
     kapa_exec = get_variable ("KAPA");
     if (kapa_exec == (char *) NULL) {
 …
     // KAPA may be either kapa://host or /path/to/program
     snprintf (name, 16, "[%d]", thisDevice);
     fd = KapaOpen (kapa_exec, name);
+    ALLOCATE (kapa_name, char, strlen(Device[entry]) + 5);
+    snprintf (kapa_name, strlen(Device[entry]) + 5, "[%s]", Device[entry]);
+    fd = KapaOpen (kapa_exec, kapa_name);
     free (kapa_exec);
+    free (kapa_name);
     if (fd < 0) {
+      gprint (GP_ERR, "error starting kapa\n");
+      // delete the active entry
+      gprint (GP_ERR, "error starting kapa device %s\n", Device[entry]);
       return (FALSE);
+    }
+    Device[Active] = thisDevice;
+    Socket[Active] = fd;
+    Socket[entry] = fd;
+  }
+  return (TRUE);
+}
+/**************** graph ops */
+// XXX for now, use a local variable.  later: get from kapa
+static Graphdata graphdata;
+void InitGraph () {
+  graphdata.xmin = graphdata.ymin = 0.0;
+  graphdata.xmax = graphdata.ymax = 1.0;
+  graphdata.style = graphdata.ptype = 0;
+  graphdata.ltype = graphdata.color = 0;
+  graphdata.etype = graphdata.ebar = 0;
+  graphdata.lweight = graphdata.size = 1.0;
+  graphdata.coords.pc1_1 = graphdata.coords.pc2_2 = 1.0;
+  graphdata.coords.pc1_2 = graphdata.coords.pc2_1 = 0.0;
+  strcpy (graphdata.coords.ctype, "RA---LIN");
+  graphdata.coords.crval1 = 0.0;
+  graphdata.coords.crval2 = 0.0;
+  graphdata.coords.crpix1 = 0.0;
+  graphdata.coords.crpix2 = 0.0;
+  graphdata.coords.cdelt1 = graphdata.coords.cdelt2 = 1.0;
+  graphdata.flipeast = TRUE;
+  graphdata.flipnorth = FALSE;
+  strcpy (graphdata.axis, "2222");
+  strcpy (graphdata.ticks, "2222");
+  strcpy (graphdata.labels, "2222");
+}
+# if (0)
+  /* test Xgraph[0], flush junk from pipe */
+  signal (SIGPIPE, XGraphDead);
+  fcntl (Socket[n], F_SETFL,  O_NONBLOCK);
+  for (i = 0; (read (Socket[n], buffer, 64) > 0) && (i < 20); i++);
+  fcntl (Socket[n], F_SETFL, !O_NONBLOCK);
+# endif
+/* return pointers for current Xgraph, set if desired, test, open if needed */
+int GetGraph (Graphdata *data, int *fd, int *dev) {
+  int thisDevice;
+  SetImageDevice (FALSE);
+  if (dev == NULL) {
+    if (Active < 0) {
+      thisDevice = 0;
+  Active = entry;
+  return (TRUE);
+}
+/**************** graph specific ops *******************/
+// return the current device name, if set
+char *GetKapaName () {
+  if (Active < 0) return NULL;
+  return Device[Active];
+}
+/* return pointers for named device or current; open if needed */
+// if fd == NULL, don't return the value
+// if name == NULL, use the currently active device
+int GetGraph (Graphdata *data, int *fd, char *name) {
+  int entry;
+  if (name == NULL) {
+    if (Active < 0) {
+      entry = AddKapaDevice ("0");
     } else {
       thisDevice = Device[Active];
+    }
   } else {
     thisDevice = *dev;
+  }
   if (!open_kapa (thisDevice)) {
     return (FALSE);
+  }
   if (data != NULL) *data = graphdata;
+      entry = Active;
+    }
+  } else {
+    entry = AddKapaDevice (name);
+  }
+  if (!open_kapa (entry)) {
+    return (FALSE);
+  }
+  if (data != NULL) KapaGetGraphData (Socket[Active], data);
   if (fd != NULL) *fd = Socket[Active];
 …
+}
+/* return pointers for given Xgraph, don't set or open */
+int GetGraphData (Graphdata *data, int *fd, int *dev) {
+  int n;
+  if (dev == NULL) {
+    if (Active < 0) {
+      gprint (GP_ERR, "invalid Xgraph window %d\n", *dev);
+      return (FALSE);
+    }
+    *fd = Socket[Active];
+    return (TRUE);
+  }
+  n = FindKapaDevice (*dev);
+  if (n < 0) {
+    gprint (GP_ERR, "invalid Xgraph window %d\n", *dev);
+    return (FALSE);
+  }
+  Active = n;
+/* return pointers for given kapa, don't set or open */
+int GetGraphData (Graphdata *data, int *fd, char *name) {
+  int entry;
+  if (name == NULL) {
+    if (Active < 0) {
+      gprint (GP_ERR, "no active kapa window\n");
+      return (FALSE);
+    }
+    entry = Active;
+  } else {
+    entry = FindKapaDevice (name);
+    if (entry < 0) {
+      gprint (GP_ERR, "invalid kapa window %s\n", name);
+      return (FALSE);
+    }
+  }
+  if (fd != NULL) *fd = Socket[entry];
+  if (data != NULL) KapaGetGraphData (Socket[entry], data);
+  return (TRUE);
+}
+/* assign given values to current kapa */
+int SetGraph (Graphdata *data) {
+  if (Active < 0) {
+    gprint (GP_ERR, "no active kapa window\n");
+    return (FALSE);
+  }
+  if (Socket[Active] == -1) {
+    gprint (GP_ERR, "no active kapa window\n");
+    return (FALSE);
+  }
+  KapaSetGraphData (Socket[Active], data);
+}
+/************* image ops ***********/
+/* return pointers for current Ximage, set if desired, test, open if needed */
+int GetImage (KapaImageData *data, int *fd, char *name) {
+  int entry;
+  if (name == NULL) {
+    if (Active < 0) {
+      entry = AddKapaDevice ("0");
+    } else {
+      entry = Active;
+    }
+  } else {
+    entry = AddKapaDevice (name);
+  }
+  if (!open_kapa (entry)) {
+    return (FALSE);
+  }
+  if (data != NULL) KapaGetImageData (Socket[Active], data);
   if (fd != NULL) *fd = Socket[Active];
+  if (data != NULL) *data = graphdata;
+  return (TRUE);
+}
+/* assign given values to current Xgraph */
+void SetGraph (Graphdata data) {
+  graphdata = data;
+}
+/** internal tracking of current active device type **/
+/* drop this stuff */
+static int       IsImage = FALSE;
+int GetCurrentDevice () {
+  return (IsImage);
+}
+void SetImageDevice (int state) {
+  IsImage = state;
+}
+/************* image ops ***********/
+// XXX for now, use local static:
+static char      Ximbuffer[512];
+static double    Xzero;
+static double    Xrange;
+void InitImage () {
+  Xzero = 0;
+  Xrange = 1024;
+  strcpy (Ximbuffer, "none");
+}
+/* return pointers for current Ximage, set if desired, test, open if needed */
+int GetImage (int *fd, int *N) {
+  int status;
+  status = GetGraph (NULL, fd, N);
+  return (status);
+}
+void SetImageName (char *name) {
+  strcpy (Ximbuffer, name);
+}
+char *GetImageName () {
+  return (Ximbuffer);
+}
+// leave this information on kapa, request when needed?
+void SetImageScale (double zero, double range) {
+  Xzero = zero;
+  Xrange = range;
+}
+void GetImageScale (double *zero, double *range) {
+  *zero = Xzero;
+  *range = Xrange;
+}
+  return (TRUE);
+}
+/* return pointers for given kapa, don't set or open */
+int GetImageData (KapaImageData *data, int *fd, char *name) {
+  int entry;
+  if (name == NULL) {
+    if (Active < 0) {
+      gprint (GP_ERR, "no active kapa window\n");
+      return (FALSE);
+    }
+    entry = Active;
+  } else {
+    entry = FindKapaDevice (name);
+    if (entry < 0) {
+      gprint (GP_ERR, "invalid kapa window %s\n", name);
+      return (FALSE);
+    }
+  }
+  if (fd != NULL) *fd = Socket[entry];
+  if (data != NULL) KapaGetImageData (Socket[entry], data);
+  return (TRUE);
+}
+/* assign given values to current kapa */
+int SetImage (KapaImageData *data) {
+  if (Active < 0) {
+    gprint (GP_ERR, "no active kapa window\n");
+    return (FALSE);
+  }
+  if (Socket[Active] == -1) {
+    gprint (GP_ERR, "no active kapa window\n");
+    return (FALSE);
+  }
+  KapaSetImageData (Socket[Active], data);
+}
+int close_kapa (char *name) {
+  int N;
+  N = FindKapaDevice (name);
+  if (N == -1) {
+    if (Active < 0) return (FALSE);
+    name = Device[Active];
+  }
+  DelKapaDevice (name);
+  return (TRUE);
+}
+void QuitKapa () {
+  int i;
+  for (i = 0; i < Ndevice; i++) {
+    if (Socket[i] != -1) close (Socket[i]);
+    if (Device[i] != NULL) free (Device[i]);
+  }
+  REALLOCATE (Socket, int, 1);
+  REALLOCATE (Device, char *, 1);
+  Ndevice = 0;
+  Active = -1;
+}

trunk/Ohana/src/opihi/lib.data/style_args.c

-              r7917
+              r13479
 # include "display.h"
 int style_args (Graphdata *graphmode, int *argc, char **argv, int Nforce) {
+int style_args (Graphdata *graphmode, int *argc, char **argv, int *kapa) {
+  int N, Ngraph;
+  char *name;
+  int N;
+  char *colorName;
+  char *kapaName;
   Ngraph = -1;
+  kapaName = NULL;
   if ((N = get_argument (*argc, argv, "-n"))) {
     remove_argument (N, argc, argv);
     Ngraph = atof (argv[N]);
+    kapaName = strcreate (argv[N]);
     remove_argument (N, argc, argv);
+  }
   if (Nforce != -1) Ngraph = Nforce;
   if (!GetGraph (graphmode, NULL, &Ngraph)) return (FALSE);
+  if (!GetGraph (graphmode, kapa, kapaName)) return (FALSE);
+  FREE (kapaName);
   if (*argc == 1) {
+    name = KapaColorName (graphmode[0].color);
+    gprint (GP_ERR, "current style (%d): -x %d -c %s -pt %d -lt %d -lw %f -sz %f\n", Ngraph,
+             graphmode[0].style, name, graphmode[0].ptype,
+    kapaName = GetKapaName();
+    colorName = KapaColorName (graphmode[0].color);
+    gprint (GP_ERR, "current style (%s): -x %d -c %s -pt %d -lt %d -lw %f -sz %f\n", kapaName,
+             graphmode[0].style, colorName, graphmode[0].ptype,
              graphmode[0].ltype, graphmode[0].lweight,
              graphmode[0].size);

trunk/Ohana/src/opihi/lib.shell/BufferOps.c

-              r9275
+              r13479
+}
-int SelectOverlay (char *name, int *number) {
-  *number = -1;
-  if (!strcmp (name, "red") || !strcmp (name, "0"))
-    *number = 0;
-  if (!strcmp (name, "green") || !strcmp (name, "1"))
-    *number = 1;
-  if (!strcmp (name, "blue") || !strcmp (name, "2"))
-    *number = 2;
-  if (!strcmp (name, "yellow") || !strcmp (name, "3"))
-    *number = 3;
-  if (*number < 0) {
-    gprint (GP_ERR, "valid overlays may be: red (0), green (1), blue (2), yellow (3)\n");
-    return (FALSE);
+  }
-  else {
-    return (TRUE);
+  }
+}
 void dump_buffers (int n) {

trunk/Ohana/src/opihi/lib.shell/startup.c

r12902	r13479
43	43	else
44	44	set_str_variable ("HOME", home);
45		~~set_str_variable ("KII", "kii");~~
46	45	set_str_variable ("KAPA", "kapa");
47	46	set_variable ("PID", getpid());

trunk/Ohana/src/opihi/mana/mana.c.in

-              r12280
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  QuitImage ();
+  QuitGraph ();
+  QuitKapa ();
   return;
+}

trunk/Ohana/src/opihi/mana/opihi.c

-              r10647
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  /* -libdisplay
+  QuitImage ();
+  QuitGraph (); */
+  QuitKapa ();
   return;
+}

trunk/Ohana/src/opihi/pantasks/pantasks.c.in

-              r12280
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  QuitImage ();
+  QuitGraph ();
+  QuitKapa ();
   QuitController ();
   return;

trunk/Ohana/src/opihi/pantasks/pantasks_client.c.in

-              r12280
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  QuitImage ();
+  QuitGraph ();
+  QuitKapa ();
   return;
+}

trunk/Ohana/src/opihi/pantasks/pantasks_server.c

-              r11890
+              r13479
 /* add program-dependent exit functions here */
 void cleanup () {
+  // QuitImage ();
+  // QuitGraph ();
+  // QuitController ();
+  QuitKapa ();
+  QuitController ();
   return;
+}

trunk/Ohana/src/relastro/src/plotstuff.c

-              r12892
+              r13479
 int open_graph (int N) {
+  Xgraph[N] = KiiOpen ("kapa", NULL);
+  char name[100];
+  sprintf (name, "gastro [%d]", N);
+  Xgraph[N] = KapaOpen ("kapa", name);
   if (Xgraph[N] < 0) {
     fprintf (stderr, "error starting kapa\n");
 …
   if (Xgraph[N] < 1) if (!open_graph(N)) return;
   KapaClear (Xgraph[N], TRUE);
+  KapaClearSections (Xgraph[N]);
+  KiiSendCommand (Xgraph[N], 4, "PLOT");
+  /* send Xgraph the plot details */
+  KiiSendMessage (Xgraph[N], "%8d %8d %d %d %d %d %d %f %f",
+                  Npts, graphmode[0].style,
+                  graphmode[0].ptype, graphmode[0].ltype,
+                  graphmode[0].etype, graphmode[0].ebar, graphmode[0].color,
+                  graphmode[0].lweight, graphmode[0].size);
+  KiiSendMessage (Xgraph[N], "%g %g %g %g",
+                  graphmode[0].xmin, graphmode[0].xmax,
+                  graphmode[0].ymin, graphmode[0].ymax);
+  KapaPrepPlot (Xgraph[N], Npts, graphmode);
   return;
+}
 …
+}
 void PlotVector (int Npts, double *vect, int mode, int N) {
+void PlotVector (int Npts, double *vect, int mode, int N, char *type) {
   float *values;
 …
+  }
+  Nbytes = Npts * sizeof (float);
+  write (Xgraph[N], values, Nbytes);
+  KapaPlotVector (Xgraph[N], Npts, values, type);
   free (values);
   return;
 …
   PrepPlotting (N, graphdata, 0);
   PlotVector (N, xlist, 0, 0);
   PlotVector (N, ylist, 1, 0);
+  PlotVector (N, xlist, 0, 0, "x");
+  PlotVector (N, ylist, 1, 0, "y");
   if (label != NULL) PlotLabel (label, 0);
   DonePlotting (graphdata, 0);

trunk/Ohana/src/relphot/src/plotstuff.c

-              r12892
+              r13479
 int open_graph (int N) {
+  Xgraph[N] = KiiOpen ("kapa", NULL);
+  char name[100];
+  sprintf (name, "gastro [%d]", N);
+  Xgraph[N] = KapaOpen ("kapa", name);
   if (Xgraph[N] < 0) {
     fprintf (stderr, "error starting kapa\n");
 …
   if (Xgraph[N] < 1) if (!open_graph(N)) return;
   KapaClear (Xgraph[N], TRUE);
+  KapaClearSections (Xgraph[N]);
+  KiiSendCommand (Xgraph[N], 4, "PLOT");
+  /* send Xgraph the plot details */
+  KiiSendMessage (Xgraph[N], "%8d %8d %d %d %d %d %d %f %f",
+                  Npts, graphmode[0].style,
+                  graphmode[0].ptype, graphmode[0].ltype,
+                  graphmode[0].etype, graphmode[0].ebar, graphmode[0].color,
+                  graphmode[0].lweight, graphmode[0].size);
+  KiiSendMessage (Xgraph[N], "%g %g %g %g",
+                  graphmode[0].xmin, graphmode[0].xmax,
+                  graphmode[0].ymin, graphmode[0].ymax);
+  KapaPrepPlot (Xgraph[N], Npts, graphmode);
   return;
+}
 …
+}
 void PlotVector (int Npts, double *vect, int mode, int N) {
+void PlotVector (int Npts, double *vect, int mode, int N, char *type) {
   float *values;
 …
+  }
+  Nbytes = Npts * sizeof (float);
+  write (Xgraph[N], values, Nbytes);
+  KapaPlotVector (Xgraph[N], Npts, values, type);
   free (values);
   return;
 …
   PrepPlotting (N, graphdata, 0);
   PlotVector (N, xlist, 0, 0);
   PlotVector (N, ylist, 1, 0);
+  PlotVector (N, xlist, 0, 0, "x");
+  PlotVector (N, ylist, 1, 0, "y");
   if (label != NULL) PlotLabel (label, 0);
   DonePlotting (graphdata, 0);

trunk/Ohana/src/uniphot/src/plotstuff.c

-              r4797
+              r13479
 int open_graph (int N) {
+  int i, InitSocket, status, addreslen;
+  struct sockaddr_un Address;
+  char temp[100], *display_name;
+  char socket_name[100];
+  FILE *f;
+  char name[100];
   active = N;
+  sprintf (socket_name, "/tmp/kapa%d", N);
+  sprintf (temp, "rm -f %s", socket_name);
+  system (temp);
+  strcpy (Address.sun_path, socket_name);
+  Address.sun_family = AF_UNIX;
+  InitSocket = socket (AF_UNIX, SOCK_STREAM, 0);
+  status = bind (InitSocket, &Address, sizeof (Address));
+  status = listen (InitSocket, 1);
+  sprintf (temp, "kapa %s &", socket_name);
+# ifndef DEBUG
+  system (temp);
+# else
+  fprintf (stderr, "start kapa, press return: %s\n", temp);
+  fscanf (stdin, "%d", &i);
+# endif
+  addreslen =  sizeof (Address);
+  Xgraph[N] = accept (InitSocket, &Address, &addreslen);
+  sprintf (name, "gastro [%d]", N);
+  Xgraph[N] = KapaOpen ("kapa", name);
   if (Xgraph[N] < 0) {
     fprintf (stderr, "error starting kapa\n");
     return (FALSE);
+  }
+  else {
+    return (TRUE);
+  }
+  return (TRUE);
+}
 void DonePlotting (Graphdata *graphmode, int N) {
-  char buffer[65], buffer2[65];
   if (Xgraph[N] == 0) return;
+  write (Xgraph[N], "DBOX", 4);
+  sprintf (buffer, "%f %f %f %f", graphmode[0].xmin, graphmode[0].xmax, graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d", strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%s %s %s", "2222", "2222", "2222");
+  sprintf (buffer2, "NBYTES: %6d", strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+}
+void JpegPlot (Graphdata *graphmode, int N, char *filename) {
+  char buffer[65], buffer2[65];
+  if (Xgraph[N] == 0) return;
+  write (Xgraph[N], "PNGF", 4);
+  sprintf (buffer, "LEN: %11d", strlen (filename));
+  write (Xgraph[N], buffer, 16);
+  write (Xgraph[N], filename, strlen (filename));
+  read (Xgraph[N], buffer, 4);
+}
+void PSPlot (Graphdata *graphmode, int N, char *filename) {
+  char buffer[65], buffer2[65];
+  if (Xgraph[N] == 0) return;
+  write (Xgraph[N], "PSIT", 4);
+  sprintf (buffer, "LEN: %11d", strlen (filename));
+  write (Xgraph[N], buffer, 16);
+  write (Xgraph[N], filename, strlen (filename));
+  read (Xgraph[N], buffer, 4);
+  KapaBox (Xgraph[N], graphmode);
+  return;
+}
 void PrepPlotting (int Npts, Graphdata *graphmode, int N) {
-  int i, status;
-  char buffer[128], buffer2[128];
   active = N;
   if (Npts < 1) return;
+  if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  KapaPrepPlot (Xgraph[N], Npts, graphmode);
+}
+  /* test Xgraph[N], flush junk from pipe */
+  signal (SIGPIPE, XDead);
+  fcntl (Xgraph[N], F_SETFL,  O_NONBLOCK);
+  for (i = 0; (read (Xgraph[N], buffer, 64) > 0) && (i < 20); i++);
+  fcntl (Xgraph[N], F_SETFL, !O_NONBLOCK);
+  write (Xgraph[N], "ERAS", 4);
+  /* tell kapa to look for the incoming image */
+  status = write (Xgraph[N], "PLOT", 4);
+void PlotVector (int Npts, float *vect, int mode, int N) {
+  /* send Xgraph[N] the plot details */
+  sprintf (buffer, "%8d %8d %d %d %d %d %f %f",
+           Npts, graphmode[0].style,
+           graphmode[0].ptype, graphmode[0].ltype,
+           graphmode[0].etype, graphmode[0].color,
+           graphmode[0].lweight, graphmode[0].size);
+  sprintf (buffer2, "NBYTES: %6d", strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  sprintf (buffer, "%f %f %f %f",
+           graphmode[0].xmin, graphmode[0].xmax,
+           graphmode[0].ymin, graphmode[0].ymax);
+  sprintf (buffer2, "NBYTES: %6d", strlen (buffer));
+  write (Xgraph[N], buffer2, 16);
+  write (Xgraph[N], buffer, strlen (buffer));
+  int Nbytes;
+  if (Npts < 1) return;
+  active = N;
+  KapaPlotVector (Xgraph[N], Npts, vect);
+}
 …
   if (Xgraph[N] == 0) return;
+  write (Xgraph[N], "LABL", 4);
+  sprintf (buffer, " %6d %6d", strlen (string), 2);
+  write (Xgraph[N], buffer, 16);
+  write (Xgraph[N], string, strlen (string));
+  KapaSendLabel (Xgraph[N[, string, 4);
+}
 void PlotVector (int Npts, double *vect, int mode, int N) {
+void PlotReset (int N) {
   float *values;
   int i, Nbytes;
+  char buffer[128];
+  int i;
+  active = N;
+  if (Npts < 1) return;
+  /* test Xgraph[N], flush junk from pipe */
+  signal (SIGPIPE, XDead);
+  fcntl (Xgraph[N], F_SETFL,  O_NONBLOCK);
+  for (i = 0; (read (Xgraph[N], buffer, 64) > 0) && (i < 20); i++);
+  fcntl (Xgraph[N], F_SETFL, !O_NONBLOCK);
+  if (Xgraph[N] < 1) if (!open_graph(N)) return;
+  KapaClearSections (Xgraph[N]);
+}
+  ALLOCATE (values, float, Npts);
+  for (i = 0; i < Npts; i++) {
+    values[i] = vect[i];
+  }
+void JpegPlot (Graphdata *graphmode, int N, char *filename) {
+  Nbytes = Npts * sizeof (float);
+  write (Xgraph[N], values, Nbytes);
+  free (values);
+  if (Xgraph[N] == 0) return;
+  KapaPNG (Xgraph[N], filename);
+  return;
+}
+void PSPlot (Graphdata *graphmode, int N, char *filename) {
+  if (Xgraph[N] == 0) return;
+  KiiPS (Xgraph[N], filename, TRUE, KAPA_PS_NEWPLOT, "default");
+  return;
+}

Context Navigation

Legend: