---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 03 of a multipart archive
# ============= Gopher.cc ==============
if test -f 'Gopher.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping Gopher.cc (File already exists)'
else
echo 'x - extracting Gopher.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Gopher.cc' &&
//
// Gopher.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the Gopher class
//
#include "Gopher.h"
#include "String.h"
#include "Connection.h"
#include "GWindow.h"
#include "Response.h"
#include <unistd.h>
#include <stdio.h>
#include <xview/notify.h>
#include <fcntl.h>
#include <time.h>
X
#define	LINE_COUNT_INCREMENT	20
#define	MAX_LIST_LINES			1023
X
X
//***************************************************************************
// Gopher::Gopher(GWindow *gwin)
//
Gopher::Gopher(GWindow *gwin)
{
X	fd = -1;
X	gwindow = gwin;
X	*filename = '\0';
X	connection = (Connection *) 0;
}
X
X
//***************************************************************************
// Gopher::~Gopher()
//
Gopher::~Gopher()
{
X	if (connection->isopen())
X		(void) notify_set_input_func((Notify_client) this, NOTIFY_FUNC_NULL, connection->get_socket());
X	fd = -1;
X	if (*filename)
X		unlink(filename);
X	if (connection)
X		delete connection;
}
X
X
//***************************************************************************
// Gopher::Gopher(char *server, int port, GWindow *gwin)
//
Gopher::Gopher(char *server, int port, GWindow *gwin)
{
X	fd = -1;
X	gwindow = gwin;
X	*filename = '\0';
X	if (open(server, port) == NOTOK)
X		exit(1);
}
X
X
//***************************************************************************
// int Gopher::open(server, port)
// PURPOSE:
//    Build a connection with the gopher server.
//
int Gopher::open(char *server, int port)
{
X	connection = new Connection;
X
X	if (connection->open() == NOTOK)
X		return NOTOK;
X	if (connection->assign_port(port) == NOTOK)
X		return NOTOK;
X	if (connection->assign_server(server) == NOTOK)
X		return NOTOK;
X	if (connection->connect() == NOTOK)
X		return NOTOK;
X
X	return OK;
}
X
X
//***************************************************************************
// int Gopher::read(char type, char *cmd)
// PURPOSE:
//    Send cmd to the server and receive the information until the
//    connection is closed by the server
//
int Gopher::read(char type, char *cmd)
{
X	gwindow->status("Retrieving information...");
X
X	//
X	// First send the command.  We need to terminate the command with
X	// a return.  Since we do not know how big cmd is, we will just make
X	// it into two writes.
X	//
X	if (cmd == NULL)
X		cmd = "";
X	connection->write(cmd, strlen(cmd));
X	connection->write("\r\n", 2);
X
X	//
X	// Now we are ready to receive the information.  The type of information
X	// depends on the command we sent to the server, so we will use it
X	// to determine where this information will be stored.
X	//
X	switch (type)
X	{
X		case GOPHER_FILE:
X			//
X			// Plain ASCII file coming through...  Save it someplace
X			//
X			read_ascii();
X			break;
X		case GOPHER_DIRECTORY:
X		case '\0':
X			//
X			// We are getting a directory listing.  Read it into our List
X			//
X			read_list();
X			break;
X		case GOPHER_CSO:
X			break;
X		case GOPHER_ERROR:
X			break;
X		case GOPHER_UU:
X			break;
X		case GOPHER_INDEX:
X			break;
X		case GOPHER_TELNET:
X			break;
X		case GOPHER_BINHEX:
X		case GOPHER_DOS:
X		case GOPHER_BIN:
X			//
X			// Some binary file coming in.  Read until connection closes
X			//
X			read_binary();
X			break;
X		case GOPHER_SOUND:
X			//
X			// Some binary file coming in.  Read until connection closes
X			//
X			read_binary();
X			datatype = TYPE_SOUND;
X			break;
X		case GOPHER_IMAGE:
X		case GOPHER_GIF:
X			//
X			// Some binary file coming in.  Read until connection closes
X			//
X			read_binary();
X			datatype = TYPE_IMAGE;
X			break;
X		case GOPHER_REDUNDANT:
X			break;
X		default:
X			printf("Hmm.  The I don't know how to read data of type '%c'\n", type);
X			break;
X	}
X	return OK;
}
X
X
//***************************************************************************
// void Gopher::start_get()
// PURPOSE:
//    Set up the list of data so we can retrieve data in order
//
void Gopher::start_get()
{
X	list.start_get();
}
X
X
//***************************************************************************
// char *Gopher::get_next()
// PURPOSE:
//    Get the next item from our list
//
char *Gopher::get_next()
{
X	String	*str = (String *) list.get_next();
X
X	if (str)
X		return str->get();
X	else
X		return NULL;
}
X
X
//***************************************************************************
// void Gopher::read_list()
//
void Gopher::read_list()
{
X	//
X	// In order not to block on a read, we will use the xview read notify
X	// to tell us when data is actually available.
X	//
X	datatype = TYPE_LIST;
X	length = 0;
X	(void) notify_set_input_func((Notify_client) this, (Notify_func) read_list_proc, connection->get_socket());
}
X
#define	INPUT_BUF_SIZE	50000
X
//***************************************************************************
// void Gopher::read_list_proc(Gopher *gopher, int ifd)
//
void Gopher::read_list_proc(Gopher *gopher, int ifd)
{
X	char			buffer[INPUT_BUF_SIZE];
X	static time_t	last = 0;
X	char			*p;
X
X	if (gopher->connection->read_line(buffer, INPUT_BUF_SIZE) == NULL || gopher->length > MAX_LIST_LINES)
X	{
X		//
X		// End of file reached.
X		//
X		(void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd);
X		gopher->connection->close();
X		gopher->gwindow->display();
X		sprintf(buffer, "Total of %d item%s", gopher->length, gopher->length == 1 ? "" : "s");
X		gopher->gwindow->status(buffer);
X
X		if (gopher->length == 0)
X		{
X			//
X			// Nothing was found.  Let the user know...
X			//
X			gopher->gwindow->nothing_found();
X		}
X	}
X	else
X	{
X		if (*buffer == '.' && buffer[1] == '\0')
X			return;
X		p = buffer;
X		while (*p == '-' || *p > 126 || *p < 32)
X			p++;
X		gopher->list.add(new String(p));
X
X		//
X		// Keep a running count and display the results every second
X		//
X		gopher->length++;
X		if (gopher->length > MAX_LIST_LINES)
X			gopher->gwindow->list_full();
X
X		if (last < time(NULL))
X		{
X			char str[20];
X			sprintf(str, "%d line%s...", gopher->length, gopher->length == 1 ? "" : "s");
X			gopher->gwindow->status(str);
X			last = time(NULL);
X		}
X	}
}
X
X
//***************************************************************************
// void Gopher::read_ascii()
//
void Gopher::read_ascii()
{
X	datatype = TYPE_ASCII;
X	strcpy(filename, "/tmp/gophXXXXXX");
X	fd = mkstemp(filename);
X	length = 0;
X	(void) notify_set_input_func((Notify_client) this, (Notify_func) read_ascii_proc, connection->get_socket());
}
X
X
//***************************************************************************
// void Gopher::read_ascii_proc(Gopher *gopher, int ifd)
//
void Gopher::read_ascii_proc(Gopher *gopher, int ifd)
{
X	char			buffer[INPUT_BUF_SIZE];
X	static time_t	last = 0;
X
X	if (gopher->connection->read_line(buffer, INPUT_BUF_SIZE) == NULL)
X	{
X		//
X		// End of file reached.
X		//
X		::close(gopher->fd);
X		(void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd);
X		gopher->connection->close();
X		gopher->gwindow->display();
X		char str[30];
X		sprintf(str, "Total of %d lines", gopher->length);
X		gopher->gwindow->status(str);
X	}
X	else
X	{
X		if (*buffer == '.' && buffer[1] == '\0')
X			return;
X		write(gopher->fd, buffer, strlen(buffer));
X		write(gopher->fd, "\n", 1);
X		gopher->length++;
X		if (last < time(NULL))
X		{
X			char str[20];
X			sprintf(str, "%d line%s...", gopher->length, gopher->length == 1 ? "" : "s");
X			gopher->gwindow->status(str);
X			last = time(NULL);
X		}
X	}
}
X
X
//***************************************************************************
// void Gopher::read_binary()
//
void Gopher::read_binary()
{
X	datatype = TYPE_BINARY;
X	strcpy(filename, "/tmp/gophXXXXXX");
X	fd = mkstemp(filename);
X	length = 0;
X	gwindow->status("Waiting for first data to arrive...");
X	(void) notify_set_input_func((Notify_client) this, (Notify_func) read_binary_proc, connection->get_socket());
}
X
X
//***************************************************************************
// void Gopher::read_binary_proc(Gopher *gopher, int ifd)
//
void Gopher::read_binary_proc(Gopher *gopher, int ifd)
{
X	char			buffer[INPUT_BUF_SIZE];
X	static time_t	last = 0;
X
X	int n = gopher->connection->read_partial(buffer, INPUT_BUF_SIZE);
X	if (n <= 0)
X	{
X		//
X		// End of file reached.
X		//
X		::close(gopher->fd);
X		(void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd);
X		gopher->connection->close();
X		gopher->gwindow->display();
X		sprintf(buffer, "Total of %d bytes", gopher->length);
X		gopher->gwindow->status(buffer);
X	}
X	else
X	{
X		::write(gopher->fd, buffer, n);
X		gopher->length += n;
X		if (last < time(NULL))
X		{
X			char status[40];
X			sprintf(status, "%d byte%s...", gopher->length, gopher->length == 1 ? "" : "s");
X			gopher->gwindow->status(status);
X			last = time(NULL);
X		}
X	}
}
X
X
SHAR_EOF
chmod 0664 Gopher.cc ||
echo 'restore of Gopher.cc failed'
Wc_c="`wc -c < 'Gopher.cc'`"
test 8621 -eq "$Wc_c" ||
	echo 'Gopher.cc: original size 8621, current size' "$Wc_c"
