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

Text File | 1992-12-29 | 47.8 KB | 2,119 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 (3/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:53:56 GMT
Lines: 2107

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

#! /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 3 (of 5)."
# Contents:  xcdplayer-2.2/cdrom_sun.c xcdplayer-2.2/internals.c
#   xcdplayer-2.2/logo_setup.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/cdrom_sun.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/cdrom_sun.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/cdrom_sun.c'\" \(12913 characters\)
sed "s/^X//" >'xcdplayer-2.2/cdrom_sun.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
Xstatic int c;
X
X# if defined(sun)
X# include <stdio.h>
X
X# include <sys/file.h>
X# include <sys/types.h>
X# include <sys/param.h>
X# include <sys/stat.h>
X
X# include <sun/dkio.h>
X
X# include <mntent.h>
X# include <string.h>
X
X# include <sys/buf.h>
X# ifdef sun4c
X# include <scsi/targets/srdef.h>
X# else
X# include <sundev/srreg.h>
X# endif
X
X# include <sys/time.h>
X
X# include "debug.h"
X# include "cdrom_sun.h"
X
Xextern char    *device;
X# if defined(notdef)
Xextern void    cdrom_print_toc();
X# endif /* defined(notdef) */
X
Xstatic char    cdrom[] =    "/dev/rsr0";
X
Xcdrom_info    cdi;
Xchar        info_filename[256];
XFILE        *disc_info = NULL;
X
Xstatic int    cdrom_fd = -1;
X
Xget_stored_info()
X{
X    int i,n;
X    char    line[100];
X    char    *title;
X
X        if ( cdi.maxtrack == 0) {
X                return(0);
X        }
X    for (i = 0, n = 0; i < cdi.maxtrack; i++)
X        n = n + ((i+1) * cdi.times[i]);
X    n = n / cdi.maxtrack;
X
X        disc_title = NULL;
X    if (cdInfoDir != NULL)
X        sprintf(info_filename, "%s/cd.%d", cdInfoDir, n);
X    else
X        sprintf(info_filename, "cd.%d", n);
X
X    if ((disc_info = fopen(info_filename, "r")) != NULL)
X    {
X        fgets(line, 100, disc_info);
X        title = strchr(line, ':');
X        if (title != NULL)
X        {
X            *(strchr(title, '\n')) = '\0';
X            disc_title = strdup(title + 1);
X        }
X        fgets(line, 100, disc_info);
X        sscanf(line, "Program: %s", program_str);
X    }
X        if (disc_title == NULL) {
X                disc_title = NOTITLESTR;
X        }
X}
X
Xint
Xcdrom_open() {
X    int    n;
X    extern void update_title();
X
X    if (cdrom_fd != -1)
X        return(cdi.curtrack);
X
X    if (device != NULL) {
X        if ((cdrom_fd = open(device, O_RDONLY)) == -1) {
X            debug-printf(stderr, "open: ");
X            return(-1);
X        }
X    } else {
X        if ((cdrom_fd = open(cdrom, O_RDONLY)) == -1) {
X            debug-printf(stderr, "open: ");
X            return(-1);
X        }
X    }
X
X    if (cdrom_get_times() == -1) {
X        cdrom_close();
X        return(-1);
X    }
X
X    if ((n = cdrom_get_curtrack()) == -1)
X        return(-1);
X
X    get_stored_info();
X
X    update_title();
X
X    if (cdi.state & CDROM_STATE_PLAY)
X        cdi.curtrack = n;
X
X    if (cdi.state & CDROM_STATE_SHUFFLE)
X        shuffle_setup();
X
X    return(cdi.curtrack);
X}
X
Xvoid
Xcdrom_close() {
X    if (cdrom_fd == -1)
X        return;
X
X    if (cdi.times != NULL) {
X        free((char *) cdi.times);
X        free((char *) cdi.addrs);
X        cdi.times = NULL;
X        cdi.addrs = NULL;
X    }
X
X    (void) close(cdrom_fd);
X    cdrom_fd = -1;
X}
X
X
Xint
Xcdrom_start() {
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMSTART) == -1) {
X        perror("ioctl(cdromstart)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_stop() {
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMSTOP) == -1) {
X        perror("ioctl(cdromstop)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_eject() {
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMEJECT) == -1) {
X        perror("ioctl(cdromeject)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_pause() {
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMPAUSE) == -1) {
X        perror("ioctl(cdrompause)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_resume() {
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMRESUME) == -1) {
X        perror("ioctl(cdromresume)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_volume(left_vol, right_vol)
X    int            left_vol;
X    int            right_vol;
X{
X    struct cdrom_volctrl    vol;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    vol.channel0 = left_vol;
X    vol.channel1 = right_vol;
X
X    if (ioctl(cdrom_fd, CDROMVOLCTRL, &vol) == -1) {
X        perror("ioctl(cdromvolctrl)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_get_times() {
X    struct cdrom_tochdr    tochdr;
X    extern unsigned short    *ushort_malloc();
X    extern struct msf    *msf_malloc();
X    unsigned long        trk, trk_total, otime;
X    struct msf        msf;
X
X    if (cdrom_read_tochdr(&tochdr) == -1)
X        return(-1);
X
X    cdi.mintrack = tochdr.cdth_trk0;
X    cdi.maxtrack = tochdr.cdth_trk1;
X
X    if (cdi.times != NULL)
X    {
X        free((char *) cdi.times);
X        free((char *) cdi.addrs);
X        cdi.times = NULL;
X        cdi.addrs = NULL;
X    }
X
X    cdi.times = ushort_malloc(cdi.maxtrack - cdi.mintrack + 1);
X    cdi.addrs = msf_malloc(cdi.maxtrack - cdi.mintrack + 2);
X
X    otime = 0;
X
X    for (trk = cdi.mintrack; trk <= cdi.maxtrack; trk++) {
X        if (cdrom_get_msf(trk, &msf, &trk_total) == -1)
X            return(-1);
X
X        /* record start address for each track (track 1 starts at 0)*/
X        cdi.addrs[trk - cdi.mintrack] = msf;
X
X        trk_total -= otime;
X
X        /* use start time of next track as length of previous */
X        if (otime != 0)
X        {
X            cdi.times[trk - cdi.mintrack - 1] = trk_total;
X        }
X
X        otime += trk_total;
X
X    }
X
X    /* find start of  leadout to get length of last track */
X    if (cdrom_get_msf(CDROM_LEADOUT, &msf, &trk_total) == -1)
X        return(-1);
X
X    /* recode leadout start address */
X    cdi.addrs[trk - cdi.mintrack] = msf;
X    trk_total -= otime;
X    otime += trk_total;
X
X    cdi.times[trk - cdi.mintrack - 1] = trk_total;
X
X    return(0);
X}
X
X# if defined(notdef)
Xstatic void
Xcdrom_print_toc() {
X    unsigned long        trk, trk_total;
X
X    for (trk = cdi.mintrack; trk <= cdi.maxtrack; trk++) {
X        trk_total = cdi.times[trk - cdi.mintrack];
X        debug_printf(1, "%02u:%02u\n", trk_total/60, trk_total%60);
X    }
X}
X# endif /* defined(notdef) */
X
Xint
Xcdrom_get_curtrack() {
X    struct cdrom_subchnl    subchnl;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMSUBCHNL, (char *) &subchnl) == -1) {
X        fprintf(stderr, "ioctl(cdromsubchnl): ");
X        perror(cdrom);
X        return(-1);
X    }
X
X    switch (subchnl.cdsc_audiostatus) {
X        case CDROM_AUDIO_INVALID:
X        return(-1);
X
X        /* playing track subchnl.cdsc_trk */
X        case CDROM_AUDIO_PLAY:
X        return((int) subchnl.cdsc_trk);
X
X        /* paused on track subchnl.cdsc_trk */
X        case CDROM_AUDIO_PAUSED:
X        return((int) subchnl.cdsc_trk);
X
X        /* punt */
X        case CDROM_AUDIO_COMPLETED:
X        return(0);
X
X        case CDROM_AUDIO_ERROR:
X        return(-1);
X
X        /* punt */
X        case CDROM_AUDIO_NO_STATUS:
X        debug_printf(1, "cdrom_get_curtrack: no status\n");
X        return(0);
X    }
X
X    /* bad value in cdsc_audiostatus */
X    return(-1);
X}
X
Xint
Xcdrom_get_msf(track, msf, length)
X    unsigned long        track;
X    struct msf        *msf;
X    unsigned long        *length;
X{
X    struct cdrom_tocentry    tocentry;
X
X    if (cdrom_read_tocentry(track, &tocentry) == -1)
X        return(-1);
X
X    msf->minute = tocentry.cdte_addr.msf.minute;
X    msf->second = tocentry.cdte_addr.msf.second;
X    msf->frame = tocentry.cdte_addr.msf.frame;
X
X    *length = ((int) tocentry.cdte_addr.msf.minute * 60) +
X        (int) tocentry.cdte_addr.msf.second;
X
X    return(0);
X}
X
Xint
Xcdrom_get_curmsf(msf)
X    struct msf *msf;
X{
X    struct cdrom_subchnl    subchnl;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    subchnl.cdsc_format = CDROM_MSF;
X
X    if (ioctl(cdrom_fd, CDROMSUBCHNL, (char *) &subchnl) == -1) {
X        perror("ioctl(cdromsubchnl)");
X        return(-1);
X    }
X
X    msf->minute = subchnl.cdsc_absaddr.msf.minute;
X    msf->second = subchnl.cdsc_absaddr.msf.second;
X    msf->frame = subchnl.cdsc_absaddr.msf.frame;
X
X    return (0);
X
X}
X
Xint
Xcdrom_play_track(start_track, end_track)
X    unsigned char        start_track;
X    unsigned char        end_track;
X{
X    struct    cdrom_ti    ti;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    ti.cdti_trk0 = start_track;
X    ti.cdti_ind0 = 1;
X    ti.cdti_trk1 = end_track;
X    ti.cdti_ind1 = 1;
X
X    if (ioctl(cdrom_fd, CDROMPLAYTRKIND, &ti) == -1) {
X        perror("ioctl(cdromplaytrkind)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_play_msf(start_msf, end_msf)
X    struct msf    *start_msf;
X    struct msf    *end_msf;
X{
X    struct    cdrom_msf    play_addr;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    play_addr.cdmsf_min0 = start_msf->minute;
X    play_addr.cdmsf_sec0 = start_msf->second;
X    play_addr.cdmsf_frame0 = start_msf->frame;
X    play_addr.cdmsf_min1 = end_msf->minute;
X    play_addr.cdmsf_sec1 = end_msf->second;
X    play_addr.cdmsf_frame1 = end_msf->frame;
X
X    if (ioctl(cdrom_fd, CDROMPLAYMSF, &play_addr) == -1) {
X        perror("ioctl(cdromplaymsf)");
X        return(-1);
X    }
X
X    return(0);
X}
Xint
Xcdrom_read_tocentry(track, tocentry)
X    unsigned int        track;
X    struct cdrom_tocentry    *tocentry;
X{
X    if (cdrom_fd == -1)
X        return(-1);
X
X    tocentry->cdte_track = track;
X    tocentry->cdte_format = CDROM_MSF;
X
X    if (ioctl(cdrom_fd, CDROMREADTOCENTRY, (char *) tocentry) == -1) {
X        perror("ioctl(cdromreadtocentry)");
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_read_tochdr(tochdr)
X    struct cdrom_tochdr    *tochdr;
X{
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMREADTOCHDR, (char *) tochdr) == -1) {
X        debug-printf(stderr,"ioctl(cdromreadtochdr): ");
X        /* perror("ioctl(cdromreadtochdr)"); */
X        return(-1);
X    }
X
X    return(0);
X}
X
Xint
Xcdrom_status() {
X    struct cdrom_subchnl    subchnl;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    if (ioctl(cdrom_fd, CDROMSUBCHNL, (char *) &subchnl) == -1) {
X        fprintf(stderr, "ioctl(cdromsubchnl): ");
X        perror(cdrom);
X        exit(1);
X    }
X
X    switch (subchnl.cdsc_audiostatus) {
X        case CDROM_AUDIO_INVALID:
X        return(CDROM_INVALID);
X
X        case CDROM_AUDIO_PLAY:
X        return(CDROM_PLAYING);
X
X        case CDROM_AUDIO_PAUSED:
X        return(CDROM_PAUSED);
X
X        case CDROM_AUDIO_COMPLETED:
X        return(CDROM_COMPLETED);
X
X        case CDROM_AUDIO_ERROR:
X        return(CDROM_ERROR);
X
X        case CDROM_AUDIO_NO_STATUS:
X        return(CDROM_NO_STATUS);
X    }
X
X    return(-1);
X}
X
X# if defined(notused)
Xint
Xcdrom_playing(track)
X    int            *track;
X{
X    struct cdrom_subchnl    sc;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    sc.cdsc_format = CDROM_MSF;
X    if (ioctl(cdrom_fd, CDROMSUBCHNL, &sc) == -1) {
X        perror("ioctl(cdromsubchnl)");
X        return(-1);
X    }
X
X    *track = sc.cdsc_trk;
X
X    if (sc.cdsc_audiostatus == CDROM_AUDIO_PLAY)
X        return(1);
X
X    return(0);
X}
X# endif /* defined(notused) */
X
X# if defined(notused)
Xint
Xcdrom_paused(track)
X    int            *track;
X{
X    struct cdrom_subchnl    sc;
X
X    if (cdrom_fd == -1)
X        return(-1);
X
X    sc.cdsc_format = CDROM_MSF;
X    if (ioctl(cdrom_fd, CDROMSUBCHNL, &sc) == -1) {
X        perror("ioctl(cdromsubchnl)");
X        return(-1);
X    }
X
X    *track = sc.cdsc_trk;
X
X    if (sc.cdsc_audiostatus == CDROM_AUDIO_PAUSED)
X        return(1);
X
X    return(0);
X}
X# endif /* defined(notused) */
X
X# if defined(notused)
Xint
Xmounted(name)
X    char        *name;
X{
X    char        buf[MAXPATHLEN], *cp;
X    struct stat    st;
X    dev_t        bdevno;
X    FILE        *fp;
X    struct mntent    *mnt;
X
X    /*
X     * Get the block device corresponding to the raw device opened,
X     * and find its device number.
X     */
X    if (stat(name, &st) != 0) {
X        (void) fprintf(stderr, "stat: ");
X        perror(name);
X        return(UNMOUNTED);
X    }
X
X    /*
X     * If this is a raw device, we have to build the block device name.
X     */
X    if ((st.st_mode & S_IFMT) == S_IFCHR) {
X        if ((cp = strchr(name, 'r')) != NULL)
X            cp++;
X
X        (void) sprintf(buf, "/dev/%s", cp);
X        if (stat(buf, &st) != 0) {
X            (void) fprintf(stderr, "stat: ");
X            perror(buf);
X            return(UNMOUNTED);
X        }
X    }
X
X    if ((st.st_mode & S_IFMT) != S_IFBLK)
X        return(UNMOUNTED);
X
X    bdevno = st.st_rdev & (dev_t)(~0x07);    /* Mask out partition. */
X
X    /*
X     * Now go through the mtab, looking at all hsfs filesystems.
X     * Compare the device mounted with our bdevno.
X     */
X    if ((fp = setmntent(MOUNTED, "r")) == NULL) {
X        (void) fprintf(stderr, "couldn't open %s\n", MOUNTED);
X        return(UNMOUNTED);
X    }
X
X    while ((mnt = getmntent(fp)) != NULL) {
X        /* avoid obvious excess stat(2)'s */
X        if (strcmp(mnt->mnt_type, "hsfs") != 0)
X            continue;
X
X        if (stat(mnt->mnt_fsname, &st) != 0)
X            continue;
X
X        if (((st.st_mode & S_IFMT) == S_IFBLK) &&
X            ((st.st_rdev & (dev_t)(~0x07)) == bdevno)) {
X            (void) endmntent(fp);
X            return(STILL_MOUNTED);
X        }
X    }
X
X    (void) endmntent(fp);
X
X    return(UNMOUNTED);
X}
X# endif /* defined(notused) */
X
Xunsigned short *
Xushort_malloc(n)
X    int        n;
X{
X    extern char    *calloc();
X    unsigned short    *ptr;
X
X    ptr = (unsigned short *) calloc(n, sizeof(unsigned short));
X    if (ptr == NULL) {
X        perror("calloc");
X        exit(1);
X    }
X
X    return(ptr);
X}
X
Xstruct msf *
Xmsf_malloc(n)
X    int        n;
X{
X    extern char    *calloc();
X    struct msf    *ptr;
X
X    ptr = (struct msf *) calloc(n, sizeof(struct msf));
X    if (ptr == NULL) {
X        perror("calloc");
X        exit(1);
X    }
X
X    return(ptr);
X}
X
Xint
Xcdrom_disp_cdi() {
X    int trk;
X
X    fprintf(stderr,"CDI structure:\n");
X    fprintf(stderr,"\tcurtrack: %d\n",cdi.curtrack);
X    fprintf(stderr,"\tmin: %d  max: %d  total: %d\n",
X        cdi.mintrack, cdi.maxtrack, cdi.ntracks);
X    fprintf(stderr,"\tdur: %d  state: %2x\n",cdi.duration, cdi.state);
X    fprintf(stderr,"\tcurrand: %d  lastprog: %d\n",
X        cdi.currand, cdi.lastprog);
X    fprintf(stderr,"\n\tTracklist:\n");
X    if (cdi.maxtrack != cdi.mintrack) {
X        for (trk=cdi.mintrack; trk<=cdi.maxtrack; trk++) {
X            fprintf(stderr,"\t%3d: %d %02d:%02d %d\n",trk,cdi.times[trk],
X                cdi.addrs[trk].minute,cdi.addrs[trk].second,
X                cdi.addrs[trk].frame);
X        }
X    }
X}
X
X# endif /* defined(sun) */
END_OF_FILE
if test 12913 -ne `wc -c <'xcdplayer-2.2/cdrom_sun.c'`; then
    echo shar: \"'xcdplayer-2.2/cdrom_sun.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/cdrom_sun.c'
fi
if test -f 'xcdplayer-2.2/internals.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/internals.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/internals.c'\" \(15296 characters\)
sed "s/^X//" >'xcdplayer-2.2/internals.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
X
Xstatic XtIntervalId    ivid            = -1;
Xstatic XtIntervalId    scanivid        = -1;
Xstatic XtIntervalId    stativid        = -1;
Xstatic unsigned int    timer_mod        = 1000 / TIMER_PERIOD;
Xunsigned int        timer_fsecs;
X
X
Xint
Xcdrom_get_curtime() {
X
X    int curtime;
X    int curtrack;
X    struct msf curmsf, track_start;
X
X    if (cdrom_open() == -1) {
X        debug_printf(1, "cdrom_get_curtime: error from cdrom_open\n");
X        return;
X    }
X
X    switch (cdrom_status()) {
X    case CDROM_PAUSED:
X    case CDROM_PLAYING:
X        if (cdrom_get_curmsf(&curmsf) == -1) {
X        debug_printf(1, "get_curtime: error reading location\n");
X        return;
X        }
X
X        if (((curtrack = cdrom_get_curtrack()) == -1) ||
X        (curtrack != cdi.curtrack))
X        {
X        return(0);
X        }
X        else
X        {
X            track_start = cdi.addrs[cdi.curtrack - 1];
X            curtime = (curmsf.minute - track_start.minute) * 60 +
X            (curmsf.second - track_start.second) + 1;
X
X            return (curtime);
X        }
X        break;
X    default:
X        return(0);
X    }
X}
X
X
X/*
X * we poll the cd-rom drive every TIMER_PERIOD milliseconds to see where
X * it is and if it's on a new track, and update the label widget.
X */
Xvoid
Xcdrom_timer_on() {
X    static void    update_track();
X
X    if (cdi.state & CDROM_STATE_PLAY)
X        ivid = XtAppAddTimeOut(appc, TIMER_PERIOD, update_track, NULL);
X}
X
X
X/*
X * cdrom_timer_off turns off the X timeout.
X */
Xvoid
Xcdrom_timer_off() {
X    if (ivid != -1) {
X        XtRemoveTimeOut(ivid);
X        ivid = -1;
X    }
X}
X
X/*
X * activates player by track/index:
X */
Xint
Xcdrom_play() {
X    int    ret;
X
X    debug_printf(1, "cdrom_play: starting track %d\n", (int) cdi.curtrack);
X
X    track_button_update();
X
X    if ((cdi.state & CDROM_STATE_SHUFFLE) ||
X        (cdi.state & CDROM_STATE_PROGRAM))
X        ret = cdrom_play_track(cdi.curtrack, cdi.curtrack);
X    else
X        ret = cdrom_play_track(cdi.curtrack, cdi.maxtrack);
X
X    cdrom_timer_on();
X
X    return(ret);
X}
X
X
X/*
X * resets player to disc origin and turns off all modes:
X */
Xvoid
Xcdrom_reset() {
X
X    cdrom_timer_off();
X
X    if (cdi.curtrack != 0)
X    {
X        cdi.curtrack = 1;
X        (void) cdrom_play(); /* force disk to beginning */
X
X        /*
X         * "pause disk" immediately; doesn't appear that you can truly
X         * stop the disk at origin; just stop at current location...
X         */
X        cdrom_stop();
X        cdi.state |= CDROM_STATE_STOP;
X        debug_printf(1, "cdrom_reset: forcing immediate stop\n");
X        leds_stop();
X        cdrom_timer_off();
X        cdi.curtrack = 0;
X    }
X
X    cdi.state &= ~(CDROM_STATE_PLAY | CDROM_STATE_PAUSE |
X                CDROM_STATE_EJECTED);
X
X    update_title();
X
X    play_button_reset();
X    pause_button_reset();
X    timer_button_reset();
X
X    track_button_update();
X    timer_button_update();
X}
X
X/*
X * rewinds the player through minute/second/frames:
X */
Xvoid
Xcdrom_rewind () {
X    struct msf    track_start;
X        struct msf    start_addr, end_addr;
X    int        curtrack;
X    extern void     scan_update();
X
X    if (cdrom_get_curmsf(&start_addr) == -1) {
X        debug_printf(1, "rew: error reading location\n");
X        return;
X    }
X
X    curtrack = cdrom_get_curtrack();
X
X    if (curtrack != cdi.curtrack)
X        track_button_update();
X
X    /* find start of current track: */
X    track_start = cdi.addrs[curtrack - 1];
X
X    /*
X     * deal with cases where we can't back up beyond the current track:
X     */
X    if ((curtrack == cdi.mintrack)  ||
X        (cdi.state & CDROM_STATE_SHUFFLE) ||
X        (cdi.state & CDROM_STATE_PROGRAM))
X    {
X        /* Ugh, this is ugly... (drich) */
X        if (((cdi.state & CDROM_STATE_PLAY) &&
X         ((track_start.minute * 60) + track_start.second) >=
X         ((start_addr.minute * 60) + start_addr.second -
X          scanSkipInterval)) ||
X        ((cdi.state & CDROM_STATE_PAUSE) &&
X         ((track_start.minute * 60) + track_start.second) >=
X         ((start_addr.minute * 60) + start_addr.second -
X          pauseSkipInterval)))
X        {
X            start_addr = track_start;
X            start_addr.second++; /* guarantee we never back up too far */
X        }
X        else
X        {
X        if (cdi.state & CDROM_STATE_PAUSE) {
X            start_addr.second -= pauseSkipInterval;
X        } else if (cdi.state & CDROM_STATE_PLAY) {
X            start_addr.second -= scanSkipInterval;
X        }
X            if ((char) start_addr.second < 0)
X            {
X            start_addr.minute--;
X            start_addr.second = 60 + (char) start_addr.second;
X            }
X        }
X
X    }
X    else /* normal case */
X    {
X        if (cdi.state & CDROM_STATE_PAUSE) {
X            start_addr.second -= pauseSkipInterval;
X        } else if (cdi.state & CDROM_STATE_PLAY) {
X            start_addr.second -= scanSkipInterval;
X        }
X        if ((char) start_addr.second < 0)
X        {
X            start_addr.minute--;
X            start_addr.second = 60 + (char) start_addr.second;
X        }
X    }
X
X    if ((cdi.state & CDROM_STATE_PROGRAM) ||
X        (cdi.state & CDROM_STATE_SHUFFLE))
X    {
X
X        /* then to end of current selection (start of next track - 1 sec) */
X        end_addr = cdi.addrs[cdi.curtrack];
X        end_addr.second--;
X        if ((char) end_addr.second < 0)
X        {
X        end_addr.minute--;
X        end_addr.second = 59;
X        }
X    }
X    else
X    {
X
X        /*
X         * to end of last track; array 0-based, so really index for
X         * leadout addr:
X         */
X        end_addr = cdi.addrs[cdi.maxtrack];
X        end_addr.second--; /* go to last second */
X        if ((char) end_addr.second < 0)
X        {
X        end_addr.minute--;
X        end_addr.second = 59;
X        }
X    }
X
X    if ((start_addr.minute == end_addr.minute) &&
X        (start_addr.second == end_addr.second))
X        end_addr.frame = start_addr.frame;
X
X    cdrom_play_msf (&start_addr, &end_addr);
X
X    timer_fsecs = 0;
X    if (cdi.state & CDROM_STATE_PAUSE)
X    {
X        if (scanivid == -1)
X        scanivid = XtAppAddTimeOut(appc,
X            (int)(pausePauseInterval * 1000.0),
X            scan_update, NULL);
X
X        cdi.state &= ~CDROM_STATE_PAUSE;    /* allow timer to change */
X        timer_button_update();
X        cdi.state |= CDROM_STATE_PAUSE;    /* restore true state */
X
X        if (cdrom_pause() != -1)        /* re-pause */
X           cdi.state &= ~CDROM_STATE_STOP;
X
X    }
X    else
X    {
X        if (scanivid != -1) {
X        XtRemoveTimeOut(scanivid);
X        ivid = -1;
X        }
X        timer_button_update();
X    }
X
X}
X
X/*
X * fast-forwards the player through minute/second/frames:
X */
Xvoid
Xcdrom_ff () {
X        struct msf    start_addr, end_addr,  next_start;
X    char        t;
X    int        curtrack;
X    extern void     scan_update();
X
X    if (cdrom_get_curmsf(&start_addr) == -1) {
X        debug_printf(1, "ff: error reading location\n");
X        return;
X    }
X
X    curtrack = cdrom_get_curtrack();
X
X    if (curtrack != cdi.curtrack)
X        track_button_update();
X
X    /* find start of next track */
X    next_start = cdi.addrs[curtrack];
X
X    /*
X     * deal with cases where we can't fast forward beyond the current
X     * track:
X     */
X    if ((curtrack == cdi.maxtrack)  ||
X        (cdi.state & CDROM_STATE_SHUFFLE) ||
X        (cdi.state & CDROM_STATE_PROGRAM))
X    {
X        /* see if skipping ahead will go beyond the current track: */
X        /* Ugh, this is ugly... (drich) */
X        if (((cdi.state & CDROM_STATE_PLAY) &&
X         ((next_start.minute * 60) + next_start.second) <=
X         ((start_addr.minute * 60) + start_addr.second +
X          scanSkipInterval)) ||
X        ((cdi.state & CDROM_STATE_PAUSE) &&
X         ((next_start.minute * 60) + next_start.second) <=
X         ((start_addr.minute * 60) + start_addr.second +
X          pauseSkipInterval)))
X        {
X
X            /* start at end of current track */
X            start_addr = next_start;
X            start_addr.second--;
X        }
X        else
X        {
X            if (cdi.state & CDROM_STATE_PAUSE) {
X                start_addr.second += pauseSkipInterval;
X            } else if (cdi.state & CDROM_STATE_PLAY) {
X                start_addr.second += scanSkipInterval;
X            }
X            if (start_addr.second >= 60)
X            {
X                start_addr.minute++;
X                start_addr.second = start_addr.second - 60;
X            }
X        }
X    }
X    else
X    {
X        if (cdi.state & CDROM_STATE_PAUSE) {
X        start_addr.second += pauseSkipInterval;
X        } else if (cdi.state & CDROM_STATE_PLAY) {
X        start_addr.second += scanSkipInterval;
X        }
X        if (start_addr.second >= 60)
X        {
X        start_addr.minute++;
X        start_addr.second = start_addr.second - 60;
X        }
X    }
X
X    if ((cdi.state & CDROM_STATE_PROGRAM) ||
X        (cdi.state & CDROM_STATE_SHUFFLE))
X    {
X
X        /* then to end of current selection */
X        end_addr = next_start;    /* use start of next */
X        end_addr.second--;         /* and back off 1 second */
X        if ((char) end_addr.second < 0)
X        {
X        end_addr.minute--;
X        end_addr.second = 59;
X        }
X    }
X    else
X    {
X        /*
X         * "to end of last track"; array 0-based, so really index for
X         * leadout addr
X         */
X        end_addr = cdi.addrs[cdi.maxtrack];
X
X        end_addr.second--; /* (you can't play the leadout) */
X        if ((char) end_addr.second < 0)
X        {
X        end_addr.minute--;
X        end_addr.second = 59;
X        }
X    }
X
X    if ((start_addr.minute == end_addr.minute) &&
X        (start_addr.second == end_addr.second))
X    {
X        start_addr.frame = end_addr.frame = 0;
X    }
X
X    cdrom_play_msf (&start_addr, &end_addr);
X
X    timer_fsecs = 0;
X    if (cdi.state & CDROM_STATE_PAUSE)
X    {
X        if (scanivid == -1)
X        scanivid = XtAppAddTimeOut(appc,
X            (int)(pausePauseInterval * 1000.0),
X            scan_update, NULL);
X
X        cdi.state &= ~CDROM_STATE_PAUSE;    /* allow timer to change */
X        timer_button_update();
X        cdi.state |= CDROM_STATE_PAUSE;    /* restore true state */
X
X        if (cdrom_pause() != -1)        /* re-pause */
X           cdi.state &= ~CDROM_STATE_STOP;
X    }
X    else
X    {
X        if (scanivid != -1) {
X        XtRemoveTimeOut(scanivid);
X        ivid = -1;
X        }
X        timer_button_update();
X    }
X}
X
X
X/*
X * called by update_track when the cd has hit
X * the end of the track or the disc.
X */
Xstatic void
Xcdrom_atend() {
X    cdrom_timer_off();
X    leds_stop();
X    debug_printf(1, "cdrom_atend: at end\n");
X
X#ifdef sgi
X    /* Force a stop to kill the child (if any).
X     * This is due to some sort of weirdness when the SGI runs off the
X     * disc during a CDreadda().
X     */
X    if (cdi.scsi_audio) {
X        cdrom_stop();
X    }
X#endif
X    if (cdi.state & CDROM_STATE_SHUFFLE) {
X
X        if (cdi.currand == cdi.ntracks) {
X            if ((cdi.state & CDROM_STATE_CYCLE) == 0) {
X                debug_printf(1, "cdrom_atend: shuffle done\n");
X
X                cdrom_reset();
X                return;
X            }
X
X            debug_printf(1, "cdrom_atend: shuffle cycling\n");
X            shuffle_setup();
X        }
X
X        cdi.curtrack = shuffle_next_track();
X    }
X    else if (cdi.state & CDROM_STATE_PROGRAM) {
X        if ((cdi.curtrack = program_goto_next_track()) == 0)
X        {
X            if (cdi.state & CDROM_STATE_CYCLE)
X            {
X                debug_printf(1, "cdrom_atend: cycling program\n");
X            cdi.curtrack = program_resume();
X            timer_fsecs = 0;
X            cdi.duration = 0;
X            timer_button_update();
X
X            (void) cdrom_play();
X            }
X            else
X            {
X                debug_printf(1, "cdrom_atend: all done\n");
X                cdrom_reset();
X            }
X            return;
X        }
X    }
X
X    else if ((cdi.curtrack < cdi.maxtrack) && (cdi.curtrack != 0)) {
X        debug_printf(1, "cdrom_atend: continuing\n");
X        cdi.curtrack++;
X    }
X    else if (cdi.state & CDROM_STATE_CYCLE) {
X        debug_printf(1, "cdrom_atend: cycling\n");
X        cdi.curtrack = cdi.mintrack;
X    }
X    else {
X        debug_printf(1, "cdrom_atend: all done\n");
X        buttons_reset();
X        cdrom_reset();
X        return;
X    }
X
X    timer_fsecs = 0;
X    cdi.duration = 0;
X    timer_button_update();
X
X    (void) cdrom_play();
X}
X
X/*
X * scan_update is called when the scan timeout fires; it updates the timer
X * and calls the label update routine.
X */
X/*ARGSUSED*/
Xstatic void
Xscan_update(data, id)
X    XtPointer    *data;
X    XtIntervalId    *id;
X{
X    unsigned int    curtrack;
X    Arg    args[1];
X    Boolean    state;
X
X    extern Widget    rew_button_widget;
X    extern Widget    ff_button_widget;
X
X    if ((curtrack = cdrom_get_curtrack()) != cdi.curtrack) {
X        if (curtrack == 0) {
X            cdrom_atend();
X
X            return;
X        }
X
X        timer_fsecs = 0;
X        cdi.duration = 0;
X        timer_button_update();
X
X        cdi.curtrack = curtrack;
X        track_button_update();
X    }
X
X
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(rew_button_widget, args, 1);
X    if (state == True)
X    {
X        cdrom_rewind();
X        leds_update(BACKWARDS);
X        if (cdi.state & CDROM_STATE_PAUSE) {
X            if (cdrom_pause() != -1)
X                 cdi.state &= ~CDROM_STATE_STOP;
X        }
X            ivid = XtAppAddTimeOut(appc,
X            (int)(scanPauseInterval * 1000.0),
X            scan_update, NULL);
X    }
X    else
X    {
X        leds_update(FORWARDS);
X        XtSetArg(args[0], XtNstate, &state);
X        XtGetValues(ff_button_widget, args, 1);
X        if (state == True)
X        {
X            cdrom_ff();
X            if (cdi.state & CDROM_STATE_PAUSE) {
X                if (cdrom_pause() != -1)
X                     cdi.state &= ~CDROM_STATE_STOP;
X            }
X
X            ivid = XtAppAddTimeOut(appc,
X                (int)(scanPauseInterval * 1000.0),
X                scan_update, NULL);
X        }
X        else if (scanivid != -1) {
X            XtRemoveTimeOut(scanivid);
X            scanivid = -1;
X        }
X    }
X}
X
X
X/*
X * update_status is called when the status timeout fires;  it maintains
X * the disc status, and will detect when a new disc has been inserted.
X */
X/*ARGSUSED*/
Xvoid
Xupdate_status(data, id)
X    XtPointer    *data;
X    XtIntervalId    *id;
X{
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        if (cdrom_open() == -1) {
X            debug_printf(1, "cdrom_open: cdrom not ready\n");
X        } else {
X            cdi.state &= ~CDROM_STATE_EJECTED;
X            buttons_reset();
X        }
X    }
X
X    /* Reset timer */
X    stativid = XtAppAddTimeOut(appc, 1000, update_status, NULL);
X}
X
X/*
X * update_track is called when the timeout fires; it updates curtrack and
X * calls the label update routine.
X */
X/*ARGSUSED*/
Xstatic void
Xupdate_track(data, id)
X    XtPointer    *data;
X    XtIntervalId    *id;
X{
X    unsigned int    curtrack;
X    Arg    args[1];
X    Boolean    state;
X
X    extern Widget    rew_button_widget;
X    extern Widget    ff_button_widget;
X#ifdef sgi
X
X    int    vol;
X#endif
X
X    if ((curtrack = cdrom_get_curtrack()) != cdi.curtrack) {
X        if (curtrack == 0) {
X            cdrom_atend();
X
X            return;
X        }
X
X        timer_fsecs = 0;
X        cdi.duration = 0;
X        timer_button_update();
X
X        cdi.curtrack = curtrack;
X        track_button_update();
X    }
X
X#ifdef sgi
X    /* Update the volume control */
X    if ((vol = cdrom_get_volume()) != 0) {
X        set_volume(vol);
X    }
X#endif
X
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(rew_button_widget, args, 1);
X    if (state == True)
X    {
X        cdrom_rewind();
X        leds_update(BACKWARDS);
X        if (cdi.state & CDROM_STATE_PAUSE) {
X            if (cdrom_pause() != -1)
X                 cdi.state &= ~CDROM_STATE_STOP;
X        }
X            ivid = XtAppAddTimeOut(appc,
X            (int)(scanPauseInterval * 1000.0),
X            update_track, NULL);
X    }
X    else
X    {
X        leds_update(FORWARDS);
X        XtSetArg(args[0], XtNstate, &state);
X        XtGetValues(ff_button_widget, args, 1);
X        if (state == True)
X        {
X            cdrom_ff();
X            if (cdi.state & CDROM_STATE_PAUSE) {
X                if (cdrom_pause() != -1)
X                     cdi.state &= ~CDROM_STATE_STOP;
X            }
X
X            ivid = XtAppAddTimeOut(appc,
X                (int)(scanPauseInterval * 1000.0),
X                update_track, NULL);
X        }
X        else
X        {
X            if ((timer_fsecs++ % timer_mod) == 0) {
X                timer_button_update();
X            }
X            ivid = XtAppAddTimeOut(appc, TIMER_PERIOD,
X                update_track, NULL);
X        }
X    }
X}
X
END_OF_FILE
if test 15296 -ne `wc -c <'xcdplayer-2.2/internals.c'`; then
    echo shar: \"'xcdplayer-2.2/internals.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/internals.c'
fi
if test -f 'xcdplayer-2.2/logo_setup.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'xcdplayer-2.2/logo_setup.c'\"
else
echo shar: Extracting \"'xcdplayer-2.2/logo_setup.c'\" \(15407 characters\)
sed "s/^X//" >'xcdplayer-2.2/logo_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 <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/Command.h>
X# include <X11/Xaw/Toggle.h>
X# include <X11/Xaw/Scrollbar.h>
X# include <X11/Xaw/Dialog.h>
X# include <X11/Xaw/Viewport.h>
X
X# include <math.h>
X# include <stdio.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 "logo.xbm"
X# include "thumb.xbm"
X# include <X11/bitmaps/gray>
X
X# define MAXVOL        0xff
X
Xvoid    Done();
X
Xstatic Widget    track_button_widget;
Xstatic Widget    timer_button_widget;
Xstatic Widget    volume_scroll_widget;
X
XWidget        title_viewport;
XWidget        title_form;
XWidget        title_button;
XWidget        title_dialog_shell;
XWidget        title_dialog_widget;
XWidget        title_done_widget;
X
Xstatic int    vol;
X
Xvoid
Xlogo_setup(parent_widget)
X    Widget        parent_widget;
X{
X    extern void    leds_label_setup();
X    extern void    cb_track_button();
X    extern void    cb_timer_button();
X    extern void    volume_jump_proc();
X    extern void    volume_scroll_proc();
X    extern void    popup_title_dialog();
X    extern void    popdown_title_dialog();
X
X    Widget        version_label_widget;
X    char        version_string[80];
X
X    Widget        logo_form_widget;
X    Widget        logo_label_widget;
X    Pixmap        logo_label_pixmap;
X    Pixmap        thumb_pixmap;
X    Pixmap        gray;
X    int            depth;
X    int        length;
X
X
X    Arg        args[4];
X    static XtActionsRec    done[] = {
X        {"done", Done},
X    };
X
X
X    logo_form_widget = XtCreateManagedWidget("logoForm", formWidgetClass,
X                         parent_widget,
X                         (ArgList) NULL, 0);
X
X    logo_label_widget = XtCreateManagedWidget("logoLabel",
X                          labelWidgetClass,
X                          logo_form_widget,
X                          (ArgList) NULL, 0);
X
X    logo_label_pixmap = XCreateBitmapFromData(XtDisplay(logo_label_widget),
X                          rootwin(logo_label_widget),
X                          logo_bits,
X                          logo_width, logo_height);
X
X    sprintf(version_string,"XCdplayer %s%d",VERSION,PATCHLEVEL);
X    if (BETA != 0) {
X        sprintf(version_string,"%s beta %d",version_string,BETA);
X    }
X    XtSetArg(args[0], XtNjustify, XtJustifyRight);
X    XtSetArg(args[1], XtNlabel, version_string);
X    version_label_widget = XtCreateManagedWidget("versionLabel",
X                             labelWidgetClass,
X                             logo_form_widget,
X                             (ArgList) args, 2);
X
X    XtSetArg(args[0], XtNbitmap, logo_label_pixmap);
X    XtSetValues(logo_label_widget, args, 1);
X
X    leds_label_setup(logo_form_widget);
X
X
X    track_button_widget = XtCreateManagedWidget("trackButton",
X                            toggleWidgetClass,
X                            logo_form_widget,
X                            (ArgList) NULL, 0);
X
X    XtAddCallback(track_button_widget, XtNcallback, cb_track_button, 0);
X
X    track_button_update();
X
X    if (display_timer == True)
X        timer_button_widget = XtCreateManagedWidget("timerButton",
X                                   toggleWidgetClass,
X                               logo_form_widget,
X                               (ArgList) NULL, 0);
X
X    XtAddCallback(timer_button_widget, XtNcallback, cb_timer_button, 0);
X
X    timer_button_update();
X    thumb_pixmap = XCreateBitmapFromData(XtDisplay(logo_form_widget),
X                          rootwin(logo_form_widget),
X                          thumb_bits,
X                          thumb_width, thumb_height);
X
X    XtSetArg (args[0], XtNdepth, &depth);
X    XtGetValues (logo_form_widget, args, 1);
X
X    if (depth == 1) {
X        gray = XCreateBitmapFromData(XtDisplay(logo_form_widget),
X                          rootwin(logo_form_widget),
X                          gray_bits,
X                          gray_width, gray_height);
X
X        XtSetArg(args[0], XtNbackgroundPixmap, gray);
X        XtSetArg(args[1], XtNthumb, thumb_pixmap);
X        volume_scroll_widget = XtCreateManagedWidget("volumeScrollbar",
X                             scrollbarWidgetClass,
X                             logo_form_widget,
X                             (ArgList) args, 2);
X    }
X    else
X    {
X         /*XtSetArg(args[0], XtNthumb, thumb_pixmap);*/
X
X         volume_scroll_widget = XtCreateManagedWidget("volumeScrollbar",
X                             scrollbarWidgetClass,
X                             logo_form_widget,
X                             (ArgList) args, 0);
X    }
X
X    XtAddCallback(volume_scroll_widget, XtNjumpProc, volume_jump_proc, 0);
X    XtAddCallback(volume_scroll_widget, XtNscrollProc, volume_scroll_proc, 0);
X
X#ifdef sgi
X    if ((vol = cdrom_get_volume()) == 0) {
X        vol = (int) ((MAXVOL - volbase) * 0.75) + volbase;
X    }
X#else
X    vol = (int) ((MAXVOL - volbase) * 0.75) + volbase;
X#endif
X    cdrom_volume(vol, vol);
X#ifdef sgi
X    XawScrollbarSetThumb(volume_scroll_widget,
X                 (float) (VAL2PCT(vol)),
X                 (float) 1.0);
X#else
X    XawScrollbarSetThumb(volume_scroll_widget, (float) 0.75, (float) 1.0);
X#endif
X
X    title_viewport = XtCreateManagedWidget ("titleBarViewport",
X                viewportWidgetClass,
X                logo_form_widget,
X                (ArgList) NULL, 0);
X
X    title_form = XtCreateManagedWidget ("titleForm",
X                formWidgetClass,
X                title_viewport,
X                (ArgList) NULL, 0);
X
X    if (disc_title != NULL)
X            XtSetArg(args[0], XtNlabel, disc_title);
X    else
X#ifdef sgi
X        if (cdrom_status() == CDROM_NO_STATUS) {
X            XtSetArg(args[0], XtNlabel, NODISCSTR);
X        } else {
X            XtSetArg(args[0], XtNlabel, NOTITLESTR);
X        }
X#else
X        XtSetArg(args[0], XtNlabel, NOTITLESTR);
X#endif
X
X    title_button = XtCreateManagedWidget ("titleBar",
X                commandWidgetClass,
X                title_form,
X                (ArgList) args, 1);
X
X    title_dialog_shell = XtCreatePopupShell("titleShell",
X                transientShellWidgetClass,
X                title_button,
X                (ArgList) NULL, 0);
X
X        XtSetArg(args[0], XtNlabel, "Title: ");
X        title_dialog_widget = XtCreateManagedWidget("titleDialog",
X                                    dialogWidgetClass,
X                                    title_dialog_shell,
X                                    (ArgList) args, 1);
X
X    title_done_widget = XtCreateManagedWidget("Done",
X                    commandWidgetClass,
X                    title_dialog_widget,
X                    (ArgList) NULL, 0);
X
X    XtAppAddActions(appc, done, XtNumber(done));
X
X    XtAddCallback(title_button, XtNcallback, popup_title_dialog,
X            (XtPointer) logo_form_widget);
X    XtAddCallback(title_done_widget, XtNcallback, popdown_title_dialog,
X            (XtPointer) title_dialog_widget);
X
X
X}
X
X/*ARGSUSED*/
Xstatic void
Xcb_track_button(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    char        track_buf[40];
X    Arg        args[1];
X    Boolean        state;
X
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(widget, args, 1);
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();
X    }
X
X    if (state == True)
X        sprintf(track_buf, "%d\n", cdi.maxtrack);
X    else
X        sprintf(track_buf, "%d\n", cdi.curtrack);
X
X    XtSetArg(args[0], XtNlabel, track_buf);
X    XtSetValues(widget, args, 1);
X}
X
Xvoid
Xtrack_button_update() {
X    char        track_buf[40];
X    Arg        args[1];
X
X    sprintf(track_buf, "%d\n", cdi.curtrack);
X
X    XtSetArg(args[0], XtNlabel, track_buf);
X    XtSetValues(track_button_widget, args, 1);
X}
X
Xstatic void
Xcb_timer_button(widget, client_data, call_data)
X    Widget        widget;
X    XtPointer    client_data;
X    XtPointer    call_data;
X{
X    char        timer_buf[40];
X    int        time_remaining;
X    Arg        args[1];
X    Boolean        state;
X
X    if (cdi.state & CDROM_STATE_EJECTED) {
X        cdrom_new_disc();
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.duration = cdrom_get_curtime();
X
X    XtSetArg(args[0], XtNstate, &state);
X    XtGetValues(widget, args, 1);
X
X    if ((state == True) && (cdi.curtrack != 0))
X    {
X        if (((cdi.state & CDROM_STATE_PAUSE) == 0) &&
X            (cdi.state & CDROM_STATE_PROGRAM))
X        {
X            time_remaining = program_time_remaining();
X        }
X        else
X            time_remaining = cdi.times[cdi.curtrack - 1] - cdi.duration;
X
X        if (time_remaining < 0)
X            sprintf(timer_buf, "-%02u:%02u\n",abs(time_remaining) / 60,
X            abs(time_remaining) % 60);
X        else
X            sprintf(timer_buf, "-%02d:%02d\n", time_remaining / 60,
X            time_remaining % 60);
X    } else if (cdi.curtrack != 0) {
X        if (cdi.duration < 0)
X            sprintf(timer_buf, "-%02u:%02u\n", cdi.duration / 60,
X                abs(cdi.duration) % 60);
X        else
X            sprintf(timer_buf, "%02u:%02u\n", cdi.duration / 60,
X                cdi.duration % 60);
X    } else {
X        if ((state == True) && (cdrom_status() != CDROM_NO_STATUS))
X            sprintf(timer_buf, "-%02u:%02u\n",
X                cdi.addrs[cdi.maxtrack].minute,
X                cdi.addrs[cdi.maxtrack].second);
X        else
X            sprintf(timer_buf, "--:--\n");
X    }
X
X    XtSetArg(args[0], XtNlabel, timer_buf);
X    XtSetValues(widget, args, 1);
X}
X
Xvoid
Xtimer_button_update() {
X    char        timer_buf[40];
X    int        time_remaining;
X    Arg        args[1];
X    Boolean        state;
X
X    if (display_timer == False)
X        return;
X
X        if ((cdi.state & CDROM_STATE_PAUSE) == 0)
X            cdi.duration = cdrom_get_curtime();
X
X        XtSetArg(args[0], XtNstate, &state);
X        XtGetValues(timer_button_widget, args, 1);
X
X        if ((state == True) && (cdi.curtrack != 0))
X        {
X        if (((cdi.state & CDROM_STATE_PAUSE) == 0) &&
X            (cdi.state & CDROM_STATE_PROGRAM))
X        {
X                time_remaining = program_time_remaining();
X        }
X        else
X                time_remaining = cdi.times[cdi.curtrack - 1] - cdi.duration;
X            if (time_remaining < 0)
X                sprintf(timer_buf, "-%02u:%02u\n",abs(time_remaining) / 60,
X                abs(time_remaining) % 60);
X            else
X                sprintf(timer_buf, "-%02d:%02d\n", time_remaining / 60,
X                time_remaining % 60);
X        }
X        else if (cdi.state & CDROM_STATE_PLAY)
X        {
X            if (cdi.duration < 0)
X                sprintf(timer_buf, "-%02u:%02u\n", cdi.duration / 60,
X                abs(cdi.duration) % 60);
X            else
X                sprintf(timer_buf, "%02u:%02u\n", cdi.duration / 60,
X                cdi.duration % 60);
X        }
X        else
X        if ((state == True) && (cdrom_status() != CDROM_NO_STATUS))
X            sprintf(timer_buf, "-%02u:%02u\n",
X                cdi.addrs[cdi.maxtrack].minute,
X                cdi.addrs[cdi.maxtrack].second);
X        else
X            sprintf(timer_buf, "--:--\n");
X
X    XtSetArg(args[0], XtNlabel, timer_buf);
X    XtSetValues(timer_button_widget, args, 1);
X}
X
Xstatic void
Xvolume_jump_proc(scroll_widget, client_data, percent)
X    Widget        scroll_widget;
X    XtPointer    client_data;
X    XtPointer    percent;
X{
X#ifdef sgi
X    /* The volume control on SGI is not linear, but is exponential */
X    vol = PCT2VAL(*(float *)percent);
X#else
X    vol = (*(float *) percent) * MAXVOL;
X    vol = (vol * volpcent) + volbase;
X#endif
X
X    if (vol > MAXVOL)
X        vol = MAXVOL;
X    if (vol <= 0)
X        vol = 1;
X
X    debug_printf(1, "volume=%u\n", (unsigned int) vol);
X
X    cdrom_volume(vol, vol);
X}
X
Xstatic void
Xvolume_scroll_proc(scroll_widget, client_data, position)
X    Widget        scroll_widget;
X    XtPointer    client_data;
X    XtPointer    position;
X{
X    Arg        args[1];
X    Dimension    length;
X    float        top;
X    double        abspos;
X    double        percent;
X    double        vdelta;
X
X    if ((abspos = (int) position) < 0)
X        abspos = -abspos;
X
X    XtSetArg(args[0], XtNlength, &length);
X    XtGetValues(scroll_widget, args, 1);
X
X    if (length <= 0)
X        length = 1;
X
X    percent = abspos / (float) length;
X
X#ifdef sgi
X    /* The volume control on SGI is not linear, but is exponential */
X    if ((vdelta = ((VAL2PCT(vol)) * percent)) < (VAL2PCT(1))) {
X        vdelta = (VAL2PCT(1));
X    }
X    if ((int) position < 0)
X        vol = (PCT2VAL((VAL2PCT(vol)) - vdelta));
X    else
X        vol = (PCT2VAL((VAL2PCT(vol)) + vdelta));
X#else
X    if ((vdelta = (vol * percent)) < 1.0)
X        vdelta = 1.0;
X
X    if ((int) position < 0)
X        vol += vdelta;
X    else
X        vol -= vdelta;
X#endif
X
X    if (vol > MAXVOL)
X        vol = MAXVOL;
X    if (vol <= 0)
X        vol = 1;
X
X    debug_printf(1, "volume=%u\n", (unsigned int) vol);
X
X    cdrom_volume(vol, vol);
X
X#ifdef sgi
X    XtSetArg (args[0], XtNlength, &length);
X    XtGetValues (volume_scroll_widget, args, 1);
X    XawScrollbarSetThumb(volume_scroll_widget,
X                 (float) (VAL2PCT(vol)),
X                 (float) -1.0);
X#endif
X    top = (double) vol / (double) MAXVOL;
X
X    XawScrollbarSetThumb(volume_scroll_widget, (float) top, (float) -1.0);
X}
X
Xvoid
Xtrack_button_set() {
X    Arg             args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(track_button_widget, args, 1);
X}
X
Xvoid
Xtrack_button_reset() {
X    Arg             args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(track_button_widget, args, 1);
X}
X
Xvoid
Xtimer_button_set() {
X    Arg             args[1];
X
X    XtSetArg(args[0], XtNstate, True);
X    XtSetValues(timer_button_widget, args, 1);
X}
X
Xvoid
Xtimer_button_reset() {
X    Arg             args[1];
X
X    XtSetArg(args[0], XtNstate, False);
X    XtSetValues(timer_button_widget, args, 1);
X}
X
X
X/*ARGSUSED*/
Xvoid
Xpopup_title_dialog(widget, parent, call_data)
XWidget        widget;
XWidget        parent;
XXtPointer    call_data;
X{
X    Position x, y;
X    Dimension width, height;
X    Arg    args[2];
X    Widget    value;
X    char    non_null[256];
X
X
X
X    if (disc_title != NULL) {
X        sscanf(disc_title, "%s", non_null);
X
X        if (strcmp ("", non_null) != 0)
X                XtSetArg(args[0], XtNvalue, disc_title);
X        else
X                XtSetArg(args[0], XtNvalue, "");
X    }
X    else
X            XtSetArg(args[0], XtNvalue, "");
X
X    XtSetValues(title_dialog_widget, args, 1);
X
X    XtTranslateCoords (widget,
X        (Position) 14,
X        (Position) 14,
X        &x, &y);
X
X    XtSetArg(args[0], XtNx, x);
X    XtSetArg(args[1], XtNy, y);
X    XtSetValues(title_dialog_shell, args, 2);
X
X    if ((value = XtNameToWidget(title_dialog_widget, "value")) != 0) {
X        XtSetArg(args[0], XtNwidth, &width);
X        XtGetValues(title_button, args, 1);
X        XtSetArg(args[0], XtNwidth, width);
X        XtSetValues(value, args, 1);
X    }
X
X    /*XtSetSensitive (widget, FALSE); */
X    XtPopup (title_dialog_shell, XtGrabNone);
X
X}
X
Xvoid
XDone(widget, event, params, num_params)
X    Widget        widget;
X    XButtonEvent    *event;
X    String        *params;
X    Cardinal    *num_params;
X{
X    Arg    args[2];
X
X    if (disc_title != NULL)
X        free(disc_title);
X    disc_title = XawDialogGetValueString(title_dialog_widget);
X    XtSetArg(args[0], XtNlabel, disc_title);
X    XtSetValues(title_button, args, 1);
X
X    XtPopdown(title_dialog_shell);
X    XtSetSensitive(title_button, TRUE);
X}
X
Xvoid
Xpopdown_title_dialog(widget, dialog, call_data)
XWidget    widget;
XWidget    dialog;
XXtPointer call_data;
X{
X    Arg    args[2];
X
X    if (disc_title != NULL)
X        free(disc_title);
X    disc_title = XawDialogGetValueString(dialog);
X    XtSetArg(args[0], XtNlabel, disc_title);
X    XtSetValues(title_button, args, 1);
X
X    XtPopdown(title_dialog_shell);
X    XtSetSensitive(title_button, TRUE);
X}
X
Xvoid
Xupdate_title () {
X    Arg        args[1];
X    char    non_null[256];
X
X    if (title_button != NULL) {
X#if 0
X        if (disc_title != NULL) {
X            sscanf(disc_title, "%s", non_null);
X            if (strcmp ("", non_null) != 0)
X                XtSetArg(args[0], XtNvalue, disc_title);
X            else
X                XtSetArg(args[0], XtNvalue, "");
X        else
X            XtSetArg(args[0], XtNvalue, "");
X        }
X
X        XtSetArg(args[0], XtNvalue, disc_title);
X        XtSetValues(title_button, args, 1);
X        XtSetArg(args[0], XtNvalue, disc_title);
X        XtSetValues(title_dialog_widget, args, 1);
X#endif
X        XtSetArg(args[0], XtNvalue, disc_title);
X        XtSetValues(title_dialog_widget, args, 1);
X        XtSetArg(args[0], XtNlabel, disc_title);
X        XtSetValues(title_button, args, 1);
X
X    }
X}
X
X#ifdef sgi
Xset_volume(vol)
X    int    vol;
X{
X    XawScrollbarSetThumb(volume_scroll_widget,
X                 (float) (VAL2PCT(vol)),
X                 (float) 1.0);
X}
X#endif
END_OF_FILE
if test 15407 -ne `wc -c <'xcdplayer-2.2/logo_setup.c'`; then
    echo shar: \"'xcdplayer-2.2/logo_setup.c'\" unpacked with wrong size!
fi
# end of 'xcdplayer-2.2/logo_setup.c'
fi
echo shar: End of archive 3 \(of 5\).
cp /dev/null ark3isdone
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