NetNews Usenet Archive 1992 #31/NN_1992_31.iso/spool/alt/sources/2895

Text File | 1992-12-29 | 55.5 KB | 2,273 lines

Newsgroups: alt.sources
Path: sparky!uunet!elroy.jpl.nasa.gov!swrinde!zaphod.mps.ohio-state.edu!magnus.acs.ohio-state.edu!usenet.ins.cwru.edu!eagle!sandman.lerc.nasa.gov!drich
From: [e-mail] (Daniel Rich)
Subject: xcdplayer-2.2, Part (4/5) - X11 CD player for Sun and SGI
Message-ID: <[e-mail]>
Sender: [e-mail]
Nntp-Posting-Host: sandman.lerc.nasa.gov
Organization: NASA Lewis Research Center
Date: Mon, 28 Dec 1992 22:56:55 GMT
Lines: 2261

Submitted-by: [e-mail]
Archive-name: xcdplayer-2.2/part04

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 4 (of 5)."
# Contents:  xcdplayer-2.2/button_setup.c xcdplayer-2.2/cdrom_callb.c
#   xcdplayer-2.2/program.c
# Wrapped by drich@sandman on Mon Dec 28 17:30:38 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -d 'xcdplayer-2.2' ; then
:
else
  mkdir xcdplayer-2.2