fi
# ============= List.cc ==============
if test -f 'List.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping List.cc (File already exists)'
else
echo 'x - extracting List.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'List.cc' &&
//
// List.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the List class
//
#include "List.h"
X
#define	NULL	((void *) 0)
X
X
//***************************************************************************
// List::List()
//
List::List()
{
X	first = last = current = (Object *) 0;
X	size = 0;
}
X
X
//***************************************************************************
// List::~List()
//
List::~List()
{
X	if (first)
X	{
X		Object	*obj;
X		start_get();
X		while (obj = get_next())
X		{
X			delete obj;
X		}
X	}
}
X
X
//***************************************************************************
// void List::add(Object *obj)
// PURPOSE:
//    Add an object to the list.  The adding will be done at the end of the
//    list.
void List::add(Object *obj)
{
X	if (!first)
X	{
X		//
X		// The list is empty.  Easy!  Just put the object in it.
X		//
X		first = last = obj;
X		obj->Next((Object *) 0);
X		obj->Previous((Object *) 0);
X	}
X	else
X	{
X		//
X		// There is something already in the list.  Just append it
X		//
X		last->Next(obj);
X		obj->Previous(last);
X		obj->Next((Object *) 0);
X		last = obj;
X	}
X	size++;
}
X
X
//***************************************************************************
// void List::start_get()
// PURPOSE:
//    Prepare the list for itteration.  This needs to be called so that
//    get_next() will return the first element of the list
//
void List::start_get()
{
X	current = first;
}
X
X
//***************************************************************************
// Object *List::get_next()
// PURPOSE:
//    Return the next object in the list
//
Object *List::get_next()
{
X	if (current)
X	{
X		Object	*temp = current;
X		current = current->Next();
X		return temp;
X	}
X	else
X		return (Object *) 0;
}
X
SHAR_EOF
chmod 0644 List.cc ||
echo 'restore of List.cc failed'
Wc_c="`wc -c < 'List.cc'`"
test 1821 -eq "$Wc_c" ||
	echo 'List.cc: original size 1821, current size' "$Wc_c"
