mirror
/
XEphem
mirror of https://github.com/XEphem/XEphem.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
XEphem/GUI/xephem/trailmenu.c

1283 lines
35 KiB
C
Raw Blame History

/* code to handle setting up and generating trails.
*
* to use: let user define a trail with tr_setup().
* when user hits Ok we call your function and you build the actual trails
* and do the drawing with tr_draw().
*
* ok to have several of these at once; they each maintain their own context.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <Xm/Xm.h>
#include <Xm/Form.h>
#include <Xm/Frame.h>
#include <Xm/Label.h>
#include <Xm/RowColumn.h>
#include <Xm/Separator.h>
#include <Xm/TextF.h>
#include <Xm/ToggleB.h>
#include <Xm/PushB.h>
#include <Xm/Scale.h>
#include "xephem.h"
#define SMALL_MAG 1.0 /* small char mag */
#define MEDIUM_MAG 1.4 /* medium char mag */
#define LARGE_MAG 2.0 /* large char mag */
#define HUGE_MAG 2.8 /* huge char mag */
#define GAP 4 /* space from line to text, pixels */
static char fontxr[] = "trailsFont"; /* X resource naming font to use */
static XFontStruct *tr_fs; /* font for trails */
/* context information per dialog.
* one of these gets malloced and saved in client callback.
*/
typedef struct {
Widget sh_w; /* overall shell */
Widget nb_w, na_w; /* Scales setting n ticks before and after */
Widget l_w[TRLR_N]; /* TBs for time stamp label rate options */
Widget i_w[TRI_N]; /* TBs for interval options */
Widget f_w[TRF_N]; /* TBs for format options */
Widget r_w[TRR_N]; /* TBs for the rounding options */
Widget s_w[TRS_N]; /* TBs for the size options */
Widget o_w[TRO_N]; /* TBs for the orientation options */
Widget custom_w; /* TextField for custom interval */
TrCB cb; /* saved caller's callback function */
XtPointer client; /* saved in tr_setup() and sent back in callbk*/
} TrContext;
/* make an array of these to create a row/col for the options */
typedef struct {
char *name; /* widget instance name */
char *label; /* widget's label */
char *tip; /* tip text */
} RCOption;
/* N.B. must correspond to the entries in TrLR */
static RCOption l_options[TRLR_N] = {
{"every1", "Every 1", "Label each tick mark"},
{"every2", "Every 2", "Label every other tick mark"},
{"every5", "Every 5", "Label every 5th tick mark"},
{"every10", "Every 10", "Label every 10th tick mark"},
{"fl", "First+Last","Label only the first and last tick mark"},
{"ml", "Mid+Last", "Label only the middle and last tick mark"},
{"fm", "First+Mid", "Label only the first and middle tick mark"},
{"fml", "F+M+L", "Label only the first, middle and last tick mark"},
{"none", "None", "Do not label any tick marks"},
};
/* N.B. must correspond to the entries in TrInt */
static RCOption i_options[TRI_N] = {
{"1min", "1 Minute", "One tick mark every minute"},
{"5mins", "5 Minutes", "One tick mark every 5 minutes"},
{"hour", "1 Hour", "One tick mark each hour"},
{"day", "1 Day", "One tick mark each day"},
{"week", "1 Week", "One tick mark each 7 days"},
{"month", "1 Month", "One tick mark per month"},
{"year", "1 Year", "One tick mark per year"},
{"custom", "Custom", "One tick mark for each interval, below"},
};
/* N.B. must correspond to the entries in TrFormat */
static RCOption f_options[TRF_N] = {
{"time", "H:M:S","Label tick marks as Hour:Minutes:Seconds"},
{"time", "H:M", "Label tick marks as Hour:Minutes"},
{"date", "Date", "Label tick marks according to the current Date format Preference"},
};
/* N.B. must correspond to the entries in TrRound */
static RCOption r_options[TRR_N] = {
{"min", "Whole min", "Begin tick marks at the next whole minute"},
{"day", "Whole day", "Begin tick marks at the next whole day"},
{"whole", "Whole interval", "Begin tick marks at the next whole interval selection"},
{"now", "Now", "Begin tick marks at the current Main menu time"},
};
/* N.B. must correspond to the entries in TrOrient */
static RCOption o_options[TRO_N] = {
{"up", "Up", "Labels written up from tick mark, tilt head left to read"},
{"down", "Down", "Labels written down from tick mark, tilt head right to read"},
{"left", "Left", "Labels written to left of tick mark"},
{"right","Right","Labels written to right of tick mark"},
{"above","Above","Labels centered above tick mark"},
{"below","Below","Labels centered below tick mark"},
{"upr", "Up 45","Labels at 45 degree angle up and right of tick mark"},
{"downr","Down 45","Labels at 45 degree angle down and right of tick mark"},
{"pathl","Path-Left","Labels would be to your left if you walked the trail"},
{"pathr","Path-Right","Labels would be to your right if you walked the trail"},
};
/* N.B. must correspond to the entries in TrSize */
static RCOption s_options[TRS_N] = {
{"small", "Small", "Tick mark labels are small"},
{"medium", "Medium", "Tick mark labels are medium size"},
{"large", "Large", "Tick mark labels are large"},
{"huge", "Huge", "Tick mark labels are huge"},
};
static Widget create_form (char *title, char *hdr, TrState *init, TrCB cb,
XtPointer client);
static void make_rb (Widget rc_w, char *title, char *name, RCOption *op,
int nop, Widget savew[]);
static void customint_cb (Widget w, XtPointer client, XtPointer call);
static void ok_cb (Widget w, XtPointer client, XtPointer call);
static void apply_cb (Widget w, XtPointer client, XtPointer call);
static int do_trails (TrContext *tcp);
static void tStep (double *tp, TrState *statep, int dir);
static int get_options (TrContext *tcp, TrState *statep);
static void popdown_cb (Widget w, XtPointer client, XtPointer call);
static void destroy_cb (Widget w, XtPointer client, XtPointer call);
static void close_cb (Widget w, XtPointer client, XtPointer call);
static void help_cb (Widget w, XtPointer client, XtPointer call);
static void draw_stamp (Display *dsp, Drawable win, GC gc, TrTS *tp,
TrState *sp, int mark, int ticklen, int lx, int ly, int x, int y);
/* put up a window to ask how to make a trail. OK will call (*cb)().
* ok to have several at once -- they keep their own context in client callback.
*/
void
tr_setup(
char *title, /* window manager title */
char *hdr, /* label across top */
TrState *init, /* default setup */
TrCB cb, /* callback when/if user hits Ok */
XtPointer client) /* saved and passed back to (*cb)() */
{
static char me[] = "tr_setup()";
Widget w;
/* do some sanity checks */
if (init->l >= TRLR_N) {
printf ("%s: Bogus label rate: %d\n", me, init->l);
abort();
}
if (init->i >= TRI_N) {
printf ("%s: Bogus interval: %d\n", me, init->i);
abort();
}
if (init->f >= TRF_N) {
printf ("%s: Bogus format: %d\n", me, init->f);
abort();
}
if (init->r >= TRR_N) {
printf ("%s: Bogus round: %d\n", me, init->r);
abort();
}
if (init->o >= TRO_N) {
printf ("%s: Bogus orientation: %d\n", me, init->o);
abort();
}
if (init->s >= TRS_N) {
printf ("%s: Bogus size: %d\n", me, init->s);
abort();
}
if (!cb) {
printf ("%s: No cb()\n", me);
abort();
}
/* ok, go for it */
w = create_form (title, hdr, init, cb, client);
if (w)
XtPopup (w, XtGrabNone);
}
/* called when basic resources change.
* rebuild and redraw.
* TODO: reclaim old stuff when called again.
*/
void
tr_newres()
{
tr_fs = NULL;
}
/* draw a line from [lx,ly] to [x,y]. iff tp, draw a tickmark (in parens if
* mark) of halfsize ticklen pixels and draw a time stamp according to tp and
* sp at [x,y]. iff ltp, do the same according to ltp and sp at [lx,ly].
*/
void
tr_draw (Display *dsp, Drawable win, GC gc, int mark, int ticklen, TrTS *tp,
TrTS *ltp, TrState *sp, int lx, int ly, int x, int y)
{
/* the base line for sure */
XPSDrawLine (dsp, win, gc, lx, ly, x, y);
/* if tp, draw tick mark and stamp at [x,y] */
if (tp) {
XPSFillArc (dsp, win, gc, x-ticklen, y-ticklen, 2*ticklen+1,
2*ticklen+1, 0, 360*64);
draw_stamp (dsp, win, gc, tp, sp, mark, ticklen, lx, ly, x, y);
}
/* same for other end if ltp */
if (ltp) {
XPSFillArc (dsp, win, gc, lx-ticklen, ly-ticklen, 2*ticklen+1,
2*ticklen+1, 0, 360*64);
draw_stamp (dsp, win, gc, ltp, sp, mark, ticklen,
x-2*(x-lx), y-2*(y-ly), lx, ly);
}
}
/* set a trail state resource
*/
void
tr_setres (name, state)
char *name;
TrState *state;
{
char val[50];
sprintf (val, "%d %d %d %d %d %d %d %d %.9f",
(int) state->l, (int) state->i, (int) state->f,
(int) state->r, (int) state->o, (int) state->s,
state->nticks, state->nbefore, state->customi);
setXRes (name, val);
}
/* get a trail state from a resource
*/
void
tr_getres (name, state)
char *name;
TrState *state;
{
char *val;
int l, i, f, r, o, s, n, b;
double c;
val = getXRes (name, "");
if (*val) {
if (sscanf (val, "%d %d %d %d %d %d %d %d %lf",
&l, &i, &f, &r, &o, &s, &n, &b, &c) == 9) {
state->l = (TrLR) l;
state->i = (TrInt) i;
state->f = (TrFormat) f;
state->r = (TrRound) r;
state->o = (TrOrient) o;
state->s = (TrSize) s;
state->nticks = n;
state->nbefore = b;
state->customi = c;
} else
xe_msg (0, "Trail state resource value of %s invalid.", name);
}
}
/* create a trail control window.
* A pointer to malloc'd TrContext is kept in client destroy callback, be sure
* to free this whenever the window is destroyed.
*/
static Widget
create_form (title, hdr, init, cb, client)
char *title;
char *hdr;
TrState *init;
TrCB cb;
XtPointer client;
{
TrContext *tcp;
Widget ok_w, apply_w, close_w, help_w;
Widget sep_w, lbl_w, n_w;
Widget sh_w, mf_w, hdr_w, rc_w, f_w, fr_w;
Widget ofr_w, ifr_w, lrfr_w;
Widget w;
XmString str;
Arg args[20];
int n;
/* make a fresh trails context */
tcp = (TrContext *) malloc (sizeof(TrContext));
if (!tcp) {
xe_msg (1, "Can not malloc for trail setup context.");
return (NULL);
}
/* save caller's callback function and client data */
tcp->cb = cb;
tcp->client = client;
/* make the shell */
n = 0;
XtSetArg (args[n], XmNallowShellResize, True); n++;
XtSetArg (args[n], XmNtitle, title); n++;
XtSetArg (args[n], XmNcolormap, xe_cm); n++;
XtSetArg (args[n], XmNiconName, "Trail"); n++;
XtSetArg (args[n], XmNdeleteResponse, XmUNMAP); n++;
sh_w = XtCreatePopupShell ("Trails", topLevelShellWidgetClass,
toplevel_w, args, n);
setup_icon (sh_w);
set_something (sh_w, XmNcolormap, (XtArgVal)xe_cm);
XtAddCallback (sh_w, XmNpopupCallback, prompt_map_cb, NULL);
XtAddCallback (sh_w, XmNpopdownCallback, popdown_cb, NULL);
XtAddCallback (sh_w, XmNdestroyCallback, destroy_cb, (XtPointer)tcp);
/* make the form */
n = 0;
XtSetArg (args[n], XmNautoUnmanage, False); n++;
XtSetArg (args[n], XmNmarginHeight, 10); n++;
XtSetArg (args[n], XmNmarginWidth, 10); n++;
XtSetArg (args[n], XmNfractionBase, 16); n++;
XtSetArg (args[n], XmNverticalSpacing, 8); n++;
mf_w = XmCreateForm (sh_w, "TF", args, n);
XtAddCallback (mf_w, XmNhelpCallback, help_cb, NULL);
XtManageChild (mf_w);
/* save shell in tcp for later destruction */
tcp->sh_w = sh_w;
/* create the bottons along the bottom */
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 1); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 3); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
ok_w = XmCreatePushButton (mf_w, "Ok", args, n);
XtAddCallback (ok_w, XmNactivateCallback, ok_cb, (XtPointer)tcp);
wtip (ok_w, "Use settings to create trail, close dialog");
XtManageChild (ok_w);
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 5); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 7); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
apply_w = XmCreatePushButton (mf_w, "Apply", args, n);
XtAddCallback (apply_w, XmNactivateCallback, apply_cb, (XtPointer)tcp);
wtip (apply_w, "Use settings to create trail, leave dialog up");
XtManageChild (apply_w);
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 9); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 11); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
close_w = XmCreatePushButton (mf_w, "Close", args, n);
XtAddCallback (close_w, XmNactivateCallback, close_cb, (XtPointer)tcp);
wtip (close_w, "Close dialog, make no trails");
XtManageChild (close_w);
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 13); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 15); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
help_w = XmCreatePushButton (mf_w, "Help", args, n);
XtAddCallback (help_w, XmNactivateCallback, help_cb, 0);
wtip (help_w, "More detailed information");
XtManageChild (help_w);
/* separator above bottom controls */
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, help_w); n++;
sep_w = XmCreateSeparator (mf_w, "Sep", args, n);
XtManageChild (sep_w);
/* labels and fields for before and after counts above separator */
n = 0;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 5); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, sep_w); n++;
lbl_w = XmCreateLabel (mf_w, "LB", args, n);
set_xmstring (lbl_w, XmNlabelString, "Ticks before Start:");
XtManageChild (lbl_w);
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 5); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 9); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, sep_w); n++;
XtSetArg (args[n], XmNshowValue, True); n++;
XtSetArg (args[n], XmNscaleMultiple, 1); n++;
XtSetArg (args[n], XmNmaximum, 256); n++;
XtSetArg (args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg (args[n], XmNprocessingDirection, XmMAX_ON_LEFT); n++;
n_w = XmCreateScale (mf_w, "TicksBefore", args, n);
wtip (n_w, "Set number of desired tick marks before Start time");
XtManageChild (n_w);
/* save counts-before widget id for later retrieval */
tcp->nb_w = n_w;
/* set default */
XmScaleSetValue (n_w, init->nbefore);
n = 0;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 11); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, sep_w); n++;
lbl_w = XmCreateLabel (mf_w, "LA", args, n);
set_xmstring (lbl_w, XmNlabelString, "after:");
XtManageChild (lbl_w);
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 11); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 15); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, sep_w); n++;
XtSetArg (args[n], XmNshowValue, True); n++;
XtSetArg (args[n], XmNscaleMultiple, 1); n++;
XtSetArg (args[n], XmNmaximum, 256); n++;
XtSetArg (args[n], XmNorientation, XmHORIZONTAL); n++;
n_w = XmCreateScale (mf_w, "TicksAfter", args, n);
wtip (n_w, "Set number of desired tick marks after Start time");
XtManageChild (n_w);
/* save counts-after widget id for later retrieval */
tcp->na_w = n_w;
/* set desired default tick mark count */
XmScaleSetValue (n_w, init->nticks - init->nbefore);
/* add tables at the top in their own form */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNbottomWidget, n_w); n++;
XtSetArg (args[n], XmNhorizontalSpacing, 5); n++;
XtSetArg (args[n], XmNverticalSpacing, 10); n++;
f_w = XmCreateForm (mf_w, "TF1", args, n);
XtManageChild (f_w);
/* make the header label across the top */
str = XmStringCreateSimple (hdr);
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNalignment, XmALIGNMENT_CENTER); n++;
XtSetArg (args[n], XmNlabelString, str); n++;
hdr_w = XmCreateLabel (f_w, "Header", args, n);
XtManageChild (hdr_w);
XmStringFree (str);
/* make a radio box for orientations in a frame. */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, hdr_w); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 2); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 33); n++;
ofr_w = XmCreateFrame (f_w, "OFR", args, n);
XtManageChild (ofr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (ofr_w, "ORC", args, n);
XtManageChild (rc_w);
/* make rb for orientation options */
make_rb(rc_w, "Orientation:", "Orientation", o_options, TRO_N,
tcp->o_w);
/* set desired default orientation */
XmToggleButtonSetState (tcp->o_w[init->o], True, True);
/* make a radio box for intervals in a frame.
* also put the custom TF and "whole" tb in the rc.
*/
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, hdr_w); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 35); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 66); n++;
ifr_w = XmCreateFrame (f_w, "IFR", args, n);
XtManageChild (ifr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (ifr_w, "IRC", args, n);
XtManageChild (rc_w);
/* make rb for interval options */
make_rb (rc_w, "Interval:", "Interval", i_options, TRI_N, tcp->i_w);
/* set desired default interval */
XmToggleButtonSetState (tcp->i_w[init->i], True, True);
/* add the TextField for entering custom interval,
* add callback to custom to let it change TextField sense,
* and init TF sens here now.
*/
n = 0;
XtSetArg (args[n], XmNcolumns, 10); n++;
w = XmCreateTextField (rc_w, "CustomInterval", args, n);
wtip (w, "Enter a custom tick mark interval, h:m:s <x>d <x>y");
XtManageChild (w);
tcp->custom_w = w;
XtSetSensitive (w, XmToggleButtonGetState(tcp->i_w[TRI_CUSTOM]));
XtAddCallback (tcp->i_w[TRI_CUSTOM], XmNvalueChangedCallback,
customint_cb, tcp->custom_w);
if (init->i == TRI_CUSTOM) {
char buf[64];
fs_sexa (buf, init->customi*24.0, 2, 3600);
XmTextFieldSetString (tcp->custom_w, buf);
}
/* make a radio box for label rates in a frame. */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, hdr_w); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 68); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 98); n++;
lrfr_w = XmCreateFrame (f_w, "LRFR", args, n);
XtManageChild (lrfr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (lrfr_w, "LRRC", args, n);
XtManageChild (rc_w);
/* make rb for label rates options */
make_rb(rc_w, "Label:", "TimeStamp",l_options,TRLR_N,tcp->l_w);
/* set desired default label rate */
XmToggleButtonSetState (tcp->l_w[init->l], True, True);
/* make a radio box for format options in a frame */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, ofr_w); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNbottomPosition, 95); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 2); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 33); n++;
fr_w = XmCreateFrame (f_w, "FFR", args, n);
XtManageChild (fr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (fr_w, "FRC", args, n);
XtManageChild (rc_w);
/* make rb for format options */
make_rb (rc_w, "Format:", "Format", f_options, TRF_N, tcp->f_w);
/* set desired default format */
XmToggleButtonSetState (tcp->f_w[init->f], True, True);
/* make a radio box for size options in a frame */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, ifr_w); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNbottomPosition, 95); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 35); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 66); n++;
fr_w = XmCreateFrame (f_w, "SFR", args, n);
XtManageChild (fr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (fr_w, "SRC", args, n);
XtManageChild (rc_w);
/* make rb for size options */
make_rb (rc_w, "Font:", "Size", s_options, TRS_N, tcp->s_w);
/* set desired default rounding */
XmToggleButtonSetState (tcp->s_w[init->s], True, True);
/* make a radio box for rounding options in a frame */
n = 0;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopWidget, lrfr_w); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNbottomPosition, 95); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 68); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 98); n++;
fr_w = XmCreateFrame (f_w, "RFR", args, n);
XtManageChild (fr_w);
n = 0;
XtSetArg (args[n], XmNadjustMargin, False); n++;
rc_w = XmCreateRowColumn (fr_w, "RRC", args, n);
XtManageChild (rc_w);
/* make rb for rounding options */
make_rb (rc_w, "Start:", "Start", r_options, TRR_N, tcp->r_w);
/* set desired default rounding */
XmToggleButtonSetState (tcp->r_w[init->r], True, True);
return (sh_w);
}
/* make a title and radio box inside rc.
* save each toggle button widget in savew[] array.
* would use frame's new title child but don't want to lock into 1.2 (yet)
*/
static void
make_rb (rc_w, title, name, op, nop, savew)
Widget rc_w;
char *title;
char *name;
RCOption *op;
int nop;
Widget savew[];
{
Widget l_w, rb_w, w;
XmString str;
Arg args[20];
int n;
int i;
str = XmStringCreateSimple (title);
n = 0;
XtSetArg (args[n], XmNlabelString, str); n++;
XtSetArg (args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
l_w = XmCreateLabel (rc_w, "L", args, n);
XtManageChild (l_w);
XmStringFree (str);
n = 0;
rb_w = XmCreateRadioBox (rc_w, name, args, n);
XtManageChild (rb_w);
for (i = 0; i < nop; i++, op++) {
str = XmStringCreateSimple (op->label);
n = 0;
XtSetArg (args[n], XmNvisibleWhenOff, True); n++;
XtSetArg (args[n], XmNindicatorType, XmONE_OF_MANY); n++;
XtSetArg (args[n], XmNlabelString, str); n++;
w = XmCreateToggleButton (rb_w, op->name, args, n);
XtManageChild (w);
XmStringFree (str);
savew[i] = w;
if (op->tip)
wtip (w, op->tip);
}
}
/* called when the Custom time interval TB changes.
* client is the TextField widget used to enter custom intervals.
*/
/* ARGSUSED */
static void
customint_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
XtSetSensitive ((Widget)client, XmToggleButtonGetState(w));
}
/* called when the Ok is hit.
* client is pointer to TrContext.
* pull out desired trail parameters then call the user's callback function.
* close if went ok.
*/
/* ARGSUSED */
static void
ok_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
TrContext *tcp;
/* fetch the TrContext */
tcp = (TrContext *)client;
/* do the work, close unless err */
if (do_trails (tcp) == 0)
XtPopdown (tcp->sh_w);
}
/* called when the Apply is hit.
* client is pointer to TrContext.
* pull out desired trail parameters then call the user's callback function.
*/
/* ARGSUSED */
static void
apply_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
TrContext *tcp;
/* fetch the TrContext */
tcp = (TrContext *)client;
/* do the work, stay up regardless */
(void) do_trails (tcp);
}
/* perform the actual trails work.
* return 0 if ok, else -1.
*/
static int
do_trails (tcp)
TrContext *tcp;
{
Now *np = mm_get_now();
TrState state;
TrTS *ttp;
int dow;
int m, y;
double d;
double t;
int cbret;
int i;
/* gather trail configuration */
if (get_options(tcp, &state) < 0)
return (-1);
/* get memory for list of time stamps */
ttp = (TrTS *) malloc (state.nticks * sizeof(TrTS));
if (!ttp) {
xe_msg (1, "Can not malloc tickmarks array.");
return (-1);
}
/* set initial time, t, as UTC according to rounding options.
*/
t = mjd;
if (pref_get(PREF_ZONE) == PREF_LOCALTZ)
t -= tz/24.; /* rounding in local time */
switch (state.r) {
case TRR_MIN:
t = ceil(t*24*60)/(24*60);
break;
case TRR_DAY:
t = ceil(t-0.5)+0.5;
break;
case TRR_INTER:
switch (state.i) {
case TRI_MIN:
t = ceil(t*24*60)/(24*60);
break;
case TRI_5MIN:
t = ceil(t*24*(60/5))/(24*(60/5));
break;
case TRI_HOUR:
t = ceil(t*24)/24;
break;
case TRI_DAY:
t = ceil(t-0.5)+0.5;
break;
case TRI_WEEK:
t = mjd_day (t);
while (mjd_dow (t, &dow) == 0 && dow != 0)
t += 1;
break;
case TRI_MONTH:
mjd_cal (t, &m, &d, &y);
d = 1;
if (++m > 12) {
m = 1;
y += 1;
}
cal_mjd (m, d, y, &t);
break;
case TRI_YEAR:
mjd_cal (t, &m, &d, &y);
d = 1;
m = 1;
y++;
cal_mjd (m, d, y, &t);
break;
case TRI_CUSTOM:
/* round to next nearest multiple of custom */
t = ceil(t*(1.0/state.customi))/(1.0/state.customi);
break;
default:
break;
}
break;
case TRR_NONE:
/* stay with current moment */
break;
default:
printf ("Bogus trail rounding code: %d\n", state.r);
abort();
}
if (pref_get(PREF_ZONE) == PREF_LOCALTZ)
t += tz/24.; /* back to UT */
/* move back by nbefore */
for (i = 0; i < state.nbefore; i++)
tStep (&t, &state, -1);
/* now fill in the time stamp times and formats */
for (i = 0; i < state.nticks; i++) {
TrTS *tp = &ttp[i];
/* time is just t */
tp->t = t;
/* determine whether to stamp this tickmark */
switch (state.l) {
case TRLR_1:
tp->lbl = 1;
break;
case TRLR_2:
tp->lbl = !(i % 2);
break;
case TRLR_5:
tp->lbl = !(i % 5);
break;
case TRLR_10:
tp->lbl = !(i % 10);
break;
case TRLR_FL:
tp->lbl = (i == 0 || i == state.nticks-1);
break;
case TRLR_FM:
tp->lbl = (i == 0 || i == state.nticks/2);
break;
case TRLR_ML:
tp->lbl = (i == state.nticks/2 || i == state.nticks-1);
break;
case TRLR_FML:
tp->lbl = (i==0 || i==state.nticks/2 || i==state.nticks-1);
break;
case TRLR_NONE:
tp->lbl = 0;
break;
default:
printf ("Bogus trail label rate code=%d\n", state.l);
abort();
}
/* advance time */
tStep (&t, &state, 1);
}
/* now call the users callback */
cbret = (*tcp->cb) (ttp, &state, tcp->client);
/* clean up what we malloced except
* TrContext isn't destroyed until user closes dialog.
*/
free ((char *)ttp);
/* ok */
return (cbret);
}
/* advance t forward or backward based on state */
static void
tStep (tp, statep, sign)
double *tp;
TrState *statep;
int sign;
{
int m, y;
double d;
if (abs(sign) != 1) {
printf ("tStep called with %d\n", sign);
abort();
}
switch (statep->i) {
case TRI_CUSTOM: *tp += sign*statep->customi; break;
case TRI_MIN: *tp += sign*1./(24.*60.); break;
case TRI_5MIN: *tp += sign*5./(24.*60.); break;
case TRI_HOUR: *tp += sign*1./24.; break;
case TRI_DAY: *tp += sign*1.0; break;
case TRI_WEEK: *tp += sign*7.0; break;
case TRI_MONTH:
mjd_cal (*tp, &m, &d, &y);
m += sign;
if (m > 12) {
m = 1;
y += 1;
} else if (m < 1) {
m = 12;
y -= 1;
}
cal_mjd (m, d, y, tp);
break;
case TRI_YEAR:
mjd_cal (*tp, &m, &d, &y);
y += sign;
cal_mjd (m, d, y, tp);
break;
default:
printf ("Bogus interval: %d\n", statep->i);
abort();
}
}
/* pull the options from tcp.
* return 0 if ok, else xe_msg() wny not and return -1.
*/
static int
get_options(tcp, statep)
TrContext *tcp;
TrState *statep;
{
int i, j;
/* find label rate */
for (i = 0; i < TRLR_N; i++) {
if (XmToggleButtonGetState(tcp->l_w[i]))
break;
}
if (i == TRLR_N) {
xe_msg (1, "Please select a tick mark label rate.");
return(-1);
}
statep->l = (TrLR)i;
/* find interval -- might be custom */
for (i = 0; i < TRI_N; i++) {
if (XmToggleButtonGetState(tcp->i_w[i]))
break;
}
if (i == TRI_N) {
xe_msg (1, "Please select a tick mark interval.");
return(-1);
}
statep->i = (TrInt)i;
if (statep->i == TRI_CUSTOM) {
char *str;
double days;
str = XmTextFieldGetString (tcp->custom_w);
if (strchr (str, 'y'))
days = strtod (str, NULL)*365.0;
else if (strchr (str, 'd'))
days = strtod (str, NULL);
else if (f_scansexa (str, &days) == 0)
days /= 24.0;
else {
xe_msg (1, "Format must be one of h:m:s <x>d <x>y");
XtFree (str);
return (-1);
}
XtFree (str);
if (days <= 0.0) {
xe_msg (1, "Please specify a positive custom interval.");
return(-1);
}
statep->customi = days;
}
/* find rounding mode */
for (i = 0; i < TRR_N; i++) {
if (XmToggleButtonGetState(tcp->r_w[i]))
break;
}
if (i == TRR_N) {
xe_msg (1, "Please select a rounding mode.");
return(-1);
}
statep->r = (TrRound)i;
/* find format mode */
for (i = 0; i < TRF_N; i++) {
if (XmToggleButtonGetState(tcp->f_w[i]))
break;
}
if (i == TRF_N) {
xe_msg (1, "Please select a format mode.");
return(-1);
}
statep->f = (TrFormat)i;
/* find size */
for (i = 0; i < TRS_N; i++) {
if (XmToggleButtonGetState(tcp->s_w[i]))
break;
}
if (i == TRS_N) {
xe_msg (1, "Please select a size.");
return(-1);
}
statep->s = (TrSize)i;
/* find orientation */
for (i = 0; i < TRO_N; i++) {
if (XmToggleButtonGetState(tcp->o_w[i]))
break;
}
if (i == TRO_N) {
xe_msg (1, "Please select an orientation.");
return(-1);
}
statep->o = (TrOrient)i;
/* get total number of tickmarks */
XmScaleGetValue (tcp->nb_w, &i);
XmScaleGetValue (tcp->na_w, &j);
if (i + j < 2) {
xe_msg (1, "Please specify at least 2 tick marks.");
return(-1);
}
statep->nbefore = i;
statep->nticks = i+j;
/* ok */
return (0);
}
/* called when unmapped */
/* ARGSUSED */
static void
popdown_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
/* N.B. don't free the userData here -- wait for destroy.
* turns out unmap callbacks run before ok_cb!
*/
XtDestroyWidget (w);
}
/* called when destroyed, client is TrContext to be free'd */
/* ARGSUSED */
static void
destroy_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
free ((char *)client);
}
/* called when the Close button is hit.
* client is a TrContext.
*/
/* ARGSUSED */
static void
close_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
TrContext *tcp;
/* fetch the TrContext */
tcp = (TrContext *)client;
XtPopdown (tcp->sh_w);
}
/* called when the Help button is hit */
/* ARGSUSED */
static void
help_cb (w, client, call)
Widget w;
XtPointer client;
XtPointer call;
{
hlp_dialog ("Trails", NULL, 0);
}
/* draw a timestamp (in parens if mark) for the given trail object at x, y.
* direction, size and content depend on tp, sp and the line endpoints.
*/
static void
draw_stamp (dsp, win, gc, tp, sp, mark, ticklen, lx, ly, x, y)
Display *dsp;
Drawable win;
GC gc;
TrTS *tp;
TrState *sp;
int mark;
int ticklen;
int lx, ly;
int x, y;
{
char buf[64], *bp;
double mag = 1.0;
double a = 0, ca, sa;
int align = 0;
int gap = GAP + ticklen;
Now *np = mm_get_now();
double t = tp->t;
/* do nothing if no labeling at all or none for this stamp */
if (sp->l == TRLR_NONE || !tp->lbl)
return;
/* make sure the fonts are ready */
if (!tr_fs)
tr_fs = getXResFont (fontxr);
/* establish character size */
switch (sp->s) {
case TRS_SMALL: mag = SMALL_MAG; break;
case TRS_MEDIUM: mag = MEDIUM_MAG; break;
case TRS_LARGE: mag = LARGE_MAG; break;
case TRS_HUGE: mag = HUGE_MAG; break;
case TRS_N: break;
}
/* fill buf with appropriate message and trim leading blanks */
if (pref_get(PREF_ZONE) == PREF_LOCALTZ) t -= tz/24.;
switch (sp->f) {
case TRF_HMS:
fs_time (buf, mjd_hr(t));
break;
case TRF_TIME:
fs_mtime (buf, mjd_hr(t));
break;
case TRF_DATE:
fs_date (buf, pref_get(PREF_DATE_FORMAT), t);
break;
case TRF_N:
buf[0] = '\0';
break;
}
for (bp = buf; *bp == ' '; bp++)
continue;
if (mark) {
int l = strlen(bp);
memmove (bp+1, bp, l);
bp[0] = '[';
bp[++l] = ']';
bp[++l] = '\0';
}
/* set up angle and alignment to rotate and translate into position.
* one rule is to never ask the user to look upside down even a little.
*/
switch (sp->o) {
case TRO_UP:
y -= gap; align = MLEFT; a = 90;
break;
case TRO_DOWN:
y += gap; align = MLEFT; a = -90;
break;
case TRO_LEFT:
x -= gap; align = MRIGHT; a = 0;
break;
case TRO_RIGHT:
x += gap; align = MLEFT; a = 0;
break;
case TRO_ABOVE:
y -= gap; align = BCENTRE; a = 0;
break;
case TRO_BELOW:
y += gap; align = TCENTRE; a = 0;
break;
case TRO_UPR:
x += gap; y -= gap; align = MLEFT; a = 45;
break;
case TRO_DOWNR:
x += gap; y += gap; align = MLEFT; a = -45;
break;
case TRO_PATHL:
if (x-lx == 0)
a = ly-y < 0 ? -PI/2 : PI/2;
else
a = atan2((double)(ly-y),(double)(x-lx)); /* -PI .. +PI */
a += PI/2;
ca = cos(a);
sa = sin(a);
x += (int)(ca*gap);
y -= (int)(sa*gap);
if (a > PI/2) {
a -= PI;
align = MRIGHT;
} else if (a < -PI/2) {
a += PI;
align = MRIGHT;
} else {
align = MLEFT;
}
a = raddeg(a);
break;
case TRO_PATHR:
if (x-lx == 0)
a = ly-y < 0 ? -PI/2 : PI/2;
else
a = atan2((double)(ly-y),(double)(x-lx)); /* -PI .. +PI */
a -= PI/2;
ca = cos(a);
sa = sin(a);
x += (int)(ca*gap);
y -= (int)(sa*gap);
if (a > PI/2) {
a -= PI;
align = MRIGHT;
} else if (a < -PI/2) {
a += PI;
align = MRIGHT;
} else {
align = MLEFT;
}
a = raddeg(a);
break;
case TRO_N:
break;
}
XPSRotDrawAlignedString (dsp, tr_fs, a, mag, win, gc, x, y, bp, align);
}
Reference in New Issue View Git Blame Copy Permalink