fi
if test -f 'xcdplayer-2.2/button_setup.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/button_setup.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/button_setup.c'\" \(15741 characters\)
sed "s/^X//" >'xcdplayer-2.2/button_setup.c' <<'END_OF_FILE'
X/*
X * Copyright (C) 1990 Regents of the University of California.
X *
X * Permission to use, copy, modify, distribute, and sell this software and
X * its documentation for any purpose is hereby granted without fee,
X * provided that the above copyright notice appear in all copies and that
X * both that copyright notice and this permission notice appear in
X * supporting documentation, and that the name of the University of
X * California not be used in advertising or publicity pertaining to
X * distribution of the software without specific, written prior
X * permission.  the University of California makes no representations
X * about the suitability of this software for any purpose.  It is provided
X * "as is" without express or implied warranty.
X */
X
X#include <stdio.h>
X# include <X11/Intrinsic.h>
X# include <X11/StringDefs.h>
X# include <X11/Xaw/Form.h>
X# include <X11/Xaw/Toggle.h>
X
X# include "cdrom_globs.h"
X#ifdef sun
X# include "cdrom_sun.h"
X#endif
X#ifdef sgi
X# include "cdrom_sgi.h"
X#endif
X
X# include "play.xbm"
X# include "pause.xbm"
X# include "stop.xbm"
X# include "prev.xbm"
X# include "next.xbm"
X# include "eject.xbm"
X#ifdef sgi
X# include "audio.xbm"
X#endif
X
X# include "quit.xbm"
X# include "cycle.xbm"
X# include "shuffle.xbm"
X# include "rewind.xbm"
X# include "ff.xbm"
X# include "pgm.xbm"
X
X
Xstatic Widget    buttons_form_widget;
Xstatic Widget    play_button_widget;
Xstatic Widget    stop_button_widget;
Xstatic Widget    pause_button_widget;
Xstatic Widget    eject_button_widget;
X#ifdef sgi
Xstatic Widget    audio_button_widget;
X#endif
Xstatic Widget    shuffle_button_widget;
Xstatic Widget    cycle_button_widget;
Xstatic Widget    pgm_button_widget;
X
X/*
X * these are global for the "scan" functions to query their state;
X * they and the code that they work with should probably be be switched
X * to repeater widgets once R5 becomes universal...
X */
XWidget    rew_button_widget;
XWidget    ff_button_widget;
X
X
Xvoid
Xbutton_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Arg        args[1];
X
X    extern void    title_dialog_setup();
X    extern void    play_button_setup();
X    extern void    stop_button_setup();
X    extern void    pause_button_setup();
X    extern void    prev_button_setup();
X    extern void    next_button_setup();
X    extern void    eject_button_setup();
X#ifdef sgi
X    extern void    audio_button_setup();
X#endif
X    extern void    quit_button_setup();
X    extern void    cycle_button_setup();
X    extern void    shuffle_button_setup();
X    extern void    rew_button_setup();
X    extern void    ff_button_setup();
X    extern void    pgm_button_setup();
X    extern void    buttons_reset();
X
X
X    buttons_form_widget = XtCreateManagedWidget("buttonsForm",
X                            formWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    play_button_setup(buttons_form_widget);
X
X    pause_button_setup(buttons_form_widget);
X
X    stop_button_setup(buttons_form_widget);
X
X    prev_button_setup(buttons_form_widget);
X
X    next_button_setup(buttons_form_widget);
X
X    eject_button_setup(buttons_form_widget);
X
X#ifdef sgi
X    audio_button_setup(buttons_form_widget);
X#endif
X
X    quit_button_setup(buttons_form_widget);
X
X    cycle_button_setup(buttons_form_widget);
X
X    shuffle_button_setup(buttons_form_widget);
X
X    rew_button_setup(buttons_form_widget);
X
X    ff_button_setup(buttons_form_widget);
X
X    pgm_button_setup(buttons_form_widget);
X
X
X    /* set the initial state of the buttons */
X    buttons_reset();
X}
X
Xstatic void
Xplay_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        play_button_pixmap;
X    Arg        args[1];
X
X    play_button_widget = XtCreateManagedWidget("playButton",
X                           toggleWidgetClass,
X                           parent_widget,
X                           (ArgList) NULL, 0);
X
X    play_button_pixmap = XCreateBitmapFromData(XtDisplay(play_button_widget),
X                           rootwin(play_button_widget),
X                           play_bits,
X                           play_width, play_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) play_button_pixmap);
X    XtSetValues(play_button_widget, args, 1);
X
X    XtAddCallback(play_button_widget, XtNcallback, cb_cdrom_play, 0);
X
X}
X
Xstatic void
Xpause_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        pause_button_pixmap;
X    Arg        args[1];
X
X    pause_button_widget = XtCreateManagedWidget("pauseButton",
X                            toggleWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    pause_button_pixmap = XCreateBitmapFromData(XtDisplay(pause_button_widget),
X                            rootwin(pause_button_widget),
X                            pause_bits,
X                            pause_width, pause_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) pause_button_pixmap);
X    XtSetValues(pause_button_widget, args, 1);
X
X    XtAddCallback(pause_button_widget, XtNcallback, cb_cdrom_pause, 0);
X}
X
Xstatic void
Xstop_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        stop_button_pixmap;
X    Arg        args[1];
X
X    stop_button_widget = XtCreateManagedWidget("stopButton",
X                           toggleWidgetClass,
X                           parent_widget,
X                           (ArgList) NULL, 0);
X
X    stop_button_pixmap = XCreateBitmapFromData(XtDisplay(stop_button_widget),
X                           rootwin(stop_button_widget),
X                           stop_bits,
X                           stop_width, stop_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) stop_button_pixmap);
X    XtSetValues(stop_button_widget, args, 1);
X
X    XtAddCallback(stop_button_widget, XtNcallback, cb_cdrom_stop, 0);
X
X}
X
Xstatic void
Xprev_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Widget        prev_button_widget;
X    Pixmap        prev_button_pixmap;
X    Arg        args[1];
X
X    prev_button_widget = XtCreateManagedWidget("prevButton",
X                          toggleWidgetClass,
X                          parent_widget,
X                          (ArgList) NULL, 0);
X
X    prev_button_pixmap = XCreateBitmapFromData(XtDisplay(prev_button_widget),
X                          rootwin(prev_button_widget),
X                          prev_bits,
X                          prev_width, prev_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) prev_button_pixmap);
X    XtSetValues(prev_button_widget, args, 1);
X
X    XtAddCallback(prev_button_widget, XtNcallback, cb_cdrom_previous, 0);
X}
X
Xstatic void
Xnext_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Widget        next_button_widget;
X    Pixmap        next_button_pixmap;
X    Arg        args[1];
X
X    next_button_widget = XtCreateManagedWidget("nextButton",
X                         toggleWidgetClass,
X                         parent_widget,
X                         (ArgList) NULL, 0);
X
X    next_button_pixmap = XCreateBitmapFromData(XtDisplay(next_button_widget),
X                         rootwin(next_button_widget),
X                         next_bits,
X                         next_width, next_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) next_button_pixmap);
X    XtSetValues(next_button_widget, args, 1);
X
X    XtAddCallback(next_button_widget, XtNcallback, cb_cdrom_next, 0);
X}
X
Xstatic void
Xeject_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        eject_button_pixmap;
X    Arg        args[1];
X
X    eject_button_widget = XtCreateManagedWidget("ejectButton",
X                            toggleWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    eject_button_pixmap = XCreateBitmapFromData(XtDisplay(eject_button_widget),
X                            rootwin(eject_button_widget),
X                            eject_bits,
X                            eject_width, eject_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) eject_button_pixmap);
X    XtSetValues(eject_button_widget, args, 1);
X
X    XtAddCallback(eject_button_widget, XtNcallback, cb_cdrom_eject, 0);
X}
X
X#ifdef sgi
Xstatic void
Xaudio_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        audio_button_pixmap;
X    Arg        args[1];
X
X    audio_button_widget = XtCreateManagedWidget("audioButton",
X                            toggleWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    audio_button_pixmap = XCreateBitmapFromData(XtDisplay(audio_button_widget),
X                            rootwin(audio_button_widget),
X                            audio_bits,
X                            audio_width, audio_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) audio_button_pixmap);
X    XtSetValues(audio_button_widget, args, 1);
X
X    XtAddCallback(audio_button_widget, XtNcallback, cb_cdrom_audio, 0);
X}
X#endif
X
Xstatic void
Xquit_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Widget        quit_button_widget;
X    Pixmap        quit_button_pixmap;
X    Arg        args[1];
X
X    quit_button_widget = XtCreateManagedWidget("quitButton",
X                            toggleWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    quit_button_pixmap = XCreateBitmapFromData(XtDisplay(quit_button_widget),
X                            rootwin(quit_button_widget),
X                            quit_bits,
X                            quit_width, quit_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) quit_button_pixmap);
X    XtSetValues(quit_button_widget, args, 1);
X
X    XtAddCallback(quit_button_widget, XtNcallback, cb_cdrom_quit, 0);
X}
X
Xstatic void
Xcycle_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Widget        cycle_button_widget;
X    Pixmap        cycle_button_pixmap;
X    Arg        args[1];
X
X    cycle_button_widget = XtCreateManagedWidget("cycleButton",
X                            toggleWidgetClass,
X                            parent_widget,
X                            (ArgList) NULL, 0);
X
X    cycle_button_pixmap = XCreateBitmapFromData(XtDisplay(cycle_button_widget),
X                            rootwin(cycle_button_widget),
X                            cycle_bits,
X                            cycle_width, cycle_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) cycle_button_pixmap);
X    XtSetValues(cycle_button_widget, args, 1);
X
X    XtAddCallback(cycle_button_widget, XtNcallback, cb_cdrom_cycle, 0);
X}
X
Xstatic void
Xshuffle_button_setup(parent_widget)
X    Widget        parent_widget;
X{
X    Pixmap        shuffle_button_pixmap;
X    Arg        args[1];
X
X    shuffle_button_widget = XtCreateManagedWidget("shuffleButton",
X                              toggleWidgetClass,
X                              parent_widget,
X                              (ArgList) NULL, 0);
X
X    shuffle_button_pixmap = XCreateBitmapFromData(XtDisplay(shuffle_button_widget),
X                              rootwin(shuffle_button_widget),
X                              shuffle_bits,
X                              shuffle_width, shuffle_height);
X
X    XtSetArg(args[0], XtNbitmap, (XtArgVal) shuffle_button_pixmap);
X    XtSetValues(shuffle_button_widget, args, 1);
X
X    XtAddCallback(shuffle_button_widget, XtNcallback, cb_cdrom_shuffle, 0);
X}
X
X
Xstatic void
Xrew_button_setup(parent_widget)
X        Widget          parent_widget;
X{
X        Pixmap          rew_button_pixmap;
X        Arg             args[1];
X
X        rew_button_widget = XtCreateManagedWidget("rewButton",
X                                                  toggleWidgetClass,
X                                                  parent_widget,
X                                                  (ArgList) NULL, 0);
X
X        rew_button_pixmap = XCreateBitmapFromData(XtDisplay(rew_button_widget),
X                                                  rootwin(rew_button_widget),
X                                                  rewind_bits,
X                                                  rewind_width, rewind_height);
X
X        XtSetArg(args[0], XtNbitmap, (XtArgVal) rew_button_pixmap);
X        XtSetValues(rew_button_widget, args, 1);
X
X        XtAddCallback(rew_button_widget, XtNcallback, cb_cdrom_rewind, 0);
X}
X
X
X
Xstatic void
Xff_button_setup(parent_widget)
X        Widget          parent_widget;
X{
X        Pixmap          ff_button_pixmap;
X        Arg             args[1];
X
X        ff_button_widget = XtCreateManagedWidget("ffButton",
X                                                 toggleWidgetClass,
X                                                 parent_widget,
X                                                 (ArgList) NULL, 0);
X
X        ff_button_pixmap = XCreateBitmapFromData(XtDisplay(ff_button_widget),
X                                                 rootwin(ff_button_widget),
X                                                 ff_bits,
X                                                 ff_width, ff_height);
X
X        XtSetArg(args[0], XtNbitmap, (XtArgVal) ff_button_pixmap);
X        XtSetValues(ff_button_widget, args, 1);
X
X        XtAddCallback(ff_button_widget, XtNcallback, cb_cdrom_ff, 0);
X}
X
Xstatic void
Xpgm_button_setup(parent_widget)
X        Widget          parent_widget;
X{
X        Pixmap          pgm_button_pixmap;
X        Arg             args[1];
X    extern Widget    top_form;
X
X        pgm_button_widget = XtCreateManagedWidget("pgmButton",
X                                                 toggleWidgetClass,
X                                                 parent_widget,
X                                                 (ArgList) NULL, 0);
X
X        pgm_button_pixmap = XCreateBitmapFromData(XtDisplay(pgm_button_widget),
X                                                 rootwin(pgm_button_widget),
X                                                 pgm_bits,
X                                                 pgm_width, pgm_height);
X
X        XtSetArg(args[0], XtNbitmap, (XtArgVal) pgm_button_pixmap);
X        XtSetValues(pgm_button_widget, args, 1);
X
X        XtAddCallback(pgm_button_widget, XtNcallback, cb_cdrom_program,
X        (XtPointer) top_form);
X}
X
Xvoid
Xplay_button_set() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(play_button_widget, args, 1);
X}
X
Xvoid
Xplay_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(play_button_widget, args, 1);
X}
X
Xvoid
Xpause_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(pause_button_widget, args, 1);
X}
X
Xvoid
Xstop_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(stop_button_widget, args, 1);
X}
X
Xvoid
Xeject_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(eject_button_widget, args, 1);
X}
X
Xvoid
Xeject_button_set() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(eject_button_widget, args, 1);
X}
X
X#ifdef sgi
Xvoid
Xaudio_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(audio_button_widget, args, 1);
X}
X
Xvoid
Xaudio_button_set() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(audio_button_widget, args, 1);
X}
X
Xint
Xaudio_button_state() {
X    Arg        args[1];
X    Boolean        state;
X
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(audio_button_widget, args, 1);
X    return(state);
X}
X#endif
X
Xvoid
Xshuffle_button_set() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(shuffle_button_widget, args, 1);
X}
X
Xvoid
Xshuffle_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(shuffle_button_widget, args, 1);
X}
X
Xvoid
Xcycle_button_reset() {
X    Arg        args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(cycle_button_widget, args, 1);
X}
X
Xvoid
Xpgm_button_set() {
X    Arg        args[2];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(pgm_button_widget, args, 1);
X}
X
Xvoid
Xpgm_button_reset() {
X    Arg        args[2];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(pgm_button_widget, args, 1);
X}
X
Xvoid
Xbuttons_reset() {
X    Arg        args[2];
X#ifdef sun
X    Boolean        state;
X#endif
X
X#ifdef sgi
X    if (cdi.scsi_audio) {
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(audio_button_widget, args, 1);
X    } else {
X        XtSetArg(args[0], XtNstate, False);
X        XtSetValues(audio_button_widget, args, 1);
X    }
X#endif
X
X    switch (cdrom_status()) {
X    case -1:
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(eject_button_widget, args, 1);
X        cdi.state |= CDROM_STATE_EJECTED;
X        disc_title = NODISCSTR;
X        update_title();
X        break;
X
X    case CDROM_PLAYING:
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(play_button_widget, args, 1);
X        cdi.state |= CDROM_STATE_PLAY;
X        cdrom_timer_on();
X        break;
X
X    case CDROM_PAUSED:
X#ifdef sun
X        /*
X         * The Sun doesn't have a "stop" state, so handle the
X         * initial startup condition.
X         */
X        XtSetArg(args[0], XtNstate, &state);
X        XtGetValues(pause_button_widget, args, 1);
X        if (state == False) {
X            XtSetArg(args[0], XtNstate, True);
X            XtSetValues(stop_button_widget, args, 1);
X            cdi.state |= CDROM_STATE_STOP;
X            break;
X        }
X#endif
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(play_button_widget, args, 1);
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(pause_button_widget, args, 1);
X        cdi.state |= CDROM_STATE_PLAY;
X        cdi.curtrack = cdrom_get_curtrack();
X        track_button_update(); /* make track button read on startup */
X        timer_button_update(); /* make timer button read on startup */
X        cdi.state |= CDROM_STATE_PAUSE;
X        break;
X
X    default:
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(stop_button_widget, args, 1);
X        cdi.state |= CDROM_STATE_STOP;
X        break;
X    }
X}
END_OF_FILE
if test 15741 -ne `wc -c <'xcdplayer-2.2/button_setup.c'`; then
    echo shar: \"'xcdplayer-2.2/button_setup.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/button_setup.c'