fi
# ============= Preferences.cc ==============
if test -f 'Preferences.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping Preferences.cc (File already exists)'
else
echo 'x - extracting Preferences.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Preferences.cc' &&
//
// Preferences.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the Preferences class
//
#include "Preferences.h"
#include "xvgopher.h"
#include <stdlib.h>
#include <fstream.h>
#include <xview/xview.h>
#include <xview/defaults.h>
X
X
//***************************************************************************
// Preferences::Preferences()
//
Preferences::Preferences()
{
X	//
X	// Get the path to the .xvgopher-defaults file in the user's home directory
X	//
X	char		*home = getenv("HOME");
X	if (!home)
X		home = ".";
X	char		filename[100];
X	sprintf(filename, "%s/.xvgopher-defaults", home);
X
X	//
X	// Read in any values from it
X	//
X	defaults_load_db(filename);
X
X	//
X	// Now get the values we are interested in.
X	//
X	remove_children = defaults_get_boolean("xvgopher.removeclients", "XvGopher.RemoveClients", FALSE);
X	popup_bookmarks = defaults_get_boolean("xvgopher.popupbookmarks", "XvGopher.PopupBookmarks", FALSE);
X	mail_filter = strdup(defaults_get_string("xvgopher.mailfilter", "XvGopher.MailFilter", DEFAULT_MAILER));
X	print_filter = strdup(defaults_get_string("xvgopher.printfilter", "XvGopher.PrintFilter", DEFAULT_PRINT_FILTER));
X	play_filter = strdup(defaults_get_string("xvgopher.playfilter", "XvGopher.PlayFilter", DEFAULT_PLAYER));
X	image_filter = strdup(defaults_get_string("xvgopher.imagefilter", "XvGopher.ImageFilter", DEFAULT_IMAGER));
X	telnet_command = strdup(defaults_get_string("xvgopher.telnetcommand", "XvGopher.TelnetCommand", DEFAULT_TELNET));
}
X
X
//***************************************************************************
// Preferences::~Preferences()
//
Preferences::~Preferences()
{
X	//
X	// Get the path to the .xvgopher-defaults file in the user's home directory
X	//
X	char		*home = getenv("HOME");
X	if (!home)
X		home = ".";
X	char		filename[100];
X	sprintf(filename, "%s/.xvgopher-defaults", home);
X
X	ofstream	out(filename);
X	if (out.fail())
X		return;
X
X	static char *truth[2] = {"False", "True"};
X
X	//
X	// Write the things we know about to the file
X	//
X	out << "XvGopher.RemoveClients:\t" << truth[remove_children] << "\n";
X	out << "XvGopher.PopupBookmarks:\t" << truth[popup_bookmarks] << "\n";
X	out << "XvGopher.MailFilter:\t" << mail_filter << "\n";
X	out << "XvGopher.PrintFilter:\t" << print_filter << "\n";
X	out << "XvGopher.PlayFilter:\t" << play_filter << "\n";
X	out << "XvGopher.ImageFilter:\t" << image_filter << "\n";
X	out << "XvGopher.TelnetCommand:\t" << telnet_command << "\n";
X	out.close();
X
X	//
X	// For good measures, we should delete the storage used by the preferences
X	//
X	delete mail_filter;
X	delete print_filter;
X	delete play_filter;
X	delete image_filter;
X	delete telnet_command;
}
X
X
//***************************************************************************
// int Preferences::get_remove_children()
//
int Preferences::get_remove_children()
{
X	return remove_children;
}
X
X
//***************************************************************************
// void Preferences::set_remove_children(int x)
//
void Preferences::set_remove_children(int x)
{
X	 remove_children = x != 0;
}
X
X
//***************************************************************************
// int Preferences::get_popup_bookmarks()
//
int Preferences::get_popup_bookmarks()
{
X	return popup_bookmarks;
}
X
X
//***************************************************************************
// void Preferences::set_popup_bookmarks(int x)
//
void Preferences::set_popup_bookmarks(int x)
{
X	 popup_bookmarks = x != 0;
}
X
X
//***************************************************************************
// char *Preferences::get_mail_filter()
//
char *Preferences::get_mail_filter()
{
X	return mail_filter;
}
X
X
//***************************************************************************
// void Preferences::set_mail_filter(char *s)
//
void Preferences::set_mail_filter(char *s)
{
X	delete mail_filter;
X	 mail_filter = strdup(s);
}
X
X
//***************************************************************************
// char *Preferences::get_print_filter()
//
char *Preferences::get_print_filter()
{
X	return print_filter;
}
X
X
//***************************************************************************
// void Preferences::set_print_filter(char *s)
//
void Preferences::set_print_filter(char *s)
{
X	delete print_filter;
X	 print_filter = strdup(s);
}
X
X
//***************************************************************************
// char *Preferences::get_play_filter()
//
char *Preferences::get_play_filter()
{
X	return play_filter;
}
X
X
//***************************************************************************
// void Preferences::set_play_filter(char *s)
//
void Preferences::set_play_filter(char *s)
{
X	delete play_filter;
X	 play_filter = strdup(s);
}
X
X
//***************************************************************************
// char *Preferences::get_image_filter()
//
char *Preferences::get_image_filter()
{
X	return image_filter;
}
X
X
//***************************************************************************
// void Preferences::set_image_filter(char *s)
//
void Preferences::set_image_filter(char *s)
{
X	delete image_filter;
X	 image_filter = strdup(s);
}
X
X
//***************************************************************************
// char *Preferences::get_telnet_command()
//
char *Preferences::get_telnet_command()
{
X	return telnet_command;
}
X
X
//***************************************************************************
// void Preferences::set_telnet_command(char *s)
//
void Preferences::set_telnet_command(char *s)
{
X	delete telnet_command;
X	telnet_command = strdup(s);
}
X
X
SHAR_EOF
chmod 0664 Preferences.cc ||
echo 'restore of Preferences.cc failed'
Wc_c="`wc -c < 'Preferences.cc'`"
test 5632 -eq "$Wc_c" ||
	echo 'Preferences.cc: original size 5632, current size' "$Wc_c"
