mikew@wyse.wyse.com (Mike Wexler) (02/23/89)
Submitted-by: koblas@mips.com (David Koblas)
Posting-number: Volume 3, Issue 33
Archive-name: xpaint/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 3)."
# Contents: AUTHOR Imakefile arbline.xbm arrow.xbm brush.xbm
# dotbox.xbm elipfill.xbm elipse.xbm eraser.xbm event.c# event.c~
# fill.xbm hand.xbm line.xbm pat_01.xbm pat_02.xbm pat_03.xbm
# pat_04.xbm pat_05.xbm pat_06.xbm pat_07.xbm pat_08.xbm pat_10.xbm
# pat_11.xbm pat_12.xbm pat_13.xbm pat_14.xbm pat_15.xbm pat_16.xbm
# patchlevel.h polygon.xbm read.c rect.xbm rectfill.xbm scissor.xbm
# spray.xbm spraypat.xbm temp text.xbm version.c xpaint.1 xpaint.h
# Wrapped by mikew@wyse on Wed Feb 22 13:37:46 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'AUTHOR' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'AUTHOR'\"
else
echo shar: Extracting \"'AUTHOR'\" \(143 characters\)
sed "s/^X//" >'AUTHOR' <<'END_OF_FILE'
XDate: Tue, 21 Feb 89 20:18:06 PST
XFrom: mips!mips.com!koblas (David Koblas)
XMessage-Id: <8902220418.AA06049@yoyodyne.mips.com>
XTo: wyse!mikew
X
END_OF_FILE
if test 143 -ne `wc -c <'AUTHOR'`; then
echo shar: \"'AUTHOR'\" unpacked with wrong size!
fi
# end of 'AUTHOR'
fi
if test -f 'Imakefile' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'Imakefile'\"
else
echo shar: Extracting \"'Imakefile'\" \(380 characters\)
sed "s/^X//" >'Imakefile' <<'END_OF_FILE'
X SYS_LIBRARIES = -ll -lm $(XMULIB) $(XLIB)
XLOCAL_LIBRARIES =
X SRCS = ReadXBM.c draw.c menu.c save.c action.c event.c \
X pattern.c version.c bitedit.c main.c read.c
X OBJS = ReadXBM.o draw.o menu.o save.o action.o event.o \
X pattern.o version.o bitedit.o main.o read.o
X
XComplexProgramTarget(xpaint)
XNormalLintTarget($(SRCS))
X
END_OF_FILE
if test 380 -ne `wc -c <'Imakefile'`; then
echo shar: \"'Imakefile'\" unpacked with wrong size!
fi
# end of 'Imakefile'
fi
if test -f 'arbline.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'arbline.xbm'\"
else
echo shar: Extracting \"'arbline.xbm'\" \(884 characters\)
sed "s/^X//" >'arbline.xbm' <<'END_OF_FILE'
X#define arbline_width 32
X#define arbline_height 32
Xstatic char arbline_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x40, 0x00,
X 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00,
X 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
X 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
X 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x10, 0x00,
X 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
X 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0x10, 0x00, 0x10, 0x00, 0x0c, 0x00,
X 0x60, 0x00, 0x03, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 884 -ne `wc -c <'arbline.xbm'`; then
echo shar: \"'arbline.xbm'\" unpacked with wrong size!
fi
# end of 'arbline.xbm'
fi
if test -f 'arrow.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'arrow.xbm'\"
else
echo shar: Extracting \"'arrow.xbm'\" \(878 characters\)
sed "s/^X//" >'arrow.xbm' <<'END_OF_FILE'
X#define arrow_width 32
X#define arrow_height 32
Xstatic char arrow_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0e, 0x00,
X 0x00, 0x80, 0x0f, 0x00, 0x00, 0xc0, 0x0f, 0x00, 0x00, 0xf0, 0x07, 0x00,
X 0x00, 0xf8, 0x07, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00,
X 0x00, 0xe0, 0x03, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x10, 0x01, 0x00,
X 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
X 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 878 -ne `wc -c <'arrow.xbm'`; then
echo shar: \"'arrow.xbm'\" unpacked with wrong size!
fi
# end of 'arrow.xbm'
fi
if test -f 'brush.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'brush.xbm'\"
else
echo shar: Extracting \"'brush.xbm'\" \(878 characters\)
sed "s/^X//" >'brush.xbm' <<'END_OF_FILE'
X#define brush_width 32
X#define brush_height 32
Xstatic char brush_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0xa0, 0x55, 0x55, 0x00, 0xe0, 0x72, 0xfe, 0x00,
X 0x40, 0x9d, 0x29, 0x00, 0xc0, 0x2d, 0x57, 0x00, 0x40, 0x90, 0x72, 0x00,
X 0xc0, 0x4a, 0x34, 0x00, 0x40, 0x34, 0x65, 0x00, 0xc0, 0xc8, 0x14, 0x00,
X 0x80, 0xf3, 0x61, 0x00, 0xc0, 0xdc, 0x7d, 0x00, 0x80, 0x87, 0x64, 0x00,
X 0x80, 0xff, 0x7f, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0xc0, 0xff, 0x7f, 0x00,
X 0x00, 0xf0, 0x01, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0xf0, 0x01, 0x00,
X 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xae, 0xac, 0x00,
X 0xa0, 0xaa, 0xa2, 0x00, 0x60, 0xa6, 0xe4, 0x00, 0xa0, 0xaa, 0xa8, 0x00,
X 0x60, 0x4a, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 878 -ne `wc -c <'brush.xbm'`; then
echo shar: \"'brush.xbm'\" unpacked with wrong size!
fi
# end of 'brush.xbm'
fi
if test -f 'dotbox.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'dotbox.xbm'\"
else
echo shar: Extracting \"'dotbox.xbm'\" \(890 characters\)
sed "s/^X//" >'dotbox.xbm' <<'END_OF_FILE'
X#define dottedbox_width 32
X#define dottedbox_height 32
Xstatic char dottedbox_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x6d, 0xdb, 0x06,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x60, 0xdb, 0xb6, 0x05,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 890 -ne `wc -c <'dotbox.xbm'`; then
echo shar: \"'dotbox.xbm'\" unpacked with wrong size!
fi
# end of 'dotbox.xbm'
fi
if test -f 'elipfill.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'elipfill.xbm'\"
else
echo shar: Extracting \"'elipfill.xbm'\" \(887 characters\)
sed "s/^X//" >'elipfill.xbm' <<'END_OF_FILE'
X#define elipfill_width 32
X#define elipfill_height 32
Xstatic char elipfill_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x2e, 0x72, 0x00,
X 0x80, 0x89, 0x88, 0x01, 0x40, 0x22, 0x22, 0x02, 0xa0, 0x88, 0x88, 0x04,
X 0x30, 0x22, 0x22, 0x0a, 0x90, 0x88, 0x88, 0x08, 0x28, 0x22, 0x22, 0x12,
X 0x88, 0x88, 0x88, 0x18, 0x24, 0x22, 0x22, 0x22, 0x8c, 0x88, 0x88, 0x28,
X 0x24, 0x22, 0x22, 0x22, 0x8c, 0x88, 0x88, 0x28, 0x24, 0x22, 0x22, 0x22,
X 0x8c, 0x88, 0x88, 0x28, 0x28, 0x22, 0x22, 0x12, 0x88, 0x88, 0x88, 0x18,
X 0x30, 0x22, 0x22, 0x0a, 0x90, 0x88, 0x88, 0x08, 0x20, 0x22, 0x22, 0x06,
X 0xc0, 0x88, 0x88, 0x02, 0x80, 0x23, 0xa2, 0x01, 0x00, 0x8e, 0x78, 0x00,
X 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 887 -ne `wc -c <'elipfill.xbm'`; then
echo shar: \"'elipfill.xbm'\" unpacked with wrong size!
fi
# end of 'elipfill.xbm'
fi
if test -f 'elipse.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'elipse.xbm'\"
else
echo shar: Extracting \"'elipse.xbm'\" \(881 characters\)
sed "s/^X//" >'elipse.xbm' <<'END_OF_FILE'
X#define elipse_width 32
X#define elipse_height 32
Xstatic char elipse_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x0e, 0x70, 0x00,
X 0x80, 0x01, 0x80, 0x01, 0x40, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x04,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x10,
X 0x08, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x20,
X 0x04, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x20,
X 0x04, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x10,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x04,
X 0x40, 0x00, 0x00, 0x02, 0x80, 0x01, 0x80, 0x01, 0x00, 0x0e, 0x70, 0x00,
X 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 881 -ne `wc -c <'elipse.xbm'`; then
echo shar: \"'elipse.xbm'\" unpacked with wrong size!
fi
# end of 'elipse.xbm'
fi
if test -f 'eraser.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'eraser.xbm'\"
else
echo shar: Extracting \"'eraser.xbm'\" \(881 characters\)
sed "s/^X//" >'eraser.xbm' <<'END_OF_FILE'
X#define eraser_width 32
X#define eraser_height 32
Xstatic char eraser_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x0f, 0x20, 0x00, 0x00, 0x18,
X 0x20, 0x00, 0x00, 0x28, 0x20, 0x00, 0x00, 0x48, 0xa0, 0x3b, 0xb1, 0x4b,
X 0xa0, 0xa8, 0x8a, 0x48, 0xa0, 0x99, 0x93, 0x49, 0xa0, 0xa8, 0xa2, 0x48,
X 0xa0, 0xab, 0x9a, 0x4b, 0x20, 0x00, 0x00, 0x48, 0x20, 0x00, 0x00, 0x48,
X 0x20, 0x00, 0x00, 0x48, 0xe0, 0xff, 0xff, 0x4f, 0x40, 0x00, 0x00, 0x50,
X 0x80, 0x00, 0x00, 0x60, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 881 -ne `wc -c <'eraser.xbm'`; then
echo shar: \"'eraser.xbm'\" unpacked with wrong size!
fi
# end of 'eraser.xbm'
fi
if test -f 'event.c#' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'event.c#'\"
else
echo shar: Extracting \"'event.c#'\" \(458 characters\)
sed "s/^X//" >'event.c#' <<'END_OF_FILE'
X***************
X*** 23,29 ****
X static int ActiveItem = C_ARROW;
X static Cursor CurrentCursor = 0;
X #ifndef lint
X! static char rcsid[]="$Header: event.c,v 1.8 89/02/21 21:41:07 koblas Exp $";
X #endif
X
X static int Done=FALSE;
X--- 23,29 ----
X static int ActiveItem = C_ARROW;
X static Cursor CurrentCursor = 0;
X #ifndef lint
X! static char rcsid[]="$Header: event.c,v 1.9 89/02/22 12:31:14 koblas Exp $";
X #endif
X
X static int Done=FALSE;
END_OF_FILE
if test 458 -ne `wc -c <'event.c#'`; then
echo shar: \"'event.c#'\" unpacked with wrong size!
fi
# end of 'event.c#'
fi
if test -f 'event.c~' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'event.c~'\"
else
echo shar: Extracting \"'event.c~'\" \(3501 characters\)
sed "s/^X//" >'event.c~' <<'END_OF_FILE'
X/* +------------------------------------------------------------------+ */
X/* | Copyright 1989, David Koblas. | */
X/* | You may copy this file in whole or in part as long as you | */
X/* | don't try to make money off it, or pretend that you wrote it. | */
X/* +------------------------------------------------------------------+ */
X
X#include <stdio.h>
X#include <sys/types.h>
X#include <X11/Xos.h>
X#include "xpaint.h"
X
X#ifndef FD_SET
X#define FD_SET(n, s) (((s)->fds_bits[0]) |= (1 << n))
X#define FD_ZERO(s) bzero((char *)(s), sizeof (*(s)))
X#endif
X#define AllEventMask (-1)
X
X#define Between(min,val,max) (((min)<=(val)) && ((val)<(max)))
X
X#define MAXINTR 20
X
Xstruct s_intr {
X int used;
X void (*func)();
X} interrupt_list[MAXINTR];
X
Xstatic int ActiveItem = C_ARROW;
Xstatic Cursor CurrentCursor = 0;
X#ifndef lint
Xstatic char rcsid[]="$Header: event.c,v 1.7 89/02/20 19:32:58 koblas Locked $";
X#endif
X
Xstatic int Done=FALSE;
X
XEventLoop()
X{
X XEvent event;
X int i,n;
X static struct timeval tv = { 0,500000 };
X fd_set read_fd;
X int nfd = getdtablesize();
X
X for (i=0;i<MAXINTR;i++) {
X interrupt_list[i].used=FALSE;
X }
X
X goto start;
X
X while (!Done) {
X
X FD_ZERO(&read_fd);
X FD_SET(ConnectionNumber(CurrentWindow->display),&read_fd);
X if ((n=select(nfd,&read_fd,NULL,NULL,&tv))<0) {
X perror("select");
X Done=TRUE;
X continue;
X }
X if (n==0) {
X tv.tv_sec = 0;
X tv.tv_usec = 500000;
X Interrupt();
X continue;
X }
Xstart:
X while (XCheckMaskEvent(CurrentWindow->display,
X AllEventMask,&event) && !Done) {
X HandleEvent(&event);
X }
X }
X}
X
XHandleEvent(event)
XXEvent *event;
X{
X int i,n;
X char buf[80];
X
X if (event->xany.window != CurrentWindow->window) {
X for (i=0;i<CurrentWindow->numsub;i++) {
X if (CurrentWindow->subwind[i].window==
X event->xany.window)
X break;
X }
X if ((i<CurrentWindow->numsub) &&
X (CurrentWindow->subwind[i].event_handler!=NULL))
X CurrentWindow->subwind[i].
X event_handler(event);
X }
X
X switch(event->type) {
X case ButtonPress:
X break;
X case ButtonRelease:
X break;
X case KeyPress :
X case KeyRelease :
X break;
X case LeaveNotify:
X break;
X case EnterNotify:
X break;
X case FocusOut :
X break;
X case FocusIn :
X break;
X case MotionNotify:
X break;
X case ConfigureNotify:
X if (event->xconfigure.window != CurrentWindow->window)
X break;
X CurrentWindow->width = event->xconfigure.width;
X CurrentWindow->height = event->xconfigure.height;
X for (i=0;i<CurrentWindow->numsub;i++) {
X if (CurrentWindow->subwind[i].resize_handler
X !=NULL)
X CurrentWindow->subwind[i].resize_handler();
X else {
X XMoveWindow(CurrentWindow->display,
X CurrentWindow->subwind[i].window,
X DELTA_XPOS(i),DELTA_YPOS(i));
X }
X }
X break;
X case Expose:
X break;
X default:
X fprintf(stderr,"Unknown event recieved == %d\n",event->type);
X break;
X }
X}
X
XWindowEvent(wind,event)
XWindow wind;
XXEvent *event;
X{
X int flag=FALSE;
X do {
X if (flag)
X HandleEvent(event);
X XNextEvent(CurrentWindow->display,event);
X flag=TRUE;
X } while (event->xany.window != wind);
X}
X
Xvoid Quit()
X{
X Done=TRUE;
X}
X
XDeleteInterrupt(id)
Xint id;
X{
X interrupt_list[id].used = FALSE;
X}
X
XAddInterrupt(func)
Xvoid (*func)();
X{
X int i;
X
X for (i=0;i<MAXINTR;i++)
X if (!interrupt_list[i].used)
X break;
X if (i==MAXINTR)
X return -1;
X interrupt_list[i].used = TRUE;
X interrupt_list[i].func = func;
X
X return i;
X}
X
XInterrupt()
X{
X int i;
X
X for (i=0;i<MAXINTR;i++)
X if (interrupt_list[i].used)
X interrupt_list[i].func();
X}
END_OF_FILE
if test 3501 -ne `wc -c <'event.c~'`; then
echo shar: \"'event.c~'\" unpacked with wrong size!
fi
# end of 'event.c~'
fi
if test -f 'fill.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fill.xbm'\"
else
echo shar: Extracting \"'fill.xbm'\" \(875 characters\)
sed "s/^X//" >'fill.xbm' <<'END_OF_FILE'
X#define fill_width 32
X#define fill_height 32
Xstatic char fill_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x24, 0x00,
X 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0xc0, 0x00, 0x01,
X 0x00, 0x70, 0x40, 0x02, 0x00, 0x30, 0xc0, 0x04, 0x00, 0x30, 0x70, 0x08,
X 0x00, 0x50, 0x18, 0x10, 0x00, 0x90, 0x14, 0x08, 0x00, 0x10, 0x0d, 0x04,
X 0x00, 0x10, 0x02, 0x02, 0x00, 0x10, 0x04, 0x01, 0x00, 0x10, 0x88, 0x00,
X 0x00, 0x10, 0x50, 0x00, 0x00, 0x10, 0x20, 0x00, 0x00, 0x10, 0x00, 0x00,
X 0x00, 0x38, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 875 -ne `wc -c <'fill.xbm'`; then
echo shar: \"'fill.xbm'\" unpacked with wrong size!
fi
# end of 'fill.xbm'
fi
if test -f 'hand.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'hand.xbm'\"
else
echo shar: Extracting \"'hand.xbm'\" \(875 characters\)
sed "s/^X//" >'hand.xbm' <<'END_OF_FILE'
X#define hand_width 32
X#define hand_height 32
Xstatic char hand_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x80, 0xe3, 0x00, 0x00, 0x4e, 0x14, 0x01, 0x00, 0x51, 0x14, 0x01,
X 0x00, 0x51, 0x14, 0x01, 0x38, 0x51, 0x14, 0x01, 0x44, 0x51, 0x14, 0x01,
X 0x44, 0x51, 0x14, 0x01, 0x44, 0x21, 0x08, 0x01, 0x44, 0x21, 0x08, 0x01,
X 0x88, 0x20, 0x08, 0x01, 0x88, 0x20, 0x88, 0x00, 0x88, 0x20, 0x88, 0x00,
X 0x88, 0x00, 0x80, 0x30, 0x10, 0x00, 0x80, 0x48, 0x10, 0x00, 0x80, 0x48,
X 0x10, 0x00, 0x80, 0x44, 0x10, 0x00, 0x80, 0x22, 0x10, 0x00, 0x80, 0x21,
X 0x10, 0x00, 0x80, 0x10, 0x20, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x04,
X 0x20, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x01,
X 0x20, 0x00, 0x80, 0x00, 0x20, 0x00, 0x80, 0x00, 0xc0, 0xff, 0x7f, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 875 -ne `wc -c <'hand.xbm'`; then
echo shar: \"'hand.xbm'\" unpacked with wrong size!
fi
# end of 'hand.xbm'
fi
if test -f 'line.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'line.xbm'\"
else
echo shar: Extracting \"'line.xbm'\" \(875 characters\)
sed "s/^X//" >'line.xbm' <<'END_OF_FILE'
X#define line_width 32
X#define line_height 32
Xstatic char line_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00,
X 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00,
X 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00,
X 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
X 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
X 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
X 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 875 -ne `wc -c <'line.xbm'`; then
echo shar: \"'line.xbm'\" unpacked with wrong size!
fi
# end of 'line.xbm'
fi
if test -f 'pat_01.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_01.xbm'\"
else
echo shar: Extracting \"'pat_01.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_01.xbm' <<'END_OF_FILE'
X#define pattern_01_width 32
X#define pattern_01_height 32
Xstatic char pattern_01_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 893 -ne `wc -c <'pat_01.xbm'`; then
echo shar: \"'pat_01.xbm'\" unpacked with wrong size!
fi
# end of 'pat_01.xbm'
fi
if test -f 'pat_02.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_02.xbm'\"
else
echo shar: Extracting \"'pat_02.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_02.xbm' <<'END_OF_FILE'
X#define pattern_02_width 32
X#define pattern_02_height 32
Xstatic char pattern_02_bits[] = {
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
X 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa};
END_OF_FILE
if test 893 -ne `wc -c <'pat_02.xbm'`; then
echo shar: \"'pat_02.xbm'\" unpacked with wrong size!
fi
# end of 'pat_02.xbm'
fi
if test -f 'pat_03.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_03.xbm'\"
else
echo shar: Extracting \"'pat_03.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_03.xbm' <<'END_OF_FILE'
X#define pattern_03_width 32
X#define pattern_03_height 32
Xstatic char pattern_03_bits[] = {
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa};
END_OF_FILE
if test 893 -ne `wc -c <'pat_03.xbm'`; then
echo shar: \"'pat_03.xbm'\" unpacked with wrong size!
fi
# end of 'pat_03.xbm'
fi
if test -f 'pat_04.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_04.xbm'\"
else
echo shar: Extracting \"'pat_04.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_04.xbm' <<'END_OF_FILE'
X#define pattern_04_width 32
X#define pattern_04_height 32
Xstatic char pattern_04_bits[] = {
X 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x33, 0x33, 0x33, 0x33,
X 0x33, 0x33, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
X 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xcc,
X 0xcc, 0xcc, 0xcc, 0xcc, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
X 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x33, 0x33, 0x33, 0x33,
X 0x33, 0x33, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
X 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xcc,
X 0xcc, 0xcc, 0xcc, 0xcc, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
X 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x33, 0x33, 0x33, 0x33,
X 0x33, 0x33, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
X 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33};
END_OF_FILE
if test 893 -ne `wc -c <'pat_04.xbm'`; then
echo shar: \"'pat_04.xbm'\" unpacked with wrong size!
fi
# end of 'pat_04.xbm'
fi
if test -f 'pat_05.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_05.xbm'\"
else
echo shar: Extracting \"'pat_05.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_05.xbm' <<'END_OF_FILE'
X#define pattern_05_width 32
X#define pattern_05_height 32
Xstatic char pattern_05_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
X 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
X 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
X 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
X 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
X 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_05.xbm'`; then
echo shar: \"'pat_05.xbm'\" unpacked with wrong size!
fi
# end of 'pat_05.xbm'
fi
if test -f 'pat_06.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_06.xbm'\"
else
echo shar: Extracting \"'pat_06.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_06.xbm' <<'END_OF_FILE'
X#define pattern_06_width 32
X#define pattern_06_height 32
Xstatic char pattern_06_bits[] = {
X 0x49, 0x92, 0x49, 0x92, 0x92, 0x24, 0x24, 0x49, 0x24, 0x49, 0x92, 0x24,
X 0x49, 0x92, 0x49, 0x92, 0x92, 0x24, 0x24, 0x49, 0x24, 0x49, 0x92, 0x24,
X 0x49, 0x92, 0x49, 0x92, 0x92, 0x24, 0x24, 0x49, 0x24, 0x49, 0x92, 0x24,
X 0x49, 0x92, 0x49, 0x92, 0x92, 0x24, 0x24, 0x49, 0x24, 0x49, 0x92, 0x24,
X 0x49, 0x92, 0x49, 0x92, 0x92, 0x24, 0x24, 0x49, 0x24, 0x49, 0x92, 0x24,
X 0x49, 0x92, 0x49, 0x92, 0x49, 0x92, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24,
X 0x92, 0x24, 0x24, 0x49, 0x49, 0x92, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24,
X 0x92, 0x24, 0x24, 0x49, 0x49, 0x92, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24,
X 0x92, 0x24, 0x24, 0x49, 0x49, 0x92, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24,
X 0x92, 0x24, 0x24, 0x49, 0x49, 0x92, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24,
X 0x92, 0x24, 0x24, 0x49, 0x49, 0x92, 0x49, 0x92};
END_OF_FILE
if test 893 -ne `wc -c <'pat_06.xbm'`; then
echo shar: \"'pat_06.xbm'\" unpacked with wrong size!
fi
# end of 'pat_06.xbm'
fi
if test -f 'pat_07.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_07.xbm'\"
else
echo shar: Extracting \"'pat_07.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_07.xbm' <<'END_OF_FILE'
X#define pattern_07_width 32
X#define pattern_07_height 32
Xstatic char pattern_07_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x80, 0xfd, 0xff, 0xff, 0xbf,
X 0x05, 0x00, 0x00, 0xa0, 0xf5, 0xff, 0xff, 0xaf, 0x15, 0x00, 0x00, 0xa8,
X 0xd5, 0xff, 0xff, 0xab, 0x55, 0x00, 0x00, 0xaa, 0x55, 0xff, 0xff, 0xaa,
X 0x55, 0x01, 0x80, 0xaa, 0x55, 0xfd, 0xbf, 0xaa, 0x55, 0x05, 0xa0, 0xaa,
X 0x55, 0xf5, 0xaf, 0xaa, 0x55, 0x15, 0xa8, 0xaa, 0x55, 0xd5, 0xab, 0xaa,
X 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0xd5, 0xab, 0xaa,
X 0x55, 0x15, 0xa8, 0xaa, 0x55, 0xf5, 0xaf, 0xaa, 0x55, 0x05, 0xa0, 0xaa,
X 0x55, 0xfd, 0xbf, 0xaa, 0x55, 0x01, 0x80, 0xaa, 0x55, 0xff, 0xff, 0xaa,
X 0x55, 0x00, 0x00, 0xaa, 0xd5, 0xff, 0xff, 0xab, 0x15, 0x00, 0x00, 0xa8,
X 0xf5, 0xff, 0xff, 0xaf, 0x05, 0x00, 0x00, 0xa0, 0xfd, 0xff, 0xff, 0xbf,
X 0x01, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 893 -ne `wc -c <'pat_07.xbm'`; then
echo shar: \"'pat_07.xbm'\" unpacked with wrong size!
fi
# end of 'pat_07.xbm'
fi
if test -f 'pat_08.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_08.xbm'\"
else
echo shar: Extracting \"'pat_08.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_08.xbm' <<'END_OF_FILE'
X#define pattern_08_width 32
X#define pattern_08_height 32
Xstatic char pattern_08_bits[] = {
X 0x06, 0x06, 0x06, 0x06, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
X 0x06, 0x06, 0x06, 0x06, 0x60, 0x60, 0x60, 0x60, 0x90, 0x90, 0x90, 0x90,
X 0x90, 0x90, 0x90, 0x90, 0x60, 0x60, 0x60, 0x60, 0x06, 0x06, 0x06, 0x06,
X 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06, 0x06, 0x06, 0x06,
X 0x60, 0x60, 0x60, 0x60, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
X 0x60, 0x60, 0x60, 0x60, 0x06, 0x06, 0x06, 0x06, 0x09, 0x09, 0x09, 0x09,
X 0x09, 0x09, 0x09, 0x09, 0x06, 0x06, 0x06, 0x06, 0x60, 0x60, 0x60, 0x60,
X 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x60, 0x60, 0x60, 0x60,
X 0x06, 0x06, 0x06, 0x06, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
X 0x06, 0x06, 0x06, 0x06, 0x60, 0x60, 0x60, 0x60, 0x90, 0x90, 0x90, 0x90,
X 0x90, 0x90, 0x90, 0x90, 0x60, 0x60, 0x60, 0x60};
END_OF_FILE
if test 893 -ne `wc -c <'pat_08.xbm'`; then
echo shar: \"'pat_08.xbm'\" unpacked with wrong size!
fi
# end of 'pat_08.xbm'
fi
if test -f 'pat_10.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_10.xbm'\"
else
echo shar: Extracting \"'pat_10.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_10.xbm' <<'END_OF_FILE'
X#define pattern_10_width 32
X#define pattern_10_height 32
Xstatic char pattern_10_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x60, 0xc0, 0x00,
X 0x00, 0x10, 0x00, 0x01, 0x30, 0x08, 0x00, 0x02, 0x28, 0x04, 0x00, 0x04,
X 0x24, 0x04, 0x00, 0x04, 0x20, 0x02, 0x00, 0x08, 0x20, 0x02, 0x00, 0x08,
X 0x20, 0x02, 0x00, 0x08, 0x20, 0x02, 0x00, 0x08, 0x20, 0x02, 0x00, 0x08,
X 0x20, 0x02, 0x00, 0x08, 0x20, 0x02, 0x00, 0x08, 0x20, 0x04, 0x00, 0x04,
X 0x20, 0x04, 0x00, 0x04, 0x20, 0x08, 0x00, 0x02, 0x20, 0x10, 0x00, 0x01,
X 0x20, 0x60, 0xc0, 0x00, 0xfc, 0x81, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_10.xbm'`; then
echo shar: \"'pat_10.xbm'\" unpacked with wrong size!
fi
# end of 'pat_10.xbm'
fi
if test -f 'pat_11.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_11.xbm'\"
else
echo shar: Extracting \"'pat_11.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_11.xbm' <<'END_OF_FILE'
X#define pattern_11_width 32
X#define pattern_11_height 32
Xstatic char pattern_11_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x06, 0x0c, 0x00, 0x00, 0x05, 0x0a, 0x00, 0x80, 0x04, 0x09, 0x00,
X 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00,
X 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00,
X 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00,
X 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x08, 0x00,
X 0x80, 0x3f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_11.xbm'`; then
echo shar: \"'pat_11.xbm'\" unpacked with wrong size!
fi
# end of 'pat_11.xbm'
fi
if test -f 'pat_12.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_12.xbm'\"
else
echo shar: Extracting \"'pat_12.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_12.xbm' <<'END_OF_FILE'
X#define pattern_12_width 32
X#define pattern_12_height 32
Xstatic char pattern_12_bits[] = {
X 0x30, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x05, 0x00, 0x00, 0x40, 0x00,
X 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x08, 0x10, 0x00, 0x00, 0x00,
X 0x18, 0x00, 0x00, 0x08, 0xc8, 0x0d, 0x08, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x60, 0x00, 0x10, 0x08, 0x70, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00,
X 0x80, 0x02, 0x20, 0x00, 0x00, 0x00, 0xc7, 0x01, 0x00, 0x02, 0x00, 0x00,
X 0x00, 0x24, 0x00, 0x00, 0x00, 0x08, 0x02, 0x08, 0x60, 0x00, 0x42, 0x00,
X 0x08, 0x00, 0x00, 0x10, 0x02, 0x10, 0x40, 0x00, 0x00, 0x20, 0x01, 0x00,
X 0x00, 0x70, 0x40, 0x10, 0x00, 0x10, 0x04, 0x00, 0x08, 0x10, 0x04, 0x10,
X 0x08, 0x00, 0x01, 0x03, 0xc8, 0x60, 0x00, 0x00, 0x10, 0x80, 0x90, 0x02,
X 0x30, 0x00, 0x00, 0x12, 0x40, 0x00, 0x00, 0x02, 0x80, 0x34, 0x0e, 0x00,
X 0x00, 0x00, 0x30, 0x14, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_12.xbm'`; then
echo shar: \"'pat_12.xbm'\" unpacked with wrong size!
fi
# end of 'pat_12.xbm'
fi
if test -f 'pat_13.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_13.xbm'\"
else
echo shar: Extracting \"'pat_13.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_13.xbm' <<'END_OF_FILE'
X#define pattern_13_width 32
X#define pattern_13_height 32
Xstatic char pattern_13_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0xf8, 0xc0, 0x07, 0x3e, 0xfc, 0xe1, 0x0f, 0x7f,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff, 0xfc, 0xe1, 0x0f, 0x7f,
X 0xf8, 0xc0, 0x07, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0xf8, 0xc0, 0x07, 0x3e, 0xfc, 0xe1, 0x0f, 0x7f, 0xfe, 0xf3, 0x9f, 0xff,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfc, 0xe1, 0x0f, 0x7f, 0xf8, 0xc0, 0x07, 0x3e,
X 0x00, 0x00, 0x00, 0x00, 0xf8, 0xc0, 0x07, 0x3e, 0xfc, 0xe1, 0x0f, 0x7f,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff,
X 0xfe, 0xf3, 0x9f, 0xff, 0xfe, 0xf3, 0x9f, 0xff, 0xfc, 0xe1, 0x0f, 0x7f,
X 0xf8, 0xc0, 0x07, 0x3e, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_13.xbm'`; then
echo shar: \"'pat_13.xbm'\" unpacked with wrong size!
fi
# end of 'pat_13.xbm'
fi
if test -f 'pat_14.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_14.xbm'\"
else
echo shar: Extracting \"'pat_14.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_14.xbm' <<'END_OF_FILE'
X#define pattern_14_width 32
X#define pattern_14_height 32
Xstatic char pattern_14_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0xe0, 0x72, 0x01, 0x00, 0x18, 0x00, 0x06, 0x00, 0x02, 0x00, 0x04,
X 0x00, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x08, 0x90, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x06, 0x00, 0x90, 0x00, 0x02, 0x00, 0x90, 0x00, 0x00, 0x00,
X 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x80, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x20, 0x00, 0x01, 0x00, 0x20,
X 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x08, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
X 0x00, 0x08, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00,
X 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
X 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_14.xbm'`; then
echo shar: \"'pat_14.xbm'\" unpacked with wrong size!
fi
# end of 'pat_14.xbm'
fi
if test -f 'pat_15.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_15.xbm'\"
else
echo shar: Extracting \"'pat_15.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_15.xbm' <<'END_OF_FILE'
X#define pattern_15_width 32
X#define pattern_15_height 32
Xstatic char pattern_15_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x78, 0x00, 0x38, 0x00, 0xcc, 0x00, 0xc8, 0x00, 0x80, 0x00, 0xa4, 0x01,
X 0x84, 0x00, 0x02, 0x02, 0x84, 0x00, 0x02, 0x02, 0xfc, 0x00, 0x02, 0x03,
X 0x00, 0x20, 0xdc, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
X 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
X 0x00, 0x90, 0x01, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x80, 0x03, 0xf8, 0x01,
X 0xc0, 0x0e, 0x1c, 0x01, 0x40, 0xf0, 0x0f, 0x01, 0x80, 0x00, 0x80, 0x00,
X 0x80, 0x00, 0x80, 0x00, 0x80, 0x01, 0xc0, 0x00, 0x00, 0x0e, 0x70, 0x00,
X 0x00, 0x30, 0x09, 0x00, 0x00, 0xf0, 0x0f, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_15.xbm'`; then
echo shar: \"'pat_15.xbm'\" unpacked with wrong size!
fi
# end of 'pat_15.xbm'
fi
if test -f 'pat_16.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pat_16.xbm'\"
else
echo shar: Extracting \"'pat_16.xbm'\" \(893 characters\)
sed "s/^X//" >'pat_16.xbm' <<'END_OF_FILE'
X#define pattern_16_width 32
X#define pattern_16_height 32
Xstatic char pattern_16_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x89, 0x3c, 0x00,
X 0x20, 0x88, 0x04, 0x00, 0x20, 0x88, 0x04, 0x00, 0x20, 0xf8, 0x1c, 0x00,
X 0x20, 0x88, 0x04, 0x00, 0x20, 0x88, 0x04, 0x00, 0x20, 0x88, 0x3c, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x82, 0x3c, 0x00,
X 0x04, 0x86, 0x44, 0x00, 0x04, 0x8a, 0x84, 0x00, 0x04, 0x8a, 0x84, 0x00,
X 0x1c, 0x92, 0x84, 0x00, 0x04, 0x92, 0x84, 0x00, 0x04, 0xa2, 0x84, 0x00,
X 0x04, 0xa2, 0x84, 0x00, 0x04, 0xc2, 0x44, 0x00, 0x7c, 0x82, 0x3c, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 893 -ne `wc -c <'pat_16.xbm'`; then
echo shar: \"'pat_16.xbm'\" unpacked with wrong size!
fi
# end of 'pat_16.xbm'
fi
if test -f 'patchlevel.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'patchlevel.h'\"
else
echo shar: Extracting \"'patchlevel.h'\" \(22 characters\)
sed "s/^X//" >'patchlevel.h' <<'END_OF_FILE'
X#define PATCHLEVEL 0
END_OF_FILE
if test 22 -ne `wc -c <'patchlevel.h'`; then
echo shar: \"'patchlevel.h'\" unpacked with wrong size!
fi
# end of 'patchlevel.h'
fi
if test -f 'polygon.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'polygon.xbm'\"
else
echo shar: Extracting \"'polygon.xbm'\" \(884 characters\)
sed "s/^X//" >'polygon.xbm' <<'END_OF_FILE'
X#define polygon_width 32
X#define polygon_height 32
Xstatic char polygon_bits[] = {
X 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x80, 0x08, 0x00,
X 0x00, 0x40, 0x10, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x20, 0x40, 0x00,
X 0x00, 0x20, 0x80, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x20, 0x00, 0x02,
X 0x00, 0x20, 0x00, 0x04, 0x00, 0x20, 0x00, 0x08, 0x00, 0x20, 0x00, 0x10,
X 0x00, 0x20, 0x00, 0x08, 0x00, 0x20, 0x00, 0x04, 0xe0, 0x3f, 0x00, 0x02,
X 0x20, 0x00, 0x00, 0x01, 0x20, 0x00, 0x80, 0x00, 0x20, 0x00, 0x40, 0x00,
X 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x10, 0x00, 0x20, 0x00, 0x08, 0x00,
X 0x20, 0x00, 0x04, 0x00, 0x20, 0x00, 0x02, 0x00, 0x40, 0x00, 0x01, 0x00,
X 0x80, 0x80, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00,
X 0x00, 0x14, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 884 -ne `wc -c <'polygon.xbm'`; then
echo shar: \"'polygon.xbm'\" unpacked with wrong size!
fi
# end of 'polygon.xbm'
fi
if test -f 'read.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'read.c'\"
else
echo shar: Extracting \"'read.c'\" \(1541 characters\)
sed "s/^X//" >'read.c' <<'END_OF_FILE'
X/* +------------------------------------------------------------------+ */
X/* | Copyright 1989, David Koblas. | */
X/* | You may copy this file in whole or in part as long as you | */
X/* | don't try to make money off it, or pretend that you wrote it. | */
X/* +------------------------------------------------------------------+ */
X
X#include <stdio.h>
X#include "xpaint.h"
X
Xchar *rindex();
X
X#ifndef lint
Xstatic char rcsid[]="$Header: read.c,v 1.3 89/02/20 19:33:01 koblas Locked $";
X#endif
X
XOpenFile()
X{
X static char str[1024];
X
X if (GetString(str)) {
X CloseDraw();
X ReadFile(str,FT_XBM);
X ShowDraw();
X }
X}
X
XReadFile(filename,type)
Xchar *filename;
Xint type;
X{
X int ret_code = FALSE;
X
X switch (type) {
X case FT_XBM:
X ret_code = read_xbm(filename);
X break;
X case FT_UTAH:
X fprintf(stderr,"file type not supported (UTAH RLE)\n");
X break;
X case FT_GIF:
X fprintf(stderr,"file type not supported (GIF)\n");
X break;
X case FT_TIFF:
X fprintf(stderr,"file type not supported (TIFF)\n");
X break;
X case FT_PIC:
X fprintf(stderr,"file type not supported (PIC)\n");
X break;
X }
X
X return ret_code;
X}
X
Xstatic read_xbm(filename)
Xchar *filename;
X{
X char *data;
X int width,height;
X
X
X if (ReadXBM(filename,&width,&height,&data)!=0) {
X fprintf(stderr,"Error reading XBM %s\n",filename);
X return FALSE;
X } else {
X CurrentWindow->img_width = width;
X CurrentWindow->img_height = height;
X CurrentWindow->master=BitmapToImage(width,height,data,TRUE);
X if (*data != NULL)
X free (data);
X return TRUE;
X }
X}
END_OF_FILE
if test 1541 -ne `wc -c <'read.c'`; then
echo shar: \"'read.c'\" unpacked with wrong size!
fi
# end of 'read.c'
fi
if test -f 'rect.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'rect.xbm'\"
else
echo shar: Extracting \"'rect.xbm'\" \(890 characters\)
sed "s/^X//" >'rect.xbm' <<'END_OF_FILE'
X#define rectangle_width 32
X#define rectangle_height 32
Xstatic char rectangle_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x0f,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08,
X 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0xf0, 0xff, 0xff, 0x0f,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 890 -ne `wc -c <'rect.xbm'`; then
echo shar: \"'rect.xbm'\" unpacked with wrong size!
fi
# end of 'rect.xbm'
fi
if test -f 'rectfill.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'rectfill.xbm'\"
else
echo shar: Extracting \"'rectfill.xbm'\" \(887 characters\)
sed "s/^X//" >'rectfill.xbm' <<'END_OF_FILE'
X#define rectfill_width 32
X#define rectfill_height 32
Xstatic char rectfill_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x0f,
X 0x10, 0x11, 0x11, 0x09, 0x50, 0x44, 0x44, 0x0c, 0x10, 0x11, 0x11, 0x09,
X 0x50, 0x44, 0x44, 0x0c, 0x10, 0x11, 0x11, 0x09, 0x50, 0x44, 0x44, 0x0c,
X 0x10, 0x11, 0x11, 0x09, 0x50, 0x44, 0x44, 0x0c, 0x10, 0x11, 0x11, 0x09,
X 0x50, 0x44, 0x44, 0x0c, 0x10, 0x11, 0x11, 0x09, 0x50, 0x44, 0x44, 0x0c,
X 0x10, 0x11, 0x11, 0x09, 0x50, 0x44, 0x44, 0x0c, 0xf0, 0xff, 0xff, 0x0f,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 887 -ne `wc -c <'rectfill.xbm'`; then
echo shar: \"'rectfill.xbm'\" unpacked with wrong size!
fi
# end of 'rectfill.xbm'
fi
if test -f 'scissor.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'scissor.xbm'\"
else
echo shar: Extracting \"'scissor.xbm'\" \(884 characters\)
sed "s/^X//" >'scissor.xbm' <<'END_OF_FILE'
X#define scissor_width 32
X#define scissor_height 32
Xstatic char scissor_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
X 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x10,
X 0x00, 0x00, 0x08, 0x0c, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0xc4, 0x00,
X 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00,
X 0x00, 0x00, 0x03, 0x00, 0x00, 0xc0, 0x02, 0x00, 0xe0, 0x30, 0x02, 0x00,
X 0x10, 0x0d, 0x01, 0x00, 0x08, 0x02, 0x01, 0x00, 0x08, 0x02, 0x01, 0x00,
X 0x08, 0x02, 0x01, 0x00, 0x10, 0x81, 0x00, 0x00, 0xe0, 0x80, 0x00, 0x00,
X 0x00, 0xe0, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x08, 0x02, 0x00,
X 0x00, 0x08, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x10, 0x01, 0x00,
X 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 884 -ne `wc -c <'scissor.xbm'`; then
echo shar: \"'scissor.xbm'\" unpacked with wrong size!
fi
# end of 'scissor.xbm'
fi
if test -f 'spray.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'spray.xbm'\"
else
echo shar: Extracting \"'spray.xbm'\" \(878 characters\)
sed "s/^X//" >'spray.xbm' <<'END_OF_FILE'
X#define spray_width 32
X#define spray_height 32
Xstatic char spray_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00,
X 0x00, 0x80, 0x02, 0x00, 0x00, 0x42, 0x05, 0x00, 0x00, 0xbe, 0x03, 0x00,
X 0x00, 0x46, 0x05, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x80, 0x08, 0x05, 0x00,
X 0x40, 0x10, 0x02, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
X 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 878 -ne `wc -c <'spray.xbm'`; then
echo shar: \"'spray.xbm'\" unpacked with wrong size!
fi
# end of 'spray.xbm'
fi
if test -f 'spraypat.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'spraypat.xbm'\"
else
echo shar: Extracting \"'spraypat.xbm'\" \(299 characters\)
sed "s/^X//" >'spraypat.xbm' <<'END_OF_FILE'
X#define spraypattern_width 16
X#define spraypattern_height 16
Xstatic char spraypattern_bits[] = {
X 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 0xc4, 0x18, 0x04, 0x01, 0x42, 0xf2,
X 0x0c, 0x68, 0x88, 0x80, 0x42, 0x83, 0x02, 0x90, 0x82, 0x01, 0x44, 0x12,
X 0x14, 0x0a, 0x00, 0x19, 0x80, 0x01, 0x00, 0x00};
END_OF_FILE
if test 299 -ne `wc -c <'spraypat.xbm'`; then
echo shar: \"'spraypat.xbm'\" unpacked with wrong size!
fi
# end of 'spraypat.xbm'
fi
if test -f 'temp' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'temp'\"
else
echo shar: Extracting \"'temp'\" \(28 characters\)
sed "s/^X//" >'temp' <<'END_OF_FILE'
Xmv dottedbox.xbm dotbox.xbm
END_OF_FILE
if test 28 -ne `wc -c <'temp'`; then
echo shar: \"'temp'\" unpacked with wrong size!
fi
# end of 'temp'
fi
if test -f 'text.xbm' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'text.xbm'\"
else
echo shar: Extracting \"'text.xbm'\" \(875 characters\)
sed "s/^X//" >'text.xbm' <<'END_OF_FILE'
X#define text_width 32
X#define text_height 32
Xstatic char text_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00,
X 0x00, 0xe0, 0x03, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0x30, 0x06, 0x00,
X 0x00, 0x30, 0x06, 0x00, 0x00, 0x18, 0x0c, 0x00, 0x00, 0x18, 0x0c, 0x00,
X 0x00, 0x0c, 0x18, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0xfe, 0x3f, 0x00,
X 0x00, 0x06, 0x30, 0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x03, 0x60, 0x00,
X 0x00, 0x03, 0x60, 0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x03, 0x60, 0x00,
X 0x80, 0x07, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 875 -ne `wc -c <'text.xbm'`; then
echo shar: \"'text.xbm'\" unpacked with wrong size!
fi
# end of 'text.xbm'
fi
if test -f 'version.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'version.c'\"
else
echo shar: Extracting \"'version.c'\" \(116 characters\)
sed "s/^X//" >'version.c' <<'END_OF_FILE'
X#include "patchlevel.h"
X
X#define VERSION 1
X
XVersion()
X{
X printf("xpaint: Version = %d.%d\n",VERSION,PATCHLEVEL);
X}
END_OF_FILE
if test 116 -ne `wc -c <'version.c'`; then
echo shar: \"'version.c'\" unpacked with wrong size!
fi
# end of 'version.c'
fi
if test -f 'xpaint.1' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xpaint.1'\"
else
echo shar: Extracting \"'xpaint.1'\" \(4318 characters\)
sed "s/^X//" >'xpaint.1' <<'END_OF_FILE'
X.TH xpaint 1 "20 February 1989"
X.SH NAME
Xxpaint \- bitmap graphics editor for X
X.SH SYNOPSIS
X.in +.5i
X.ti -.5i
Xxpaint \%[-v] \%[-x size] \%[-y size] \%[-d display]
X.in -.5i
X.SH DESCRIPTION
X.I Xpaint is a utility for doing bitmap editing under the X windows
Xenvironment.
X.LP
XThe
X.I -v
Xflag displays the current version information about
X.I xpaint.
XThe
X.I -x
Xand
X.I -y
Xflags are used to set the default bitmap size when there is a blank
Xbitmap being edited (size is specified in pixels).
XAnd the
X.I -d
Xflag can specify the display for the graphics interaction to take
Xplace.
XWhen
X.I xpaint
Xcome up on your screen you are presented with 4 active regions,
Xan actions section a menu section a graphics section and a pattern
Xsection.
X.PP
XIn the pattern section of the display you will find a varied set of
Xpattern, selecting any on of these patterns with a single mouse click
Xon will set the fill pattern for filled actions to the specified
Xpattern. Double clicking on the pattern information will allow you
Xto edit the selected pattern.
X.PP
XThe menu section of the program contains a menu for selection based
Xon File information Buffer information and Font information (the
Xfont selection is used by the text action). The Buffer menu
Xcontains an Undo feature which will undo your previous action on the
Xdraw area. The Flip Horz. and the Flip Vert. and Invert options all
Xhave to do with selected regions on the drawable. The File menu
Xcontains a Close function which closes the current bitmap. An Open
Xfunction which opens a new scratch image, a Read function which reads
Xa bitmap from a file into the current bitmap. Also contained are
Xa Save and a Save As which will save an bitmap to a file of the
Xsame name and if it is a untilted image to a specified name. The
XSave Region function allows you to save a portion of a bitmap into
Xa file. And finally a Quit function to exit you from the program.
X.PP
XIn the Actions sections of the display there are the following:
X.IP
XArrow, double clicking this action will allow you to enter fatbits
Xmode, similar to the bitmap editor. Clicking on the normal size
Xtext in fatbits mode exits you from fatbits. Also the arrow is the
Xdefault action and the selected action when there is selected drawable.
X.IP
XHand, this allows you to roam over image space also the only other
Xavailable action in fatbits mode.
X.IP
XDotted Box, this allows you to selected a region of the current bitmap
Xfor movement purposes [Bug: this region is not indicated in any way].
X.IP
XStraight Line, this allows you to draw a straight line on your current
Ximage, color of the line is the inverse of the pixel under the
Xstarting point.
X.IP
XArbitrary Line, this allows you to draw an arbitrary line on you
Xcurrent bitmap, the color is the inverse of the color of your starting
Xpoint.
X.IP
XRectangle, draw an arbitrarly sized box on the current bitmap.
X.IP
XEllipse, draw an arbitrary ellipse on the current bitmap.
X.IP
XBrush, draw a 10x16 mono-colored box on the bitmap.
X.IP
XEraser, draw a 10x16 mono-colored (inverse of brush) box on the bitmap.
X.IP
XText, place informative text onto the current bitmap [bug:
Xthe insertion point the text isn't visible]. Clicking the mouse
Xon the drawable selected the point of insertion.
X.IP
XSpray, draw a fuzzy area on the bitmap. Double clicking allows you to
Xedit the spray pattern.
X.IP
XFilled Rectangle, same as rectangle but filled with the current
Xpattern.
X.IP
XFilled Ellipse, same as ellipse but filled with the current pattern.
X.PP
XIn Fatbits mode and in the Bitmap editor you are presented with a
Xbitgraphic interface to a object, to select a drawing color you
Xneed to click a mouse button at a specific point, this will cause
Xthe inverse color of that point to be drawn onto the current bitmap.
X.SH BUGS
XThere are still many: "fatbits" has a bugs, there are problems when
Xusing some function and passing expose events. Focus of key press
Xevents is not perfect. Does not use resources, doesn't look fonts
Xup on the server, uses getopt to parse arguments. Menu:Cut, Menu:Copy,
XMenu:Clear don't work. No alert information for all File options,
Xthe is no Read Region menu item.
X.SH AUTHOR
XCopyright 1989, David Koblas (koblas@mips.com).
XYou may copy this file in whole or in part as long as you
Xdon't try to make money off it, or pretend that you wrote it.
END_OF_FILE
if test 4318 -ne `wc -c <'xpaint.1'`; then
echo shar: \"'xpaint.1'\" unpacked with wrong size!
fi
# end of 'xpaint.1'
fi
if test -f 'xpaint.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xpaint.h'\"
else
echo shar: Extracting \"'xpaint.h'\" \(2731 characters\)
sed "s/^X//" >'xpaint.h' <<'END_OF_FILE'
X/* +------------------------------------------------------------------+ */
X/* | Copyright 1989, David Koblas. | */
X/* | You may copy this file in whole or in part as long as you | */
X/* | don't try to make money off it, or pretend that you wrote it. | */
X/* +------------------------------------------------------------------+ */
X
X#include <X11/X.h>
X#include <X11/Xlib.h>
X#include <X11/Xutil.h>
X
X#if 0
X$Header: xpaint.h,v 1.4 89/02/20 19:33:02 koblas Locked $
X#endif
X
Xtypedef struct {
X Window (*create_handler)();
X void (*event_handler)();
X void (*resize_handler)();
X Window window;
X int delta_x,delta_y;
X int delta_flag;
X#define DELTA_LEFT 0x0001
X#define DELTA_RIGHT 0x0002
X#define DELTA_TOP 0x0010
X#define DELTA_BOTTOM 0x0020
X} t_sub_window;
X
Xtypedef struct {
X Display *display;
X int screen;
X Window rootwindow;
X Window window;
X Window draw_window;
X Visual *visual;
X int depth;
X int numsub;
X t_sub_window *subwind;
X int img_offx,img_offy;
X int img_width,img_height;
X long black,white;
X int width,height;
X GC igc,gc;
X Cursor default_cursor;
X XImage *master;
X} t_window;
X
X#define SAVE_ID 5
X#define BITEDIT_ID 4
X#define MENU_ID 3
X#define PATTERN_ID 2
X#define ACTION_ID 1
X#define DRAW_ID 0
X
X#define DELTA_XPOS(id) (((CurrentWindow->subwind[id].delta_flag& \
X (DELTA_LEFT|DELTA_RIGHT))==DELTA_LEFT)? \
X (CurrentWindow->subwind[id].delta_x): \
X (CurrentWindow->width- \
X CurrentWindow->subwind[id].delta_x))
X#define DELTA_YPOS(id) (((CurrentWindow->subwind[id].delta_flag& \
X (DELTA_TOP|DELTA_BOTTOM))==DELTA_TOP)? \
X (CurrentWindow->subwind[id].delta_y): \
X (CurrentWindow->height- \
X CurrentWindow->subwind[id].delta_y))
X
X#define PATTERN_VAL(x,y) PatternBits[(((CurrentWindow->img_offy+(y))%32)*32)+\
X ((CurrentWindow->img_offx + (x))%32)]
X
X#define C_ARROW 0
X#define C_HAND 1
X#define C_DOTBOX 2
X#define C_SCISSORS 3
X#define C_LINE 4
X#define C_ARBLINE 5
X#define C_RECTANGLE 6
X#define C_ELIPSE 7
X#define C_POLYGON 8
X#define C_FILL 9
X#define C_BRUSH 10
X#define C_ERASER 11
X#define C_TEXT 12
X#define C_SPRAY 13
X#define C_ELIPF 14
X#define C_RECTF 15
X#define C_NONE -1
X
X#define FT_NONE 0
X#define FT_XBM 1
X#define FT_UTAH 2
X#define FT_GIF 3
X#define FT_TIFF 4
X#define FT_PIC 5
X
X#define N_PATTERN 16
X
Xextern t_window *CurrentWindow;
Xextern int CurrentActionID;
Xextern int CurrentPatternID;
Xextern int FileType;
Xextern char *FileName;
X
Xtypedef struct {
X int width,height;
X char *bits;
X} t_bitdata;
X
X#define TRUE 1
X#define FALSE 0
X
XXImage *BitmapToImage();
Xextern char PatternBits[];
Xextern int DefaultXsize,DefaultYsize;
X
X#define Between(min,val,max) (((min)<=(val)) && ((val)<(max)))
X
X#define DEF_FONT "8x13"
END_OF_FILE
if test 2731 -ne `wc -c <'xpaint.h'`; then
echo shar: \"'xpaint.h'\" unpacked with wrong size!
fi
# end of 'xpaint.h'
fi
echo shar: End of archive 3 \(of 3\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 3 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
--
Mike Wexler(wyse!mikew) Phone: (408)433-1000 x1330
Moderator of comp.sources.x