fi
if test -f 'xcdplayer-2.2/cdrom_callb.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/cdrom_callb.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/cdrom_callb.c'\" \(17018 characters\)
sed "s/^X//" >'xcdplayer-2.2/cdrom_callb.c' <<'END_OF_FILE'
X/*
X * Copyright (C) 1990 Regents of the University of California.
X *
X * Permission to use, copy, modify, distribute, and sell this software and
X * its documentation for any purpose is hereby granted without fee,
X * provided that the above copyright notice appear in all copies and that
X * both that copyright notice and this permission notice appear in
X * supporting documentation, and that the name of the University of
X * California not be used in advertising or publicity pertaining to
X * distribution of the software without specific, written prior
X * permission.  the University of California makes no representations
X * about the suitability of this software for any purpose.  It is provided
X * "as is" without express or implied warranty.
X */
X
X# include <X11/Intrinsic.h>
X# include <X11/StringDefs.h>
X# include <X11/Xaw/Form.h>
X# include <X11/Xaw/Toggle.h>
X
X# include <stdio.h>
X
X# include "debug.h"
X# include "cdrom_globs.h"
X#ifdef sun
X# include "cdrom_sun.h"
X#endif
X#ifdef sgi
X# include "cdrom_sgi.h"
X#endif
X
Xvoid        cdrom_new_disc();
X
X/*
X * cb_cdrom_play checks to see if we're playing; if so do nothing.
X * if not playing turns on playing.  if paused then return.
X * otherwise start cd playing.
X */
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_play(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_play: error from cdrom_open\n");
X        /* Turn the play button back off */
X        play_button_reset();
X        eject_button_set();
X        return;
X    }
X
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        cdrom_new_disc(widget);
X    }
X
X    /*
X     * toggle button weirdness; play and stop are radio toggles, ie. if
X     * you hit stop, and you are playing, play is supposed to stop, so
X     * toggle buttons automatically invoke the notify procedure of other
X     * members of a toggle group when another member of the toggle group
X     * is activated, before the requested notification takes place.
X     * The practical upshot of this is that this routine can be called
X     * even if you didn't press play, and so it really takes no action.
X     */
X    if (cdi.state & CDROM_STATE_PLAY) {
X        debug_printf(1, "cb_cdrom_play: already playing track %d\n",
X                cdi.curtrack);
X        return;
X    }
X
X    if (cdi.curtrack == 0)     /* (no track selected) */
X    {
X        cdi.curtrack = cdi.mintrack;
X        track_button_update();
X    }
X
X    cdi.state |= CDROM_STATE_PLAY;
X
X    if (cdi.state & CDROM_STATE_PAUSE) {
X        debug_printf(1, "cb_cdrom_play: paused on track %d\n",
X                cdi.curtrack);
X        return;
X    }
X
X    timer_fsecs = 0;
X    cdi.duration = 0;
X
X    if (cdi.state & CDROM_STATE_SHUFFLE)
X        cdi.curtrack = shuffle_next_track();
X
X    else if (cdi.state & CDROM_STATE_PROGRAM)
X    {
X        if ((cdi.curtrack = program_resume()) == 0) {
X
X        /* cancel program */
X        debug_printf(1, "cb_cdrom_play: cancelling program\n");
X        program_cancel();
X            cdi.curtrack = cdi.mintrack;
X        }
X        else {
X        debug_printf(1, "cb_cdrom_play: resetting timer button\n");
X            timer_button_reset();
X        }
X    }
X
X    if (cdrom_play() != -1) {
X        cdi.state &= ~CDROM_STATE_STOP;
X    }
X
X    timer_button_update();
X}
X
X/*
X * cb_cdrom_pause toggles pausing on or off.
X */
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_pause(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_pause: error from cdrom_open\n");
X        pause_button_reset();
X        return;
X    }
X
X#ifdef sgi
X    if (cdrom_status() == CDROM_NO_STATUS) {
X        cdi.state |= CDROM_STATE_EJECTED;
X        buttons_reset();
X        pause_button_reset();
X        return;
X    }
X#endif
X
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        cdrom_new_disc(widget);
X    }
X
X    if (cdi.state & CDROM_STATE_PAUSE) {
X        cdi.state &= ~CDROM_STATE_PAUSE;
X
X        if (cdi.state & CDROM_STATE_PROGRAM)
X            cdi.curtrack = program_resume();
X
X        else if (cdi.curtrack == 0)     /* (no track selected) */
X        {
X            cdi.curtrack = cdi.mintrack;
X            track_button_update();
X        }
X
X        debug_printf(1, "cb_cdrom_pause: resuming track %d\n",
X                cdi.curtrack);
X
X        /*
X         * if we use next or prev after a pause we can't
X         * just resume but have to move to the track.
X         */
X        if ((cdi.curtrack == cdrom_get_curtrack())  &&
X            (cdi.duration > 0))
X        {
X            if (cdrom_resume() != -1) {
X                cdi.state &= ~CDROM_STATE_EJECTED;
X                eject_button_reset();
X                cdi.state &= ~CDROM_STATE_STOP;
X            }
X
X            cdrom_timer_on();
X
X            return;
X        }
X
X        if (cdrom_play() != -1) {
X            cdi.state &= ~CDROM_STATE_EJECTED;
X            eject_button_reset();
X            cdi.state &= ~CDROM_STATE_STOP;
X        }
X
X        return;
X    }
X
X    cdi.state |= CDROM_STATE_PAUSE;
X
X    debug_printf(1, "cb_cdrom_pause: pausing on track %d\n",
X            cdi.curtrack);
X
X    if (cdrom_pause() != -1) {
X        cdi.state &= ~CDROM_STATE_STOP;
X        cdi.state |= CDROM_STATE_PLAY;
X        eject_button_reset();
X        play_button_set();
X    }
X
X    cdrom_timer_off();
X}
X
X/*
X * cb_cdrom_stop checks to see if we're playing; if not then
X * do nothing.  sets the current track to the first audio track.
X * turns off play, pause, stops the cd, and closes it so that the
X * disc can be ejected with the eject button on the drive.
X */
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_stop(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    Arg    args[1];
X    Boolean    state;
X
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_stop: error from cdrom_open\n");
X        /* Turn the stop button back off */
X        stop_button_reset();
X        eject_button_set();
X        return;
X    }
X
X#ifdef sgi
X    if (cdrom_status() == CDROM_NO_STATUS) {
X        cdi.state |= CDROM_STATE_EJECTED;
X        buttons_reset();
X        /* Turn the stop button back off */
X        stop_button_reset();
X        return;
X    }
X#endif
X
X    /* toggle button weirdness; see comment in cb_cdrom_play for details */
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(widget, args, 1);
X
X    if (state == False) {
X        debug_printf(1, "cb_cdrom_stop: already stopped\n");
X        return;
X    }
X
X    debug_printf(1, "cb_cdrom_stop: resetting disc\n");
X
X    cdrom_reset();
X
X    if (cdi.state & CDROM_STATE_SHUFFLE) {
X        debug_printf(1, "cb_cdrom_shuffle: shuffle on\n");
X        cdi.state |= CDROM_STATE_SHUFFLE;
X        shuffle_setup();
X    }
X}
X
X/*
X * cb_cdrom_previous decrments the current track.  if paused or stopped
X * then return.  otherwise start playing the (new) current track.
X */
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_previous(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_previous: error from cdrom_open\n");
X        return;
X    }
X
X#ifdef sgi
X    if (cdrom_status() == CDROM_NO_STATUS) {
X        cdi.state |= CDROM_STATE_EJECTED;
X        buttons_reset();
X        return;
X    }
X#endif
X
X    cdi.state &= ~CDROM_STATE_EJECTED;
X    eject_button_reset();
X    cdi.state &= ~CDROM_STATE_STOP;
X
X    cdrom_timer_off();
X
X    /*
X     * if playing less than replayThreshold seconds, back up to
X     * previous track; otherwise start at beginning of current track:
X     */
X    if (cdi.duration < replayThreshold)
X    {
X        if ((cdi.program != NULL) &&
X             (cdi.state & CDROM_STATE_PLAY) &&
X         ((cdi.state & CDROM_STATE_PAUSE) == 0))
X        {
X            if (program_prev_track() == 0)
X                debug_printf(1, "cb_cdrom_previous: no previous selections in program\n");
X            else
X        {
X                 debug_printf(1, "cb_cdrom_previous: going to prev selection\n");
X             cdi.curtrack = program_goto_prev_track();
X        }
X        }
X        else if (cdi.curtrack > cdi.mintrack) /* can't go below 1st track:*/
X            cdi.curtrack--;
X    }
X
X    timer_fsecs = 0;
X    cdi.duration = 0;
X
X    if (cdi.state & CDROM_STATE_SHUFFLE)
X        cdi.curtrack = shuffle_prev_track();
X
X    track_button_update();
X    timer_button_update();
X
X    if (cdi.state & CDROM_STATE_PAUSE) {
X        debug_printf(1, "cb_cdrom_previous: paused on track %d\n",
X                cdi.curtrack);
X        if (cdrom_play() != -1) {
X            cdi.state &= ~CDROM_STATE_STOP;
X        }
X        if (cdrom_pause() != -1) {
X            cdi.state &= ~CDROM_STATE_STOP;
X        }
X        cdrom_timer_off();
X        return;
X    }
X
X    if ((cdi.state & CDROM_STATE_PLAY) == 0) {
X        debug_printf(1, "cb_cdrom_previous: stopped on track %d\n",
X                cdi.curtrack);
X        return;
X    }
X
X    debug_printf(1, "cb_cdrom_previous: playing track %d\n",
X             cdi.curtrack);
X
X
X    /* restart playing if not paused and currently playing */
X    (void) cdrom_play();
X}
X
X
X/*
X * cb_cdrom_next incrments the current track.  if paused or stopped
X * then return.  otherwise start playing the (new) current track.
X */
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_next(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_next: error from cdrom_open\n");
X        return;
X    }
X
X#ifdef sgi
X    if (cdrom_status() == CDROM_NO_STATUS) {
X        cdi.state |= CDROM_STATE_EJECTED;
X        buttons_reset();
X        return;
X    }
X#endif
X
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        cdrom_new_disc(widget);
X    }
X
X    cdi.state &= ~CDROM_STATE_EJECTED;
X    eject_button_reset();
X    cdi.state &= ~CDROM_STATE_STOP;
X
X    if (cdi.state & CDROM_STATE_SHUFFLE) {
X        if (cdi.currand == cdi.ntracks) {
X            debug_printf(1, "cb_cdrom_next: at last track\n");
X            return;
X        }
X    }
X    else if ((cdi.program != NULL) &&
X             (cdi.state & CDROM_STATE_PLAY) &&
X         ((cdi.state & CDROM_STATE_PAUSE) == 0))
X    {
X        if (program_next_track() == 0)
X            debug_printf(1, "cb_cdrom_next: no further selections in program\n");
X        else
X        {
X            debug_printf(1, "cb_cdrom_next: going to next selection\n");
X            cdi.curtrack = program_goto_next_track();
X        }
X    }
X    else {
X        if (cdi.curtrack >= cdi.maxtrack) {
X            debug_printf(1, "cb_cdrom_next: at last track\n");
X            return;
X        }
X        else
X            cdi.curtrack++;
X    }
X
X    cdrom_timer_off();
X
X    timer_fsecs = 0;
X    cdi.duration = 0;
X
X
X    track_button_update();
X    timer_button_update();
X
X    if (cdi.state & CDROM_STATE_PAUSE) {
X        debug_printf(1, "cb_cdrom_next: paused on track %d\n",
X                cdi.curtrack);
X        if (cdrom_play() != -1) {
X            cdi.state &= ~CDROM_STATE_STOP;
X        }
X        if (cdrom_pause() != -1) {
X            cdi.state &= ~CDROM_STATE_STOP;
X        }
X        cdrom_timer_off();
X        return;
X    }
X
X    if ((cdi.state & CDROM_STATE_PLAY) == 0) {
X        debug_printf(1, "cb_cdrom_next: stopped on track %d\n",
X                cdi.curtrack);
X        return;
X    }
X
X    if (cdi.state & CDROM_STATE_SHUFFLE)
X        cdi.curtrack = shuffle_next_track();
X
X    debug_printf(1, "cb_cdrom_next: playing track %d\n",
X            cdi.curtrack);
X
X    /* restart playing if not paused and currently playing */
X    (void) cdrom_play();
X}
X
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_eject(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    Arg    args[1];
X    Boolean    state;
X
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_eject: error from cdrom_open\n");
X        return;
X    }
X
X#ifdef sgi
X    if (cdrom_status() == CDROM_NO_STATUS) {
X        cdi.state |= CDROM_STATE_EJECTED;
X        buttons_reset();
X        return;
X    }
X#endif
X
X    /* Check if this is just a toggle event.  If so, do nothing */
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(widget, args, 1);
X    if (state == False) {
X        return;
X    }
X
X    /* toggle button weirdness; see comment in cb_cdrom_play for details */
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        debug_printf(1, "cb_cdrom_eject: already ejected\n");
X        return;
X    }
X
X    debug_printf(1, "cb_cdrom_eject: ejecting on track %d\n",
X            cdi.curtrack);
X
X    cdrom_reset();
X    cdi.maxtrack = 0;
X
X    program_cancel();
X    cdrom_eject();
X    cdi.state |= CDROM_STATE_EJECTED;
X    cdrom_close();
X
X    disc_title = NODISCSTR;
X    update_title();
X}
X
X#ifdef sgi
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_audio(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_audio: error from cdrom_open\n");
X        return;
X    }
X
X    if (cdi.state & CDROM_STATE_PLAY) {
X        XBell(XtDisplay(widget), 100);
X        if (cdi.scsi_audio) {
X            audio_button_set();
X        } else {
X            audio_button_reset();
X        }
X        return;
X    }
X
X    if (cdi.scsi_audio) {
X        debug_printf(1, "cb_cdrom_audio: toggling audio off\n");
X        cdrom_toggle_audio();
X        audio_button_reset();
X        return;
X    }
X
X    /* Check if it's available before turning it on */
X    if ( cdrom_audio_avail() ) {
X        debug_printf(1, "cb_cdrom_audio: toggling audio on\n");
X        cdrom_toggle_audio();
X        audio_button_set();
X        return;
X    }
X    XBell(XtDisplay(widget), 100);
X    audio_button_reset();
X}
X#endif /* sgi */
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_cycle(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdi.state & CDROM_STATE_CYCLE) {
X        debug_printf(1, "cb_cdrom_cycle: cycle off\n");
X        cdi.state &= ~CDROM_STATE_CYCLE;
X
X        return;
X    }
X
X    debug_printf(1, "cb_cdrom_cycle: cycle on\n");
X    cdi.state |= CDROM_STATE_CYCLE;
X}
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_shuffle(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdi.state & CDROM_STATE_SHUFFLE) {
X
X        debug_printf(1, "cb_cdrom_shuffle: shuffle off\n");
X        cdi.state &= ~CDROM_STATE_SHUFFLE;
X
X        return;
X    }
X
X    if (cdi.state & CDROM_STATE_PLAY) {
X        XBell(XtDisplay(widget), 100);
X        shuffle_button_reset();
X        return;
X    }
X
X    if (cdi.state & CDROM_STATE_PROGRAM) {
X        debug_printf(1, "cb_cdrom_shuffle: cancelling program\n");
X        program_cancel();
X    }
X
X    debug_printf(1, "cb_cdrom_shuffle: shuffle on\n");
X    cdi.state |= CDROM_STATE_SHUFFLE;
X    shuffle_setup();
X}
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_quit(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    debug_printf(1, "cb_cdrom_quit: bye\n");
X
X    cdrom_timer_off();
X    cdrom_close();
X
X    exit(0);
X}
X
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_rewind(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_rew: error from cdrom_open\n");
X        return;
X    }
X
X    if ((cdi.state & CDROM_STATE_PLAY) || (cdi.state & CDROM_STATE_PAUSE)) {
X        debug_printf(1, "cb_cdrom_rew: moving backward in track %d\n",
X                cdi.curtrack);
X
X        cdrom_rewind();
X    }
X}
X
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_ff(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_ff: error from cdrom_open\n");
X        return;
X    }
X
X
X    if ((cdi.state & CDROM_STATE_PLAY) || (cdi.state & CDROM_STATE_PAUSE)) {
X        debug_printf(1, "cb_cdrom_ff: moving forward in track %d\n",
X                cdi.curtrack);
X
X        cdrom_ff();
X    }
X}
X
Xstatic Boolean pgmButtonUp = False;
X
X/*ARGSUSED*/
Xvoid
Xcb_cdrom_program(widget, topLevel, call_data)
X    Widget        widget;
X    Widget        topLevel;
X    XtPointer    call_data;
X{
X    if (pgmButtonUp)
X    {
X        track_button_reset();
X        pgm_button_set();
X
X        /*
X             * have to keep track of button position internally, since toggle
X             * widgets screw up when you mess with their state programatically,
X             * in that if you set the state to false when notified on a button
X             * press, if you also notify on button release, the state is
X             * auto-reset to true prior to notification, so there is no
X             * longer any way to tell if it's a button release:
X             * THIS IS A HACK! (necessary, but *still* a hack.)
X             */
X            pgmButtonUp = False;
X
X        return;
X    }
X
X    if ((cdi.state & CDROM_STATE_PROGRAM) == 0)
X    {
X        if (cdrom_open() == -1) {
X        debug_printf(1, "cb_cdrom_play: error from cdrom_open\n");
X        return;
X        }
X        if (cdi.state & CDROM_STATE_EJECTED) {
X            cdrom_new_disc(widget);
X        }
X        if (cdi.state & CDROM_STATE_SHUFFLE) {
X            debug_printf(1, "cb_cdrom_program: cancelling shuffle mode\n");
X            cdi.state &= ~CDROM_STATE_SHUFFLE;
X        shuffle_button_reset();
X        }
X        cdi.state &= ~CDROM_STATE_EJECTED;
X        eject_button_reset();
X        cdi.state &= ~CDROM_STATE_STOP;
X
X        debug_printf(1, "cb_cdrom_program: program on\n");
X        cdi.state |= CDROM_STATE_PROGRAM;
X        timer_button_set();
X        popup_program_form (widget, topLevel, call_data);
X            /*
X             * have to keep track of button position internally, since command
X             * widgets screw up if you mess with their state programatically:
X             */
X            pgmButtonUp = True;
X        return;
X    }
X
X    if (((cdi.state & CDROM_STATE_PAUSE) ||
X         ((cdi.state & CDROM_STATE_PLAY) == 0)) &&
X        (cdi.curtrack != 0))
X    {
X        /* indicate to user he's programmed a track: */
X        pgm_button_reset();
X        track_button_set();
X        timer_button_update();
X
X        debug_printf(1, "cb_cdrom_program: adding track %d to program list\n",
X        cdi.curtrack);
X        program_add_track (cdi.curtrack);
X    }
X        /*
X         * have to keep track of button position internally, since command
X         * widgets screw up if you mess with their state programatically:
X         */
X        pgmButtonUp = True;
X
X}
X
X
Xvoid
Xcdrom_new_disc(widget)
X    Widget    widget;
X{
X    Arg    args[1];
X    Boolean    state;
X
X    debug_printf(1, "cdrom_new_disc: resetting disc\n");
X
X    cdrom_reset();
X
X    cdi.state &= ~CDROM_STATE_EJECTED;
X    eject_button_reset();
X
X    /* toggle button weirdness; see comment in cb_cdrom_play for details */
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(widget, args, 1);
X    if (state == False) {
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(widget, args, 1);
X    }
X
X    if (cdi.state & CDROM_STATE_SHUFFLE) {
X        debug_printf(1, "cb_cdrom_shuffle: shuffle on\n");
X        cdi.state |= CDROM_STATE_SHUFFLE;
X        shuffle_setup();
X    }
X}
END_OF_FILE
if test 17018 -ne `wc -c <'xcdplayer-2.2/cdrom_callb.c'`; then
    echo shar: \"'xcdplayer-2.2/cdrom_callb.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/cdrom_callb.c'