fi
# ============= Response.cc ==============
if test -f 'Response.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping Response.cc (File already exists)'
else
echo 'x - extracting Response.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Response.cc' &&
//
// Response.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the Response class
//
#include "Response.h"
#include <string.h>
#include <stdio.h>
X
X
//***************************************************************************
// Response::Response()
//
Response::Response()
{
X	words[0] = NULL;
X	wordcount = 0;
}
X
X
//***************************************************************************
// Response::Response(Response *r)
//
Response::Response(Response *r)
{
X	for (wordcount = 0; wordcount < r->wordcount; wordcount++)
X		words[wordcount] = strdup(r->words[wordcount]);
X	type = r->type;
}
X
X
//***************************************************************************
// Response::Response(char *str)
//
Response::Response(char *str)
{
X	words[0] = NULL;
X	wordcount = 0;
X
X	set(str);
}
X
X
//***************************************************************************
// Response::~Response()
//
Response::~Response()
{
X	for (int i = 0; i < wordcount; i++)
X		if (words[i])
X			delete words[i];
}
X
X
//***************************************************************************
// int Response::set(char *str)
//
int Response::set(char *str)
{
X	extern char *good_strtok(char *, char *);
X	char	*temp = strdup(str);
X
X	type = *temp;
X	char *token = good_strtok(temp + 1, "\t\r\n");
X	if (!token)
X	{
X		delete temp;
X		return 0;
X	}
X	words[0] = strdup(token);
X	for (wordcount = 1; (token = good_strtok((char *) 0, "\t\r\n")); wordcount++)
X		words[wordcount] = strdup(token);
X	delete temp;
X	return wordcount;
}
X
X
//***************************************************************************
// char *Response::get_nth(int n)
//
char *Response::get_nth(int n)
{
X	if (n >= wordcount || n < 0)
X		return (char *) 0;
X	else
X		return words[n];
}
X
X
//***************************************************************************
// void Response::set_nth(int n, char *str)
//
void Response::set_nth(int n, char *str)
{
X	if (n >= MAX_WORDS || n < 0)
X		return;
X	else
X	{
X		words[n] = strdup(str);
X		if (n >= wordcount)
X			wordcount = n + 1;
X	}
}
X
X
//***************************************************************************
// void Response::set_nth(int n, int x)
//
void Response::set_nth(int n, int x)
{
X	if (n >= MAX_WORDS || n < 0)
X		return;
X	else
X	{
X		char buffer[20];
X		sprintf(buffer, "%d", x);
X		words[n] = strdup(buffer);
X		if (n >= wordcount)
X			wordcount = n + 1;
X	}
}
X
X
SHAR_EOF
chmod 0644 Response.cc ||
echo 'restore of Response.cc failed'
Wc_c="`wc -c < 'Response.cc'`"
test 2479 -eq "$Wc_c" ||
	echo 'Response.cc: original size 2479, current size' "$Wc_c"
