---- Cut Here and feed the following to sh ----

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 02 of a multipart archive
# ============= GWDownload.cc ==============
if test -f 'GWDownload.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWDownload.cc (File already exists)'
else
echo 'x - extracting GWDownload.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWDownload.cc' &&
//
// GWDownload.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWDownload class
//
#include "GWDownload.h"
#include "xvgopher.h"
#include "cursor.h"
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
X
#define KEY_TEXT_ITEM 20000
#define KEY_SAVE 20001
#define KEY_CANCEL 20002
#define KEY_OTHER 20003
X
X
//***************************************************************************
// GWDownload::GWDownload(Frame par, int download_type)
//
GWDownload::GWDownload(Frame par, int download_type)
{
X parent = par;
X type = download_type;
X button = NULL;
X button_command = NULL;
}
X
X
//***************************************************************************
// GWDownload::GWDownload(Frame par, int download_type, char *btn, char *btncmd)
//
GWDownload::GWDownload(Frame par, int download_type, char *btn, char *btncmd)
{
X parent = par;
X type = download_type;
X button = btn;
X button_command = btncmd;
}
X
X
//***************************************************************************
// void GWDownload::bin_save_notify(Panel_item item, Event *)
// PURPOSE:
// We get here when the user wants to copy our temporary copy into a more
// permanent file.
//
void GWDownload::bin_save_notify(Panel_item item, Event *)
{
X GWDownload *gwindow = (GWDownload *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X Gopher *gopher = gwindow->gopher;
X Panel_item txt = (Panel_item) xv_get(item, XV_KEY_DATA, KEY_TEXT_ITEM);
X int fd = ::open((char *) xv_get(txt, PANEL_VALUE), O_CREAT | O_WRONLY, 0644);
X if (fd < 0)
X {
X gwindow->status("Unable to create file");
X return;
X }
X
X //
X // Ok, we now have a new file we can write to. We will just open the
X // temporary file and copy its contents block by block to the new file.
X //
X gwindow->status("Saving...");
X int old = ::open(gopher->filename, O_RDONLY);
X char buffer[10240];
X int n;
X while ((n = ::read(old, buffer, 10240)) > 0)
X {
X ::write(fd, buffer, n);
X }
X ::close(fd);
X ::close(old);
X gwindow->status("File saved");
}
X
X
//***************************************************************************
// void GWDownload::bin_cancel_notify(Panel_item, Event *)
//
void GWDownload::bin_cancel_notify(Panel_item item , Event *)
{
X GWDownload *gwindow = (GWDownload *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X delete gwindow;
X Frame frame = (Frame) xv_get(item, XV_KEY_DATA, KEY_FRAME);
X xv_destroy_safe(frame);
}
X
X
//***************************************************************************
// void GWDownload::bin_other_notify(Panel_item, Event *)
//
void GWDownload::bin_other_notify(Panel_item item , Event *)
{
X GWDownload *gwindow = (GWDownload *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X Gopher *gopher = gwindow->gopher;
X Panel_item txt = (Panel_item) xv_get(item, XV_KEY_DATA, KEY_TEXT_ITEM);
X
X char command[1000];
X sprintf(command, "%s %s &", gwindow->button_command, gopher->filename);
X system(command);
X
X sprintf(command, "Started %s on %s", gwindow->button, gopher->filename);
X gwindow->status(command);
}
X
X
//***************************************************************************
// Panel_setting GWDownload::bin_text_notify(Panel_item item, Event *event)
//
Panel_setting GWDownload::bin_text_notify(Panel_item item, Event *event)
{
X bin_save_notify(item, event);
X return PANEL_NONE;
}
X
X
//***************************************************************************
// int GWDownload::open(Response *resp)
// PURPOSE:
// This will create a prompt window
//
int GWDownload::open(Response *resp)
{
X info = resp;
X compute_location(407, 107);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 407,
X XV_HEIGHT, 107,
X FRAME_LABEL, "Saving a file",
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
X FRAME_SHOW_RESIZE_CORNER, FALSE,
X XV_SHOW, TRUE,
X FRAME_SHOW_FOOTER, TRUE,
X FRAME_RIGHT_FOOTER, info->get_server(),
X FRAME_DONE_PROC, done_proc,
X FRAME_ACCELERATOR, 'q', quit_proc, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X //
X // Create the text field and put a usable default name in it.
X //
X char *p = strrchr(info->get_command(), '/');
X if (!p)
X p = info->get_command();
X else
X p++;
X char *str = strdup(p);
X for (p = str; *p; p++)
X if (*p <= ' ' || *p > 126)
X *p = '_';
X Panel_item txt = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 16,
X XV_Y, 28,
X PANEL_LABEL_STRING, "Save file as:",
X PANEL_VALUE_DISPLAY_LENGTH, 35,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_VALUE, str,
X PANEL_NOTIFY_PROC, bin_text_notify,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X XV_KEY_DATA, KEY_GOPHER, gopher,
X PANEL_INACTIVE, TRUE,
X NULL);
X delete str;
X xv_set(txt,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X NULL);
X
X //
X // Create the buttons. There may be two or three buttons. We need to spread them
X // evenly to make it look better.
X //
X int ob_x, sb_x, cb_x;
X if (button)
X {
X //
X // There will be three buttons
X //
X ob_x = 107;
X sb_x = 175;
X cb_x = 241;
X }
X else
X {
X //
X // Only two buttons
X //
X sb_x = 141;
X cb_x = 207;
X }
X Panel_item sb = (Panel_item) xv_create(panel, PANEL_BUTTON,
X XV_X, sb_x,
X XV_Y, 64,
X PANEL_LABEL_STRING, "Save",
X PANEL_NOTIFY_PROC, bin_save_notify,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X XV_KEY_DATA, KEY_GOPHER, gopher,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X PANEL_INACTIVE, TRUE,
X NULL);
X Panel_item cb = (Panel_item) xv_create(panel, PANEL_BUTTON,
X XV_X, cb_x,
X XV_Y, 64,
X PANEL_LABEL_STRING, "Cancel",
X PANEL_NOTIFY_PROC, bin_cancel_notify,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X PANEL_INACTIVE, TRUE,
X NULL);
X Panel_item ob = NULL;
X if (button)
X {
X ob = (Panel_item) xv_create(panel, PANEL_BUTTON,
X XV_X, ob_x,
X XV_Y, 64,
X PANEL_LABEL_STRING, button,
X PANEL_NOTIFY_PROC, bin_other_notify,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X PANEL_INACTIVE, TRUE,
X NULL);
X }
X
X //
X // Associate the panel items with the frame so we can get at them later on
X //
X xv_set(frame,
X XV_KEY_DATA, KEY_SAVE, sb,
X XV_KEY_DATA, KEY_CANCEL, cb,
X XV_KEY_DATA, KEY_OTHER, ob,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X NULL);
X //
X // Now we need to build the connection and get information from it
X //
X frame_busy(frame);
X status("Building connection...");
X gopher = new Gopher(this);
X if (gopher->open(info->get_server(), info->get_port()) == NOTOK) // Connection
X return NOTOK;
X gopher->read(info->get_type(), info->get_command()); // Get info
X
X return OK;
}
X
X
//***************************************************************************
// void GWDownload::display()
// PURPOSE:
// This is called when the receive of a file has been completed.
//
void GWDownload::display()
{
X //
X // Now make the items in the window active so that the file can be saved
X //
X frame_unbusy(frame);
X Panel_item b = (Panel_item) xv_get(frame, XV_KEY_DATA, KEY_SAVE);
X xv_set(b, PANEL_INACTIVE, FALSE, NULL);
X b = (Panel_item) xv_get(frame, XV_KEY_DATA, KEY_CANCEL);
X xv_set(b, PANEL_INACTIVE, FALSE, NULL);
X b = (Panel_item) xv_get(frame, XV_KEY_DATA, KEY_TEXT_ITEM);
X xv_set(b, PANEL_INACTIVE, FALSE, NULL);
X b = (Panel_item) xv_get(frame, XV_KEY_DATA, KEY_OTHER);
X if (b)
X xv_set(b, PANEL_INACTIVE, FALSE, NULL);
}
X
X
SHAR_EOF
chmod 0644 GWDownload.cc ||
echo 'restore of GWDownload.cc failed'
Wc_c="`wc -c < 'GWDownload.cc'`"
test 7644 -eq "$Wc_c" ||
echo 'GWDownload.cc: original size 7644, current size' "$Wc_c"
fi
# ============= GWFile.cc ==============
if test -f 'GWFile.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWFile.cc (File already exists)'
else
echo 'x - extracting GWFile.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWFile.cc' &&
//
// GWFile.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWFile class
//
#include "GWFile.h"
#include "xvgopher.h"
#include "cursor.h"
#include <xview/textsw.h>
X
#define KEY_TEXT_ITEM 20000
#define KEY_TYPE 20001
#define KEY_TEXT 20002
#define TYPE_SAVE 1
#define TYPE_MAIL 2
X
X
//***************************************************************************
// GWFile::GWFile(Frame par)
//
GWFile::GWFile(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// static void menu_proc(Menu menu, Menu_item menu_item)
//
static void menu_proc(Menu menu, Menu_item menu_item)
{
X char *str = (char *) xv_get(menu_item, MENU_STRING);
X Panel_item txt = (Panel_item) xv_get(menu, XV_KEY_DATA, KEY_TEXT_ITEM);
X Textsw t = (Textsw) xv_get(menu, XV_KEY_DATA, KEY_TEXT);
X char command[200];
X
X if (strcmp(str, "Save...") == 0)
X {
X xv_set(txt,
X PANEL_LABEL_STRING, "Save as:",
X XV_KEY_DATA, KEY_TYPE, TYPE_SAVE,
X XV_SHOW, TRUE,
X NULL);
X }
X else if (strcmp(str, "Print") == 0)
X {
X //
X // First save the file
X //
X textsw_save(t, 0, 0);
X char name[200];
X name[0] = '\0';
X textsw_append_file_name(t, name);
X
X //
X // This needs to use a user definable print method!!!
X //
X sprintf(command, "%s %s &", preferences.get_print_filter(), name);
X system(command);
X }
X else if (strcmp(str, "Mail...") == 0)
X {
X xv_set(txt,
X PANEL_LABEL_STRING, "Mail to:",
X XV_KEY_DATA, KEY_TYPE, TYPE_MAIL,
X XV_SHOW, TRUE,
X NULL);
X }
}
X
X
//***************************************************************************
// static Panel_setting text_notify(Panel_item item, Event *event)
//
static Panel_setting text_notify(Panel_item item, Event *event)
{
X event = event;
X char *string = (char *) xv_get(item, PANEL_VALUE);
X Textsw t = (Textsw) xv_get(item, XV_KEY_DATA, KEY_TEXT);
X GWindow *gwindow = (GWindow *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X
X switch (xv_get(item, XV_KEY_DATA, KEY_TYPE))
X {
X case TYPE_SAVE:
X gwindow->status("Saving...");
X if (textsw_store_file(t, string, 0, 0) != 0)
X {
X //
X // Some problem occured... Notify the user
X //
X gwindow->status("Unable to save!");
X }
X else
X gwindow->status("File saved");
X break;
X case TYPE_MAIL:
X {
X textsw_save(t, 0, 0);
X char name[200];
X name[0] = '\0';
X
X Frame frame = (Frame) xv_get(item, XV_KEY_DATA, KEY_FRAME);
X char *subject = (char *) xv_get(frame, FRAME_LABEL);
X
X textsw_append_file_name(t, name);
X gwindow->status("Mailing...");
X char command[200];
X sprintf(command, "%s -s '%s' %s < %s", preferences.get_mail_filter(), subject, string, name);
X system(command);
X gwindow->status("File mailed");
X break;
X }
X }
X return PANEL_NONE;
}
X
X
//***************************************************************************
// int GWFile::open(Response *resp)
// PURPOSE:
// This will create a window in which a file will be displayed. We will create
// a command frame with a textsw at the bottom. The top will be a panel with
// a menu and a hidden text field.
//
int GWFile::open(Response *resp)
{
X info = resp;
X compute_location(600, 500);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 600,
X XV_HEIGHT, 500,
X FRAME_LABEL, info->get_title(),
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
X FRAME_SHOW_RESIZE_CORNER, TRUE,
X XV_SHOW, TRUE,
X FRAME_SHOW_FOOTER, TRUE,
X FRAME_RIGHT_FOOTER, info->get_server(),
X FRAME_DONE_PROC, done_proc,
X FRAME_ACCELERATOR, 'q', quit_proc, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X textsw = (Textsw) xv_create(frame, TEXTSW,
X XV_X, 0,
X XV_Y, 29,
X NULL);
X
X //
X // Child windows have a close button
X //
X dir_quit = xv_create(panel, PANEL_BUTTON,
X XV_X, 488, // It will be relocated anyway...
X XV_Y, 4,
X PANEL_LABEL_STRING, "Dismiss",
X PANEL_NOTIFY_PROC, quit_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X
X //
X // Create the menu and button which go in the panel...
X //
X Menu menu = (Menu) xv_create(NULL, MENU,
X MENU_NOTIFY_PROC, menu_proc,
X MENU_STRINGS, "Save...",
X "Print",
X "Mail...",
X NULL,
X NULL);
X xv_create(panel, PANEL_BUTTON,
X XV_X, 8,
X XV_Y, 4,
X PANEL_LABEL_STRING, "Options",
X PANEL_ITEM_MENU, menu,
X NULL);
X
X //
X // Create the text item (which will not be visible until one of the options has been
X // selected)
X //
X Panel_item txt = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 128,
X XV_Y, 8,
X PANEL_LABEL_STRING, "",
X PANEL_VALUE_DISPLAY_LENGTH, 40,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_NOTIFY_PROC, text_notify,
X XV_SHOW, FALSE, // Invisible, initially
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_TEXT, textsw,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X
X //
X // Attach the Frame to the menu so that we can see where we were created
X // when a menu option was selected.
X //
X xv_set(menu,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_TEXT_ITEM, txt,
X XV_KEY_DATA, KEY_TEXT, textsw,
X NULL);
X
X //
X // Now we need to build the connection and get information from it
X //
X frame_busy(frame);
X gopher = new Gopher(this);
X if (gopher->open(info->get_server(), info->get_port()) == NOTOK) // Connection
X return NOTOK;
X status("Got connection, Retrieving text...");
X gopher->read(info->get_type(), info->get_command()); // Get info
X
X return OK;
}
X
X
//***************************************************************************
// void GWFile::display()
//
void GWFile::display()
{
X frame_unbusy(frame);
X xv_set(textsw,
X TEXTSW_FILE, gopher->filename,
X NULL);
}
X
X
SHAR_EOF
chmod 0664 GWFile.cc ||
echo 'restore of GWFile.cc failed'
Wc_c="`wc -c < 'GWFile.cc'`"
test 5861 -eq "$Wc_c" ||
echo 'GWFile.cc: original size 5861, current size' "$Wc_c"
fi
# ============= GWGopher.cc ==============
if test -f 'GWGopher.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWGopher.cc (File already exists)'
else
echo 'x - extracting GWGopher.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWGopher.cc' &&
//
// GWGopher.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWGopher class
//
#include "GWGopher.h"
#include "xvgopher.h"
#include "cursor.h"
#include <fcntl.h>
#include <unistd.h>
X
#define KEY_TEXT_ITEM 20000
X
X
//***************************************************************************
// GWGopher::GWGopher(Frame par)
//
GWGopher::GWGopher(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// int GWGopher::open(Response *)
// PURPOSE:
// This will create a dialog window to get information about a new gopher server
//
int GWGopher::open(Response *)
{
X info = NULL;
X compute_location(407, 107);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 416,
X XV_HEIGHT, 128,
X FRAME_LABEL, "Another Gopher",
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_OUT,
X FRAME_SHOW_RESIZE_CORNER, FALSE,
X XV_SHOW, TRUE,
X FRAME_SHOW_FOOTER, FALSE,
X FRAME_DONE_PROC, done_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X //
X // Create all the panel items
X //
X server = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 32,
X XV_Y, 16,
X PANEL_LABEL_STRING, "Server name:",
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X NULL);
X port = (Panel_item) xv_create(panel, PANEL_NUMERIC_TEXT,
X XV_X, 43,
X XV_Y, 41,
X PANEL_LABEL_STRING, "Server port:",
X PANEL_VALUE_DISPLAY_LENGTH, 5,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_MAX_VALUE, 30000,
X PANEL_MIN_VALUE, 1,
X PANEL_VALUE, 70,
X NULL);
X xv_create(panel, PANEL_BUTTON,
X XV_X, 185,
X XV_Y, 88,
X PANEL_LABEL_STRING, "Start",
X PANEL_NOTIFY_PROC, start_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X return OK;
}
X
X
//***************************************************************************
// void GWGopher::start_proc(Frame frame, Event *)
// PURPOS:
// This gets called when the user presses 'q' in a window.
//
void GWGopher::start_proc(Frame frame, Event *)
{
X GWGopher *win = (GWGopher *) xv_get(frame, XV_KEY_DATA, KEY_GWINDOW);
X
X int port = (int) xv_get(win->port, PANEL_VALUE);
X char *server = (char *) xv_get(win->server, PANEL_VALUE);
X
X Response *r = new Response("1");
X r->set_server(server);
X r->set_port(port);
X GWindow *main_window = CreateWindow(r, win->frame);
X if (main_window)
X main_window->open(r);
X
X xv_destroy_safe(frame);
}
X
X
SHAR_EOF
chmod 0664 GWGopher.cc ||
echo 'restore of GWGopher.cc failed'
Wc_c="`wc -c < 'GWGopher.cc'`"
test 2602 -eq "$Wc_c" ||
echo 'GWGopher.cc: original size 2602, current size' "$Wc_c"
fi
# ============= GWImage.cc ==============
if test -f 'GWImage.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWImage.cc (File already exists)'
else
echo 'x - extracting GWImage.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWImage.cc' &&
//
// GWImage.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWImage class
//
#include "GWImage.h"
#include "xvgopher.h"
X
X
//***************************************************************************
// GWImage::GWImage(Frame par)
//
GWImage::GWImage(Frame par) : GWDownload(par, GWDownload::BINARY, "View", preferences.get_image_filter())
{
}
X
X
SHAR_EOF
chmod 0644 GWImage.cc ||
echo 'restore of GWImage.cc failed'
Wc_c="`wc -c < 'GWImage.cc'`"
test 472 -eq "$Wc_c" ||
echo 'GWImage.cc: original size 472, current size' "$Wc_c"
fi
# ============= GWIndex.cc ==============
if test -f 'GWIndex.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWIndex.cc (File already exists)'
else
echo 'x - extracting GWIndex.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWIndex.cc' &&
//
// GWIndex.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWIndex class
//
#include "GWIndex.h"
#include "xvgopher.h"
#include "cursor.h"
#include <fcntl.h>
#include <unistd.h>
X
#define KEY_TEXT_ITEM 20000
X
X
//***************************************************************************
// GWIndex::GWIndex(Frame par)
//
GWIndex::GWIndex(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// Panel_setting GWIndex::index_notify(Panel_item item, Event *event)
// PURPOSE:
// This is called whenever the user hits return on the text field.
// When this happens, we will use the string to send to the server
// and then we can wait for the server to send us the results of the
// search.
//
Panel_setting GWIndex::index_notify(Panel_item item, Event *event)
{
X event = event;
X //
X // We need to build the connection and get information from it
X //
X GWIndex *gwindow = (GWIndex *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X
X gwindow->status("Performing search...");
X
X //
X // Build a new command string to send to the server. This means that we just add
X // a tab and the string in our text field to the command.
X //
X char new_command[10000];
X
X Response *r = new Response("1Results of search");
X r->set_server(gwindow->info->get_server());
X r->set_port(gwindow->info->get_port());
X sprintf(new_command, "%s\t%s",
X gwindow->info->get_command(),
X (char *) xv_get(item, PANEL_VALUE));
X r->set_command(new_command);
X GWindow *sub = CreateWindow(r, gwindow->frame);
X
X gwindow->status("");
X return PANEL_NONE;
}
X
X
//***************************************************************************
// int GWIndex::open(Response *resp)
// PURPOSE:
// This will create a prompt window
//
int GWIndex::open(Response *resp)
{
X info = resp;
X char frame_title[2000];
X sprintf(frame_title, "Index search: %s", info->get_title());
X compute_location(407, 107);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 407,
X XV_HEIGHT, 107,
X FRAME_LABEL, frame_title,
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
X FRAME_SHOW_RESIZE_CORNER, FALSE,
X XV_SHOW, TRUE,
X FRAME_SHOW_FOOTER, TRUE,
X FRAME_RIGHT_FOOTER, info->get_server(),
X FRAME_DONE_PROC, done_proc,
X FRAME_ACCELERATOR, 'q', quit_proc, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 16,
X XV_Y, 28,
X PANEL_LABEL_STRING, "Search for:",
X PANEL_VALUE_DISPLAY_LENGTH, 35,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_NOTIFY_PROC, index_notify,
X XV_KEY_DATA, KEY_FRAME, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X XV_KEY_DATA, KEY_GOPHER, gopher,
X NULL);
X
X return OK;
}
X
SHAR_EOF
chmod 0644 GWIndex.cc ||
echo 'restore of GWIndex.cc failed'
Wc_c="`wc -c < 'GWIndex.cc'`"
test 2924 -eq "$Wc_c" ||
echo 'GWIndex.cc: original size 2924, current size' "$Wc_c"
fi
# ============= GWInfo.cc ==============
if test -f 'GWInfo.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWInfo.cc (File already exists)'
else
echo 'x - extracting GWInfo.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWInfo.cc' &&
//
// GWInfo.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWInfo class
//
#include "GWInfo.h"
X
//***************************************************************************
// GWInfo::GWInfo(Frame par)
//
GWInfo::GWInfo(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// int GWInfo::open(Response *resp)
// Create a little popup which contains information about a response.
//
int GWInfo::open(Response *resp)
{
X info = resp;
X char frame_title[2000];
X sprintf(frame_title, "Info for '%s'", info->get_title());
X compute_location(390, 180);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 390,
X XV_HEIGHT, 180,
X FRAME_LABEL, frame_title,
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
X FRAME_SHOW_RESIZE_CORNER, FALSE,
X XV_SHOW, TRUE,
X FRAME_DONE_PROC, done_proc,
X FRAME_ACCELERATOR, 'q', quit_proc, frame,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X //
X // Create the textsw in the window with the text describing the item.
X //
X char buffer[10240];
X sprintf(buffer, "Name=%s\nType=%c\nPort=%d\nPath=%s\nHost=%s\n",
X info->get_title(),
X info->get_type(),
X info->get_port(),
X info->get_command(),
X info->get_server());
X xv_create(frame, TEXTSW,
X XV_X, 0,
X XV_Y, 0,
X XV_WIDTH, 390,
X XV_HEIGHT, 180,
X TEXTSW_CONTENTS, buffer,
X TEXTSW_IGNORE_LIMIT, TEXTSW_INFINITY,
X TEXTSW_READ_ONLY, TRUE,
X NULL);
X
X return OK;
}
X
SHAR_EOF
chmod 0644 GWInfo.cc ||
echo 'restore of GWInfo.cc failed'
Wc_c="`wc -c < 'GWInfo.cc'`"
test 1679 -eq "$Wc_c" ||
echo 'GWInfo.cc: original size 1679, current size' "$Wc_c"
fi
# ============= GWList.cc ==============
if test -f 'GWList.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWList.cc (File already exists)'
else
echo 'x - extracting GWList.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWList.cc' &&
//
// GWList.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// This file contains the routines of the GWList class which
// deal with the opening of windows.
//
#include "GWList.h"
#include "xvgopher.h"
#include "cursor.h"
#include "icons.h"
#include "GWBookmarks.h"
#include "GWInfo.h"
#include <stream.h>
#include <string.h>
#include <xview/svrimage.h>
#include <xview/icon.h>
#include <xview/defaults.h>
X
X
static long double_click_timeout = defaults_get_integer("openwindows.multiclicktimeout", "OpenWindows.MultiClickTimeout", 4) * 100;
X
//***************************************************************************
// GWList::GWList()
// Do generic initialization. This should be called from any derived constructor.
//
GWList::GWList()
{
X parent = NULL;
X dir_list = NULL;
X dir_quit = NULL;
X current_selected = -1;
}
X
X
//***************************************************************************
// void GWList::frame_event(Xv_Window window, Event *event, Notify_arg)
// This is where we will take care of window resize events. This is rather
// messy because XView does not allow for arbitrarily sized scrolling lists.
// Instead we have to specify the height in rows, not in pixels like the width
//
void GWList::frame_event(Xv_Window window, Event *event, Notify_arg)
{
X if (event_action(event) == WIN_RESIZE)
X {
X //
X // The window has been resized. We need to resize the list and
X // relocate the quit button.
X //
X GWList *gwindow = (GWList *) xv_get(window, XV_KEY_DATA, KEY_GWINDOW);
X int width = (int) xv_get(window, XV_WIDTH);
X int height = (int) xv_get(window, XV_HEIGHT);
X
X //
X // If you can figure out the formula for the number of rows, you
X // deserve a raise!!!
X //
X xv_set(gwindow->dir_list,
X PANEL_LIST_WIDTH, width - 30,
X PANEL_LIST_DISPLAY_ROWS, (int) ((height - 61.69) / 18.91) + 1,
X NULL);
X
X //
X // Ok, we have resized the list. Now relocate the quit or dismiss button if
X // it is present.
X //
X if (gwindow->dir_quit)
X xv_set(gwindow->dir_quit,
X XV_X, width - 10 - (gwindow->parent ? 69 : 47),
X NULL);
X }
}
X
X
//***************************************************************************
// int GWList::open(Response *resp)
// PURPOSE:
// This will create a window with a panel at the top and a scrolling list
// at the bottom. The panel will be empty.
// The only special thing that is taken care of is that when there is no
// parent, the window will be a real window, while if there is a parent,
// the window will be a command window.
//
int GWList::open(Response *resp)
{
X info = resp;
X if (!parent)
X {
X //
X // This is the main window
X //
X char version[200];
X sprintf(version, "XvGopher %s. Root Directory", VERSION);
X frame = (Frame) xv_create(NULL, FRAME,
X XV_WIDTH, WINDOW_WIDTH,
X XV_HEIGHT, WINDOW_HEIGHT,
X FRAME_LABEL, version,
X NULL);
X panel = (Panel) xv_create(frame, PANEL,
X NULL);
X assign_icon(frame);
X
X //
X // The main window has a quit button
X //
X dir_quit = xv_create(panel, PANEL_BUTTON,
X XV_X, 468, // It will be relocated anyway...
X XV_Y, 8,
X PANEL_LABEL_STRING, "Quit",
X PANEL_NOTIFY_PROC, quit_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X }
X else
X {
X //
X // We are creating a child window
X //
X compute_location(WINDOW_WIDTH, WINDOW_HEIGHT);
X frame = xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, WINDOW_WIDTH,
X XV_HEIGHT, WINDOW_HEIGHT,
X FRAME_LABEL, info->get_title(),
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_IN,
X FRAME_DONE_PROC, done_proc,
X FRAME_SHOW_RESIZE_CORNER, TRUE,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X //
X // Child windows have a close button
X //
X dir_quit = xv_create(panel, PANEL_BUTTON,
X XV_X, 468, // It will be relocated anyway...
X XV_Y, 8,
X PANEL_LABEL_STRING, "Dismiss",
X PANEL_NOTIFY_PROC, quit_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X }
X
X //
X // Now some things which need to be set for both FRAMEs and
X // FRAME_CMDs
X //
X xv_set(frame,
X FRAME_SHOW_FOOTER, TRUE,
X XV_KEY_DATA, KEY_GWINDOW, this,
X FRAME_MIN_SIZE, 280, 118,
X FRAME_MAX_SIZE, 0, 0,
X WIN_EVENT_PROC, frame_event,
X WIN_CONSUME_EVENTS,
X WIN_NO_EVENTS,
X WIN_RESIZE,
X NULL,
X NULL);
X
X //
X // Create the scrolling list. Make it so that 0 or 1 rows can be selected.
X //
X dir_list = (Panel_item) xv_create(panel, PANEL_LIST,
X XV_X, 8,
X XV_Y, 36,
X PANEL_LIST_WIDTH, 500,
X PANEL_LIST_DISPLAY_ROWS, 15,
X PANEL_NOTIFY_PROC, list_notify,
X PANEL_READ_ONLY, TRUE,
X PANEL_CHOOSE_ONE, TRUE,
X PANEL_CHOOSE_NONE, TRUE,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X
X return OK;
}
X
X
//***************************************************************************
// void GWList::list_notify(Panel_item item, char *, caddr_t cd, Panel_list_op op, Event *event, int row)
// This is called when the mouse is clicked in the scrolling list.
// We will determine if this is a double click or not. If it is,
// we need to create a new window to display the data.
//
void GWList::list_notify(Panel_item item, char *, caddr_t cd, Panel_list_op op, Event *event, int row)
{
X static long prev_click_time = 0;
X static int previous_row = -1;
X long click_time = event->ie_time.tv_sec * 1000 +
X event->ie_time.tv_usec / 1000;
X GWList *gwindow = (GWList *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X
X if (op == 0)
X {
X //
X // The currently selected row was deselected.
X //
X gwindow->current_selected = -1;
X gwindow->row_deselect(row, (Response *) cd);
X }
X else
X {
X //
X // A new row was selected.
X //
X gwindow->current_selected = row;
X gwindow->row_select(row, (Response *) cd);
X }
X
X if (row == previous_row)
X {
X //
X // Check if this is a double click
X //
X if (click_time - prev_click_time < double_click_timeout)
X {
X //
X // It is. Start a new window.
X //
X Response *r = new Response((Response *) cd);
X GWindow *sub;
X if (preferences.get_remove_children())
X sub = CreateWindow(r, gwindow->frame);
X else
X sub = CreateWindow(r, !gwindow->parent ? gwindow->frame : gwindow->parent);
X
X prev_click_time = 0;
X previous_row = -1;
X
X //
X // Make sure that the current item is now selected.
X // It can happen that the user double clicked on an item which was
X // not yet selected. The first click will selected and the second
X // click will deselect it. After the second click, we will fall through
X // to this point, so now we want to select the row again.
X xv_set(item, PANEL_LIST_SELECT, row, TRUE, NULL);
X gwindow->row_select(row, (Response *) cd);
X return;
X }
X }
X previous_row = row;
X prev_click_time = click_time;
}
X
X
static unsigned short icon_bits[] = {
#include "icons/gopher.icon"
};
static unsigned short icon_mask_bits[] = {
#include "icons/gopher.icon.mask"
};
X
//***************************************************************************
// void GWList::assign_icon(Frame frame)
//
void GWList::assign_icon(Frame frame)
{
X //
X // The main frame needs an icon. Give it a good one!
X //
X Icon ic;
X Server_image icon, icon_mask;
X
X icon = (Server_image) xv_create(NULL, SERVER_IMAGE,
X XV_WIDTH, 64,
X XV_HEIGHT, 64,
X SERVER_IMAGE_BITS, icon_bits,
X NULL);
X icon_mask = (Server_image) xv_create(NULL, SERVER_IMAGE,
X XV_WIDTH, 64,
X XV_HEIGHT, 64,
X SERVER_IMAGE_BITS, icon_mask_bits,
X NULL);
X ic = (Icon) xv_create(frame, ICON,
X ICON_IMAGE, icon,
X ICON_MASK_IMAGE, icon_mask,
X NULL);
X xv_set(frame,
X FRAME_ICON, ic,
X NULL);
}
X
X
//***************************************************************************
// void GWList::row_deselect(int, Response *)
//
void GWList::row_deselect(int, Response *)
{
}
X
X
//***************************************************************************
// void GWList::row_select(int, Response *)
//
void GWList::row_select(int, Response *)
{
}
X
X
//***************************************************************************
// void GWList::show_item_info_proc(Menu, Menu_item mi)
// Create a little popup which displays the information about the currently
// selected item.
//
void GWList::show_item_info_proc(Menu, Menu_item mi)
{
X GWList *gwindow = (GWList *) xv_get(mi, XV_KEY_DATA, KEY_GWINDOW);
X
X GWInfo *list = new GWInfo(gwindow->frame);
X if (gwindow->current_selected == -1)
X {
X //
X // No row is selected. We will assume we want to display info
X // about the window itself.
X //
X list->open(new Response(gwindow->info));
X }
X else
X {
X //
X // Some row was selected. Display info about this item.
X //
X Response *r;
X r = (Response *) xv_get(gwindow->dir_list, PANEL_LIST_CLIENT_DATA, gwindow->current_selected);
X list->open(r);
X }
}
SHAR_EOF
chmod 0664 GWList.cc ||
echo 'restore of GWList.cc failed'
Wc_c="`wc -c < 'GWList.cc'`"
test 8870 -eq "$Wc_c" ||
echo 'GWList.cc: original size 8870, current size' "$Wc_c"
fi
# ============= GWPref.cc ==============
if test -f 'GWPref.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWPref.cc (File already exists)'
else
echo 'x - extracting GWPref.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWPref.cc' &&
//
// GWPref.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWPref class
//
#include "xvgopher.h"
#include "GWPref.h"
#include "Preferences.h"
X
GWPref *gwpref;
X
X
//***************************************************************************
// GWPref::GWpref(Frame par)
//
GWPref::GWPref(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// GWPref::~GWpref()
//
GWPref::~GWPref()
{
}
X
X
//***************************************************************************
// void GWPref::done_proc(Frame frame)
// This gets called whenever a command frame is destroyed. In the case
// of the preferences window, we only need to hide the window.
//
void GWPref::done_proc(Frame frame)
{
X xv_set(frame,
X XV_SHOW, FALSE,
X NULL);
}
X
X
//***************************************************************************
// int GWPref::open(Response *)
// Create the preferences window.
//
int GWPref::open(Response *)
{
X compute_location(600, 500);
X frame = (Frame) xv_create(parent, FRAME_CMD,
X XV_X, next_x,
X XV_Y, next_y,
X XV_WIDTH, 447,
X XV_HEIGHT, 248,
X FRAME_LABEL, "Preferences",
X FRAME_CMD_PIN_STATE, FRAME_CMD_PIN_OUT,
X FRAME_SHOW_RESIZE_CORNER, FALSE,
X XV_SHOW, FALSE,
X FRAME_SHOW_FOOTER, FALSE,
X FRAME_DONE_PROC, (void (*)(Frame)) done_proc,
X XV_KEY_DATA, KEY_GWINDOW, this,
X NULL);
X panel = (Panel) xv_get(frame, FRAME_CMD_PANEL);
X
X int value = preferences.get_popup_bookmarks() * 2 |
X preferences.get_remove_children();
X
X choices = (Panel_item) xv_create(panel, PANEL_CHECK_BOX,
X XV_X, 16,
X XV_Y, 8,
X PANEL_LAYOUT, PANEL_VERTICAL,
X PANEL_CHOICE_STRINGS, "Remove all child windows when parent is unpinned",
X "Popup Bookmarks at startup",
X NULL,
X PANEL_VALUE, value,
X NULL);
X
X play = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 16,
X XV_Y, 76,
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_LABEL_STRING, "Sound play command:",
X NULL);
X image = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 14,
X XV_Y, 101,
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_LABEL_STRING, "Image view command:",
X NULL);
X telnet = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 48,
X XV_Y, 126,
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_LABEL_STRING, "Telnet command:",
X NULL);
X print = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 59,
X XV_Y, 151,
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_LABEL_STRING, "Print command:",
X NULL);
X mail = (Panel_item) xv_create(panel, PANEL_TEXT,
X XV_X, 62,
X XV_Y, 176,
X PANEL_VALUE_DISPLAY_LENGTH, 30,
X PANEL_VALUE_STORED_LENGTH, 80,
X PANEL_LABEL_STRING, "Mail command:",
X NULL);
X
X xv_create(panel, PANEL_BUTTON,
X XV_X, 197,
X XV_Y, 208,
X PANEL_LABEL_STRING, "Apply",
X XV_KEY_DATA, KEY_GWINDOW, this,
X PANEL_NOTIFY_PROC, apply,
X NULL);
X
X return OK;
}
X
X
//***************************************************************************
// void GWPref::show()
//
void GWPref::show()
{
X xv_set(mail,
X PANEL_VALUE, preferences.get_mail_filter(),
X NULL);
X xv_set(print,
X PANEL_VALUE, preferences.get_print_filter(),
X NULL);
X xv_set(telnet,
X PANEL_VALUE, preferences.get_telnet_command(),
X NULL);
X xv_set(image,
X PANEL_VALUE, preferences.get_image_filter(),
X NULL);
X xv_set(play,
X PANEL_VALUE, preferences.get_play_filter(),
X NULL);
X xv_set(frame,
X XV_SHOW, TRUE,
X NULL);
}
X
X
//***************************************************************************
// void GWPref::apply(Panel_item item, Event *)
// Read the changes made to the preferences panel and put them in our
// database.
//
void GWPref::apply(Panel_item item, Event *)
{
X GWPref *gw = (GWPref *) xv_get(item, XV_KEY_DATA, KEY_GWINDOW);
X
X int value = (int) xv_get(gw->choices, PANEL_VALUE);
X preferences.set_remove_children(value & 1);
X preferences.set_popup_bookmarks(value & 2);
X
X preferences.set_mail_filter((char *) xv_get(gw->mail, PANEL_VALUE));
X preferences.set_print_filter((char *) xv_get(gw->print, PANEL_VALUE));
X preferences.set_play_filter((char *) xv_get(gw->play, PANEL_VALUE));
X preferences.set_image_filter((char *) xv_get(gw->image, PANEL_VALUE));
X preferences.set_telnet_command((char *) xv_get(gw->telnet, PANEL_VALUE));
X
X //
X // Finally, remove the window.
X //
X xv_set(gw->frame,
X XV_SHOW, FALSE,
X NULL);
}
X
X
SHAR_EOF
chmod 0644 GWPref.cc ||
echo 'restore of GWPref.cc failed'
Wc_c="`wc -c < 'GWPref.cc'`"
test 4701 -eq "$Wc_c" ||
echo 'GWPref.cc: original size 4701, current size' "$Wc_c"
fi
# ============= GWSound.cc ==============
if test -f 'GWSound.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWSound.cc (File already exists)'
else
echo 'x - extracting GWSound.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWSound.cc' &&
//
// GWSound.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWSound class
//
#include "GWSound.h"
#include "xvgopher.h"
X
X
//***************************************************************************
// GWSound::GWSound(Frame par)
//
GWSound::GWSound(Frame par) : GWDownload(par, GWDownload::BINARY, "Play", preferences.get_play_filter())
{
}
SHAR_EOF
chmod 0644 GWSound.cc ||
echo 'restore of GWSound.cc failed'
Wc_c="`wc -c < 'GWSound.cc'`"
test 469 -eq "$Wc_c" ||
echo 'GWSound.cc: original size 469, current size' "$Wc_c"
fi
# ============= GWTelnet.cc ==============
if test -f 'GWTelnet.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWTelnet.cc (File already exists)'
else
echo 'x - extracting GWTelnet.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWTelnet.cc' &&
//
// GWTelnet.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the GWTelnet class
//
#include "GWTelnet.h"
#include "xvgopher.h"
#include <fcntl.h>
#include <unistd.h>
X
X
//***************************************************************************
// GWTelnet::GWTelnet(Frame par)
//
GWTelnet::GWTelnet(Frame par)
{
X parent = par;
}
X
X
//***************************************************************************
// int GWTelnet::open(Response *resp)
// PURPOSE:
// This is called when a telnet record has been received. We need to start a
// terminal emulator and start telnet in it (to the correct host...)
//
int GWTelnet::open(Response *resp)
{
X char command[2000];
X char new_title[2000];
X int port;
X
X info = resp;
X if (info->get_port() == 0)
X port = 23; // There seems to be a problem with Mark Boyns. He didn't want to fix this in the gopher files!
X else
X port = info->get_port();
X if (*info->get_command())
X sprintf(new_title, "%s (login as %s)", info->get_title(), info->get_command());
X else
X strcpy(new_title, info->get_title());
X sprintf(command, preferences.get_telnet_command(),
X new_title,
X info->get_server(),
X port,
X info->get_type());
X system(command);
X return OK;
}
X
X
SHAR_EOF
chmod 0644 GWTelnet.cc ||
echo 'restore of GWTelnet.cc failed'
Wc_c="`wc -c < 'GWTelnet.cc'`"
test 1331 -eq "$Wc_c" ||
echo 'GWTelnet.cc: original size 1331, current size' "$Wc_c"
fi
# ============= GWindow.cc ==============
if test -f 'GWindow.cc' -a X"$1" != X"-c"; then
echo 'x - skipping GWindow.cc (File already exists)'
else
echo 'x - extracting GWindow.cc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'GWindow.cc' &&
//
// GWindow.cc
//
// (c) Copyright 1993, San Diego State University -- College of Sciences
// (See the COPYRIGHT file for more Copyright information)
//
// Implementation of the Window class
//
#include "GWBinary.h"
#include "GWDirectory.h"
#include "GWBookmarks.h"
#include "GWFile.h"
#include "GWIndex.h"
#include "GWSound.h"
#include "GWImage.h"
#include "GWTelnet.h"
#include "Connection.h"
#include <unistd.h>
#include <xview/notice.h>
#include "xvgopher.h"
#include "icons.h"
#include "cursor.h"
X
int GWindow::next_x = 0;
int GWindow::next_y = 0;
X
X
//***************************************************************************
// char *good_strtok(char *str, char *term)
// PURPOSE:
// This is a replacement for the standard strtok() which has a MAJOR
// problem when it comes to having multiple delimiters in a row.
// This one will return after EVERY terminator that is found.
//
char *good_strtok(char *str, char *term)
{
X static char *string;
X if (str)
X {
X string = str;
X }
X
X if (string == NULL || *string == '\0')
X return NULL;
X
X char *p = string;
X while (*string && strchr(term, *string) == NULL)
X string++;
X if (*string)
X *string++ = '\0';
X return p;
}
X
X
//***************************************************************************
// GWindow::GWindow()
//
GWindow::GWindow()
{
X gopher = NULL;
X frame = parent = NULL;
X panel = NULL;
X info = NULL;
}
X
X
//***************************************************************************
// GWindow::~GWindow()
//
GWindow::~GWindow()
{
X if (gopher)
X delete gopher;
X if (info)
X delete info;
X
X //
X // If this is the parent of all windows, also delete the bookmarks so that
X // all changes get written to disk.
X //
X if (!parent)
X delete bookmarks;
X
X xv_destroy_safe(frame);
}
X
X
//***************************************************************************
// void GWindow::main_loop()
// PURPOSE:
// This is the main loop for the windowing program.
// When we return from this, the program should terminate
//
void GWindow::main_loop()
{
X xv_main_loop(frame);
}
X
X
//***************************************************************************
// void GWindow::display()
// PURPOSE:
// Display information from the gopher server in our window
//
void GWindow::display()
{
X frame_unbusy(frame);
}
X
X
//***************************************************************************
// int GWindow::open(Response *resp)
//
int GWindow::open(Response *resp)
{
X resp = resp;
X printf("ERROR!!! THIS SHOULD NEVER HAPPEN!\n");
X exit(42);
X return 0;
}
X
X
//***************************************************************************
// void GWindow::quit_proc(Frame frame, Event *event)
// PURPOS:
// This gets called when the user presses 'q' in a window.
//
void GWindow::quit_proc(Frame frame, Event *event)
{
X event = event;
X GWindow *win = (GWindow *) xv_get(frame, XV_KEY_DATA, KEY_GWINDOW);
X delete win;
X xv_destroy_safe(frame);
}
X
X
//***************************************************************************
// void GWindow::done_proc(Frame frame)
// PURPOSE:
// This gets called whenever a command frame is destroyed. We need to
// clean up the associated GWindow structure. Since we want all children
// to go away as well, we will call this function recursively on our subframes.
//
void GWindow::done_proc(Frame frame)
{
X if (!frame)
X return;
X GWindow *win = (GWindow *) xv_get(frame, XV_KEY_DATA, KEY_GWINDOW);
X Frame subframe = (Frame) xv_get(frame, FRAME_NTH_SUBFRAME, 1);
X done_proc(subframe);
X delete win;
X xv_destroy_safe(frame);
}
X
X
//***************************************************************************
// void GWindow::status(char *str)
// PURPOSE:
// Display an informative message in the footer of the window
//
void GWindow::status(char *str)
{
X xv_set(frame,
X FRAME_LEFT_FOOTER, str,
X NULL);
}
X
X
//***************************************************************************
// void GWindow::compute_location(int width, int height)
// PURPOSE:
// Compute the location of the next window. The size of the next window is
// given so that we can make sure that the whole window is displayed on the
// screen.
//
void GWindow::compute_location(int width, int height)
{
X GWindow * gwindow = (GWindow *) xv_get(parent, XV_KEY_DATA, KEY_GWINDOW);
X static int first_time = 2;
X
X if (!gwindow->parent && first_time)
X {
X //
X // The current window is the second window of the program. This is because
X // our parent doesn't have a parent.
X //
X next_x = (int) xv_get(parent, XV_X);
X next_y = (int) xv_get(parent, XV_Y);
X first_time--;
X }
X
X //
X // We now have next_x and next_y to work with as the location of the previous window.
X // Now we need to increment them and possibly wrap them if the window will not fit
X // on the screen.
X //
X next_x += 10;
X next_y += 25;
X
X //
X // Get the size of the screen. We will use the parent frame for this since
X // we are not sure that our frame has been initialized, yet.
X //
X Display *dpy = (Display *) xv_get(parent, XV_DISPLAY);
X int screen_width = DisplayWidth(dpy, DefaultScreen(dpy));
X int screen_height = DisplayHeight(dpy, DefaultScreen(dpy));
X if (next_x + width + 20 > screen_width)
X next_x = 0;
X if (next_y + height + 40 > screen_height)
X next_y = 0;
}
X
X
//***************************************************************************
// GWindow *CreateWindow(Response *resp, Frame par)
// PURPOSE:
// This function will create a new window which will display the
// data specified in the arguments correctly.
//
GWindow *CreateWindow(Response *resp, Frame par)
{
X GWindow *gw;
X
X switch (resp->get_type())
X {
X case GOPHER_FILE:
X gw = new GWFile(par);
X break;
X case GOPHER_DIRECTORY:
X gw = new GWDirectory(par);
X break;
X case GOPHER_SPECIAL:
X gw = new GWDirectory(par);
X break;
X case GOPHER_SOUND:
X gw = new GWSound(par);
X break;
X case GOPHER_BIN:
X gw = new GWBinary(par);
X break;
X case GOPHER_CSO:
X case GOPHER_ERROR:
X xv_create(par, NOTICE,
X NOTICE_MESSAGE_STRINGS, "XvGopher currently doesn not support this",
X NULL,
X NOTICE_BUTTON_YES, "Bummer",
X NOTICE_BLOCK_THREAD, TRUE,
X NOTICE_LOCK_SCREEN, TRUE,
X XV_SHOW, TRUE,
X NULL);
X return NULL;
X break;
X case GOPHER_BINHEX:
X case GOPHER_DOS:
X case GOPHER_UU:
X gw = new GWBinary(par);
X break;
X case GOPHER_INDEX:
X gw = new GWIndex(par);
X break;
X case GOPHER_TELNET:
X gw = new GWTelnet(par);
X break;
X case GOPHER_IMAGE:
X gw = new GWImage(par);
X break;
X case GOPHER_REDUNDANT:
X default:
X printf("Sorry, '%c' not implemented, yet!\n", resp->get_type());
X return NULL;
X }
X if (gw->open(resp) == OK)
X return gw;
X else
X {
X delete gw;
X return NULL;
X }
}
X
X
//***************************************************************************
// void GWindow::nothing_found()
// PURPOSE:
// This function will create a new window which will display the
// data specified in the arguments correctly.
//
void GWindow::nothing_found()
{
X xv_create(parent, NOTICE,
X NOTICE_BLOCK_THREAD, TRUE,
X NOTICE_LOCK_SCREEN, TRUE,
X NOTICE_MESSAGE_STRINGS, "Nothing was found!", NULL,
X NOTICE_BUTTON_YES, "Bummer",
X XV_SHOW, TRUE,
X NULL);
X delete this;
}
X
X
//***************************************************************************
// void GWindow::list_full()
// This will create a popup telling the user that the scrolling list is full.
// I have imposed a limit because xview will hang when a scrolling list gets
// more than a couple thousand entries in it.
//
void GWindow::list_full()
{
X xv_create(frame, NOTICE,
X NOTICE_MESSAGE_STRINGS, "The scrolling list is full. Sorry",
X NULL,
X NOTICE_BUTTON_YES, "Oh well",
X NOTICE_BLOCK_THREAD, TRUE,
X NOTICE_LOCK_SCREEN, TRUE,
X XV_SHOW, TRUE,
X NULL);
}
X
X
SHAR_EOF
chmod 0664 GWindow.cc ||
echo 'restore of GWindow.cc failed'
Wc_c="`wc -c < 'GWindow.cc'`"
test 7751 -eq "$Wc_c" ||
echo 'GWindow.cc: original size 7751, current size' "$Wc_c"
fi
true || echo 'restore of Gopher.cc failed'
echo End of part 2, continue with part 3
exit 0