fi
if test -f 'xcdplayer-2.2/program.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/program.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/program.c'\" \(18485 characters\)
sed "s/^X//" >'xcdplayer-2.2/program.c' <<'END_OF_FILE'
X/*
X * Copyright (C) 1990 Regents of the University of California.
X *
X * Permission to use, copy, modify, distribute, and sell this software and
X * its documentation for any purpose is hereby granted without fee,
X * provided that the above copyright notice appear in all copies and that
X * both that copyright notice and this permission notice appear in
X * supporting documentation, and that the name of the University of
X * California not be used in advertising or publicity pertaining to
X * distribution of the software without specific, written prior
X * permission.  the University of California makes no representations
X * about the suitability of this software for any purpose.  It is provided
X * "as is" without express or implied warranty.
X */
X
X# include <X11/Intrinsic.h>
X# include <X11/StringDefs.h>
X# include <X11/Shell.h>
X# include <X11/Xaw/Form.h>
X# include <X11/Xaw/Label.h>
X# include <X11/Xaw/List.h>
X# include <X11/Xaw/Command.h>
X# include <X11/Xaw/Toggle.h>
X# include <X11/Xaw/Viewport.h>
X# include <X11/Xaw/Dialog.h>
X
X
X# include <stdio.h>
X# include <string.h>
X# include <malloc.h>
X
X# include "debug.h"
X# include "cdrom_globs.h"
X#ifdef sun
X# include "cdrom_sun.h"
X#endif
X#ifdef sgi
X# include "cdrom_sgi.h"
X#endif
X
X
X/* externally manipulated vars: */
Xchar    program_str[100];
Xchar    *disc_title = NULL;
X
Xstatic    Widget    program_form;
Xstatic    Widget    program_display_form;
Xstatic    Widget    program_anchor;
Xstatic    Widget    trackbuttons[9];
Xstatic    Widget    plus10_button;
Xstatic    Widget    new_track_button;
Xstatic    Boolean    adding_to_new_track = False;
Xstatic    struct    prognode *current_node = NULL;
X
Xvoid
Xprogram_form_setup (parent_widget)
X    Widget    parent_widget;
X{
X        Arg    args[10];
X    char    namestr[2];
X    int    i;
X
X    Widget    program_display_viewport;
X    Widget    track_select_form;
X    Widget    clear_button;
X    Widget    cancel_button;
X    Widget    save_button;
X    Widget    all_button;
X
X    extern    void    cb_move_program_ptr();
X    extern    void    cb_clear_program();
X    extern    void    cb_cancel_program();
X    extern    void    cb_save_program();
X    extern    void    cb_trackbuttons();
X    extern    void    cb_add_10();
X    extern    void    cb_new_track();
X    extern    void    cb_program_all();
X
X    /*
X     * create program form as a non-managed widget, because this
X     * form "pops up" when requested, as part of the main form, and
X     * therefore moves along with the main form. (Pop-ups don't do this
X     * easily.)
X     */
X        program_form = XtCreateWidget("programForm",
X                formWidgetClass,
X                                parent_widget,
X                                (ArgList) NULL, 0);
X
X        program_display_viewport = XtCreateManagedWidget(
X                "programDisplayViewport",
X                                viewportWidgetClass,
X                program_form,
X                                (ArgList) NULL, 0);
X
X        program_display_form = XtCreateManagedWidget("programDisplayForm",
X                                formWidgetClass,
X                                program_display_viewport,
X                                (ArgList) NULL, 0);
X
X
X    XtSetArg(args[0], XtNlabel, " ");
X    XtSetArg(args[1], XtNstate, TRUE);
X    program_anchor = XtCreateManagedWidget("programSelection",
X                toggleWidgetClass,
X                program_display_form,
X                (ArgList) args, 2);
X    XtAddCallback (program_anchor, XtNcallback, cb_move_program_ptr, NULL);
X
X
X    XtSetArg(args[0], XtNfromVert, program_display_viewport);
X    clear_button = XtCreateManagedWidget("Clear",
X                commandWidgetClass,
X                program_form,
X                (ArgList) args, 1);
X    XtAddCallback (clear_button, XtNcallback, cb_clear_program, NULL);
X
X    XtSetArg(args[0], XtNfromVert, program_display_viewport);
X    XtSetArg(args[1], XtNfromHoriz, clear_button);
X    cancel_button = XtCreateManagedWidget("Cancel",
X                commandWidgetClass,
X                program_form,
X                (ArgList) args, 2);
X    XtAddCallback (cancel_button, XtNcallback, cb_cancel_program, NULL);
X
X
X    XtSetArg(args[0], XtNfromVert, program_display_viewport);
X    XtSetArg(args[1], XtNfromHoriz, cancel_button);
X    save_button = XtCreateManagedWidget("Save",
X                commandWidgetClass,
X                program_form,
X                (ArgList) args, 2);
X    XtAddCallback (save_button, XtNcallback, cb_save_program, NULL);
X
X
X    XtSetArg(args[0], XtNfromVert, clear_button);
X        track_select_form = XtCreateManagedWidget("selectForm",
X                formWidgetClass,
X                program_form,
X                (ArgList) args, 1);
X
X
X    for (i = 1; i <= 9; i++)
X    {
X        sprintf(namestr, "%d",i);
X        trackbuttons[i-1] = XtCreateManagedWidget(namestr,
X                    commandWidgetClass,
X                    track_select_form,
X                    (ArgList) NULL, 0);
X
X    }
X
X    XtAddCallback (trackbuttons[0], XtNcallback, cb_trackbuttons, NULL);
X
X    for (i = 1; i < 9; i++)
X    {
X        XtSetArg(args[0], XtNfromHoriz, trackbuttons[i-1]);
X        XtSetValues(trackbuttons[i], args, 1);
X        XtAddCallback (trackbuttons[i], XtNcallback, cb_trackbuttons, NULL);
X    }
X
X    XtSetArg(args[0], XtNfromVert, trackbuttons[0]);
X    plus10_button = XtCreateManagedWidget("+10",
X                commandWidgetClass,
X                track_select_form,
X                (ArgList) args, 1);
X    XtAddCallback (plus10_button, XtNcallback, cb_add_10, NULL);
X
X    XtSetArg(args[0], XtNfromVert, trackbuttons[0]);
X    XtSetArg(args[1], XtNfromHoriz, plus10_button);
X    new_track_button = XtCreateManagedWidget("  ",
X                commandWidgetClass,
X                track_select_form,
X                (ArgList) args, 2);
X    XtAddCallback (new_track_button, XtNcallback, cb_new_track, NULL);
X
X    XtSetArg(args[0], XtNfromVert, trackbuttons[0]);
X    XtSetArg(args[1], XtNfromHoriz, trackbuttons[6]);
X    all_button = XtCreateManagedWidget("All",
X                commandWidgetClass,
X                track_select_form,
X                (ArgList) args, 2);
X    XtAddCallback (all_button, XtNcallback, cb_program_all, NULL);
X
X}
X
Xvoid
Xpopup_program_form (widget, topLevel, call_data)
XWidget        widget;
XWidget        topLevel;
XXtPointer    call_data;
X{
X        Arg             args[2];
X    int        i;
X    char        *progstr;
X    char        *token;
X    int        track;
X
X    extern FILE     *disc_info;
X
X
X    cdi.selection = NULL;
X
X    /* load saved program (if any) */
X    if (disc_info != NULL)
X    {
X        /* copy "open" program str for tokenization */
X        progstr = strdup(program_str);
X        token = strtok(progstr, "-");     /* find 1st programmed track */
X        if (token != NULL)
X        {
X            debug_printf(1, "using stored program\n");
X            while (token != NULL)
X            {
X                sscanf(token, "%d",&track); /* convert to # */
X                program_add_track((unsigned char)track);
X                token = strtok(NULL,"-"); /* get next track str */
X            }
X        }
X    }
X
X    /* clear sensitivity for all */
X    for (i=0; i < 9; i++)
X    {
X        XtSetArg(args[0], XtNsensitive, FALSE);
X        XtSetValues(trackbuttons[i], args, 1);
X    }
X
X    XtSetArg(args[0], XtNsensitive, FALSE);
X    XtSetValues(plus10_button, args, 1);
X    XtSetValues(new_track_button, args, 1);
X
X    for (i = 0; (i < 9) && (i < cdi.maxtrack); i++)
X    {
X        /* set sensitivity for active buttons */
X        XtSetArg(args[0], XtNsensitive, TRUE);
X        XtSetValues(trackbuttons[i], args, 1);
X    }
X    if (cdi.maxtrack > 9)
X    {
X        XtSetArg(args[0], XtNsensitive, TRUE);
X        XtSetValues(plus10_button, args, 1);
X    }
X
X
X    XtManageChild(program_form);
X}
X
X
X
Xvoid
Xmake_program_button(node, next_to, label)
Xstruct    prognode *node;
XWidget    next_to;
Xchar    label[];
X{
X    Arg    args[10];
X    char    name[2];
X    int    i = 0;
X
X    XtSetArg(args[i], XtNfromHoriz, next_to); i++;
X    XtSetArg(args[i], XtNlabel, label); i++;
X    XtSetArg(args[i], XtNradioGroup, program_anchor); i++;
X    XtSetArg(args[i], XtNstate, TRUE); i++; /* activates *this* button */
X
X    node->button = XtCreateManagedWidget("programSelection",
X                toggleWidgetClass,
X                program_display_form,
X                (ArgList) args, i);
X    XtAddCallback(node->button, XtNcallback, cb_move_program_ptr,
X              (XtPointer) node);
X
X    if (node->next != NULL) /* then reposition widget following */
X    {
X        XtSetArg(args[0], XtNfromHoriz, node->button);
X        XtSetValues(node->next->button, args, 1);
X    }
X}
X
Xvoid
Xprogram_add_track (track)
Xunsigned char    track;
X{
X    struct prognode    *insert_point, *new, *next;
X    Arg    args[10];
X    char    *p;
X    char    label[3];
X    int    i;
X
X    XawFormDoLayout (program_display_form, FALSE);
X
X    if (cdi.program == NULL)
X    {
X        new = (struct prognode *) malloc(sizeof(struct prognode));
X        new->track = track;
X        new->next = NULL;
X        new->prev = NULL;
X        current_node = cdi.program = new;
X        cdi.lastprog = 1;
X
X        sprintf(label, "%d", track);
X        make_program_button(new, program_anchor, label);
X    }
X
X    else if (current_node == NULL) /* pre-insert */
X    {
X        new = (struct prognode *) malloc(sizeof(struct prognode));
X            new->track = track;
X            new->next = cdi.program;
X            new->prev = NULL;
X        current_node = cdi.program->prev = new;
X        cdi.program = cdi.program->prev;
X        cdi.lastprog++;
X
X        sprintf(label, "%d", track);
X        make_program_button(new, program_anchor, label);
X
X        sprintf(label, "-%d", new->next->track);
X        XtSetArg(args[0], XtNlabel, label);
X        XtSetValues(new->next->button, args, 1);
X    }
X    else
X    {
X        insert_point = cdi.program;
X
X        while ((insert_point->next != NULL) &&
X           (insert_point != current_node))
X         insert_point = insert_point->next;
X
X        new = (struct prognode *) malloc(sizeof(struct prognode));
X        new->track = track;
X        new->next = insert_point->next;
X        new->prev = insert_point;
X        if (new->next != NULL)
X            new->next->prev = new; /* complete link back */
X
X        cdi.lastprog++;
X        current_node = insert_point->next = new;
X
X        sprintf(label, "-%d", track);
X        make_program_button(new, insert_point->button, label);
X    }
X
X    next = cdi.program;
X    sprintf(program_str, "%d", next->track);
X    for (i = 1; i < cdi.lastprog; i++)
X    {
X        next = next->next;
X        sprintf(program_str, "%s-%d", program_str, next->track);
X    }
X
X
X    XawFormDoLayout (program_display_form, TRUE);
X
X
X    if (cdi.state & CDROM_STATE_PAUSE)
X    {
X        cdi.selection = new;
X        cdi.curtrack = new->track;
X        track_button_update();
X        timer_button_update();
X    }
X}
X
Xvoid
Xprogram_delete_track (node)
Xstruct prognode    *node;
X{
X    int i;
X    Arg    args[2];
X    char    *p;
X    char    label[3];
X
X    if (cdi.program == NULL)
X        return;
X
X    if (node->prev != NULL)
X    {
X        node->prev->next = node->next;
X        current_node = node->prev;
X        XtSetArg(args[0], XtNstate, True);
X        XtSetValues(current_node->button, args, 1);
X
X        XtSetArg(args[0], XtNfromHoriz, node->prev->button);
X    }
X    else
X    {
X        cdi.program = node->next;
X        current_node = cdi.program;
X        if (current_node != NULL)
X        {
X            sprintf(label, "%d", current_node->track);
X            XtSetArg(args[0], XtNlabel, label);
X            XtSetArg(args[1], XtNstate, True);
X            XtSetValues(current_node->button, args, 2);
X
X            XtSetArg(args[0], XtNfromHoriz, program_anchor);
X
X        }
X        else
X        {
X            XtSetArg(args[0], XtNstate, True);
X            XtSetValues(program_anchor, args, 1);
X        }
X    }
X
X    if (node->next != NULL)
X    {
X        node->next->prev = node->prev;
X        XtSetValues(node->next->button, args, 1);
X    }
X
X
X    XtDestroyWidget(node->button);
X    free(node);
X
X    cdi.lastprog--;
X
X    if (cdi.program == NULL)
X    {
X        program_str[0] = '\0';
X        cdi.selection = NULL;
X    }
X    else
X    {
X        cdi.selection = current_node;
X
X        if (cdi.state & CDROM_STATE_PAUSE)
X        {
X        cdi.curtrack = current_node->track;
X            track_button_update();
X            timer_button_update();
X        }
X
X        node = cdi.program;
X        sprintf(program_str, "%d", node->track);
X        for (i = 1; i < cdi.lastprog; i++)
X        {
X        node = node->next;
X        sprintf(program_str, "%s-%d", program_str, node->track);
X        }
X    }
X
X}
X
X
Xint
Xprogram_time_remaining()
X{
X    struct prognode *node;
X    int        time_remaining = 0;
X
X    if ((cdi.program == NULL) || (cdi.selection == NULL))
X        return (0);
X
X    node = cdi.selection;
X    while (node != NULL)
X    {
X        time_remaining += cdi.times[node->track - 1];
X        node = node->next;
X    }
X    time_remaining -= cdi.duration;
X    return (time_remaining);
X}
X
X
Xunsigned char
Xprogram_goto_next_track()
X{
X    Arg    arg;
X    Boolean    already_on;
X
X    if (cdi.program == NULL)
X        return (0);
X    else if (cdi.selection == NULL)
X        cdi.selection = cdi.program;
X    else if (cdi.selection->next == NULL)
X    {
X        cdi.selection = NULL;
X        return (0);
X    }
X    else
X        cdi.selection = cdi.selection->next;
X
X
X    XtSetArg(arg, XtNstate, &already_on);
X    XtGetValues(cdi.selection->button, &arg, 1);
X    if (already_on == FALSE)
X    {
X        XtSetArg(arg, XtNstate, TRUE);
X        XtSetValues(cdi.selection->button, &arg, 1);
X    }
X
X    pgm_button_set();
X    return(cdi.selection->track);
X}
X
Xunsigned char
Xprogram_resume()
X{
X    unsigned char    track;
X
X    if (cdi.program != NULL)
X    {
X        if (cdi.selection == NULL)
X        track = program_goto_next_track();
X        else
X        track = cdi.selection->track;
X    }
X    else
X        track = cdi.curtrack;
X    pgm_button_set();
X
X    return(track);
X}
X
X
Xunsigned char
Xprogram_goto_prev_track()
X{
X    Arg    arg;
X    Boolean    already_on;
X
X    if ((cdi.program == NULL) || (cdi.selection->prev == NULL))
X        return (0);
X
X    cdi.selection = cdi.selection->prev;
X
X    XtSetArg(arg, XtNstate, &already_on);
X    XtGetValues(cdi.selection->button, &arg, 1);
X    if (already_on == FALSE)
X    {
X        XtSetArg(arg, XtNstate, TRUE);
X        XtSetValues(cdi.selection->button, &arg, 1);
X    }
X
X    pgm_button_set();
X    return (cdi.selection->track);
X}
X
Xunsigned char
Xprogram_next_track()
X{
X    if (cdi.program == NULL)
X        return (0);
X
X    else if (cdi.selection == NULL)
X        return (cdi.program->track);
X
X    else if (cdi.selection->next == NULL)
X        return (0);
X    else
X        return (cdi.selection->next->track);
X
X}
X
Xunsigned char
Xprogram_prev_track()
X{
X    if ((cdi.program == NULL) || (cdi.selection == NULL) ||
X        (cdi.selection->prev == NULL))
X        return (0);
X
X    else
X        return (cdi.selection->prev->track);
X
X}
X
Xvoid
Xclear_program()
X{
X    Arg    arg;
X
X    /* clear new_track button and deactivate */
X    XtSetArg(arg, XtNlabel, "  ");
X    XtSetValues(new_track_button, &arg, 1);
X    XtSetArg(arg, XtNsensitive, False);
X    XtSetValues(new_track_button, &arg, 1);
X    adding_to_new_track = False;
X
X    if (cdi.program == NULL)
X        return;
X
X    cdi.selection = cdi.program;
X    while (cdi.selection->next != NULL)
X    {
X        cdi.program = cdi.program-> next;
X        XtDestroyWidget(cdi.selection->button);
X        free(cdi.selection);
X        cdi.selection = cdi.program;
X    }
X    XtDestroyWidget(cdi.selection->button);
X    free(cdi.selection);
X    cdi.selection = cdi.program = NULL;
X    cdi.lastprog = 0;
X    XtSetArg(arg, XtNstate, True);
X    XtSetValues(program_anchor, &arg, 1);
X
X    program_str[0]= '\0'; /* clear "store" string */
X
X}
X
Xvoid
Xprogram_cancel()
X{
X    debug_printf(1, "program mode cancelled\n");
X    clear_program();
X
X    XtUnmanageChild(program_form);
X    pgm_button_reset();
X    timer_button_reset();
X    timer_button_update();
X    cdi.state &= ~CDROM_STATE_PROGRAM;
X}
X
Xvoid
Xcb_move_program_ptr(widget, node, call_data)
XWidget        widget;
Xstruct prognode *node;
XXtPointer    call_data;
X{
X    /*
X     * I cannot get XawToggleGetCurrent to work at all, so this
X     * is a bastardized way of doing this:
X     */
X
X    Arg    arg;
X    Boolean    state;
X
X    XtSetArg(arg, XtNstate, &state);
X    XtGetValues(widget, &arg, 1);
X
X    if (state == True)
X    {
X        if ((current_node == node) && (current_node != NULL))
X        {
X        debug_printf(1, "deleting selection from program\n");
X        program_delete_track(node);
X        }
X        else
X        {
X            current_node = node;
X
X        if ((current_node != NULL) &&
X            ((cdi.state & CDROM_STATE_PAUSE) ||
X             ((cdi.state & CDROM_STATE_PLAY) == 0)))
X        {
X            cdi.selection = node;
X            cdi.curtrack = node->track;
X                track_button_update();
X                timer_button_update();
X        }
X        }
X    }
X
X}
X
X
Xstatic void
Xcb_program_all(widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    Arg    arg;
X    int i;
X
X    clear_program();
X
X    debug_printf(1, "program replaced by in-sequence track list\n");
X    for (i = 1; i <= cdi.maxtrack; i++)
X        program_add_track ((unsigned char) i);
X}
X
Xstatic void
Xcb_clear_program (widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    clear_program(); /* get rid of program */
X    debug_printf(1, "program cleared\n");
X}
X
Xstatic void
Xcb_cancel_program (widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    program_cancel(); /* get rid of program and form */
X}
X
Xvoid
Xcb_save_program (widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    Arg    arg;
X    char    *progstr;
X    extern FILE    *disc_info;
X
X    disc_info = fopen(info_filename, "w+"); /* open for r/w */
X    if (disc_info == NULL) {
X        fprintf(stderr,"Can't open save file %s\n",info_filename);
X        perror("cb_save_program");
X        return;
X    }
X    fprintf(disc_info, "Title:%s\nProgram: %s\n", disc_title, program_str);
X    fflush(disc_info);
X
X    debug_printf(1, "program saved to %s\n", info_filename);
X}
X
Xvoid
Xadd_to_new_track (number)
Xint    number;
X{
X    Arg    arg;
X    char    *namestr;
X    int    track = 0;
X
X    /* an apparent bug in my system won't allow the auto-display of this
X     * label change without explicit forcing redraw via something other
X     * than the label itself
X     */
X    XtSetArg(arg, XtNsensitive, False);
X    XtSetValues(new_track_button, &arg, 1);
X
X    XtSetArg(arg, XtNlabel, &namestr);
X    XtGetValues(new_track_button, &arg, 1);
X    if (namestr[0] != ' ')
X        sscanf (namestr, "%d", &track);
X    track += number;
X    sprintf(namestr, "%d\n", track);
X    XtSetArg(arg, XtNlabel, namestr);
X    XtSetValues(new_track_button, &arg, 1);
X
X    /* reset the sensitive flage for redraw */
X    XtSetArg(arg, XtNsensitive, True);
X    XtSetValues(new_track_button, &arg, 1);
X}
X
Xstatic void
Xcb_add_10(widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    Arg    arg;
X    char    *namestr;
X    int    track = 0;
X
X    XtSetArg(arg, XtNsensitive, True);
X    XtSetValues(new_track_button, &arg, 1);
X    adding_to_new_track = True;
X    add_to_new_track(10);
X}
X
Xstatic void
Xcb_new_track(widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    Arg    arg;
X    char    *namestr;
X    int    track;
X
X    XtSetArg(arg, XtNlabel, &namestr);
X    XtGetValues(widget, &arg, 1);
X    sscanf (namestr, "%d", &track);
X
X    if ((track >= cdi.mintrack) && (track <= cdi.maxtrack))
X    {
X        debug_printf(1, "adding track %d to program\n", track);
X        program_add_track((unsigned char) track);
X    }
X    XtSetArg(arg, XtNlabel, "  ");
X    XtSetValues(new_track_button, &arg, 1);
X    XtSetArg(arg, XtNsensitive, False);
X    XtSetValues(new_track_button, &arg, 1);
X    adding_to_new_track = False;
X}
X
X
Xstatic void
Xcb_trackbuttons(widget, client_data, call_data)
XWidget        widget;
XXtPointer    client_data;
XXtPointer    call_data;
X{
X    Arg    arg;
X    char    *namestr;
X    int    track;
X    Boolean state;
X
X    XtSetArg(arg, XtNlabel, &namestr);
X    XtGetValues(widget, &arg, 1);
X    sscanf (namestr, "%d", &track);
X
X    if (adding_to_new_track)
X        add_to_new_track(track);
X    else
X    {
X        debug_printf(1, "adding track %d to program\n", track);
X        program_add_track((unsigned char) track);
X    }
X
X}
END_OF_FILE
if test 18485 -ne `wc -c <'xcdplayer-2.2/program.c'`; then
    echo shar: \"'xcdplayer-2.2/program.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/program.c'
fi
echo shar: End of archive 4 \(of 5\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 5 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 5 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
--
Dan Rich                    | [e-mail]   |  [phone]
Sr. Systems Engineer        | "Danger, you haven't seen the last of me!"
RMS Technologies, Inc.      |    "No, but the first of you turns my stomach!"
NASA Lewis Research Center  | -- The Firesign Theatre's Nick Danger