fi
# ============= cursor.cc ==============
if test -f 'cursor.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping cursor.cc (File already exists)'
else
echo 'x - extracting cursor.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'cursor.cc' &&
//
// cursor.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This file deals with the different cursors which may be used
//
#include <xview/xview.h>
#include <xview/svrimage.h>
#include <xview/cursor.h>
#include <xview/notify.h>
X
X
static Cursor		busy_cursor[2];
static Server_image	busy_image[2];
static Cursor		old_cursor;
static int			current_cursor = 0;
X
#define	BLINK_DELAY	200000
X
static unsigned short busy1_bits[] = {
#include "icons/gopher1"
};
X
static unsigned short busy2_bits[] = {
#include "icons/gopher2"
};
X
//***************************************************************************
// void init_cursors()
//
static void init_cursors()
{
X	static int	had_init = FALSE;
X
X	if (had_init)
X		return;
X
X	had_init = TRUE;
X
X	busy_image[0] = (Server_image) xv_create(NULL, SERVER_IMAGE,
X		XV_WIDTH,					64,
X		XV_HEIGHT,					64,
X		SERVER_IMAGE_BITS,			busy1_bits,
X		NULL);
X	busy_cursor[0] = (Cursor) xv_create(NULL, CURSOR,
X		CURSOR_IMAGE,				busy_image[0],
X		CURSOR_XHOT,				32,
X		CURSOR_YHOT,				32,
X		NULL);
X	busy_image[1] = (Server_image) xv_create(NULL, SERVER_IMAGE,
X		XV_WIDTH,					64,
X		XV_HEIGHT,					64,
X		SERVER_IMAGE_BITS,			busy2_bits,
X		NULL);
X	busy_cursor[1] = (Cursor) xv_create(NULL, CURSOR,
X		CURSOR_IMAGE,				busy_image[1],
X		CURSOR_XHOT,				32,
X		CURSOR_YHOT,				32,
X		NULL);
}
X
X
//***************************************************************************
// Server_image get_gopher(int n)
//
Server_image get_gopher(int n)
{
X	return busy_image[n];
}
X
X
static int	isbusy = FALSE;
X
//***************************************************************************
// static Notify_value blink_cursor(Frame frame, int which)
//
Notify_value blink_cursor(Frame frame, int which)
{
X	which = which;
X
X	current_cursor ^= 1;
X
X	Xv_opaque	sub;
X	int			n = 1;
X	while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL)
X	{
X		xv_set(sub,
X			WIN_CURSOR,					busy_cursor[current_cursor],
X			NULL);
X		n++;
X	}
X	return (Notify_value) 0;
}
X
X
//***************************************************************************
// void frame_busy(Frame frame)
//
void frame_busy(Frame frame)
{
X	notify_dispatch();
X	if (isbusy)
X		return;
X	isbusy = TRUE;
X	init_cursors();
X	old_cursor = (Cursor) xv_get(frame, WIN_CURSOR);
X	xv_set(frame,
X		FRAME_BUSY,					TRUE,
X		NULL);
X
X	//
X	// Now go through all sub windows and change their cursor
X	//
X	Xv_opaque	sub;
X	int			n = 1;
X	while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL)
X	{
X		xv_set(sub,
X			WIN_CURSOR,					busy_cursor[0],
X			NULL);
X		n++;
X	}
X
X	//
X	// Start the timer to change the cursor icon every once in a while
X	//
X	struct itimerval	timer;
X	timer.it_value.tv_usec = BLINK_DELAY;
X	timer.it_value.tv_sec = 0;
X	timer.it_interval.tv_usec = BLINK_DELAY;
X	timer.it_interval.tv_sec = 0;
X	notify_set_itimer_func(frame, (Notify_func) blink_cursor, ITIMER_REAL, &timer, NULL);
}
X
X
//***************************************************************************
// void frame_unbusy(Frame frame)
//
void frame_unbusy(Frame frame)
{
X	//
X	// First stop the interval timer which is blinking the cursor
X	//
X	notify_set_itimer_func(frame, NOTIFY_FUNC_NULL, ITIMER_REAL, NULL, NULL);
X
X	notify_dispatch();
X	if (!isbusy)
X		return;
X	isbusy = FALSE;
X	init_cursors();
X	xv_set(frame,
X		FRAME_BUSY,					FALSE,
X		NULL);
X
X	//
X	// Now go through all sub windows and change their cursor
X	//
X	Xv_opaque	sub;
X	int			n = 1;
X	while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL)
X	{
X		xv_set(sub,
X			WIN_CURSOR,					old_cursor,
X			NULL);
X		n++;
X	}
}
X
X
SHAR_EOF
chmod 0644 cursor.cc ||
echo 'restore of cursor.cc failed'
Wc_c="`wc -c < 'cursor.cc'`"
test 3627 -eq "$Wc_c" ||
	echo 'cursor.cc: original size 3627, current size' "$Wc_c"
