#ifndef lint
static char *rcsid = "$Header: xglobe.c,v 1.12 90/10/25 13:50:05 klee Exp Locker: klee $";
#endif lint
/*
 *			  COPYRIGHT 1990
 *		   DIGITAL EQUIPMENT CORPORATION
 *		       MAYNARD, MASSACHUSETTS
 *			ALL RIGHTS RESERVED.
 *
 * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
 * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
 * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
 * ANY PURPOSE.  IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
 *
 * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT RIGHTS,
 * APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN ADDITION TO THAT
 * SET FORTH ABOVE.
 *
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted, provided
 * that the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting documenta-
 * tion, and that the name of Digital Equipment Corporation not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.
 */
#include "xglobe.h"
#include "xmisc.h"
#include "Flip.h"

Widget slider, topLevel, globeWidget;
Cardinal n;
Arg wargs[20];
extern void slider2timer();

/* command line options */
static
XrmOptionDescRec options[] = {
    {"-minDelay", "*minDelay", XrmoptionSepArg, NULL },
};
/* resource lookup */
APP appResources;
static XtResource resources[] = {
    {"minDelay", "MinDelay", XtRInt, sizeof(int),
        XtOffset(APP_PTR, minDelay), XtRImmediate, (caddr_t)DEFAULT_MIN_DELAY },
};

main(argc, argv)
    int argc;
    char *argv[];
{
    Widget menuBar, workArea, mainWindow, commandArea;
    extern Widget createMenuBar(), createWorkArea(), createCommandArea();

    topLevel = XtInitialize(argv[0], "XGlobe", options, XtNumber(options),
	&argc, argv);
    XtGetApplicationResources(topLevel, &appResources, resources,
        XtNumber(resources), NULL, 0);
    if (appResources.minDelay < 1)
	appResources.minDelay = 1;
    createIcon(topLevel);

    mainWindow = XtCreateManagedWidget("mainWindow",
	xmMainWindowWidgetClass, topLevel, wargs, 0);
    menuBar = createMenuBar(mainWindow);
    workArea = createWorkArea(mainWindow);
    commandArea = createCommandArea(mainWindow);
    XmMainWindowSetAreas(mainWindow, menuBar, commandArea, NULL, NULL, workArea);

    XtRealizeWidget(topLevel);
    XtMainLoop();
}

Widget createCommandArea(parent)
    Widget parent;
{
    Widget frame, widget;
    extern void buttonCB(), sliderCB();

    frame = XtCreateManagedWidget("commandArea", xmRowColumnWidgetClass,
	    parent, wargs, 0);

    widget = XtCreateManagedWidget("start", xmPushButtonWidgetClass,
	frame, wargs, 0);
    XtAddCallback(widget, XmNactivateCallback, buttonCB, START_CB);
    widget = XtCreateManagedWidget("stop", xmPushButtonWidgetClass,
	frame, wargs, 0);
    XtAddCallback(widget, XmNactivateCallback, buttonCB, STOP_CB);

    widget = XtCreateManagedWidget("speed", xmLabelWidgetClass,
	frame, wargs, 0);
    slider = XtCreateManagedWidget("slider", xmScaleWidgetClass,
	frame, wargs, 0);
    XtAddCallback(slider, XmNvalueChangedCallback, sliderCB, VALUE_CB);
    return(frame);
}

void buttonCB(widget, clientData, callData)
    Widget widget;
    caddr_t clientData;
    caddr_t callData;
{
    extern void globeStart(), globeStop();
    switch((int)clientData) {
	case START_CB:
	    globeStart();
	    break;
	case STOP_CB:
	    globeStop();
	    break;
	default:
	    break;
    }
}

void sliderCB(widget, clientData, callData)
    Widget widget;
    caddr_t clientData;
    XmScaleCallbackStruct *callData;
{
    slider2timer(callData->value);
}

Widget createWorkArea(parent)
    Widget parent;
{
    /* workArea */
    globeWidget = XtCreateManagedWidget("globe", xkFlipWidgetClass,
	parent, wargs, 0);
    return(globeWidget);
}

void globeStart()
{
    n = 0;
    XtSetArg(wargs[n], XmNvalue, CCWISE); n++;
    XtSetValues(slider, wargs, n);
    slider2timer(CCWISE);
}

void globeStop()
{
    n = 0;
    XtSetArg(wargs[n], XmNvalue, XkSTOP); n++;
    XtSetValues(slider, wargs, n);
    slider2timer(XkSTOP);
}

void slider2timer(value)
    int value;
{
    extern void changeGlobe();
    unsigned int delay;

    if (value == XkSTOP) {
	n = 0;
	XtSetArg(wargs[n], XkNdelay, XkSTOP); n++;
	XtSetValues(globeWidget, wargs, n);
    } else if (value < 0) {
	int min;
	n = 0;
	XtSetArg(wargs[n], XmNminimum, &min); n++;
	XtGetValues(slider, wargs, n);
	delay = (value - min) * (value - min) + appResources.minDelay;
	changeGlobe(CWISE, delay);
    } else {
	int max;
	n = 0;
	XtSetArg(wargs[n], XmNmaximum, &max); n++;
	XtGetValues(slider, wargs, n);
	delay = (max - value) * (max - value) + appResources.minDelay;
	changeGlobe(CCWISE, delay);
    }
}

void changeGlobe(direction, delay)
    int direction;
    unsigned int delay;
{
    /* hyperdrive */
    int skip;
    if (delay < 40)
	skip = 8;
    else if (delay < 80)
	skip = 4;
    else if (delay < 160)
	skip = 2;
    else
	skip = 1;

    n = 0;
    XtSetArg(wargs[n], XkNdelay, delay); n++;
    XtSetArg(wargs[n], XkNdirection, direction); n++;
    XtSetArg(wargs[n], XkNskip, skip); n++;
    XtSetValues(globeWidget, wargs, n);
}