diff options
Diffstat (limited to 'plot/plot.c')
| -rw-r--r-- | plot/plot.c | 2511 |
1 files changed, 2511 insertions, 0 deletions
diff --git a/plot/plot.c b/plot/plot.c new file mode 100644 index 0000000..c5ca910 --- /dev/null +++ b/plot/plot.c @@ -0,0 +1,2511 @@ + +/* + * Copyright 1998 - 2004 Graeme W. Gill + * All rights reserved. + * + * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :- + * see the License.txt file for licencing details. + */ + +/* This is a simple 2d graph plotter that runs on MSWindows/OSX/X11 */ +/* The code is in three sections, one for each GUI environment. */ +/* (Perhaps common code could be consolidated ?) */ + + +/* + * TTBD: + * + * Allow for a window title for each plot. + * + * Put all state information in plot_info (window handles etc.) + * Create thread to handle events, so it updates correctly. + * (Will have to lock plot info updates or ping pong them); + * Have call to destroy window. + * (Could then move to having multiple instances of plot). + * + * OS X Cocoa code doesn't get window focus. No idea why. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#ifdef UNIX +#include <unistd.h> +#endif +#include <math.h> +#include "numlib.h" +#include "plot.h" + +#undef DODEBUG /* Print error messages & progress reports */ +//#define STANDALONE_TEST /* Defined by build script */ + +#define NTICK 10 +#define LTHICK 1.2 /* Plot line thickness */ +#define ILTHICK ((int)(LTHICK+0.5)) /* Integer line thickness */ +//#define ILTHICK 2 +#undef CROSSES /* Mark input points with crosses */ + +#define DEFWWIDTH 500 +#define DEFWHEIGHT 500 + +/* Graph order is Black = Y1, Red = Y2, Green = Y3, Blue = Y4, Yellow = Y5, Purple = Y6 */ +/* Brown = Y7, Orange = Y8, Grey = Y9, Magenta = Y10 */ + +double nicenum(double x, int round); + +#define MXGPHS 10 /* Number of graphs with common X axis */ + +/* Colors of the graphs */ +static int gcolors[MXGPHS][3] = { + { 0, 0, 0}, /* Black */ + { 210, 30, 0}, /* Red */ + { 0, 200, 90}, /* Green */ + { 0, 10, 255}, /* Blue */ + { 200, 200, 0}, /* Yellow */ + { 220, 0, 255}, /* Purple */ + { 136, 86, 68}, /* Brown */ + { 248, 95, 0}, /* Orange */ + { 160, 160, 160}, /* Grey */ + { 220, 30, 220} /* Magenta */ +}; + +/* Information defining plot */ +/* There is one global instance of this. */ +struct _plot_info { + void *cx; /* Other Context */ + + int dowait; /* Wait for user key if > 0, wait for n secs if < 0 */ + double ratio; /* Aspect ratio of window, X/Y */ + + /* Plot point information */ + double mnx, mxx, mny, mxy; /* Extrema of values to be plotted */ + int graph; /* NZ if graph, Z if vectors */ + int revx; /* reversed X axis */ + + double *x1, *x2; + double *yy[MXGPHS]; /* y1 - y10 */ + char **ntext; + int n; + + double *x7, *y7; + plot_col *mcols; + char **mtext; + int m; + + double *x8, *y8, *x9, *y9; + plot_col *ocols; + int o; + + /* Plot instance information */ + int sx,sy; /* Screen offset */ + int sw,sh; /* Screen width and height */ + double scx, scy; /* Scale from input values to screen pixels */ + + }; typedef struct _plot_info plot_info; + +/* Global to transfer info to window callback */ +static plot_info pd; + +/* Declaration of superset */ +static int do_plot_imp( + double xmin, double xmax, double ymin, double ymax, /* Bounding box */ + double ratio, /* Aspect ratio of window, X/Y */ + int dowait, /* > 0 wait for user to hit space key, < 0 delat dowait seconds. */ + double *x1, double *x2, + double *yy[MXGPHS], char **ntext, + int n, + double *x7, double *y7, plot_col *mcols, char **mtext, + int m, + double *x8, double *y8, double *x9, double*y9, plot_col *ocols, + int o +); + + +#define MAX(a,b) (((a) > (b)) ? (a) : (b)) + +/* Public routines */ +/* Plot up to 3 graphs. Wait for key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot( +double *x, +double *y1, /* Up to 3 graphs */ +double *y2, +double *y3, +int n) { + int i, j; + double xmin, xmax, ymin, ymax; + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + NULL, NULL, NULL, NULL, 0, + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Public routines */ +/* Plot up to 3 graphs + crosses. Wait for key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot_p( +double *x, +double *y1, /* Up to 3 graphs */ +double *y2, +double *y3, +int n, +double *x4, double *y4, /* And crosses */ +int m) { + int i, j; + double xmin, xmax, ymin, ymax; + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + for (i = 0; i < m; i++) { + if (x4 != NULL) { + if (xmin > x4[i]) + xmin = x4[i]; + if (xmax < x4[i]) + xmax = x4[i]; + } + if (y4 != NULL) { + if (ymin > y4[i]) + ymin = y4[i]; + if (ymax < y4[i]) + ymax = y4[i]; + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + x4, y4, NULL, NULL, m , + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Plot up to 3 graphs with specified window size. */ +/* if dowait > 0, wait for user key */ +/* if dowait < 0, wait for no seconds */ +/* If xmax > xmin, use as x scale, else auto. */ +/* If ymax > ymin, use as y scale, else auto. */ +/* ratio is window X / Y */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot_x( +double *x, +double *y1, +double *y2, +double *y3, +int n, +int dowait, +double pxmin, +double pxmax, +double pymin, +double pymax, +double ratio +) { + int i, j; + double xmin, xmax, ymin, ymax; + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + if (pxmax > pxmin) { + xmax = pxmax; + xmin = pxmin; + } + if (pymax > pymin) { + ymax = pymax; + ymin = pymin; + } + + return do_plot_imp(xmin, xmax, ymin, ymax, ratio, dowait, + x, NULL, yy, NULL, n, + NULL, NULL, NULL, NULL, 0, + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Public routines */ +/* Plot up to 6 graphs. Wait for a key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot6( +double *x, /* X coord */ +double *y1, /* Black */ +double *y2, /* Red */ +double *y3, /* Green */ +double *y4, /* Blue */ +double *y5, /* Yellow */ +double *y6, /* Purple */ +int n) { /* Number of values */ + int i, j; + double xmin, xmax, ymin, ymax; + int nn = abs(n); + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + yy[3] = y4; + yy[4] = y5; + yy[5] = y6; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + NULL, NULL, NULL, NULL, n , + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Public routines */ +/* Plot up to 6 graphs + optional crosses. Wait for a key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot6p( +double *x, /* X coord */ +double *y1, /* Black */ +double *y2, /* Red */ +double *y3, /* Green */ +double *y4, /* Blue */ +double *y5, /* Yellow */ +double *y6, /* Purple */ +int n, /* Number of values */ +double *xp, double *yp, /* And crosses */ +int m) { + int i, j; + double xmin, xmax, ymin, ymax; + int nn = abs(n); + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + yy[3] = y4; + yy[4] = y5; + yy[5] = y6; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + for (i = 0; i < m; i++) { + if (xp != NULL) { + if (xmin > xp[i]) + xmin = xp[i]; + if (xmax < xp[i]) + xmax = xp[i]; + } + if (yp != NULL) { + if (ymin > yp[i]) + ymin = yp[i]; + if (ymax < yp[i]) + ymax = yp[i]; + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + xp, yp, NULL, NULL, m, + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Public routines */ +/* Plot up to 10 graphs. Wait for a key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot10( +double *x, /* X coord */ +double *y1, /* Black */ +double *y2, /* Red */ +double *y3, /* Green */ +double *y4, /* Blue */ +double *y5, /* Yellow */ +double *y6, /* Purple */ +double *y7, /* Brown */ +double *y8, /* Orange */ +double *y9, /* Grey */ +double *y10,/* White */ +int n, /* Number of values */ +int zero /* Flag - make sure zero is in y range */ +) { + int i, j; + double xmin, xmax, ymin, ymax; + int nn = abs(n); + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + yy[3] = y4; + yy[4] = y5; + yy[5] = y6; + yy[6] = y7; + yy[7] = y8; + yy[8] = y9; + yy[9] = y10; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + if (zero && ymin > 0.0) + ymin = 0.0; + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + NULL, NULL, NULL, NULL, n , + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Public routines */ +/* Plot up to 10 graphs + optional crosses. Wait for a key */ +/* return 0 on success, -1 on error */ +/* If n is -ve, reverse the X axis */ +int +do_plot10p( +double *x, /* X coord */ +double *y1, /* Black */ +double *y2, /* Red */ +double *y3, /* Green */ +double *y4, /* Blue */ +double *y5, /* Yellow */ +double *y6, /* Purple */ +double *y7, /* Brown */ +double *y8, /* Orange */ +double *y9, /* Grey */ +double *y10,/* White */ +int n, /* Number of values */ +double *xp, double *yp, /* And crosses */ +int m) { + int i, j; + double xmin, xmax, ymin, ymax; + int nn = abs(n); + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + yy[2] = y3; + yy[3] = y4; + yy[4] = y5; + yy[5] = y6; + yy[6] = y7; + yy[7] = y8; + yy[9] = y9; + yy[5] = y10; + + /* Determine min and max dimensions of plot */ + xmin = ymin = 1e6; + xmax = ymax = -1e6; + + for (i = 0; i < n; i++) { + if (xmin > x[i]) + xmin = x[i]; + if (xmax < x[i]) + xmax = x[i]; + + for (j = 0; j < MXGPHS; j++) { + if (yy[j] != NULL) { + if (ymin > yy[j][i]) + ymin = yy[j][i]; + if (ymax < yy[j][i]) + ymax = yy[j][i]; + } + } + } + + for (i = 0; i < m; i++) { + if (xp != NULL) { + if (xmin > xp[i]) + xmin = xp[i]; + if (xmax < xp[i]) + xmax = xp[i]; + } + if (yp != NULL) { + if (ymin > yp[i]) + ymin = yp[i]; + if (ymax < yp[i]) + ymax = yp[i]; + } + } + + /* Work out scale factors */ + if ((xmax - xmin) == 0.0) + xmax += 0.5, xmin -= 0.5; + if ((ymax - ymin) == 0.0) + ymax += 0.5, ymin -= 0.5; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, 1, + x, NULL, yy, NULL, n, + xp, yp, NULL, NULL, m, + NULL, NULL, NULL, NULL, NULL, 0); +} + + +/* Plot a bunch of vectors + optional crosses */ +/* return 0 on success, -1 on error */ +int do_plot_vec( +double xmin, +double xmax, +double ymin, +double ymax, +double *x1, /* vector start */ +double *y1, +double *x2, /* vector end */ +double *y2, +int n, /* Number of vectors */ +int dowait, +double *x3, /* extra point */ +double *y3, +plot_col *mcols, /* point colors */ +char **mtext, /* notation */ +int m /* Number of points */ +) { + int j; + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, dowait, + x1, x2, yy, NULL, n, + x3, y3, mcols, mtext, m, + NULL, NULL, NULL, NULL, NULL, 0); +} + +/* Plot a bunch of vectors + optional crosses + optional vectors*/ +/* return 0 on success, -1 on error */ +int do_plot_vec2( +double xmin, +double xmax, +double ymin, +double ymax, +double *x1, /* n vector start */ +double *y1, +double *x2, /* vector end and diagonal cross */ +double *y2, +char **ntext, /* text annotation at cross */ +int n, /* Number of vectors */ +int dowait, +double *x3, /* m extra point */ +double *y3, +plot_col *mcols,/* point colors */ +char **mtext, /* text annotation */ +int m, /* Number of points */ +double *x4, /* o vector start */ +double *y4, +double *x5, /* o vector end */ +double *y5, +plot_col *ocols,/* Vector colors */ +int o /* Number of vectors */ +) { + int j; + double *yy[MXGPHS]; + + for (j = 0; j < MXGPHS; j++) + yy[j] = NULL; + + yy[0] = y1; + yy[1] = y2; + + return do_plot_imp(xmin, xmax, ymin, ymax, 1.0, dowait, + x1, x2, yy, ntext, n, + x3, y3, mcols, mtext, m, + x4, y4, x5, y5, ocols, o); +} +/* ********************************** NT version ********************** */ +#ifdef NT + +#include <windows.h> + +#ifdef DODEBUG +# define debugf(xx) printf xx +#else +# define debugf(xx) +#endif + +double plot_ratio = 1.0; +HANDLE plot_th; /* Thread */ +char plot_AppName[] = "PlotWin"; +HWND plot_hwnd = NULL; /* Open only one window per session */ +int plot_signal = 0; /* Signal a key or quit */ + +static LRESULT CALLBACK MainWndProc (HWND, UINT, WPARAM, LPARAM); + +/* Thread to handle message processing, so that there is no delay */ +/* when the main thread is doing other things. */ +DWORD WINAPI plot_message_thread(LPVOID lpParameter) { + MSG msg; + WNDCLASS wc; + ATOM arv; + HWND _hwnd; + + // Fill in window class structure with parameters that describe the + // main window. + + wc.style = CS_HREDRAW | CS_VREDRAW; // Class style(s). + wc.lpfnWndProc = MainWndProc; // Function to retrieve messages for windows of this class. + wc.cbClsExtra = 0; // No per-class extra data. + wc.cbWndExtra = 0; // No per-window extra data. + wc.hInstance = NULL; // Application that owns the class. + wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); + wc.hCursor = LoadCursor(NULL, IDC_CROSS); + wc.hbrBackground = GetStockObject(WHITE_BRUSH); + wc.lpszMenuName = NULL; + wc.lpszClassName = plot_AppName; + + arv = RegisterClass(&wc); + + if (!arv) { + debugf(("RegisterClass failed, lasterr = %d\n",GetLastError())); + return -1; + } + + _hwnd = CreateWindow( + plot_AppName, + "2D Diagnostic Graph Plot", + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, + CW_USEDEFAULT, + (int)(DEFWWIDTH * plot_ratio + 0.5), + DEFWHEIGHT, + NULL, + NULL, + NULL, // hInstance, + NULL); + + if (!_hwnd) { + debugf(("CreateWindow failed, lasterr = %d\n",GetLastError())); + return -1; + } + + ShowWindow(_hwnd, SW_SHOW); + + plot_hwnd = _hwnd; + + /* Now process messages until we're done */ + for (;;) { + if (GetMessage(&msg, NULL, 0, 0)) { + TranslateMessage(&msg); + DispatchMessage(&msg); + if (plot_signal == 99) + break; + } + } + + if (UnregisterClass(plot_AppName, NULL) == 0) { + debugf(("UnregisterClass failed, lasterr = %d\n",GetLastError())); + } + + plot_hwnd = NULL; /* Signal it's been deleted */ + + return 0; +} + +/* Superset implementation function: */ +/* return 0 on success, -1 on error */ +/* Hybrid Graph uses x1 : y1, y2, y3, y4, y5, y6 for up to 6 graph curves + */ +/* optional diagonal crosses at x7, y7 in yellow (x2 == NULL). */ +/* Vector uses x1, y1 to x2, y2 as a vector with a diagonal cross at x2, y2 all in black, */ +/* with annotation ntext at the cross, */ +/* plus a diagonal cross at x7, y7 in yellow. The color for x7, y7 can be overidden by an */ +/* array of colors mcols, and augmented by optional label text mtext. (x2 != NULL) */ +/* n = number of points/vectors. -ve for reversed X axis */ +/* m = number of extra points (x2,y3 or x7,y7) */ +static int do_plot_imp( + double xmin, double xmax, double ymin, double ymax, /* Bounding box */ + double ratio, /* Aspect ratio of window, X/Y */ + int dowait, /* > 0 wait for user to hit space key, < 0 delat dowait seconds. */ + double *x1, double *x2, + double *yy[MXGPHS], char **ntext, + int n, + double *x7, double *y7, plot_col *mcols, char **mtext, + int m, + double *x8, double *y8, double *x9, double*y9, plot_col *ocols, + int o +) { + pd.dowait = 10 * dowait; + pd.ratio = ratio; + { + int j; + double xr,yr; + + pd.mnx = xmin; + pd.mny = ymin; + pd.mxx = xmax; + pd.mxy = ymax; + + /* Allow some extra around plot */ + xr = pd.mxx - pd.mnx; + yr = pd.mxy - pd.mny; + if (xr < 1e-6) + xr = 1e-6; + if (yr < 1e-6) + yr = 1e-6; + pd.mnx -= xr/10.0; + pd.mxx += xr/10.0; + pd.mny -= yr/10.0; + pd.mxy += yr/10.0; + + /* Transfer raw point info */ + if (x2 == NULL) + pd.graph = 1; /* 6 graphs + points */ + else + pd.graph = 0; + pd.x1 = x1; + pd.x2 = x2; + for (j = 0; j < MXGPHS; j++) + pd.yy[j] = yy[j]; + pd.ntext = ntext; + pd.n = abs(n); + + if (n < 0) { + double tt; + tt = pd.mxx; + pd.mxx = pd.mnx; + pd.mnx = tt; + pd.revx = 1; + } else { + pd.revx = 0; + } + pd.x7 = x7; + pd.y7 = y7; + pd.mcols = mcols; + pd.mtext = mtext; + pd.m = abs(m); + + pd.x8 = x8; + pd.y8 = y8; + pd.x9 = x9; + pd.y9 = y9; + pd.ocols = ocols; + pd.o = abs(o); + } + + /* ------------------------------------------- */ + /* Setup windows stuff */ + { + + /* It would be nice to reduce number of globals. */ + + /* We don't clean up properly either - ie. don't delete thread etc. */ + + /* Create thread that creats window and processes window messages */ + if (plot_hwnd == NULL) { + + plot_ratio = ratio; + + plot_th = CreateThread(NULL, 0, plot_message_thread, NULL, 0, NULL); + if (plot_th == NULL) { + debugf(("new_athread failed\n")); + return -1; + } + while (plot_hwnd == NULL) + Sleep(50); + } + + plot_signal = 0; + + SetForegroundWindow(plot_hwnd); + + /* Force a repaint with the new data */ + if (!InvalidateRgn(plot_hwnd,NULL,TRUE)) { + debugf(("InvalidateRgn failed, lasterr = %d\n",GetLastError())); + return -1; + } + + if (dowait > 0) { /* Wait for a space key */ + while(plot_signal == 0 && plot_hwnd != NULL) + Sleep(50); + plot_signal = 0; + } else if (dowait < 0) { + Sleep(-dowait * 1000); + } + } + return 0; +} + +void DoPlot(HDC hdc, plot_info *pd); + +static LRESULT CALLBACK MainWndProc( + HWND hwnd, + UINT message, + WPARAM wParam, + LPARAM lParam +) { + HDC hdc; + PAINTSTRUCT ps; + RECT rect; + + debugf(("Handling message type 0x%x\n",message)); + // Could use Set/GetWindowLong() to pass window class info instead of global pd (beware NULL) + switch(message) { + case WM_PAINT: + debugf(("It's a paint message\n")); + hdc = BeginPaint(hwnd, &ps); + GetClientRect(hwnd, &rect); + + /* Setup the plot info structure for this drawing */ + pd.sx = rect.left; + pd.sy = rect.top; + pd.sw = 1 + rect.right - rect.left; + pd.sh = 1 + rect.bottom - rect.top; + pd.scx = (pd.sw - 10)/(pd.mxx - pd.mnx); + pd.scy = (pd.sh - 10)/(pd.mxy - pd.mny); + + DoPlot(hdc, &pd); + + EndPaint(hwnd, &ps); + + return 0; + + case WM_CHAR: + debugf(("It's a char message, wParam = 0x%x\n",wParam)); + switch(wParam) { + case ' ': /* Space */ + debugf(("It's a SPACE, so signal it\n")); + plot_signal = 1; + return 0; + } + + case WM_CLOSE: + debugf(("It's a close message\n")); + DestroyWindow(hwnd); + return 0; + + case WM_DESTROY: + debugf(("It's a destroy message\n")); + plot_signal = 99; + PostQuitMessage(0); + return 0; + } + + debugf(("It's a message not handled here\n")); + return DefWindowProc(hwnd, message, wParam, lParam); +} + +void +xtick(HDC hdc, plot_info *pdp, double x, char *lab) + { + int xx,yy; + RECT rct; +// GrLine(10 + (int)((x - pdp->mnx) * scx + 0.5), sh - 10 - 5, +// 10 + (int)((x - pdp->mnx) * scx + 0.5), sh - 10 + 5, 1); +// GrTextXY(5 + (int)((x - pdp->mnx) * scx + 0.5), sh - 10 - 10, lab, 1, 0); + + xx = 10 + (int)((x - pdp->mnx) * pdp->scx + 0.5); + yy = pdp->sh - 10; + + MoveToEx(hdc,xx, yy, NULL); + LineTo( hdc,xx, 0); + rct.right = + rct.left = xx; + rct.top = + rct.bottom = yy; + DrawText(hdc, lab, -1, &rct, DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOCLIP); + } + +void +ytick(HDC hdc, plot_info *pdp, double y, char *lab) + { + int xx,yy; + RECT rct; +// GrLine(5, 10 + (int)((y - pdp->mny) * pdp->scy + 0.5), +// 15, 10 + (int)((y - pdp->mny) * pdp->scy + 0.5), 1); +// GrTextXY(5, pdp->sh - 10 - (int)((y - pdp->mny) * pdp->scy + 0.5), lab, 1, 0); + + xx = 5; + yy = pdp->sh - 10 - (int)((y - pdp->mny) * pdp->scy + 0.5); + MoveToEx(hdc,xx, yy,NULL); + LineTo( hdc,pdp->sw, yy); + rct.right = + rct.left = xx; + rct.top = + rct.bottom = yy; + DrawText(hdc, lab, -1, &rct, DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_NOCLIP); + } + +void +loose_label(HDC hdc, plot_info *pdp, double min, double max, void (*pfunc)(HDC hdc, plot_info *pdp, double, char *) +) { + char str[6], temp[20]; + int nfrac; + double d; + double graphmin, graphmax; + double range,x; + + range = nicenum(min-max,0); + d = nicenum(range/(NTICK-1),1); + graphmin = floor(min/d) * d; + graphmax = ceil(max/d) * d; + nfrac = (int)MAX(-floor(log10(d)),0); + sprintf(str,"%%.%df", nfrac); + for (x = graphmin; x < graphmax + 0.5 * d; x += d) { + sprintf(temp,str,x); + pfunc(hdc,pdp,x,temp); + } +} + +void +DoPlot( +HDC hdc, +plot_info *pdp +) { + int i, j; + int lx,ly; /* Last x,y */ + HPEN pen; + + pen = CreatePen(PS_DOT,0,RGB(200,200,200)); + + SaveDC(hdc); + SelectObject(hdc,pen); + + /* Plot horizontal axis */ + if (pdp->revx) + loose_label(hdc, pdp, pdp->mxx, pdp->mnx, xtick); + else + loose_label(hdc, pdp, pdp->mnx, pdp->mxx, xtick); + + /* Plot vertical axis */ + loose_label(hdc, pdp, pdp->mny, pdp->mxy, ytick); + + RestoreDC(hdc,-1); + DeleteObject(pen); + + if (pdp->graph) { /* Up to MXGPHS graphs + crosses */ + int gcolors[MXGPHS][3] = { + { 0, 0, 0}, /* Black */ + { 210, 30, 0}, /* Red */ + { 0, 200, 90}, /* Green */ + { 0, 10, 255}, /* Blue */ + { 200, 200, 0}, /* Yellow */ + { 220, 0, 255}, /* Purple */ + { 136, 86, 68}, /* Brown */ + { 248, 95, 0}, /* Orange */ + { 160, 160, 160}, /* Grey */ + { 220, 220, 220} /* White */ + }; + for (j = MXGPHS-1; j >= 0; j--) { + double *yp = pdp->yy[j]; + + if (yp == NULL) + continue; + + pen = CreatePen(PS_SOLID,ILTHICK,RGB(gcolors[j][0],gcolors[j][1],gcolors[j][2])); + SelectObject(hdc,pen); + + lx = (int)((pdp->x1[0] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)(( yp[0] - pdp->mny) * pdp->scy + 0.5); + + for (i = 0; i < pdp->n; i++) { + int cx,cy; + cx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)(( yp[i] - pdp->mny) * pdp->scy + 0.5); + + MoveToEx(hdc, 10 + lx, pdp->sh - 10 - ly, NULL); + LineTo(hdc, 10 + cx, pdp->sh - 10 - cy); +#ifdef CROSSES + MoveToEx(hdc, 10 + cx - 5, pdp->sh - 10 - cy - 5, NULL); + LineTo(hdc, 10 + cx + 5, pdp->sh - 10 - cy + 5); + GrLine(10 + cx + 5, pdp->sh - 10 - cy - 5); + LineTo(hdc, 10 + cx - 5, pdp->sh - 10 - cy + 5); +#endif + lx = cx; + ly = cy; + } + DeleteObject(pen); + } + + } else { /* Vectors with cross */ + + pen = CreatePen(PS_SOLID,ILTHICK,RGB(0,0,0)); + SelectObject(hdc,pen); + + if (pdp->ntext != NULL) { + HFONT fon; + + fon = CreateFont(12, 0, 0, 0, FW_LIGHT, FALSE, FALSE, FALSE, ANSI_CHARSET, + OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, + FF_DONTCARE, NULL); + + if (fon == NULL) + fprintf(stderr,"plot: CreateFont returned NULL\n"); + else { + SelectObject(hdc,fon); + DeleteObject(fon); + } + } + + for (i = 0; i < pdp->n; i++) { + int cx,cy; + + lx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->yy[0][i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x2[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->yy[1][i] - pdp->mny) * pdp->scy + 0.5); + + MoveToEx(hdc, 10 + lx, pdp->sh - 10 - ly, NULL); + LineTo(hdc, 10 + cx, pdp->sh - 10 - cy); + + MoveToEx(hdc, 10 + cx - 5, pdp->sh - 10 - cy - 5, NULL); + LineTo(hdc, 10 + cx + 5, pdp->sh - 10 - cy + 5); + MoveToEx(hdc, 10 + cx + 5, pdp->sh - 10 - cy - 5, NULL); + LineTo(hdc, 10 + cx - 5, pdp->sh - 10 - cy + 5); + + if (pdp->ntext != NULL) { + RECT rct; + rct.right = + rct.left = 10 + cx + 10; + rct.top = + rct.bottom = pdp->sh - 10 - cy + 10; + DrawText(hdc, pdp->ntext[i], -1, &rct, DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOCLIP); + } + } + DeleteObject(pen); + } + + /* Extra points */ + if (pdp->x7 != NULL && pdp->y7 != NULL && pdp->m > 0 ) { + pen = CreatePen(PS_SOLID,ILTHICK,RGB(210,150,0)); + SelectObject(hdc,pen); + + if (pdp->mtext != NULL) { + HFONT fon; + + + fon = CreateFont(12, 0, 0, 0, FW_LIGHT, FALSE, FALSE, FALSE, ANSI_CHARSET, + OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, + FF_DONTCARE, NULL); + + if (fon == NULL) + fprintf(stderr,"plot: CreateFont returned NULL\n"); + else { + SelectObject(hdc,fon); + DeleteObject(fon); + } + } + + for (i = 0; i < pdp->m; i++) { + lx = (int)((pdp->x7[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y7[i] - pdp->mny) * pdp->scy + 0.5); + + if (pdp->mcols != NULL) { + int rgb[3]; + + for (j = 0; j < 3; j++) + rgb[j] = (int)(pdp->mcols[i].rgb[j] * 255.0 + 0.5); + + DeleteObject(pen); + pen = CreatePen(PS_SOLID,ILTHICK,RGB(rgb[0],rgb[1],rgb[2])); + SelectObject(hdc,pen); + + if (pdp->mtext != NULL) + SetTextColor(hdc, RGB(rgb[0],rgb[1],rgb[2])); + } + MoveToEx(hdc, 10 + lx - 5, pdp->sh - 10 - ly, NULL); + LineTo(hdc, 10 + lx + 5, pdp->sh - 10 - ly); + MoveToEx(hdc, 10 + lx, pdp->sh - 10 - ly - 5, NULL); + LineTo(hdc, 10 + lx, pdp->sh - 10 - ly + 5); + + if (pdp->mtext != NULL) { + RECT rct; + rct.right = + rct.left = 10 + lx + 10; + rct.top = + rct.bottom = pdp->sh - 10 - ly - 10; + DrawText(hdc, pdp->mtext[i], -1, &rct, DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOCLIP); + } + } + DeleteObject(pen); + } + /* Extra vectors */ + if (pdp->x8 != NULL && pdp->y8 != NULL && pdp->x9 != NULL && pdp->y9 && pdp->o > 0 ) { + pen = CreatePen(PS_SOLID,ILTHICK,RGB(150,255,255)); + SelectObject(hdc,pen); + + for (i = 0; i < pdp->o; i++) { + int cx,cy; + + lx = (int)((pdp->x8[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y8[i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x9[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->y9[i] - pdp->mny) * pdp->scy + 0.5); + + if (pdp->ocols != NULL) { + int rgb[3]; + + for (j = 0; j < 3; j++) + rgb[j] = (int)(pdp->ocols[i].rgb[j] * 255.0 + 0.5); + + DeleteObject(pen); + pen = CreatePen(PS_SOLID,ILTHICK,RGB(rgb[0],rgb[1],rgb[2])); + SelectObject(hdc,pen); + + if (pdp->mtext != NULL) + SetTextColor(hdc, RGB(rgb[0],rgb[1],rgb[2])); + } + MoveToEx(hdc, 10 + lx, pdp->sh - 10 - ly, NULL); + LineTo(hdc, 10 + cx, pdp->sh - 10 - cy); + } + DeleteObject(pen); + } + +// while(!kbhit()); + } + +#else /* !NT */ + +/* ************************** APPLE OSX Cocoa version ****************** */ +#ifdef __APPLE__ + +#include <Foundation/Foundation.h> +#include <AppKit/AppKit.h> + +#ifndef CGFLOAT_DEFINED +#ifdef __LP64__ +typedef double CGFloat; +#else +typedef float CGFloat; +#endif /* defined(__LP64__) */ +#endif + +#ifdef DODEBUG +# define debugf(xx) printf xx +#else +# define debugf(xx) +#endif + +/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ + + +@class PLWin; +@class PLView; + +/* Our static instance variables */ +typedef struct { + PLWin *window; /* NSWindow */ + PLView *view; /* NSTextField */ + volatile int plot_signal; /* Signal a key or quit */ +} cntx_t; + +/* Global plot instanc */ + +cntx_t *plot_cx = NULL; + +// - - - - - - - - - - - - - - - - - - - - - - - - - +@interface PLView : NSView { + cntx_t *cntx; +} +- (void)setCntx:(cntx_t *)cntx; +@end + +@implementation PLView + +- (void)setCntx:(cntx_t *)val { + cntx = val; +} + +/* This function does the work */ +static void DoPlot(NSRect *rect, plot_info *pdp); + +- (void)drawRect:(NSRect)rect { + + /* Use global plot data struct for now */ + DoPlot(&rect, &pd); +} + +@end + +// - - - - - - - - - - - - - - - - - - - - - - - - - + +@interface PLWin : NSWindow { + cntx_t *cntx; +} +- (void)setCntx:(cntx_t *)cntx; +@end + +@implementation PLWin + +- (void)setCntx:(cntx_t *)val { + cntx = val; +} + +- (BOOL)canBecomeMainWindow { + return YES; +} + +- (void)keyDown:(NSEvent *)event { + const char *chars; + + chars = [[event characters] UTF8String]; +// printf("Got Window KeyDown type %d char %s\n",(int)[event type], chars); + + if (chars[0] == ' ') { +// printf("Set plot_signal = 1\n"); + plot_cx->plot_signal = 1; + } +} + +- (BOOL)windowShouldClose:(id)sender { +// printf("Got Window windowShouldClose\n"); + + [NSApp terminate: nil]; + return YES; +} + +@end + +/* Create our window */ +static void create_my_win(cntx_t *cx) { + NSRect wRect; + + /* Create Window */ + wRect.origin.x = 100; + wRect.origin.y = 100; + wRect.size.width = (int)(DEFWWIDTH*pd.ratio+0.5); + wRect.size.height = DEFWHEIGHT; + + cx->window = [[PLWin alloc] initWithContentRect: wRect + styleMask: (NSTitledWindowMask | + NSClosableWindowMask | + NSMiniaturizableWindowMask | + NSResizableWindowMask) + backing: NSBackingStoreBuffered + defer: YES + screen: nil]; /* Main screen */ + + [cx->window setBackgroundColor: [NSColor whiteColor]]; + + [cx->window setLevel: NSMainMenuWindowLevel]; // ~~99 + + [cx->window setTitle: @"PlotWin"]; + + /* Use our view for the whole window to draw plot */ + cx->view = [PLView new]; + [cx->view setCntx:(void *)cx]; + [cx->window setContentView: cx->view]; + + [cx->window makeKeyAndOrderFront: nil]; + +// [cx->window makeMainWindow]; +} + +/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ + +/* + Cocoa NSApp is pretty horrible - it will only get user events + if created and run in the main thread. So the only way we could + decouble the windows from the application would be to intercept + main() and create a secondary thread to run the appication while + leaving main() in reserve for creating an NSApp and windows. + + Instead we poll events for a while and then go back to the main application. + */ + +/* Superset implementation function: */ +/* return 0 on success, -1 on error */ +/* Hybrid Graph uses x1 : y1, y2, y3, y4, y5, y6 for up to 6 graph curves + */ +/* optional diagonal crosses at x7, y7 in yellow (x2 == NULL). */ +/* Vector uses x1, y1 to x2, y2 as a vector with a diagonal cross at x2, y2 all in black, */ +/* with annotation ntext at the cross, */ +/* plus a diagonal cross at x7, y7 in yellow. The color for x7, y7 can be overidden by an */ +/* array of colors mcols, and augmented by optional label text mtext. (x2 != NULL) */ +/* n = number of points/vectors. -ve for reversed X axis */ +/* m = number of extra points (x2,y3 or x7,y7) */ +static int do_plot_imp( + double xmin, double xmax, double ymin, double ymax, /* Bounding box */ + double ratio, /* Aspect ratio of window, X/Y */ + int dowait, /* > 0 wait for user to hit space key, < 0 delat dowait seconds. */ + double *x1, double *x2, + double *yy[MXGPHS], char **ntext, + int n, + double *x7, double *y7, plot_col *mcols, char **mtext, + int m, + double *x8, double *y8, double *x9, double*y9, plot_col *ocols, + int o +) { + /* Put information in global pd */ + { + int j; + double xr,yr; + + pd.dowait = dowait; + pd.ratio = ratio; + + pd.mnx = xmin; + pd.mny = ymin; + pd.mxx = xmax; + pd.mxy = ymax; + + /* Allow some extra arround plot */ + xr = pd.mxx - pd.mnx; + yr = pd.mxy - pd.mny; + if (xr < 1e-6) + xr = 1e-6; + if (yr < 1e-6) + yr = 1e-6; + pd.mnx -= xr/10.0; + pd.mxx += xr/10.0; + pd.mny -= yr/10.0; + pd.mxy += yr/10.0; + + /* Transfer raw point info */ + if (x2 == NULL) + pd.graph = 1; /* 6 graphs + points */ + else + pd.graph = 0; + pd.x1 = x1; + pd.x2 = x2; + for (j = 0; j < MXGPHS; j++) + pd.yy[j] = yy[j]; + pd.ntext = ntext; + pd.n = abs(n); + + if (n < 0) { + double tt; + tt = pd.mxx; + pd.mxx = pd.mnx; + pd.mnx = tt; + pd.revx = 1; + } else { + pd.revx = 0; + } + pd.x7 = x7; + pd.y7 = y7; + pd.mcols = mcols; + pd.mtext = mtext; + pd.m = abs(m); + + pd.x8 = x8; + pd.y8 = y8; + pd.x9 = x9; + pd.y9 = y9; + pd.ocols = ocols; + pd.o = abs(o); + } + + /* If needed, create the indow */ + if (plot_cx == NULL) { + + /* If there is no NSApp */ + /* (This should go in a common library) */ + /* Note that we don't actually clean this up on exit - */ + /* possibly we can't. */ + if (NSApp == nil) { + static NSAutoreleasePool *pool = nil; + ProcessSerialNumber psn = { 0, 0 }; + + /* Transform the process so that the desktop interacts with it properly. */ + /* We don't need resources or a bundle if we do this. */ + if (GetCurrentProcess(&psn) == noErr) { + OSStatus stat; + if (psn.lowLongOfPSN != 0 && (stat = TransformProcessType(&psn, + kProcessTransformToForegroundApplication)) != noErr) { +// fprintf(stderr,"TransformProcess failed with code %d\n",stat); + } else { +// fprintf(stderr,"TransformProcess suceeded\n"); + } + } + + + pool = [NSAutoreleasePool new]; + [NSApplication sharedApplication]; /* Creates NSApp */ + [NSApp finishLaunching]; + + /* We seem to need this, because otherwise we don't get focus automatically */ + [NSApp activateIgnoringOtherApps: YES]; + } + + if ((plot_cx = (cntx_t *)calloc(sizeof(cntx_t), 1)) == NULL) + error("new_dispwin: Malloc failed (cntx_t)\n"); + + create_my_win(plot_cx); + + } else { /* Trigger an update */ + [plot_cx->view setNeedsDisplay: YES ]; + } + + /* Wait until the events are done */ + { + NSEvent *event; + double tot; + NSDate *to; + /* We're creating and draining a pool here to ensure that all the */ + /* auto release objects get drained when we're finished (?) */ + NSAutoreleasePool *tpool = [NSAutoreleasePool new]; + + if (dowait > 0) { /* Wait for a space key */ + tot = 24.0 * 60.0 * 60.0; + } else if (dowait < 0) { + tot = (double)-dowait; + } else { + tot = 0.1; + } + to = [NSDate dateWithTimeIntervalSinceNow:tot]; /* autorelease ? */ + plot_cx->plot_signal = 0; + for (;plot_cx->plot_signal == 0;) { + /* Hmm. Assume event is autorelease */ + if ((event = [NSApp nextEventMatchingMask:NSAnyEventMask + untilDate:to inMode:NSDefaultRunLoopMode dequeue:YES]) != nil) { + [NSApp sendEvent:event]; + } else { + break; + } + } + [tpool release]; + } + return 0; +} + +/* - - - - - - - - - - - - - - - - - - - - - - - - - */ +/* Cleanup code (not called) */ + +static void cleanup() { + [plot_cx->window release]; /* Take down the plot window */ + free(plot_cx); + plot_cx = NULL; +} + +/* - - - - - - - - - - - - - - - - - - - - - - - - - - */ + +/* Utility to draw text in Cocoa with centering */ +/* Size is points */ +/* Flags 0x1 == horizontal center */ +/* Flags 0x2 == vertical center */ +static void ADrawText(NSColor *col, float size, float x, float y, int flags, char *text) { + NSFont* font = [NSFont systemFontOfSize:size]; + NSDictionary *att = [NSDictionary dictionaryWithObjectsAndKeys: + font, NSFontAttributeName, + col, NSForegroundColorAttributeName, + nil]; + NSString *str = [[NSString alloc] initWithUTF8String: text]; + + if (flags != 0x0) { + NSSize size; + + /* Figure out how big it will be */ + size = [str sizeWithAttributes: att ]; + if (flags & 0x1) { + double w = fabs(size.width); + x -= 0.5 * w; + } + if (flags & 0x2) { + double h = fabs(size.height); + y -= 0.5 * h; + } + } + + [str drawAtPoint: NSMakePoint(x, y) withAttributes: att]; + [str release]; /* Others are autorelease */ +} + +/* Draw a line */ +/* We re-use the same path so that we can set the dash style */ +static void ADrawLine(NSBezierPath *path, float xs, float ys, float xe, float ye) { + [path removeAllPoints ]; + [path moveToPoint:NSMakePoint(xs, ys)]; + [path lineToPoint:NSMakePoint(xe, ye)]; + [path stroke]; +} + +/* Draw X axis grid lines */ +void +xtick( +plot_info *pdp, +NSBezierPath *path, +NSColor *lcol, +NSColor *tcol, +double x, char *lab +) { + float xx, yy; + + xx = 20.0 + (x - pdp->mnx) * pdp->scx; + yy = 20.0; + + [lcol setStroke]; /* There is a bug in 10.4 which resets this after each stroke */ + ADrawLine(path, xx, yy, xx, (float)pdp->sh); + ADrawText(tcol, 10.0, xx, 5.0, 0x1, lab); +} + +/* Draw Y axis grid lines */ +void +ytick( +plot_info *pdp, +NSBezierPath *path, +NSColor *lcol, +NSColor *tcol, +double y, char *lab +) { + float xx, yy; + + xx = 20.0; + yy = 20.0 + (y - pdp->mny) * pdp->scy; + + [lcol setStroke]; /* There is a bug in 10.4 which resets this after each stroke */ + ADrawLine(path, xx, yy, (float)pdp->sw, yy); + ADrawText(tcol, 10.0, 3.0, yy, 0x2, lab); +} + +void +loose_label( +plot_info *pdp, +NSBezierPath *path, +NSColor *lcol, +NSColor *tcol, +double min, double max, +void (*pfunc)(plot_info *pdp, NSBezierPath *path, NSColor *lcol, NSColor *tcol, double, char *) +) { + char str[6], temp[20]; + int nfrac; + double d; + double graphmin, graphmax; + double range,x; + + range = nicenum(min-max,0); + d = nicenum(range/(NTICK-1),1); + graphmin = floor(min/d) * d; + graphmax = ceil(max/d) * d; + nfrac = (int)MAX(-floor(log10(d)),0); + sprintf(str,"%%.%df", nfrac); + for (x = graphmin; x < graphmax + 0.5 * d; x += d) { + sprintf(temp,str,x); + pfunc(pdp, path, lcol, tcol, x, temp); + } +} + +/* Called from within view to plot overall graph */ +static void DoPlot(NSRect *rect, plot_info *pdp) { + int i, j; + int lx,ly; /* Last x,y */ + CGFloat dash_list[2] = {7.0, 2.0}; + /* Note path and tcol are autorelease */ + NSBezierPath *path = [NSBezierPath bezierPath]; /* Path to use */ + NSColor *lcol = nil; + NSColor *tcol = nil; + + /* Setup the plot info structure for this drawing */ + /* Note port rect is raster like, pdp/Quartz2D is Postscript like */ + pdp->sx = rect->origin.x; + pdp->sy = rect->origin.y; + pdp->sw = rect->size.width; + pdp->sh = rect->size.height; + pdp->scx = (pdp->sw - 20)/(pdp->mxx - pdp->mnx); + pdp->scy = (pdp->sh - 20)/(pdp->mxy - pdp->mny); + + /* Plot the axis lines */ + [path setLineWidth:1.0]; + [path setLineDash: dash_list count: 2 phase: 0.0 ]; /* Set dashed lines for axes */ + + /* Make sure text is black */ + tcol = [NSColor colorWithCalibratedRed: 0.0 + green: 0.0 + blue: 0.0 + alpha: 1.0]; + + lcol = [NSColor colorWithCalibratedRed:0.7 green: 0.7 blue:0.7 alpha: 1.0]; /* Grey */ + + /* Plot horizontal axis */ + if (pdp->revx) + loose_label(pdp, path, lcol, tcol, pdp->mxx, pdp->mnx, xtick); + else + loose_label(pdp, path, lcol, tcol, pdp->mnx, pdp->mxx, xtick); + + /* Plot vertical axis */ + loose_label(pdp, path, lcol, tcol, pdp->mny, pdp->mxy, ytick); + + /* Set to non-dashed line */ + [path setLineWidth: LTHICK]; + [path setLineDash: NULL count: 0 phase: 0.0 ]; + + if (pdp->graph) { /* Up to 6 graphs */ + int gcolors[MXGPHS][3] = { + { 0, 0, 0}, /* Black */ + { 210, 30, 0}, /* Red */ + { 0, 200, 90}, /* Green */ + { 0, 10, 255}, /* Blue */ + { 200, 200, 0}, /* Yellow */ + { 220, 0, 255}, /* Purple */ + { 136, 86, 68}, /* Brown */ + { 248, 95, 0}, /* Orange */ + { 160, 160, 160}, /* Grey */ + { 220, 220, 220} /* White */ + }; + for (j = MXGPHS-1; j >= 0; j--) { + double *yp = pdp->yy[j]; + + if (yp == NULL) + continue; + [[NSColor colorWithCalibratedRed: gcolors[j][0]/255.0 + green: gcolors[j][1]/255.0 + blue: gcolors[j][2]/255.0 + alpha: 1.0] setStroke]; + + lx = (int)((pdp->x1[0] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)(( yp[0] - pdp->mny) * pdp->scy + 0.5); + + for (i = 0; i < pdp->n; i++) { + int cx,cy; + cx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)(( yp[i] - pdp->mny) * pdp->scy + 0.5); + + ADrawLine(path, 20.0 + lx, 20.0 + ly, 20 + cx, 20.0 + cy); +#ifdef CROSSES + ADrawLine(path, 20.0 + cx - 5, 20.0 - cy - 5, 20.0 + cx + 5, 20.0 + cy + 5); + ADrawLine(path, 20.0 + cx + 5, 20.0 - cy - 5, 20.0 + cx - 5, 20.0 + cy + 5); +#endif + lx = cx; + ly = cy; + } + } + + } else { /* Vectors */ + [[NSColor colorWithCalibratedRed: 0.0 + green: 0.0 + blue: 0.0 + alpha: 1.0] setStroke]; + if (pdp->ntext != NULL) { + tcol = [NSColor colorWithCalibratedRed: 0.0 + green: 0.0 + blue: 0.0 + alpha: 1.0]; + } + for (i = 0; i < pdp->n; i++) { + int cx,cy; + + lx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->yy[0][i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x2[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->yy[1][i] - pdp->mny) * pdp->scy + 0.5); + + ADrawLine(path, 20.0 + lx, 20.0 + ly, 20.0 + cx, 20.0 + cy); + + ADrawLine(path, 20.0 + cx - 5, 20.0 + cy - 5, 20.0 + cx + 5, 20.0 + cy + 5); + ADrawLine(path, 20.0 + cx + 5, 20.0 + cy - 5, 20.0 + cx - 5, 20.0 + cy + 5); + + if (pdp->ntext != NULL) + ADrawText(tcol, 9.0, 20.0 + cx + 9, 20.0 + cy - 7, 0x1, pdp->ntext[i]); + } + } + + /* Extra points */ + if (pdp->x7 != NULL && pdp->y7 != NULL && pdp->m > 0 ) { + [[NSColor colorWithCalibratedRed: 0.82 /* Orange ? */ + green: 0.59 + blue: 0.0 + alpha: 1.0] setStroke]; + + for (i = 0; i < pdp->m; i++) { + + if (pdp->mcols != NULL) { + [[NSColor colorWithCalibratedRed: pdp->mcols[i].rgb[0] + green: pdp->mcols[i].rgb[1] + blue: pdp->mcols[i].rgb[2] + alpha: 1.0] setStroke]; + + if (pdp->mtext != NULL) { + tcol = [NSColor colorWithCalibratedRed: pdp->mcols[i].rgb[0] + green: pdp->mcols[i].rgb[1] + blue: pdp->mcols[i].rgb[2] + alpha: 1.0]; + } + } + lx = (int)((pdp->x7[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y7[i] - pdp->mny) * pdp->scy + 0.5); + + ADrawLine(path, 20.0 + lx - 5, 20.0 + ly, 20.0 + lx + 5, 20.0 + ly); + ADrawLine(path, 20.0 + lx, 20.0 + ly - 5, 20.0 + lx, 20.0 + ly + 5); + + if (pdp->mtext != NULL) { + ADrawText(tcol, 9.0, 20.0 + lx + 9, 20.0 + ly + 7, 0x1, pdp->mtext[i]); + } + } + } + + /* Extra vectors */ + if (pdp->x8 != NULL && pdp->y8 != NULL && pdp->x9 != NULL && pdp->y9 && pdp->o > 0 ) { + [[NSColor colorWithCalibratedRed: 0.5 /* Light blue */ + green: 0.9 + blue: 0.9 + alpha: 1.0] setStroke]; + + for (i = 0; i < pdp->o; i++) { + int cx,cy; + + if (pdp->ocols != NULL) { + [[NSColor colorWithCalibratedRed: pdp->ocols[i].rgb[0] + green: pdp->ocols[i].rgb[1] + blue: pdp->ocols[i].rgb[2] + alpha: 1.0] setStroke]; + if (pdp->mtext != NULL) { + tcol = [NSColor colorWithCalibratedRed: pdp->ocols[i].rgb[0] + green: pdp->ocols[i].rgb[1] + blue: pdp->ocols[i].rgb[2] + alpha: 1.0]; + } + } + lx = (int)((pdp->x8[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y8[i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x9[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->y9[i] - pdp->mny) * pdp->scy + 0.5); + + ADrawLine(path, 20.0 + lx, 20.0 + ly, 20.0 + cx, 20.0 + cy); + } + } +} + +#else /* Assume UNIX + X11 */ +/* ********************************** X11 version ********************** */ + +/* !!!! There is a problem if the user closes the window - an X11 error results */ +/* This seems to happen before a DestroyNotify !. How to fix ??? !!!! */ + +#include <X11/Xlib.h> +#include <X11/Xutil.h> + +#ifdef DODEBUG +# define debugf(xx) printf xx +#else +# define debugf(xx) +#endif + +void DoPlot(Display *mydisplay, Window mywindow, GC mygc, plot_info *pdp); + +/* Superset implementation function: */ +/* return 0 on success, -1 on error */ +/* Hybrid Graph uses x1 : y1, y2, y3, y4, y5, y6 for up to 6 graph curves + */ +/* optional diagonal crosses at x7, y7 in yellow (x2 == NULL). */ +/* Vector uses x1, y1 to x2, y2 as a vector with a diagonal cross at x2, y2 all in black, */ +/* with annotation ntext at the cross, */ +/* plus a diagonal cross at x7, y7 in yellow. The color for x7, y7 can be overidden by an */ +/* array of colors mcols, and augmented by optional label text mtext. (x2 != NULL) */ +/* n = number of points/vectors. -ve for reversed X axis */ +/* m = number of extra points (x2,y3 or x7,y7) */ +static int do_plot_imp( + double xmin, double xmax, double ymin, double ymax, /* Bounding box */ + double ratio, /* Aspect ratio of window, X/Y */ + int dowait, /* > 0 wait for user to hit space key, < 0 delat dowait seconds. */ + double *x1, double *x2, + double *yy[MXGPHS], char **ntext, + int n, + double *x7, double *y7, plot_col *mcols, char **mtext, + int m, + double *x8, double *y8, double *x9, double*y9, plot_col *ocols, + int o +) { + { + int j; + double xr,yr; + + pd.dowait = dowait; + pd.ratio = ratio; + + pd.mnx = xmin; + pd.mny = ymin; + pd.mxx = xmax; + pd.mxy = ymax; + + /* Allow some extra arround plot */ + xr = pd.mxx - pd.mnx; + yr = pd.mxy - pd.mny; + if (xr < 1e-6) + xr = 1e-6; + if (yr < 1e-6) + yr = 1e-6; + pd.mnx -= xr/10.0; + pd.mxx += xr/10.0; + pd.mny -= yr/10.0; + pd.mxy += yr/10.0; + + /* Transfer raw point info */ + if (x2 == NULL) + pd.graph = 1; /* 6 graphs + points */ + else + pd.graph = 0; + pd.x1 = x1; + pd.x2 = x2; + for (j = 0; j < MXGPHS; j++) + pd.yy[j] = yy[j]; + pd.ntext = ntext; + pd.n = abs(n); + + if (n < 0) { + double tt; + tt = pd.mxx; + pd.mxx = pd.mnx; + pd.mnx = tt; + pd.revx = 1; + } else { + pd.revx = 0; + } + pd.x7 = x7; + pd.y7 = y7; + pd.mcols = mcols; + pd.mtext = mtext; + pd.m = abs(m); + + pd.x8 = x8; + pd.y8 = y8; + pd.x9 = x9; + pd.y9 = y9; + pd.ocols = ocols; + pd.o = abs(o); + } + + { + /* stuff for X windows */ + char plot[] = {"plot"}; + static Display *mydisplay = NULL; + static Window mywindow = -1; + int dorefresh = 1; + GC mygc; + XEvent myevent; + XSizeHints myhint; + XWindowAttributes mywattributes; + int myscreen; + unsigned long myforeground,mybackground; + int done; + + /* open the display */ + if (mydisplay == NULL) { + mydisplay = XOpenDisplay(""); + if(!mydisplay) + error("Unable to open display"); + dorefresh = 0; + } + myscreen = DefaultScreen(mydisplay); + mybackground = WhitePixel(mydisplay,myscreen); + myforeground = BlackPixel(mydisplay,myscreen); + + myhint.x = 100; + myhint.y = 100; + myhint.width = (int)(DEFWWIDTH * ratio + 0.5); + myhint.height = DEFWHEIGHT; + myhint.flags = PPosition | USSize; + + debugf(("Opened display OK\n")); + + if (mywindow == -1) { + debugf(("Opening window\n")); + mywindow = XCreateSimpleWindow(mydisplay, + DefaultRootWindow(mydisplay), + myhint.x,myhint.y,myhint.width,myhint.height, + 5, myforeground,mybackground); + XSetStandardProperties(mydisplay,mywindow,plot,plot,None, + NULL,0, &myhint); + } + + mygc = XCreateGC(mydisplay,mywindow,0,0); + XSetBackground(mydisplay,mygc,mybackground); + XSetForeground(mydisplay,mygc,myforeground); + + XSelectInput(mydisplay,mywindow, + KeyPressMask | ExposureMask | StructureNotifyMask); + + if (dorefresh) { + XExposeEvent ev; + + ev.type = Expose; + ev.display = mydisplay; + ev.send_event = True; + ev.window = mywindow; + ev.x = 0; + ev.y = 0; + ev.width = myhint.width; + ev.height = myhint.height; + ev.count = 0; + + XClearWindow(mydisplay, mywindow); + XSendEvent(mydisplay, mywindow, False, ExposureMask, (XEvent *)&ev); + + } else { + XMapRaised(mydisplay,mywindow); + debugf(("Raised window\n")); + } + + /* Main event loop */ + debugf(("About to enter main loop\n")); + done = 0; + while(done == 0) { + XNextEvent(mydisplay,&myevent); + switch(myevent.type) { + case Expose: + if(myevent.xexpose.count == 0) { /* Repare the exposed region */ + XGetWindowAttributes(mydisplay, mywindow, & mywattributes); + /* Setup the plot info structure for this drawing */ + pd.sx = mywattributes.x; + pd.sy = mywattributes.y; + pd.sw = mywattributes.width; + pd.sh = mywattributes.height; + pd.scx = (pd.sw - 10)/(pd.mxx - pd.mnx); + pd.scy = (pd.sh - 10)/(pd.mxy - pd.mny); + + DoPlot(mydisplay,mywindow, mygc, &pd); + + if (pd.dowait <= 0) { /* Don't wait */ + if (pd.dowait < 0) + sleep(-pd.dowait); + debugf(("Not waiting, so set done=1\n")); + done = 1; + } + } + break; + case MappingNotify: + XRefreshKeyboardMapping(&myevent.xmapping); + break; + case KeyPress: + debugf(("Got a button press\n")); + done = 1; + break; + } + } + debugf(("About to close display\n")); + XFreeGC(mydisplay,mygc); +// XDestroyWindow(mydisplay,mywindow); +// XCloseDisplay(mydisplay); + debugf(("finished\n")); + } + return 0; +} + +/* Draw X axis grid lines */ +void +xtick( +Display *mydisplay, +Window mywindow, +GC mygc, +plot_info *pdp, +double x, char *lab +) { + int xx,yy; + + xx = 10 + (int)((x - pdp->mnx) * pdp->scx + 0.5); + yy = pdp->sh - 10; + + XDrawLine(mydisplay, mywindow, mygc, xx, yy, xx, 0); + XDrawImageString(mydisplay, mywindow, mygc, xx-6, yy, lab, strlen(lab)); +} + +/* Draw Y axis grid lines */ +void +ytick( +Display *mydisplay, +Window mywindow, +GC mygc, +plot_info *pdp, +double y, char *lab +) { + int xx,yy; + + xx = 5; + yy = pdp->sh - 10 - (int)((y - pdp->mny) * pdp->scy + 0.5); + + XDrawLine(mydisplay, mywindow, mygc, xx, yy, pdp->sw, yy); + XDrawImageString(mydisplay, mywindow, mygc, xx, yy+4, lab, strlen(lab)); +} + +void +loose_label( +Display *mydisplay, +Window mywindow, +GC mygc, +plot_info *pdp, +double min, double max, +void (*pfunc)(Display *mydisplay, Window mywindow, GC mygc, plot_info *pdp, double, char *) +) { + char str[6], temp[20]; + int nfrac; + double d; + double graphmin, graphmax; + double range,x; + + range = nicenum(min-max,0); + d = nicenum(range/(NTICK-1),1); + graphmin = floor(min/d) * d; + graphmax = ceil(max/d) * d; + nfrac = (int)MAX(-floor(log10(d)),0); + sprintf(str,"%%.%df", nfrac); + for (x = graphmin; x < graphmax + 0.5 * d; x += d) { + sprintf(temp,str,x); + pfunc(mydisplay, mywindow, mygc, pdp, x, temp); + } +} + +void +DoPlot( +Display *mydisplay, +Window mywindow, +GC mygc, +plot_info *pdp +) { + int i, j; + int lx,ly; /* Last x,y */ + char dash_list[2] = {5, 1}; + Colormap mycmap; + XColor col; + + mycmap = DefaultColormap(mydisplay, 0); + col.red = col.green = col.blue = 150 * 256; + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + + /* Set dashed lines for axes */ + XSetLineAttributes(mydisplay, mygc, 1, LineOnOffDash, CapButt, JoinBevel); + XSetDashes(mydisplay, mygc, 0, dash_list, 2); + // ~~ doesn't seem to work. Why ? + + /* Plot horizontal axis */ + if (pdp->revx) + loose_label(mydisplay, mywindow, mygc, pdp, pdp->mxx, pdp->mnx, xtick); + else + loose_label(mydisplay, mywindow, mygc, pdp, pdp->mnx, pdp->mxx, xtick); + + /* Plot vertical axis */ + loose_label(mydisplay, mywindow, mygc, pdp, pdp->mny, pdp->mxy, ytick); + + if (pdp->graph) { /* Up to 10 graphs */ + for (j = MXGPHS-1; j >= 0; j--) { + double *yp = pdp->yy[j]; + + if (yp == NULL) + continue; + + col.red = gcolors[j][0] * 256; + col.green = gcolors[j][1] * 256; + col.blue = gcolors[j][2] * 256; + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + XSetLineAttributes(mydisplay, mygc, ILTHICK, LineSolid, CapButt, JoinBevel); + + lx = (int)((pdp->x1[0] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)(( yp[0] - pdp->mny) * pdp->scy + 0.5); + + for (i = 0; i < pdp->n; i++) { + int cx,cy; + cx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)(( yp[i] - pdp->mny) * pdp->scy + 0.5); + + XDrawLine(mydisplay, mywindow, mygc, 10 + lx, pdp->sh - 10 - ly, 10 + cx, pdp->sh - 10 - cy); +#ifdef CROSSES + + XDrawLine(mydisplay, mywindow, mygc, 10 + cx - 5, pdp->sh - 10 - cy - 5, 10 + cx + 5, pdp->sh - 10 - cy + 5); + XDrawLine(mydisplay, mywindow, mygc, 10 + cx + 5, pdp->sh - 10 - cy - 5, 10 + cx - 5, pdp->sh - 10 - cy + 5); +#endif + lx = cx; + ly = cy; + } + } + + } else { /* Vectors */ + + col.red = col.green = col.blue = 0 * 256; + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + XSetLineAttributes(mydisplay, mygc, ILTHICK, LineSolid, CapButt, JoinBevel); + + for (i = 0; i < pdp->n; i++) { + int cx,cy; + + lx = (int)((pdp->x1[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->yy[0][i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x2[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->yy[1][i] - pdp->mny) * pdp->scy + 0.5); + + XDrawLine(mydisplay, mywindow, mygc, 10 + lx, pdp->sh - 10 - ly, 10 + cx, pdp->sh - 10 - cy); + + XDrawLine(mydisplay, mywindow, mygc, 10 + cx - 5, pdp->sh - 10 - cy - 5, 10 + cx + 5, pdp->sh - 10 - cy + 5); + XDrawLine(mydisplay, mywindow, mygc, 10 + cx + 5, pdp->sh - 10 - cy - 5, 10 + cx - 5, pdp->sh - 10 - cy + 5); + + if (pdp->ntext != NULL) + XDrawImageString(mydisplay, mywindow, mygc, 10 + cx + 5, pdp->sh - 10 - cy + 7, + pdp->ntext[i], strlen(pdp->ntext[i])); + } + } + + /* Extra points */ + if (pdp->x7 != NULL && pdp->y7 != NULL && pdp->m > 0 ) { + col.red = 210 * 256; col.green = 150 * 256; col.blue = 0 * 256; + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + XSetLineAttributes(mydisplay, mygc, ILTHICK, LineSolid, CapButt, JoinBevel); + + for (i = 0; i < pdp->m; i++) { + lx = (int)((pdp->x7[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y7[i] - pdp->mny) * pdp->scy + 0.5); + + if (pdp->mcols != NULL) { + col.red = (int)(pdp->mcols[i].rgb[0] * 65535.0 + 0.5); + col.green = (int)(pdp->mcols[i].rgb[1] * 65535.0 + 0.5); + col.blue = (int)(pdp->mcols[i].rgb[2] * 65535.0 + 0.5); + + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + + } + XDrawLine(mydisplay, mywindow, mygc, 10 + lx - 5, pdp->sh - 10 - ly, + 10 + lx + 5, pdp->sh - 10 - ly); + XDrawLine(mydisplay, mywindow, mygc, 10 + lx, pdp->sh - 10 - ly - 5, + 10 + lx, pdp->sh - 10 - ly + 5); + + if (pdp->mtext != NULL) + XDrawImageString(mydisplay, mywindow, mygc, 10 + lx + 5, pdp->sh - 10 - ly - 7, + pdp->mtext[i], strlen(pdp->mtext[i])); + } + } + + /* Extra vectors */ + if (pdp->x8 != NULL && pdp->y8 != NULL && pdp->x9 != NULL && pdp->y9 && pdp->o > 0 ) { + col.red = 150 * 256; col.green = 255 * 256; col.blue = 255 * 256; + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + XSetLineAttributes(mydisplay, mygc, ILTHICK, LineSolid, CapButt, JoinBevel); + + for (i = 0; i < pdp->o; i++) { + int cx,cy; + + lx = (int)((pdp->x8[i] - pdp->mnx) * pdp->scx + 0.5); + ly = (int)((pdp->y8[i] - pdp->mny) * pdp->scy + 0.5); + + cx = (int)((pdp->x9[i] - pdp->mnx) * pdp->scx + 0.5); + cy = (int)((pdp->y9[i] - pdp->mny) * pdp->scy + 0.5); + + if (pdp->ocols != NULL) { + col.red = (int)(pdp->ocols[i].rgb[0] * 65535.0 + 0.5); + col.green = (int)(pdp->ocols[i].rgb[1] * 65535.0 + 0.5); + col.blue = (int)(pdp->ocols[i].rgb[2] * 65535.0 + 0.5); + + XAllocColor(mydisplay, mycmap, &col); + XSetForeground(mydisplay,mygc, col.pixel); + + } + + XDrawLine(mydisplay, mywindow, mygc, 10 + lx, pdp->sh - 10 - ly, 10 + cx, pdp->sh - 10 - cy); + } + } +} + +#endif /* UNIX + X11 */ +#endif /* !NT */ +/***********************************************************************/ + + +/* Nice graph labeling functions */ + +#define expt(a,n) pow(a,(double)(n)) + +double nicenum(double x, int round) { + int ex; + double f; + double nf; +// printf("nocenum called with %f and %d\n",x,round); + if (x < 0.0) + x = -x; + ex = (int)floor(log10(x)); +// printf("ex = %d\n",ex); + f = x/expt(10.0,ex); +// printf("f = %f\n",f); + if (round) { + if (f < 1.5) nf = 1.0; + else if (f < 3.0) nf = 2.0; + else if (f < 7.0) nf = 5.0; + else nf = 10.0; + } else { + if (f < 1.0) nf = 1.0; + else if (f < 2.0) nf = 2.0; + else if (f < 5.0) nf = 5.0; + else nf = 10.0; + } +// printf("nf = %f\n",nf); +// printf("about to return %f\n",(nf * expt(10.0, ex))); + return (nf * expt(10.0, ex)); +} + +/* ---------------------------------------------------------------- */ +#ifdef STANDALONE_TEST +/* test code */ + +// ~~99 +#define TEST_NON_CONSOLE /* Version that works from command line and GUI */ +// May have to add link flag -Wl,-subsystem,windows +// since MingW is stupid about noticing WinMain or pragma + +//#include <windows.h> +//#include <stdio.h> +#include <fcntl.h> +//#include <io.h> + + +#ifdef NEVER +/* Append debugging string to log.txt */ +static void dprintf(char *fmt, ...) { + FILE *fp = NULL; + if ((fp = fopen("log.txt", "a+")) != NULL) { + va_list args; + va_start(args, fmt); + vfprintf(fp, fmt, args); + fflush(fp); + fclose(fp); + va_end(args); + } +} +#endif // NEVER + +#ifdef NEVER /* Other non-working enable console output code */ +{ + /* This clever code have been found at: + Adding Console I/O to a Win32 GUI App + Windows Developer Journal, December 1997 + http://dslweb.nwnexus.com/~ast/dload/guicon.htm + Andrew Tucker's Home Page */ + + /* This is not so clever, since it doesn't work... */ + + // redirect unbuffered STDOUT to the console + long lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE); + int hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); + FILE *fp = _fdopen(hConHandle, "w"); + *stdout = *fp; + setvbuf(stdout, NULL, _IONBF, 0); + + // redirect unbuffered STDIN to the console + lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE); + hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); + fp = _fdopen( hConHandle, "r" ); + *stdin = *fp; + setvbuf(stdin, NULL, _IONBF, 0); + + // redirect unbuffered STDERR to the console + lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE); + hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); + fp = _fdopen( hConHandle, "w" ); + *stderr = *fp; + setvbuf(stderr, NULL, _IONBF, 0); + + +} +#endif // NEVER + +#ifdef NEVER +// ~~~~~~~~~~~~~ +// AllocConsole(); + { + ULONG pbi[6]; + ULONG ulSize = 0; + LONG (WINAPI *NtQueryInformationProcess)(HANDLE ProcessHandle, + ULONG ProcessInformationClass, + PVOID ProcessInformation, + ULONG ProcessInformationLength, + PULONG ReturnLength); + + BOOL (WINAPI *AttachConsole)(DWORD dwProcessId); + + *(FARPROC *)&NtQueryInformationProcess = + GetProcAddress(LoadLibraryA("NTDLL.DLL"), "NtQueryInformationProcess"); + if(NtQueryInformationProcess) { +printf("~1 found NtQueryInformationProcess\n"); fflush(stdout); + if(NtQueryInformationProcess(GetCurrentProcess(), 0, + &pbi, sizeof(pbi), &ulSize) >= 0 && ulSize == sizeof(pbi)) { +printf("~1 NtQueryInformationProcess suceeded\n"); fflush(stdout); + + *(FARPROC *)&AttachConsole = + GetProcAddress(LoadLibraryA("kernel32.dll"), "AttachConsole"); + + if (AttachConsole) { +printf("~1 found AttachConsole\n"); fflush(stdout); + AttachConsole(pbi[5]); +printf("~1 about to freopen CONNOUT\n"); fflush(stdout); + freopen("CONOUT$","wb",stdout); + } else { +printf("~1 failed to find AttachConsole\n"); fflush(stdout); + } + } + } + // AttachConsole(ID ATTACH_PARENT_CONSOLE); // Should work on XP ?? + + /* i mean OpenConsoleW - you are as picky as i am - its + ordinal=519 and it is exported by name; the header(s) + do not include it, which tells me there's got to be a + reason for that. + */ + } +// ~~~~~~~~~~~~~ +#endif // NEVER + +#if defined(TEST_NON_CONSOLE) && defined(NT) +# pragma comment( linker, "/subsystem:windows" ) + +APIENTRY WinMain( + HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpCmdLine, + int nCmdShow +) { + { /* Only works on >= XP though */ + BOOL (WINAPI *AttachConsole)(DWORD dwProcessId); + + *(FARPROC *)&AttachConsole = + GetProcAddress(LoadLibraryA("kernel32.dll"), "AttachConsole"); + + if (AttachConsole != NULL && AttachConsole(((DWORD)-1))) + { + if (_fileno(stdout) < 0) + freopen("CONOUT$","wb",stdout); + if (_fileno(stderr) < 0) + freopen("CONOUT$","wb",stderr); + if (_fileno(stdin) < 0) + freopen("CONIN$","rb",stdin); +#ifdef __cplusplus + // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog point to console as well + std::ios::sync_with_stdio(); +#endif + } + } + + return main(__argc, __argv); +} +#endif /* TEST_NON_CONSOLE && NT */ + +int main(int argc, char *argv[]) { + double x[10] = {0.0, 0.5, 0.7, 1.0}; + double y1[10] = {0.0, 0.5, 0.7, 1.0}; + double y2[10] = {0.9, 0.8, 1.4, 1.2}; + double y3[10] = {0.1, 0.8, 0.7, -0.1}; + + double Bx1[10] = {0.0, 0.5, 0.9, 0.5}; + double By1[10] = {0.0, 0.3, 1.2, 0.2}; + double Bx2[10] = {0.1, 0.8, 0.1, 0.2}; + double By2[10] = {0.1, 1.8, 2.0, 0.5}; + + double Bx3[10] = {0.8, 0.4, 1.3, 0.5, 0.23}; + double By3[10] = {0.5, 1.3, 0.4, 0.7, 0.77}; + + plot_col mcols[5] = { + { 1.0, 0.0, 0.0 }, + { 0.0, 1.0, 0.0 }, + { 0.0, 0.0, 1.0 }, + { 0.6, 0.6, 0.6 }, + { 1.0, 1.0, 0.0 } }; + + char *ntext[5] = { "A", "B", "C", "D" }; + char *mtext[5] = { "10", "20", "30", "40", "50" }; + + printf("Doing first plot\n"); + if (do_plot(x,y1,y2,y3,4) < 0) + printf("Error - do_plot returned -1!\n"); + + /* Try a second plot */ + printf("Doing second plot\n"); + x[2] = 0.55; + if (do_plot(x,y2,y3,y1,3) < 0) + printf("Error - do_plot returned -1!\n"); + + /* Try vectors */ + printf("Doing vector plot\n"); + if (do_plot_vec(0.0, 1.4, 0.0, 2.0, Bx1, By1, Bx2, By2, 4, 1, Bx3, By3, NULL, NULL, 5)) + printf("Error - do_plot_vec returned -1!\n"); + + printf("Doing vector plot with colors and notation\n"); + if (do_plot_vec(0.0, 1.4, 0.0, 2.0, Bx1, By1, Bx2, By2, 4, 1, Bx3, By3, mcols, mtext, 5)) + printf("Error - do_plot_vec returned -1!\n"); + + printf("Doing vector plot with colors and notation + extra vectors\n"); + if (do_plot_vec2(0.0, 1.4, 0.0, 2.0, Bx1, By1, Bx2, By2, ntext, 4, 1, Bx3, By3, mcols, mtext, 5, + x,y1,y2,y3,mcols,4)) + printf("Error - do_plot_vec returned -1!\n"); + + printf("We're done\n"); + return 0; +} + +#endif /* STANDALONE_TEST */ +/* ---------------------------------------------------------------- */ + |