fi
# ============= icons.cc ==============
if test -f 'icons.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping icons.cc (File already exists)'
else
echo 'x - extracting icons.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'icons.cc' &&
//
// icons.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This file defines all the glyphs used in the xvgopher program
//
#include <xview/xview.h>
#include <xview/svrimage.h>
#include "icons.h"
X
static unsigned short bin_bits[] = {
#include "icons/bin"
};
static unsigned short cso_bits[] = {
#include "icons/cso"
};
static unsigned short dir_bits[] = {
#include "icons/dir"
};
static unsigned short doc_bits[] = {
#include "icons/doc"
};
static unsigned short dos_bits[] = {
#include "icons/dos"
};
static unsigned short error_bits[] = {
#include "icons/error"
};
static unsigned short idx_bits[] = {
#include "icons/idx"
};
static unsigned short mac_bits[] = {
#include "icons/mac"
};
static unsigned short tel_bits[] = {
#include "icons/tel"
};
static unsigned short unknown_bits[] = {
#include "icons/unknown"
};
static unsigned short uu_bits[] = {
#include "icons/uu"
};
static unsigned short sound_bits[] = {
#include "icons/sound"
};
static unsigned short image_bits[] = {
#include "icons/image"
};
static unsigned short info_bits[] = {
#include "icons/info"
};
static unsigned short info_dragging_bits[] = {
#include "icons/info_dragging"
};
X
X
struct
{
X	unsigned char	type;
X	Server_image	image;
X	unsigned short	*bits;
} icons[] =
{
X	{'.', NULL, unknown_bits},
X	{'0', NULL, doc_bits},
X	{'1', NULL, dir_bits},
X	{'2', NULL, cso_bits},
X	{'3', NULL, error_bits},
X	{'4', NULL, mac_bits},
X	{'5', NULL, dos_bits},
X	{'6', NULL, uu_bits},
X	{'7', NULL, idx_bits},
X	{'8', NULL, tel_bits},
X	{'9', NULL, bin_bits},
X	{'s', NULL, sound_bits},
X	{'I', NULL, image_bits},
X	{'g', NULL, image_bits},
X
X	//
X	// The following are images used by other parts of xvgopher.  They are
X	// identified by characters with the high bit set.
X	//
X	{'i' | 0x80, NULL, info_bits},
X	{'d' | 0x80, NULL, info_dragging_bits},
X	{'\0', NULL, NULL}
};
X
X
//***************************************************************************
// void icon_init()
//
void icon_init()
{
X	static int	had_init = FALSE;
X	if (had_init)
X		return;
X	had_init = TRUE;
X
X	for (int i = 0; icons[i].type; i++)
X	{
X		icons[i].image = (Server_image) xv_create(NULL, SERVER_IMAGE,
X			XV_WIDTH,					16,
X			XV_HEIGHT,					16,
X			SERVER_IMAGE_BITS,			icons[i].bits,
X			NULL);
X	}
}
X
X
//***************************************************************************
// Server_image get_image(char type)
//
Server_image get_image(char type)
{
X	icon_init();
X
X	//
X	// Search through the list of icons to find the right one...
X	//
X	for (int i = 0; icons[i].type; i++)
X	{
X		if (icons[i].type == (unsigned char) type)
X			return icons[i].image;
X	}
X
X	//
X	// Nothing found.  Return the unknown icons
X	//
X	return icons[0].image;
}
X
SHAR_EOF
chmod 0664 icons.cc ||
echo 'restore of icons.cc failed'
Wc_c="`wc -c < 'icons.cc'`"
test 2754 -eq "$Wc_c" ||
	echo 'icons.cc: original size 2754, current size' "$Wc_c"
fi
# ============= main.cc ==============
if test -f 'main.cc' -a X"$1" != X"-c"; then
	echo 'x - skipping main.cc (File already exists)'
else
echo 'x - extracting main.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'main.cc' &&
//
// main.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// Main program for xvgopher
//
#include "xvgopher.h"
#include "GWindow.h"
#include "Preferences.h"
#include <xview/xview.h>
X
X
Preferences	preferences;
X
static int error_proc()
{
X	abort();
X	return XV_OK;
}
X
X
//***************************************************************************
// main(int ac, char **av)
//
main(int ac, char **av)
{
X	char		*server = GOPHER_SERVER;
X	char		*port = "70";
X
X	xv_init(XV_INIT_ARGC_PTR_ARGV,		&ac, av,
X		XV_ERROR_PROC,			error_proc,
X		NULL);
X
X	switch (ac)
X	{
X		case 2:	// A machine was specified
X			server = av[1];
X			break;
X		case 3:	// A machine and port were specified
X			server = av[1];
X			port = av[2];
X			break;
X	}
X
X	Response	*r = new Response("1");
X	r->set_server(server);
X	r->set_port(port);
X	GWindow	*main_window = CreateWindow(r);
X
X	if (main_window)
X		main_window->main_loop();
X
X	return 0;
}
SHAR_EOF
chmod 0664 main.cc ||
echo 'restore of main.cc failed'
Wc_c="`wc -c < 'main.cc'`"
test 996 -eq "$Wc_c" ||
	echo 'main.cc: original size 996, current size' "$Wc_c"
fi
# ============= Config.h ==============
if test -f 'Config.h' -a X"$1" != X"-c"; then
	echo 'x - skipping Config.h (File already exists)'
else
echo 'x - extracting Config.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Config.h' &&
//
// Config.h
//
// This class deals with configuration.  All configurable options are kept in this class
//
#ifndef	_Config_h_
#define	_Config_h_
X
#include "List.h"
X
X
class Config
{
public:
X	//
X	// Constructor
X	//
X							Config();
X
X	//
X	// Configuration file access
X	//
X	void					read();
X	int						write();
X
X	//
X	// Configuration parameters.  These are directly accessible to make it easier.
X	//
X	List					bookmarks;
X	String					server;
X	int						port;
private:
};
X
#endif	_Config_h_
SHAR_EOF
chmod 0644 Config.h ||
echo 'restore of Config.h failed'
Wc_c="`wc -c < 'Config.h'`"
test 486 -eq "$Wc_c" ||
	echo 'Config.h: original size 486, current size' "$Wc_c"
fi
# ============= Connection.h ==============
if test -f 'Connection.h' -a X"$1" != X"-c"; then
	echo 'x - skipping Connection.h (File already exists)'
else
echo 'x - extracting Connection.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'Connection.h' &&
//
// Connection.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class forms a easy to use interface to the berkeley tcp socket library.
// All the calls are basically the same, but the parameters do not have any
// stray _addr or _in mixed in...
//
X
#if !defined(_Connection_h_)
# define	_Connection_h_
X
#include "xvgopher.h"
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
X
class Connection
{
public:
X	// Constructors & Destructors
X					Connection();
X					Connection(int socket);
X					~Connection();
X
X	// (De)initialization
X	int				open(int priv = 0);
X	int				close();
X
X	// Port stuff
X	int				assign_port(int port = 0);
X	int				assign_port(char *service);
X	int				get_port();
X	int				is_privileged();
X
X	// Host stuff
X	int				assign_server(char *name);
X	int				assign_server(dword addr = INADDR_ANY);
X
X	// Connection establishment
X	int				connect();
X	Connection		*accept(int priv = 0);
X	Connection		*accept_privileged();
X
X	// Registration things
X	int				bind();
X	int				listen(int n = 5);
X
X	// IO
X	int				write(char *buffer, int length);
X	int				write(char *buffer);
X	int				read(char *buffer, int length);
X	char			*read_line(char *buffer, int length);
X	int				read_partial(char *buffer, int maxlength);
X	int				bytes_available();
X	int				get_char();
X
X	// Access to socket number
X	char			*socket_as_string();
X	int				get_socket();
X	int				isopen();
X
private:
X	enum
X	{
X		BUFFER_SIZE = 1024,
X	};
X	int				sock;
X	struct sockaddr_in	server;
X	char			buffer[BUFFER_SIZE];
X	int				pos, pos_max;
};
X
X
//*************************************************************************
// inline int Connection::is_privileged()
// PURPOSE:
//   Return whether the port is priveleged or not.
//
inline int Connection::is_privileged()
{
X	return server.sin_port < 1023;
}
X
X
#endif
SHAR_EOF
chmod 0644 Connection.h ||
echo 'restore of Connection.h failed'
Wc_c="`wc -c < 'Connection.h'`"
test 1949 -eq "$Wc_c" ||
	echo 'Connection.h: original size 1949, current size' "$Wc_c"
fi
# ============= GWAbout.h ==============
if test -f 'GWAbout.h' -a X"$1" != X"-c"; then
	echo 'x - skipping GWAbout.h (File already exists)'
else
echo 'x - extracting GWAbout.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWAbout.h' &&
//
// GWAbout.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class produces a popup window describing the who, what, and where of
// xvgopher.
//
#ifndef	_GWAbout_h_
#define	_GWAbout_h_
X
#include "GWindow.h"
X
class GWAbout : public GWindow
{
public:
X							GWAbout(Frame par);
X	int						open(Response *resp);
private:
X	static void				done_proc(Frame);
X	static void				dismiss_proc(Panel_item, Event *);
X	static Notify_value		panel_events(Xv_window, Event *, Notify_arg, Notify_event_type);
};
X
#endif	_GWAbout_h_
SHAR_EOF
chmod 0644 GWAbout.h ||
echo 'restore of GWAbout.h failed'
Wc_c="`wc -c < 'GWAbout.h'`"
test 620 -eq "$Wc_c" ||
	echo 'GWAbout.h: original size 620, current size' "$Wc_c"
fi
# ============= GWBinary.h ==============
if test -f 'GWBinary.h' -a X"$1" != X"-c"; then
	echo 'x - skipping GWBinary.h (File already exists)'
else
echo 'x - extracting GWBinary.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWBinary.h' &&
//
// GWBinary.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class deals with the getting and saving of ASCII files from
// a gopher server.
//
#ifndef	_GWBinary_h_
#define	_GWBinary_h_
X
#include "GWDownload.h"
X
class GWBinary : public GWDownload
{
public:
X							GWBinary(Frame par);
};
X
#endif	_GWBinary_h_
SHAR_EOF
chmod 0644 GWBinary.h ||
echo 'restore of GWBinary.h failed'
Wc_c="`wc -c < 'GWBinary.h'`"
test 417 -eq "$Wc_c" ||
	echo 'GWBinary.h: original size 417, current size' "$Wc_c"
fi
# ============= GWBookmarks.h ==============
if test -f 'GWBookmarks.h' -a X"$1" != X"-c"; then
	echo 'x - skipping GWBookmarks.h (File already exists)'
else
echo 'x - extracting GWBookmarks.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWBookmarks.h' &&
//
// GWBookmarks.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class deals with bookmarks and the window that displays them.
//
#ifndef	_GWBookmarks_h_
#define	_GWBookmarks_h_
X
#include "GWList.h"
X
class GWBookmarks : public GWList
{
public:
X	//
X	// Constructor/Destructor
X	//
X							GWBookmarks(Frame);
X							~GWBookmarks();
X
X	//
X	// Window creation
X	//
X	int						open(Response *resp);
X	void					show();
X
X	//
X	// Bookmarks access
X	//
X	void					add(Response *r);
X
protected:
X	void					row_deselect(int, Response *);
X	void					row_select(int, Response *);
X
X	void					read_bookmarks();
X	void					write_bookmarks();
X
X	static void				remove_bookmark_proc(Menu menu, Menu_item mi);
X	static void				done_proc(Frame);
X
X	//
X	// The following are used to perform certain specific tasks when creating windows.
X	// They are split up to make the code more readable and modular
X	//
X	void					modify_list_menu();
X
X	Menu_item				bookmark_mi;
X	Menu_item				show_info_mi;
};
X
extern GWBookmarks	*bookmarks;
X
#endif	_GWBookmarks_h_
SHAR_EOF
chmod 0644 GWBookmarks.h ||
echo 'restore of GWBookmarks.h failed'
Wc_c="`wc -c < 'GWBookmarks.h'`"
test 1124 -eq "$Wc_c" ||
	echo 'GWBookmarks.h: original size 1124, current size' "$Wc_c"
fi
# ============= GWDirectory.h ==============
if test -f 'GWDirectory.h' -a X"$1" != X"-c"; then
	echo 'x - skipping GWDirectory.h (File already exists)'
else
echo 'x - extracting GWDirectory.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWDirectory.h' &&
//
// GWDirectory.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class deals with the getting and saving of ASCII files from
// a gopher server.
//
#ifndef	_GWDirectory_h_
#define	_GWDirectory_h_
X
#include "GWList.h"
X
class GWDirectory : public GWList
{
public:
X							GWDirectory(Frame par);
X	int						open(Response *resp);
X	void					display();
X
protected:
X	//
X	// Callbacks for the XView interface
X	//
#if		USE_SAVE
X	static void				save_notify(Panel_item item, Event *);
#endif	USE_SAVE
X	static void				menu_proc(Menu menu, Menu_item mi);
X
X	//
X	// The next two callbacks are for the menu attached to the scrolling list
X	//
X	static void				set_bookmark_proc(Menu menu, Menu_item mi);
X
X	void					row_deselect(int, Response *);
X	void					row_select(int, Response *);
X
X	//
X	// Various window thingies that we need to keep track of
X	//
X	Menu_item				bookmark_mi;
X	Menu_item				show_info_mi;
X
X	//
X	// The following are used to perform certain specific tasks when creating windows.
X	// They are split up to make the code more readable and modular
X	//
X	void					modify_list_menu();
};
X
#endif	_GWDirectory_h_
SHAR_EOF
chmod 0664 GWDirectory.h ||
echo 'restore of GWDirectory.h failed'
Wc_c="`wc -c < 'GWDirectory.h'`"
test 1210 -eq "$Wc_c" ||
	echo 'GWDirectory.h: original size 1210, current size' "$Wc_c"
fi
# ============= GWDownload.h ==============
if test -f 'GWDownload.h' -a X"$1" != X"-c"; then
	echo 'x - skipping GWDownload.h (File already exists)'
else
echo 'x - extracting GWDownload.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWDownload.h' &&
//
// GWDownload.h
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
//       (See the COPYRIGHT file for more Copyright information)
//
// This class deals with the getting and saving of ASCII files from
// a gopher server.
//
#ifndef	_GWDownload_h_
#define	_GWDownload_h_
X
#include "GWindow.h"
X
class GWDownload : public GWindow
{
public:
X							GWDownload(Frame par, int type, char *btn, char *btncmd);
X							GWDownload(Frame par, int type);
X