smtalk43/0407550003270021170000000000005477556355011035 5 0temccuned355 1 0 smtalk43/Makefile1006440003270021170000000317205477252510011143 037777777777 1 0 osf1: cd stdwin/Conf ;\ ./mkmf -a sun4 -o sunos cd stdwin/Build/sun4/x11/lib ;\ make "CONFDEFS=-DXLIB_ILLEGAL_ACCESS" cd smtalk/src ;\ make "ARCH=sun4" "OS=sunos" bsdx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . sunos: cd stdwin/Conf ;\ ./mkmf -a sun4 -o sunos cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=sun4" "OS=sunos" bsdx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . scounix: cd stdwin/Conf ;\ ./mkmf -a sun4 -o bsd cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=sun4" "OS=bsd" bsdx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . linux: cd stdwin/Conf ;\ ./mkmf -a sun4 -o bsd cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=sun4" "OS=bsd" bsdx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . sequent: cd stdwin/Conf ;\ ./mkmf -a sun4 -o sysv cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=sun4" "OS=sysv" sysvx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . ultrix: cd stdwin/Conf ;\ ./mkmf -a mips -o bsd cd stdwin/Build/mips/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=mips" "OS=bsd" bsdx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . uts: cd stdwin/Conf ;\ ./mkmf -a sun4 -o sysv cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "ARCH=sun4" "OS=sysv" sysvx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . unicos: cd stdwin/Conf ;\ ./mkmf -a sun4 -o sysv cd stdwin/Build/sun4/x11/lib ;\ make cd smtalk/src ;\ make "CFLAGS=-h stdc" "ARCH=sun4" "OS=sysv" sysvx11 cp smtalk/src/st ./xst cp smtalk/src/systemImage . clean: find . -name "*.o" -exec rm {} \; smtalk43/stdwin/0407550003270021170000000000005477556140010210 5 0 1 0 smtalk43/stdwin/Appls/0407550003270021170000000000005477556060011270 5 0 1 0 smtalk43/stdwin/Appls/bed/0407550003270021170000000000005477556044012024 5 0 1 0 smtalk43/stdwin/Appls/bed/2x21004440003270021170000000042005434024272013144 037777777777 1 0 #define 2x2_width 16 #define 2x2_height 16 static char 2x2_bits[] = { 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33, 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33, 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33, 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0x33, 0x33}; smtalk43/stdwin/Appls/bed/Dada1006440003270021170000001123705434024273013375 037777777777 1 0 #define dadada_width 75 #define dadada_height 75 static char dadada_bits[] { 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x1c, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x00, 0x24, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x00, 0x44, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x08, 0x84, 0x01, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x30, 0x04, 0x02, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x40, 0x04, 0x04, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x20, 0x80, 0x02, 0x18, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x20, 0xfe, 0xfc, 0xdf, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0x00, 0x20, 0xfe, 0xf9, 0xbf, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0x00, 0x40, 0xfe, 0xf6, 0x7f, 0xf1, 0xfb, 0x0f, 0x00, 0x00, 0x00, 0x40, 0xfe, 0xce, 0xff, 0x0e, 0xe4, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x7e, 0xbf, 0xff, 0x07, 0x9c, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x7e, 0x7f, 0x7f, 0x18, 0x7c, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x9d, 0xff, 0xbc, 0x20, 0xfc, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xe2, 0xff, 0xdb, 0x40, 0xfc, 0x0d, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xe7, 0x80, 0xfd, 0x0b, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xcf, 0x00, 0xfe, 0x0b, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xb7, 0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x77, 0xfe, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xfd, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xfb, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xe7, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xdf, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xbf, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0x7f, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xff, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xff, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xef, 0xff, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xef, 0xff, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xdf, 0xff, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0xff, 0xff, 0xff, 0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x08, 0xff, 0xff, 0xff, 0xe0, 0x07, 0x00, 0x00, 0x10, 0x00, 0x04, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x20, 0x00, 0x02, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; smtalk43/stdwin/Appls/bed/Make.proto1006440003270021170000000041005434024273014552 037777777777 1 0 # # Makefile prototype for bed (bitmap editor) application # BED= $(APPLS)/bed SRCS= \ $(BED)/bed.c \ $(BED)/file.c \ $(BED)/fmenu.c \ $(BED)/mouse.c \ $(BED)/mmenu.c \ $(BED)/opmenu.c SRCLIBS= -lm all: bed _bootstrap: @putprogmf bed $(SRCS) smtalk43/stdwin/Appls/bed/Woman1006440003270021170000001123405434024273013622 037777777777 1 0 #define woman_width 75 #define woman_height 75 static char woman_bits[] { 0xfc, 0x7e, 0x40, 0x20, 0x90, 0x00, 0x07, 0x80, 0x23, 0x00, 0x00, 0xc6, 0xc1, 0x41, 0x98, 0xb8, 0x01, 0x07, 0x66, 0x00, 0x15, 0x9f, 0x03, 0x47, 0x8c, 0xc6, 0xdc, 0x7b, 0xcc, 0x00, 0xb0, 0x71, 0x0e, 0x4d, 0x06, 0x66, 0x73, 0x8e, 0x8f, 0x01, 0x18, 0xc4, 0x39, 0x4b, 0x02, 0x23, 0x0c, 0x04, 0x1e, 0x03, 0x0c, 0x08, 0xc7, 0xef, 0x08, 0x30, 0x06, 0x07, 0x1c, 0x02, 0x06, 0x30, 0x18, 0xae, 0xc8, 0x98, 0x3f, 0x78, 0x20, 0x06, 0x02, 0x20, 0x60, 0xa0, 0xc4, 0x1d, 0xc0, 0xff, 0x41, 0x04, 0xfa, 0x63, 0x80, 0xa1, 0xa4, 0xbd, 0x00, 0x84, 0xbf, 0x04, 0x0f, 0x06, 0xfc, 0xa1, 0x34, 0x6b, 0x01, 0x1c, 0xc9, 0x05, 0x06, 0xc7, 0x06, 0xbe, 0x11, 0x1e, 0x43, 0x30, 0x91, 0x07, 0xc3, 0x61, 0x02, 0x30, 0x1b, 0x30, 0xcc, 0x30, 0x11, 0x00, 0xc1, 0x3c, 0x03, 0x20, 0x0a, 0x00, 0xe8, 0x60, 0x21, 0x00, 0x61, 0x1b, 0xc1, 0x63, 0x08, 0xf0, 0xc6, 0xc7, 0x21, 0x03, 0xf8, 0x08, 0xe1, 0xcf, 0x0a, 0xfc, 0x4d, 0x99, 0x43, 0x07, 0x3c, 0x0c, 0xf1, 0x9f, 0x0b, 0xfc, 0x5b, 0x91, 0x47, 0x02, 0x16, 0x04, 0x31, 0x1c, 0x0b, 0x1f, 0x17, 0x89, 0x4d, 0x06, 0x1a, 0x04, 0x31, 0x38, 0x02, 0x07, 0x56, 0x99, 0x4b, 0x04, 0x0b, 0x04, 0xb1, 0x72, 0x82, 0xa1, 0x54, 0xba, 0x49, 0x04, 0x1d, 0x66, 0x50, 0xe7, 0xc2, 0xf0, 0x54, 0x9a, 0x58, 0x04, 0x0d, 0x62, 0xc1, 0x1f, 0x44, 0xfc, 0x51, 0x90, 0x90, 0x04, 0x86, 0x63, 0xe0, 0x74, 0x04, 0xef, 0x31, 0x1a, 0x91, 0x00, 0x02, 0xe2, 0xc1, 0xfd, 0x84, 0xf9, 0x30, 0x0a, 0x91, 0x00, 0x82, 0xa9, 0xc0, 0xb9, 0x84, 0xf9, 0x31, 0x16, 0x81, 0x00, 0x42, 0xa9, 0xdb, 0x7f, 0x0c, 0xff, 0x1c, 0x16, 0x11, 0x00, 0x02, 0x28, 0x0b, 0x07, 0x08, 0x60, 0x1c, 0x02, 0x91, 0x00, 0x46, 0x29, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x16, 0x11, 0x02, 0x06, 0x29, 0x04, 0x00, 0x00, 0x00, 0x10, 0x16, 0x91, 0x06, 0xa6, 0x2a, 0x04, 0x00, 0x00, 0x00, 0x18, 0x24, 0x91, 0x04, 0x86, 0x2a, 0x04, 0x00, 0x00, 0x00, 0x18, 0x27, 0x93, 0x04, 0x96, 0x4a, 0x04, 0x00, 0x00, 0x20, 0x04, 0x02, 0x91, 0x04, 0x86, 0x4a, 0x0c, 0x00, 0x00, 0x00, 0x1e, 0x23, 0x93, 0x04, 0x56, 0x88, 0x08, 0x00, 0x00, 0x00, 0x90, 0x21, 0x93, 0x04, 0x52, 0x0a, 0x09, 0x80, 0x01, 0x00, 0xd0, 0x21, 0x95, 0x04, 0x57, 0x0a, 0x0f, 0x80, 0x27, 0x00, 0xd8, 0x20, 0x9d, 0x04, 0x5d, 0x08, 0x1c, 0x80, 0x67, 0x00, 0xe4, 0x01, 0x85, 0x04, 0x79, 0x8a, 0x3f, 0x00, 0x00, 0x00, 0xf4, 0x11, 0x85, 0x06, 0x39, 0x08, 0x7d, 0x00, 0x00, 0x18, 0xb7, 0x10, 0x81, 0x03, 0x29, 0x12, 0xcb, 0x00, 0x7e, 0x30, 0x28, 0x00, 0x85, 0x03, 0x29, 0x10, 0xbe, 0x81, 0xff, 0x27, 0x0c, 0x10, 0x85, 0x03, 0x29, 0x32, 0xfa, 0xc1, 0xff, 0x27, 0x94, 0x11, 0x85, 0x03, 0x28, 0x20, 0x6c, 0xe1, 0xff, 0x07, 0x0c, 0x01, 0x85, 0x01, 0x28, 0x62, 0x5c, 0xe3, 0x8f, 0x03, 0x4e, 0x91, 0x80, 0x05, 0x39, 0x40, 0xf4, 0xc2, 0xff, 0x00, 0x9f, 0x91, 0x84, 0x05, 0x31, 0xc6, 0xe8, 0x07, 0x7f, 0x80, 0xcd, 0x00, 0xc4, 0x04, 0x31, 0x06, 0xc9, 0x0e, 0x00, 0xc0, 0x48, 0x88, 0xe0, 0x04, 0x79, 0x04, 0xdb, 0x12, 0x00, 0x30, 0x0c, 0xc8, 0xe4, 0x04, 0x6d, 0x06, 0xb6, 0x23, 0x00, 0x18, 0x1c, 0xc0, 0x84, 0x06, 0x25, 0x0c, 0xff, 0xc2, 0x00, 0x4e, 0x06, 0xb0, 0x80, 0x04, 0x3f, 0x8a, 0xb3, 0x83, 0xff, 0xc3, 0x03, 0x91, 0x84, 0x04, 0x2e, 0xd8, 0x0f, 0x3f, 0x00, 0x00, 0x5f, 0x83, 0x84, 0x04, 0x2a, 0x70, 0xfd, 0x7f, 0x00, 0x00, 0xc8, 0xc0, 0x84, 0x04, 0x4b, 0xe2, 0x2f, 0x01, 0x00, 0x08, 0x58, 0x60, 0x80, 0x05, 0x5b, 0x82, 0xff, 0x01, 0x00, 0x08, 0xd0, 0xa0, 0x84, 0x04, 0x72, 0x80, 0xe5, 0x00, 0x00, 0x28, 0xd2, 0x20, 0x44, 0x04, 0xca, 0x02, 0xff, 0x00, 0x00, 0x08, 0xde, 0xa0, 0x44, 0x04, 0x82, 0x02, 0x6d, 0x00, 0x00, 0x08, 0xf6, 0xb0, 0x40, 0x02, 0x82, 0x07, 0x3f, 0x00, 0x00, 0x08, 0x44, 0x58, 0xc4, 0x02, 0x93, 0x3f, 0x1f, 0x00, 0x00, 0x30, 0x88, 0x4f, 0x44, 0x03, 0x83, 0x23, 0x3e, 0x00, 0x00, 0x00, 0x18, 0x60, 0xe0, 0x07, 0xe3, 0x0f, 0xfe, 0x00, 0x00, 0x00, 0x70, 0x70, 0xe4, 0x07, 0xc7, 0x1b, 0xfe, 0x01, 0x00, 0x40, 0xe0, 0x3c, 0xe4, 0x07, 0xc7, 0xe3, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0x1f, 0xfc, 0x07, 0xc7, 0x03, 0xf8, 0x33, 0x00, 0xc0, 0xf0, 0x07, 0xff, 0x07, 0x87, 0x02, 0xfc, 0x43, 0x00, 0x60, 0xf0, 0xff, 0xff, 0x07, 0x8f, 0x06, 0xbe, 0x87, 0x00, 0x30, 0xf8, 0xff, 0xff, 0x07, 0x8f, 0x14, 0x9c, 0x8f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x9f, 0x8d, 0x8a, 0x0f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x07, 0xbf, 0x0b, 0x80, 0x1f, 0x00, 0x40, 0xff, 0xff, 0xff, 0x07, 0x7f, 0x3a, 0x80, 0x3f, 0x00, 0x80, 0xff, 0xff, 0xff, 0x07, 0xff, 0x20, 0xc0, 0x3f, 0x00, 0x80, 0xff, 0xff, 0xff, 0x07, 0xff, 0x01, 0xe0, 0x7f, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x07, 0xff, 0x0f, 0xf8, 0xff, 0x40, 0xe0, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x40, 0xf0, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x41, 0xf0, 0xff, 0xff, 0xff, 0x07}; smtalk43/stdwin/Appls/bed/bed.c1006440003270021170000001240305465303016013512 037777777777 1 0 #include #include #include "bed.h" #include "menu.h" #define MINSQRSIZE 5 #define MAXSQRSIZE 15 MENU *pfmenu ; MENU *pmmenu ; MENU *popmenu ; int sqrsize ; int map_width = DEF_COLS ; int map_height = DEF_ROWS ; char *raster = NULL ; int raster_lenght ; int stride ; int lastbyte ; char bits[] = { 0xFF, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F } ; char *title = NULL ; char *fname = NULL ; WINDOW *win ; bool changed = FALSE ; bool text_only = FALSE ; extern bool drawline ; extern bool drawcircle ; extern bool selrect ; extern int sr_left ; extern int sr_top ; extern int sr_right ; extern int sr_bottom ; extern void invertbit () ; void drawproc (win, left, top, right, bottom) WINDOW *win ; int left ; int top ; int right ; int bottom ; { int row ; register int col ; register int l ; register int r ; int t ; int b ; int rend ; int fcol, fbyte, fbit, flr ; if (left < 0) left = 0 ; if (right > map_width * sqrsize) right = map_width * sqrsize ; if (top < 0) top = 0 ; if (bottom > map_height * sqrsize ) bottom = map_height * sqrsize ; rend = (right+sqrsize-1) / sqrsize ; fcol = left / sqrsize ; flr = fcol * sqrsize ; fbyte = fcol / 8 ; fbit = fcol % 8 ; for (row = top / sqrsize, t = row * sqrsize, b = t + sqrsize ; t < bottom ; ++row, t += sqrsize, b = t + sqrsize) { register char *byte ; register int pbit ; col = fcol ; l = r = flr ; byte = raster + (row * stride) + fbyte ; pbit = fbit ; while (col++ < rend) { if (*byte & (1 << pbit)) { r += sqrsize ; } else { if (l < r) { wpaint(l, t, r, b); l = r ; } l += sqrsize ; r = l ; } if (++pbit >= 8) { pbit = 0 ; ++byte ; } } if (l < r) wpaint (l, t, r, b) ; } if (drawline) plotline (invertbit, TRUE) ; else if (drawcircle) plotline (invertbit, TRUE) ; else if (selrect) wxorrect (sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; } void newraster () { int i ; if (raster != NULL) { free (raster) ; raster = NULL ; } lastbyte = map_width % 8 ; stride = (map_width + 7) / 8 ; raster_lenght = stride * map_height ; raster = (char *) malloc (raster_lenght) ; if (raster == NULL) { wdone () ; fprintf (stderr, "cannot get enough memory\n") ; exit (1) ; } for (i = 0 ; i < raster_lenght ; ++i) raster[i] = 0 ; } void setsqrsize () { if (wlineheight () == 1) text_only = sqrsize = 1 ; else { sqrsize = 1 ; /* int width ; int height ; int swidth ; int sheight ; wgetscrsize (&width, &height) ; swidth = (2 * width) / (3 * map_width) ; sheight = (2 * height) / (3 * map_height) ; sqrsize = swidth < sheight ? swidth : sheight ; if (sqrsize < MINSQRSIZE) sqrsize = MINSQRSIZE ; else if (sqrsize > MAXSQRSIZE) sqrsize = MAXSQRSIZE ; */ } } void setup() { int i ; setsqrsize () ; wsetdefwinsize (map_width * sqrsize, map_height * sqrsize) ; win = wopen (title == NULL ? "Untitled" : title, drawproc) ; if (win == NULL) { wmessage ("Can't open window") ; return ; } wsetdocsize (win, map_width * sqrsize, map_height * sqrsize) ; pfmenu = wmenucreate(FILE_MENU, "File"); wmenuadditem (pfmenu, "Open", 'O') ; wmenuadditem (pfmenu, "New", 'N') ; wmenuadditem (pfmenu, "", -1) ; wmenuadditem (pfmenu, "Save", 'S') ; wmenuadditem (pfmenu, "Save As ...", -1) ; wmenuadditem (pfmenu, "", -1) ; wmenuadditem (pfmenu, "Quit", 'Q') ; pmmenu = wmenucreate (MODE_MENU, "Mode") ; wmenuadditem (pmmenu, "Pencil", -1) ; wmenuadditem (pmmenu, "Line", -1) ; wmenuadditem (pmmenu, "Circle", -1) ; wmenuadditem (pmmenu, "Select", -1) ; popmenu = wmenucreate(OP_MENU, "Operations") ; wmenuadditem (popmenu, "Clear bits", -1) ; wmenuadditem (popmenu, "Set bits", -1) ; wmenuadditem (popmenu, "Invert bits", -1) ; wmenuadditem (popmenu, "", -1) ; wmenuadditem (popmenu, "Transpose major", -1) ; wmenuadditem (popmenu, "Transpose minor", -1) ; wmenuadditem (popmenu, "Rotate left", -1) ; wmenuadditem (popmenu, "Rotate right", -1) ; wmenuadditem (popmenu, "Flip horizontal", -1) ; wmenuadditem (popmenu, "Flip vertical", -1) ; wmenuadditem (popmenu, "Zoom in", '+') ; wmenuadditem (popmenu, "Zoom out", '-') ; wmenucheck (pmmenu, PENCIL_ITEM, TRUE) ; for (i = TRANS_MAJ_ITEM ; i <= FLIP_VERT_ITEM ; i++) wmenuenable (popmenu, i, FALSE) ; } void mainloop () { for (;;) { EVENT e ; wgetevent (&e) ; switch (e.type) { case WE_MOUSE_DOWN : case WE_MOUSE_MOVE : case WE_MOUSE_UP : do_mouse (&e) ; break; case WE_COMMAND : switch (e.u.command) { case WC_CLOSE : if (do_quit ()) return ; break ; case WC_CANCEL : return ; } break ; case WE_CLOSE : if (do_quit ()) return ; break ; case WE_MENU : switch (e.u.m.id) { case FILE_MENU : if (do_file_menu (&e)) return ; break ; case MODE_MENU : do_mode_menu (&e) ; break ; case OP_MENU : do_op_menu (&e) ; break ; } break ; } } } main (argc, argv) int argc ; char *argv[] ; { extern char *strip () ; winitargs (&argc, &argv) ; if (argc > 1) { fname = strdup (argv[1]) ; title = strip (fname) ; if (!readbitmap ()) { free (fname) ; fname = title = NULL ; newraster () ; } } else newraster () ; setup () ; mainloop () ; wdone () ; exit (0) ; } smtalk43/stdwin/Appls/bed/bed.h1006440003270021170000000012005434024273013511 037777777777 1 0 #include "stdwin.h" #include "tools.h" #define DEF_ROWS 48 #define DEF_COLS 48 smtalk43/stdwin/Appls/bed/file.c1006440003270021170000000561105465303016013702 037777777777 1 0 #include #include "bed.h" extern char *rindex () ; extern int sqrsize ; extern int map_width ; extern int map_height ; extern char *raster ; extern int raster_lenght ; extern int stride ; extern char *fname ; extern char *title ; extern WINDOW *win ; extern bool changed ; char *strip (fname) char *fname ; { char *p ; if ((p = rindex (fname, '/')) == NULL && /* UNIX */ (p = rindex (fname, '\\')) == NULL && /* GEMDOS & MSDOS */ (p = rindex (fname, ':')) == NULL) return (fname) ; return (p + 1) ; } bool input(fp) FILE *fp; { int value ; char ibuf[81] ; char *id ; char *p ; char *type ; int i ; for (;;) { if (fgets (ibuf, 81, fp) == NULL) /* ** EOF */ break ; if (strlen (ibuf) == 80) { /* ** Line too long, not a bitmap file */ fclose (fp) ; return (FALSE) ; } if (strncmp (ibuf, "#define ", 8) == 0) { id = ibuf + 8 ; if ((type = rindex (id, '_')) == NULL) type = id ; else type++ ; if (!strncmp (type, "width", 5)) { map_width = atoi (type + 5) ; } if (!strncmp (type, "height", 6)) { map_height = atoi (type + 6) ; } continue ; } if (strncmp (ibuf, "static unsigned char ", 21) == 0) id = ibuf + 21 ; else if (strncmp (ibuf, "static char ", 12) == 0) id = ibuf + 12 ; else continue ; if ((type = rindex (id, '_')) == NULL) type = id ; else type++ ; if (strncmp (type, "bits[]", 6) != 0) continue ; newraster () ; for (i = 0, p = raster ; i < raster_lenght ; ++i, ++p) { if (fscanf (fp, " 0x%2x%*[,}]%*[ \n]", &value) != 1) { free (raster) ; raster = NULL ; fclose (fp) ; return (FALSE) ; } *p = value ; } } fclose (fp) ; return (TRUE) ; } bool readbitmap () { FILE *fp ; char namebuf[256] ; if (fname == NULL) { namebuf[0] = 0 ; if (!waskfile ("Read file", namebuf, sizeof (namebuf), FALSE)) return (FALSE) ; fname = strdup (namebuf) ; title = strip (fname) ; wsettitle (win, title) ; } fp = fopen (fname, "r") ; if (fp == NULL) { perror(fname); return (FALSE) ; } return (input(fp)) ; } void output(fp) FILE *fp ; { int i ; fprintf (fp, "#define %s_width\t%d\n", title, map_width) ; fprintf (fp, "#define %s_height\t%d\n", title, map_height) ; fprintf (fp, "static char %s_bits[] {\n 0x%02x", title, raster[0] & 0xFF) ; for (i = 1 ; i < raster_lenght ; ++i) { fprintf (fp, i % 12 ? ", " : ",\n ") ; fprintf (fp, "0x%02x", raster[i] & 0xFF) ; } fprintf (fp, "};\n") ; } bool writebitmap() { FILE *fp; char namebuf[256]; namebuf[0] = '\0' ; if (fname == NULL) { if (!waskfile ("Save as", namebuf, sizeof (namebuf), TRUE)) return (FALSE) ; fname = strdup (namebuf) ; title = strip (namebuf) ; wsettitle (win, title) ; } fp = fopen (fname, "w") ; if (fp == NULL) { wperror (fname) ; return (FALSE) ; } output (fp) ; fclose (fp) ; return (TRUE) ; } smtalk43/stdwin/Appls/bed/fmenu.c1006440003270021170000000533505465303016014100 037777777777 1 0 #include #include "bed.h" #include "menu.h" extern char *strip () ; extern int sqrsize ; extern int map_width ; extern int map_height ; extern char *fname ; extern char *title ; extern WINDOW *win ; extern char *raster ; extern bool changed ; void do_open_file () { if (changed) { switch (waskync ("Save changes ?", 1)) { case 1: if (!writebitmap ()) return ; break ; case -1 : return ; } changed = FALSE ; } if (fname != NULL) { free (fname) ; fname = title = NULL ; } if (!readbitmap ()) { if (fname != NULL) { free (fname) ; fname = title = NULL ; wsettitle (win, "Untitled") ; } newraster () ; } } void do_new_map () { char str[20] ; if (changed) { switch (waskync ("Save changes ?", 1)) { case 1 : if (!writebitmap ()) return ; break ; case -1 : return ; } changed = FALSE ; } if (fname != NULL) { free (fname) ; fname = title = NULL ; wsettitle (win, "Untitled") ; } *str = 0 ; if (waskstr ("Enter width of new raster", str, 20)) { while ((map_width = atoi (str)) <= 0) { *str = 0 ; if (!waskstr ("Please enter a number greater 0", str, 20)) { map_width = -1 ; break ; } } if (waskstr ("Enter height of new raster", str, 20)) { while ((map_height = atoi (str)) <= 0) { *str = 0 ; if (!waskstr ("Please enter a number greater 0", str, 20)) break ; } } else map_width = -1 ; } if (map_width == -1) { map_width = DEF_COLS ; map_height = DEF_ROWS ; } newraster () ; } bool do_quit () { if (changed) { switch (waskync ("Save changes ?", 1)) { case 1 : if (!writebitmap ()) return (FALSE) ; break ; case -1 : return (FALSE) ; } changed = FALSE ; } wclose (win) ; free (raster) ; raster = NULL ; return (TRUE) ; } bool do_file_menu (ep) EVENT *ep ; { switch (ep->u.m.item) { case OPEN_ITEM: do_open_file () ; setsqrsize () ; wchange (win, 0, 0, map_width * sqrsize, map_height * sqrsize) ; wsetdocsize (win, map_width * sqrsize, map_height * sqrsize) ; break ; case NEW_ITEM: do_new_map () ; setsqrsize () ; wchange (win, 0, 0, map_width * sqrsize, map_height * sqrsize) ; wsetdocsize (win, map_width * sqrsize, map_height * sqrsize) ; break ; case SAVE_ITEM: if (changed) { if (writebitmap ()) changed = FALSE ; } break ; case SAVE_AS_ITEM: { char namebuf[256] ; strcpy (namebuf, fname) ; if (waskstr ("Save as ?", namebuf, 256, FALSE)) { char *savedname = fname ; fname = strdup (namebuf) ; title = strip (fname) ; (void) writebitmap () ; free (fname) ; fname = savedname ; title = strip (fname) ; } break ; } case QUIT_ITEM: return (do_quit ()) ; } return (FALSE) ; } smtalk43/stdwin/Appls/bed/menu.h1006440003270021170000000101005434024274013723 037777777777 1 0 #define FILE_MENU 1 #define OPEN_ITEM 0 #define NEW_ITEM 1 #define SAVE_ITEM 3 #define SAVE_AS_ITEM 4 #define QUIT_ITEM 6 #define MODE_MENU 2 #define PENCIL_ITEM 0 #define LINE_ITEM 1 #define CIRCLE_ITEM 2 #define SELECT_ITEM 3 #define OP_MENU 3 #define CLEAR_ITEM 0 #define SET_ITEM 1 #define INVERT_ITEM 2 #define TRANS_MAJ_ITEM 4 #define TRANS_MIN_ITEM 5 #define ROT_LEFT_ITEM 6 #define ROT_RIGHT_ITEM 7 #define FLIP_HOR_ITEM 8 #define FLIP_VERT_ITEM 9 #define ZOOM_IN 10 #define ZOOM_OUT 11 #define NOPS 11 smtalk43/stdwin/Appls/bed/mmenu.c1006440003270021170000000362205465303016014104 037777777777 1 0 #include "bed.h" #include "menu.h" int state = PENCIL_ITEM ; extern MENU *pmmenu ; extern MENU *popmenu ; extern bool drawline ; extern bool drawcircle ; extern bool selrect ; extern int sr_left ; extern int sr_top ; extern int sr_right ; extern int sr_bottom ; extern void invertbit () ; void do_mode_menu (ep) EVENT *ep ; { int i ; switch (ep->u.m.item) { case PENCIL_ITEM : if (drawline) { plotline (invertbit, FALSE) ; drawline = FALSE ; } else if (drawcircle) { plotcircle (invertbit, FALSE) ; drawcircle = FALSE ; } else if (selrect) { drawselrect (sr_left, sr_top, sr_right, sr_bottom) ; selrect = FALSE ; } wmenucheck (pmmenu, state, FALSE) ; wmenucheck (pmmenu, PENCIL_ITEM, TRUE) ; state = PENCIL_ITEM ; break ; case LINE_ITEM : if (drawcircle) { plotcircle (invertbit, FALSE) ; drawcircle = FALSE ; } else if (selrect) { drawselrect (sr_left, sr_top, sr_right, sr_bottom) ; selrect = FALSE ; } wmenucheck (pmmenu, state, FALSE) ; wmenucheck (pmmenu, LINE_ITEM, TRUE) ; state = LINE_ITEM ; break ; case CIRCLE_ITEM : if (drawline) { plotline (invertbit, FALSE) ; drawline = FALSE ; } else if (selrect) { drawselrect (sr_left, sr_top, sr_right, sr_bottom) ; selrect = FALSE ; } wmenucheck (pmmenu, state, FALSE) ; wmenucheck (pmmenu, CIRCLE_ITEM, TRUE) ; state = CIRCLE_ITEM ; break ; case SELECT_ITEM : if (drawline) { plotline (invertbit, FALSE) ; drawline = FALSE ; } else if (drawcircle) { plotcircle (invertbit, FALSE) ; drawcircle = FALSE ; } wmenucheck (pmmenu, state, FALSE) ; wmenucheck (pmmenu, SELECT_ITEM, TRUE) ; state = SELECT_ITEM ; break ; } if (state == SELECT_ITEM) { for (i = TRANS_MAJ_ITEM ; i <= FLIP_VERT_ITEM ; ++i) wmenuenable (popmenu, i, TRUE) ; } else { for (i = TRANS_MAJ_ITEM ; i <= FLIP_VERT_ITEM ; ++i) wmenuenable (popmenu, i, FALSE) ; } } smtalk43/stdwin/Appls/bed/mouse.c1006440003270021170000001711005465303016014110 037777777777 1 0 #include "bed.h" #include "menu.h" #ifndef ABS #define ABS(var) ((var) >= 0 ? (var) : -(var)) #endif extern int sqrsize ; extern int map_width ; extern int map_height ; extern char *raster ; extern int raster_lenght ; extern int stride ; extern WINDOW *win ; extern bool changed ; extern int state ; bool drawline = FALSE ; int beg_h ; int beg_v ; int end_h ; int end_v ; bool drawcircle = FALSE ; int cent_h ; int cent_v ; int c_dh ; int c_dv ; bool selrect = FALSE ; int sr_left ; int sr_top ; int sr_right ; int sr_bottom ; void wxorrect (left, top, right, bottom) int left ; int top ; int right ; int bottom ; { wxorline (left, top, right - 1, top) ; wxorline (right - 1, top, right -1, bottom - 1) ; wxorline (left, bottom - 1, right -1, bottom - 1) ; wxorline (left, top, left, bottom - 1) ; if (right - left <= bottom - top) { wxorline (left, top, right - 1, top + (right - left) - 1) ; wxorline (right - 1, top, left, top + (right - left) - 1) ; } else { wxorline (left, top, left + (bottom - top) - 1, bottom - 1) ; wxorline (right - 1, top, right - (bottom - top) - 1, bottom -1) ; } } void drawselrect () { int l = sr_left * sqrsize ; int t = sr_top * sqrsize ; int r = sr_right * sqrsize ; int b = sr_bottom * sqrsize ; wbegindrawing (win) ; wxorrect (l, t, r, b) ; wenddrawing (win) ; } int getbit(col, row) { char *byte ; int rc ; if (row >= 0 && row < map_height && col >= 0 && col < map_width) { byte = raster + (row * stride) + (col / 8) ; rc = (*byte & (1 << (col % 8))) ? 1 : 0 ; } else rc = 0 ; return (rc) ; } void setbit(col, row, value) { char *byte ; if (row >= 0 && row < map_height && col >= 0 && col < map_width) { changed = 1 ; byte = raster + (row * stride) + (col / 8) ; *byte = (*byte & ~(1 << (col %8))) | (value << (col % 8)) ; wchange (win, col * sqrsize, row * sqrsize, (col+1) * sqrsize, (row+1) * sqrsize); } } void do_pencil (ep) EVENT *ep ; { static int value ; if (ep->type == WE_MOUSE_DOWN) value = !getbit (ep->u.where.h / sqrsize, ep->u.where.v / sqrsize) ; setbit (ep->u.where.h / sqrsize, ep->u.where.v / sqrsize, value) ; } void invertbit (h, v, value) int h ; int v ; bool value ; { if (h < 0 || v < 0 || h >= map_width || v >= map_height) return ; winvert (h * sqrsize, v * sqrsize, (h + 1) * sqrsize, (v + 1) * sqrsize) ; } void plotline (fp, value) void (*fp) () ; bool value ; { int d_h = end_h - beg_h ; int d_v = end_v - beg_v ; int e ; int h = 0 ; int v = 0 ; int hsign = 1 ; int vsign = 1 ; int i ; if (d_h < 0) { d_h = -d_h ; hsign = -1 ; } if (d_v < 0) { d_v = -d_v ; vsign = -1 ; } wbegindrawing (win) ; if (d_v <= d_h) { for (i = 0, e = 2 * d_v - d_h ; i <= d_h ; ++i) { (*fp) (beg_h + (hsign * h), beg_v + (vsign * v), value) ; if (e > 0) { ++v ; e -= (2 * d_h) ; } e += (2 * d_v) ; ++h ; } } else { for (i = 0, e = 2 * d_h - d_v ; i <= d_v ; ++i) { (*fp) (beg_h + (hsign * h), beg_v + (vsign * v), value) ; if (e > 0) { ++h ; e -= (2 * d_v) ; } e += (2 * d_h) ; ++v ; } } wenddrawing (win) ; } void plotcircle (fp, value) void (*fp) () ; bool value ; { long h_sqr = c_dh * c_dh ; long v_sqr = c_dv * c_dv ; long r_sqr = h_sqr * v_sqr ; long prev_r = r_sqr ; long min_h ; long min_v ; long min_hv ; int h = c_dh ; int v = 0 ; wbegindrawing (win) ; while (h >= 0 && v <= c_dv) { (*fp) (cent_h + h, cent_v + v, value) ; if (v) (*fp) (cent_h + h, cent_v - v, value) ; if (h) (*fp) (cent_h - h, cent_v + v, value) ; if (h && v) (*fp) (cent_h - h, cent_v - v, value) ; min_h = (long) (2 * h - 1) * v_sqr ; min_v = (long) (2 * v + 1) * -h_sqr ; min_hv = min_h + min_v ; if (ABS (r_sqr - (prev_r - min_h)) <= ABS (r_sqr - (prev_r - min_v))) { if (ABS (r_sqr - (prev_r - min_hv)) <= ABS (r_sqr - (prev_r - min_h))) { prev_r = prev_r - min_hv ; --h ; ++v ; } else { prev_r = prev_r - min_h ; --h ; } } else { if (ABS (r_sqr - (prev_r - min_hv)) <= ABS (r_sqr - (prev_r - min_v))) { prev_r = prev_r - min_hv ; --h ; ++v ; } else { prev_r = prev_r - min_v ; ++v ; } } } wenddrawing (win) ; } void do_line (ep) EVENT *ep ; { int curr_h = ep->u.where.h / sqrsize ; int curr_v = ep->u.where.v / sqrsize ; if (curr_h > map_height - 1) curr_h = map_height - 1 ; if (curr_v > map_width - 1) curr_v = map_width - 1 ; switch (ep->type) { case WE_MOUSE_DOWN : if (drawline) { plotline (invertbit, FALSE) ; drawline = FALSE ; } drawline = TRUE ; beg_h = end_h = curr_h ; beg_v = end_v = curr_v ; plotline (invertbit, TRUE) ; break ; case WE_MOUSE_MOVE : if (drawline) { if (curr_h == end_h && curr_v == end_v) return ; plotline (invertbit, FALSE) ; end_h = curr_h ; end_v = curr_v ; plotline (invertbit, TRUE) ; } break ; case WE_MOUSE_UP : if (drawline) { if (curr_h != end_h || curr_v != end_v) { plotline (invertbit, FALSE) ; end_h = curr_h ; end_v = curr_v ; plotline (invertbit, TRUE) ; } plotline (setbit, TRUE) ; drawline = FALSE ; } break ; } } void do_circle (ep) EVENT *ep ; { int curr_h = ep->u.where.h / sqrsize ; int curr_v = ep->u.where.v / sqrsize ; if (curr_h > map_height - 1) curr_h = map_height - 1 ; if (curr_v > map_width - 1) curr_v = map_width - 1 ; switch (ep->type) { case WE_MOUSE_DOWN : if (drawcircle) { plotcircle (invertbit, FALSE) ; drawcircle = FALSE ; } drawcircle = TRUE ; cent_h = curr_h ; cent_v = curr_v ; c_dh = c_dv = 0 ; plotcircle (invertbit, TRUE) ; break ; case WE_MOUSE_MOVE : if (drawcircle) { if (ABS ((curr_h - cent_h) + 1) == c_dh && ABS ((curr_v - cent_v) + 1) == c_dv) return ; plotcircle (invertbit, FALSE) ; c_dh = ABS (curr_h - cent_h) ; c_dv = ABS (curr_v - cent_v) ; plotcircle (invertbit, TRUE) ; } break ; case WE_MOUSE_UP : if (drawcircle) { if (ABS ((curr_h - cent_h) + 1) != c_dh || ABS ((curr_v - cent_v) + 1) != c_dv) { plotcircle (invertbit, FALSE) ; c_dh = ABS (curr_h - cent_h) ; c_dv = ABS (curr_v - cent_v) ; plotcircle (invertbit, TRUE) ; } plotcircle (setbit, TRUE) ; drawcircle = FALSE ; } break ; } } void do_select (ep) EVENT *ep ; { static int sr_h ; /* coord. of mouse down */ static int sr_v ; int curr_h = ep->u.where.h / sqrsize ; int curr_v = ep->u.where.v / sqrsize ; switch (ep->type) { case WE_MOUSE_DOWN : if (selrect) { drawselrect () ; selrect = FALSE ; } if (curr_h >= map_width || curr_v >= map_height) return ; selrect = TRUE ; sr_h = curr_h ; sr_v = curr_v ; sr_left = curr_h ; sr_top = curr_v ; sr_right = sr_left + 1 ; sr_bottom = sr_top + 1 ; drawselrect () ; break ; case WE_MOUSE_MOVE : if (selrect) { if (curr_h >= map_width) curr_h = map_width - 1 ; if (curr_v >= map_height) curr_v = map_height - 1 ; if (curr_h < 0) curr_h = 0 ; if (curr_v < 0) curr_v = 0 ; drawselrect () ; if (curr_h < sr_h) { sr_left = curr_h ; sr_right = sr_h + 1 ; } else { sr_left = sr_h ; sr_right = curr_h + 1 ; } if (curr_v < sr_v) { sr_top = curr_v ; sr_bottom = sr_v + 1 ; } else { sr_top = sr_v ; sr_bottom = curr_v + 1 ; } drawselrect () ; } break ; case WE_MOUSE_UP : break ; } } void do_mouse (ep) EVENT *ep ; { switch (state) { case PENCIL_ITEM : do_pencil (ep) ; break ; case LINE_ITEM : do_line (ep) ; break ; case CIRCLE_ITEM : do_circle (ep) ; break ; case SELECT_ITEM : do_select (ep) ; break ; } } 0407550003270021170000000000005477556060011270 5 0 1 0 smtalk43/stdwin/Appls/bed/opmenu.c1006440003270021170000001654105465303016014272 037777777777 1 0 #include "bed.h" #include "menu.h" extern int sqrsize ; extern int map_width ; extern int map_height ; extern char *raster ; extern int raster_lenght ; extern int stride ; static int bits[] = { 0xFF, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F } ; extern int lastbyte ; extern WINDOW *win ; extern bool changed ; extern bool selrect ; extern int sr_left ; extern int sr_top ; extern int sr_right ; extern int sr_bottom ; /* Data manipulation routines */ void clear_bits() { register int row ; if (!selrect) { sr_left = sr_top = 0 ; sr_right = map_width ; sr_bottom = map_height ; } for (row = sr_top ; row < sr_bottom ; ++row) { register int col = sr_left ; register char *byte = raster + (row * stride) + (col / 8) ; register int pbit = col % 8 ; while (col++ < sr_right) { *byte &= ~(1 << pbit) ; if (++pbit >= 8) { pbit = 0 ; ++byte ; } } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } void set_bits() { register int row ; if (!selrect) { sr_left = sr_top = 0 ; sr_right = map_width ; sr_bottom = map_height ; } for (row = sr_top ; row < sr_bottom ; ++row) { register int col = sr_left ; register char *byte = raster + (row * stride) + (col / 8) ; register int pbit = col % 8 ; while (col++ < sr_right) { *byte |= (1 << pbit) ; if (++pbit >= 8) { pbit = 0 ; ++byte ; } } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } void invert_bits() { register int row ; if (!selrect) { sr_left = sr_top = 0 ; sr_right = map_width ; sr_bottom = map_height ; } for (row = sr_top ; row < sr_bottom ; ++row) { register int col = sr_left ; register char *byte = raster + (row * stride) + (col / 8) ; register int pbit = col % 8 ; while (col++ < sr_right) { *byte ^= (1 << pbit) ; if (++pbit >= 8) { pbit = 0 ; ++byte ; } } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } int transpose_major() { int i ; int j ; int tmp ; if (selrect) { if (sr_right - sr_left != sr_bottom - sr_top) { wfleep () ; wmessage ("You can only transpose a square") ; return ; } for (i = 0 ; i < sr_bottom - sr_top ; ++i) { for (j = 0 ; j < i ; ++j) { int row = i + sr_top ; int col = j + sr_left ; tmp = getbit (col, row) ; setbit (col, row, getbit (i + sr_left, j + sr_top)) ; setbit (i + sr_left, j + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } else wfleep () ; } void transpose_minor () { int size ; int i ; int j ; int tmp ; if (selrect) { if (sr_bottom - sr_top != sr_right - sr_left) { wfleep () ; wmessage ("You can only transpose a square") ; return ; } size = sr_bottom - sr_top ; for (i = 0 ; i < size ; ++i) { for (j = 0 ; j < size - 1 - i ; ++j) { tmp = getbit (j + sr_left, i + sr_top) ; setbit (j + sr_left, i + sr_top, getbit (size - 1 - i + sr_left, size - 1 - j + sr_top)) ; setbit (size - 1 - i + sr_left, size - 1 - j + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } else wfleep () ; } int rotate_left() { int i ; int j ; int size ; int tmp ; if (selrect) { if (sr_bottom - sr_top != sr_right - sr_left) { wfleep () ; wmessage ("You can only rotate a square") ; return ; } size = sr_bottom - sr_top ; for (i = 0 ; i < size / 2 ; ++i) { for (j = 0 ; j < (size + 1) / 2 ; ++j) { tmp = getbit (j + sr_left, i + sr_top) ; setbit (j + sr_left, i + sr_top, getbit (size - 1 - i + sr_left, j + sr_top)) ; setbit (size - 1 - i + sr_left, j + sr_top, getbit (size - 1 - j + sr_left, size - 1 - i + sr_top)) ; setbit (size - 1 - j + sr_left, size - 1 - i + sr_top, getbit (i + sr_left, size - 1 - j + sr_top)) ; setbit (i + sr_left, size - 1 - j + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } else wfleep () ; } void rotate_right() { int i ; int j ; int size ; int tmp ; if (selrect) { if (sr_bottom - sr_top != sr_right - sr_left) { wfleep () ; wmessage ("You can only rotate a square") ; return ; } size = sr_bottom - sr_top ; for (i = 0 ; i < size / 2 ; ++i) { for (j = 0 ; j < (size + 1) / 2 ; ++j) { tmp = getbit (j + sr_left, i + sr_top) ; setbit (j + sr_left, i + sr_top, getbit (i + sr_left, size - 1 - j + sr_top)) ; setbit (i + sr_left, size - 1 - j + sr_top, getbit (size - 1 - j + sr_left, size - 1 - i + sr_top)) ; setbit (size - 1 - j + sr_left, size - 1 - i + sr_top, getbit (size - 1 - i + sr_left, j + sr_top)) ; setbit (size - 1 - i + sr_left, j + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } } void flip_horizontal() { int i ; int j ; int sr_width ; int sr_height ; int tmp ; if (selrect) { sr_width = sr_right - sr_left ; sr_height = sr_bottom - sr_top ; for (i = 0 ; i < sr_height ; ++ i) { for (j = 0 ; j < sr_width / 2 ; ++j) { tmp = getbit (j + sr_left, i + sr_top) ; setbit (j + sr_left, i + sr_top, getbit (sr_width - 1 - j + sr_left, i + sr_top)) ; setbit (sr_width - 1 - j + sr_left, i + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } else wfleep () ; } void flip_vertical() { int i ; int j ; int sr_width ; int sr_height ; int tmp ; if (selrect) { sr_width = sr_right - sr_left ; sr_height = sr_bottom - sr_top ; for (i = 0 ; i < sr_height / 2 ; ++i) { for (j = 0 ; j < sr_width ; ++j) { tmp = getbit (j + sr_left, i + sr_top) ; setbit (j + sr_left, i + sr_top, getbit (j + sr_left, sr_height - 1 - i + sr_top)) ; setbit (j + sr_left, sr_height - 1 - i + sr_top, tmp) ; } } wchange (win, sr_left * sqrsize, sr_top * sqrsize, sr_right * sqrsize, sr_bottom * sqrsize) ; changed = TRUE ; } else wfleep () ; } void zoom_in () { sqrsize *= 2 ; wsetdocsize (win, map_width * sqrsize, map_height * sqrsize) ; wchange (win, 0, 0, map_width * sqrsize, map_height * sqrsize) ; } void zoom_out () { int oss = sqrsize ; if (sqrsize == 1) wfleep () ; else { if ((sqrsize /= 2) < 1) sqrsize = 1 ; wsetdocsize (win, map_width * sqrsize, map_height * sqrsize) ; wchange (win, 0, 0, map_width * oss, map_height * oss) ; } } void do_op_menu (ep) EVENT *ep ; { switch (ep->u.m.item) { case CLEAR_ITEM : clear_bits () ; break ; case SET_ITEM : set_bits () ; break ; case INVERT_ITEM : invert_bits () ; break ; case TRANS_MAJ_ITEM : transpose_major () ; break ; case TRANS_MIN_ITEM : transpose_minor () ; break ; case ROT_LEFT_ITEM : rotate_left () ; break ; case ROT_RIGHT_ITEM : rotate_right () ; break ; case FLIP_HOR_ITEM : flip_horizontal () ; break ; case FLIP_VERT_ITEM : flip_vertical () ; break ; case ZOOM_IN : zoom_in () ; break ; case ZOOM_OUT : zoom_out () ; break ; } } smtalk43/stdwin/Appls/dpv/0407550003270021170000000000005477556050012060 5 0 1 0 smtalk43/stdwin/Appls/dpv/Make.proto1006440003270021170000000054505434024275014624 037777777777 1 0 # # Makefile prototype for dpv application # DPV= $(APPLS)/dpv SRCS= \ $(DPV)/dpv.c \ $(DPV)/dpvcontrol.c \ $(DPV)/dpvfonts.c \ $(DPV)/dpvfunny.c \ $(DPV)/dpvmachine.c \ $(DPV)/dpvoutput.c \ $(DPV)/dpvparse.c \ $(DPV)/dpvrestart.c SRCLIBS= -lm all: dpv choose _bootstrap: @putprogmf dpv $(SRCS) @putprogmf choose $(DPV)/choose.c 0x60, 0x21, 0x00, 0x61, 0x1b, 0xc1, 0x63, 0x08, 0xf0, 0xc6, 0xc7, 0x21, 0x03, 0xf8, 0x08, 0xe1, 0xcf, 0x0a, 0xfc, 0x4d, 0x99, 0x43, 0x07, 0x3c, 0x0c,smtalk43/stdwin/Appls/dpv/README1006440003270021170000000442305434024275013541 037777777777 1 0 Name: dpv -- Ditroff previewer using STDWIN Author: Guido van Rossum Started: Jan 12 1988 Ditroff output describes pages to be typeset (see comments in the source for a description). Pages are started by 'p' commands. Each page is a contiguous segment of the file, but operations within a page can contain arbitrary vertical movements. I have made the decision not to display the entire file as one document, since this would limit us to approx. 32 pages (given a practical limit on STDWIN documents of 32K pixels, and an average screen height of 1K pixels). To allow reasonably efficient displaying, we need to remember the file offsets where each page starts in the input, and the state of the ditroff engine at the start of the page (font etc.). Thus, we must make a pre-scan of the input to compute this info; after that, the draw procedure only needs to read the particular page being displayed. (Note that it would be easy enough to change the interface so that all pages are mapped to a single document.) As an optimization, we actually don't pre-scan the entire file when the program starts up; rather, when a page is first displayed the pre-scan information is computed as a by-product of the displaying process. There are two page numbering schemes: internally, the pages are always numbered 0, 1, ..., with 0 being the configuration data (everything that comes before the first 'p' command). Externally, page numbers are taken from the argument to the 'p' command. State to remember for each page start: - mounted fonts ('x f' command) - character height and slant ('x H' and 'x S' commands) (not used?) - current font and size The following state, although it can be reset using 'x' commands, is assumed to be set once and for all on page 0: - device name ('x T' command) - resolution ('x r' command) Formally, one should also remember the stack of state records manipulated by '{' and '}' commands; I assume these are used only by pictures, and the stack is empty at page boundaries. TO DO: Print special chars as what they should look like, instead of as their ditroff names. Use real troff fonts. This requires a translation between ASCII codes output by ditroff and character codes in the font. Perhaps the fonts should be stored different, so that for ASCII at least no mapping is necessary. 00, 0x70, 0x70, 0xe4, 0x07, 0xc7, 0x1b, 0xfe, 0x01, 0x00, 0x40, 0xe0, 0x3c, 0xe4, 0x07, 0xc7, 0xe3, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0x1f, 0xfc, 0x07, 0xc7, 0x03, 0xf8, 0x33, 0x00, 0xc0, 0xf0, 0x07, 0xff, 0x07, 0x87, 0x02, 0xfc, 0xsmtalk43/stdwin/Appls/dpv/To.do1006440003270021170000000041605434024275013565 037777777777 1 0 Incorporate Robbert's changes to arcs (see ../ndpv) Re-read the input (so user can rerun ditroff w/o need to restart dpv) Read the print menu from a file Add ditroff new names to funny char table Show external page numbers; use external page numbers in GOTO command smtalk43/stdwin/Appls/dpv/choose.c1006440003270021170000002121205465303016014275 037777777777 1 0 /* Application to choose ditroff special character names for glyphs in a given font. Usage: choose [-f glyphfont] [-s size] [-c columns] Mac defaults: -f Symbol -s 24 -c 8 X defaults: -f '*-symbol-*--24-*' -c 8 TO DO: - start with font choosing dialog on Mac - more object-like file interface (pretend we're editing a table object) - more syntax checking on input - check for duplicate names? */ #define CHARWIDTHBUG /* wcharwidth(i) == 0 for all i >= 128 */ #include #include /* Number of possible characters per font -- limited by char = 8 bit */ #define NGLYPHS 256 /* Table of names for each char -- 3rd is terminating zero */ char namelist[NGLYPHS][3]; /* Random global variables */ char *progname= "choose"; /* Program name for error messages */ WINDOW *win; /* Where it all happens */ int selected= -1; /* Glyph currently selected, -1 if none */ bool changed; /* Set if any changes made */ char *filename; /* Namelist file name */ /* Variables controlling the window lay-out */ char *glyphfont, *namefont; /* Fonts used for ditto */ int glyphsize, namesize; /* Point sizes used for glyph and name */ int firstglyph, lastglyph; /* First and last glyphs */ int ncols, nrows; /* Matrix dimensions */ int colwidth, rowheight; /* Cell dimensions */ /* Parse the command line */ parse(argc, argv) int argc; char **argv; { if (argc > 0 && argv[0] != NULL && argv[0][0] != EOS) { progname= rindex(argv[0], '/'); if (progname == NULL) progname= argv[0]; else progname++; } for (;;) { int c= getopt(argc, argv, "c:f:s:"); if (c == EOF) break; switch (c) { case 'c': ncols= atoi(optarg); break; case 'f': glyphfont= optarg; break; case 's': glyphsize= atoi(optarg); break; default: usage(); /*NOTREACHED*/ } } if (optind < argc) filename= argv[optind++]; if (optind < argc) usage(); } /* Print usage message and exit */ usage() { wdone(); fprintf(stderr, "usage: %s [-c columns] [-f font] [-s size]\n", progname); exit(2); } /* Initialize the control variables */ setup() { /* Fill in defaults */ if (ncols <= 0) ncols= 8; if (glyphfont == NULL || *glyphfont == EOS) { #ifdef macintosh glyphfont= "Symbol"; #else #ifdef X11R2 glyphfont= "symbol22"; #else glyphfont= "*-symbol-*--24-*"; #endif #endif } if (glyphsize <= 0) glyphsize= 24; if (namefont == NULL || *namefont == EOS) { #ifdef machintosh namefont= "Courier"; #else #ifdef X11R2 namefont= "courier12f"; #else namefont= "*-courier-*--12-*"; #endif #endif } if (namesize <= 0) namesize= 10; /* Find first and last existing character */ firstglyph= 0; lastglyph= NGLYPHS-1; wsetfont(glyphfont); wsetsize(glyphsize); while (firstglyph < lastglyph && wcharwidth(firstglyph) == 0) ++firstglyph; firstglyph= (firstglyph/ncols) * ncols; #ifndef CHARWIDTHBUG while (lastglyph > firstglyph && wcharwidth(lastglyph) == 0) --lastglyph; lastglyph= (lastglyph/ncols + 1) * ncols - 1; #endif /* Compute remaining variables */ nrows= (lastglyph - firstglyph + ncols) / ncols; colwidth= 2*wcharwidth('M'); rowheight= wlineheight(); wsetfont(namefont); wsetsize(namesize); rowheight += 4 + wlineheight(); { int cw= wtextwidth("MM MM", -1) + 4; if (colwidth < cw) colwidth= cw; } } /* Draw procedure */ void drawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { int i; /* Draw vertical grid lines */ for (i= 1; i < ncols; ++i) wdrawline(i*colwidth-1, 0, i*colwidth-1, nrows*rowheight); /* Draw horizontal grid lines */ for (i= 1; i < nrows; ++i) wdrawline(0, i*rowheight-1, ncols*colwidth, i*rowheight-1); /* Draw glyph cells */ for (i= firstglyph; i <= lastglyph; ++i) { int h, v, h2, v2; int glyphwidth; cellbounds(i, &h, &v, &h2, &v2); if (v >= bottom) break; if (!intersects(h, v, h2, v2, left, top, right, bottom)) continue; wsetfont(glyphfont); wsetsize(glyphsize); glyphwidth= wcharwidth(i); #ifndef CHARWIDTHBUG if (glyphwidth == 0) continue; #endif wdrawchar(h + (colwidth-glyphwidth) / 2, v+2, i); wsetfont(namefont); wsetsize(namesize); { char buf[10]; sprintf(buf, "%02X", i); wdrawtext(h+2, v2 - 2 - wlineheight(), buf, -1); } if (namelist[i][0] != EOS) { int namewidth; namewidth= wtextwidth(namelist[i], -1); wdrawtext(h + colwidth - namewidth - 2, v2 - 2 - wlineheight(), namelist[i], -1); } if (i == selected) winvert(h+1, v+1, h2-2, v2-2); } } /* Main program */ main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); parse(argc, argv); setup(); readnamelist(); wsetdefwinsize(colwidth*ncols, 0); win= wopen(glyphfont, drawproc); if (win == NULL) { wdone(); fprintf(stderr, "%s: can't create window\n", progname); } wsetdocsize(win, colwidth*ncols, rowheight*nrows); eventloop(); /*NOTREACHED*/ } /* Event loop. Never returns. */ eventloop() { for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: do_select(&e); break; case WE_CHAR: do_char(e.u.character); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: case WC_CANCEL: close_it: if (changed) { int ok; ok= waskync("Save changes?", 1); if (ok > 0) { if (!writenamelist()) ok= -1; } if (ok < 0) continue; } wclose(win); wdone(); exit(0); /*NOTREACHED*/ case WC_BACKSPACE: do_char('\b'); break; } break; case WE_CLOSE: goto close_it; } } /*NOTREACHED*/ } /* Handle mouse events */ do_select(ep) EVENT *ep; { int left, top, right, bottom; int col= ep->u.where.h / colwidth; int row= ep->u.where.v / rowheight; int i= firstglyph + col + ncols*row; wsetfont(glyphfont); wsetsize(glyphsize); if (ep->u.where.h < 0 || ep->u.where.v < 0 || col >= ncols || row >= nrows || i < firstglyph || i > lastglyph || wcharwidth(i) == 0) i= -1; if (i != selected) { wbegindrawing(win); if (selected >= 0) { cellbounds(selected, &left, &top, &right, &bottom); winvert(left+1, top+1, right-2, bottom-2); } selected= i; if (selected >= 0) { cellbounds(selected, &left, &top, &right, &bottom); winvert(left+1, top+1, right-2, bottom-2); } wenddrawing(win); } /* Must do this here because wshow may have no effect while the mouse is down. */ if (selected >= 0) { cellbounds(selected, &left, &top, &right, &bottom); wshow(win, left, top, right, bottom); } } /* Handle character events and backspace */ do_char(c) int c; { int n; int left, top, right, bottom; if (selected < 0) { wfleep(); return; } if (c == '\b') { n= 0; } else { n= strlen(namelist[selected]) % 2; namelist[selected][n++]= c; } namelist[selected][n]= EOS; wsetfont(namefont); wsetsize(namesize); cellbounds(selected, &left, &top, &right, &bottom); wshow(win, left, top, right, bottom); wchange(win, right - 3*wcharwidth('m'), bottom - 2 - wlineheight(), right-2, bottom-2); changed= TRUE; } /* Subroutine to find a glyph's cell */ cellbounds(i, pleft, ptop, pright, pbottom) int i; int *pleft, *ptop, *pright, *pbottom; { int row= (i - firstglyph) / ncols; int col= (i - firstglyph) % ncols; *pleft= col*colwidth; *pright= *pleft + colwidth; *ptop= row * rowheight; *pbottom= *ptop + rowheight; } /* Predicate for rectangle intersection */ bool intersects(l1, t1, r1, b1, l2, t2, r2, b2) { if (l1 >= r2 || r1 <= l2) return FALSE; if (t1 >= b2 || b1 <= t2) return FALSE; return TRUE; } /* Read the namelist */ bool readnamelist() { FILE *fp; char buf[256]; if (filename == NULL) { buf[0]= EOS; if (!waskfile("Read file:", buf, sizeof buf, FALSE)) return FALSE; filename= strdup(buf); } fp= fopen(filename, "r"); if (fp == NULL) { char buf[256]; sprintf(buf, "Can't read file %s", filename); wmessage(buf); return FALSE; } while (fgets(buf, sizeof buf, fp) != NULL) { int glyph; char name[256]; if (sscanf(buf, "%s - 0x%x", name, &glyph) == 2 || sscanf(buf, "%s 0x%x", name, &glyph) == 2) { if (glyph >= 0 && glyph < NGLYPHS) strncpy(namelist[glyph], name, 2); } } fclose(fp); } /* Write the namelist */ bool writenamelist() { char name[256]; FILE *fp; int i; if (filename == NULL) name[0]= EOS; else strcpy(name, filename); if (!waskfile("Write to file:", name, sizeof name, TRUE)) return FALSE; filename= strdup(name); fp= fopen(filename, "w"); if (fp == NULL) { sprintf(name, "Can't create file %s", filename); wmessage(name); filename= NULL; return FALSE; } for (i= 0; i < NGLYPHS; ++i) { if (namelist[i][0] != EOS) fprintf(fp, "%-2s - 0x%02X\n", namelist[i], i); } fclose(fp); changed= FALSE; return TRUE; } return (FALSE) ; } *p = value ; } } fclose (fp) ; return (TRUE) ; } bool readbitmap () { FILE *fp ; char namebuf[256] ; if (fname == NULL) { namebuf[0] = 0 ; if (!waskfile ("Read file", namebuf, sizeof (namebuf), FALSE)) return (FALSE) ; fname = strdup (namebuf) ; title = strip (fname) ; wsettitle (win, title) ; } fp = fopen (fname, "smtalk43/stdwin/Appls/dpv/dpv.c1006440003270021170000000370205465303016013612 037777777777 1 0 /* dpv -- ditroff previewer. Main program. */ #include "dpv.h" int dbg; /* Amount of debugging output wanted */ int windowarn; /* Set if errors must go to dialog box */ char *progname= "dpv"; /* Program name if not taken from argv[0] */ /* Main program. Scan arguments and call other routines. */ main(argc, argv) int argc; char **argv; { int firstpage; winitargs(&argc, &argv); if (argc > 0 && *argv != NULL && **argv != EOS) { progname= rindex(argv[0], '/'); if (progname != NULL) ++progname; else progname= argv[0]; } for (;;) { int c; c= getopt(argc, argv, "df:t:P:"); if (c == EOF) break; switch (c) { case 'f': /* Alternate funnytab file */ funnyfile = optarg; break; case 't': /* Alternative font translations file */ readtrans(optarg); break; case 'd': /* Ask for debugging output */ ++dbg; /* Use -dd to increment debug level */ break; case 'P': /* Add printer definition */ addprinter(optarg); break; default: usage(); /*NOTREACHED*/ } } if (optind < argc && argv[optind][0] == '+') { if (argv[optind][1] == EOS || argv[optind][1] == '$') firstpage= 32000; else firstpage= atoi(argv[optind] + 1); ++optind; } else firstpage= 1; if (optind+1 != argc || strcmp(argv[optind], "-") == 0) usage(); windowarn= 1; /* From now on, use dialog box for warnings */ preview(argv[optind], firstpage); exit(0); } usage() { error(ABORT, "usage: %s [-d] [-f funnytab] [-t translationsfile] [-P printer] [+page] file", progname); } /*VARARGS2*/ error(f, s, a1, a2, a3, a4, a5, a6, a7) int f; char *s; { if (f != WARNING || !windowarn) { /* Use stderr */ if (f != 0) wdone(); fprintf(stderr, "%s: ", progname); fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7); fprintf(stderr, "\n"); if (f != 0) exit(f); } else { /* use dialog box */ char buf[256]; sprintf(buf, s, a1, a2, a3, a4, a5, a6, a7); wmessage(buf); } } "Untitled") ; } *str = 0 ; if (waskstr ("Enter width of smtalk43/stdwin/Appls/dpv/dpv.h1006440003270021170000000071505434024276013624 037777777777 1 0 /* dpv -- ditroff previewer. Global definitions */ #include "tools.h" #include #define DEBUGABLE /* defined if can set dbg flag (-d) */ #define ABORT 2 /* exit code for aborts */ #define FATAL 1 /* type of error */ #define WARNING 0 /* non-fatal (also !FATAL) */ extern int dbg; /* amount of debugging output wanted */ extern char *progname; /* program name, for error messages */ extern char *funnyfile; /* alternate funnytab filename */ map_height * sqrsize) ; wsetdocsize (win, map_wsmtalk43/stdwin/Appls/dpv/dpvcontrol.c1006440003270021170000001243205465303016015213 037777777777 1 0 /* dpv -- ditroff previewer. User interface, controlling the rest. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" #ifdef unix #define DO_PRINTMENU #endif char *devname; preview(file, firstpage) char *file; int firstpage; { initialize(file, firstpage); addmenus(); eventloop(file); cleanup(); wdone(); } MENU *mainmmenu; /* Menu IDs */ #define MAINMENU 1 #define PRINTMENU 2 /* Control menu items */ #define FIRSTPAGE 0 #define PREVPAGE 1 #define NEXTPAGE 2 #define LASTPAGE 3 /* --- */ #define GOTOPAGE 5 /* --- */ #define QUIT 7 #ifdef DO_PRINTMENU MENU *printmenu; #define MAXNPRINT 50 /* Max # items in print menu */ struct _printitem { char *text; /* Menu item text */ char *device; /* Required device, or NULL if N/A */ char *command; /* Shell command to execute */ } printitems[MAXNPRINT]= { /* XXX This is extremely site-dependent */ {"Typeset on Harris", "har", "lpr -Phar -n %s"}, {"Harris emulation on Agfa", "har", "toagfa %s"}, {"Print on ${PRINTER-psc}", "psc", "lpr -P${PRINTER-psc} -n %s"}, {"Print on Oce", "psc", "lpr -Poce -n %s"}, {"Print on PostScript", "psc", "lpr -Ppsc -n %s"}, {"Print on Agfa", "psc", "lpr -Pagfa -n %s"}, }; int nprint; int countprintmenu() { while (nprint < MAXNPRINT && printitems[nprint].text != NULL) nprint++; } int addprinter(name) char *name; { char buf[100]; countprintmenu(); if (nprint >= MAXNPRINT) { error(WARNING, "too many printer definitions, rest igonred"); return; } sprintf(buf, "Print on %s", name); printitems[nprint].text = strdup(buf); printitems[nprint].device = NULL; /* Unspecified */ sprintf(buf, "lpr -P%s -n %%s", name); printitems[nprint].command = strdup(buf); nprint++; } #endif addmenus() { MENU *mp; int i; mainmmenu= mp= wmenucreate(MAINMENU, "Command"); wmenuadditem(mp, "First page", 'F'); wmenuadditem(mp, "Previous page", 'P'); wmenuadditem(mp, "Next page", 'N'); wmenuadditem(mp, "Last page", 'L'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Go to page...", 'G'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Quit", 'Q'); #ifdef DO_PRINTMENU countprintmenu(); printmenu= mp= wmenucreate(PRINTMENU, "Print"); for (i= 0; i < nprint; ++i) { wmenuadditem(mp, printitems[i].text, -1); if (!canprint(i)) wmenuenable(mp, i, FALSE); } #endif } eventloop(filename) char *filename; { int num= -1; for (;;) { EVENT e; int lastnum= num; wgetevent(&e); num= -1; switch(e.type) { case WE_MENU: switch (e.u.m.id) { case MAINMENU: if (e.u.m.item == QUIT) return; do_mainmenu(e.u.m.item); break; case PRINTMENU: do_printmenu(filename, e.u.m.item); break; } break; case WE_CHAR: /* The mnemonics used here may remind you of the main menu's shortcuts, the 'vi' editor, the 'more' pages, or the 'rn' news reader... */ switch (e.u.character) { case 'q': case 'Q': return; case ' ': case '+': case 'n': case 'N': forwpage(lastnum); break; case '-': if (lastnum > 0) backpage(lastnum); else gotopage(prevpage); break; case 'b': case 'B': case 'p': case 'P': backpage(lastnum); break; case '^': case 'f': case 'F': gotopage(1); break; case '$': gotopage(32000); break; case 'g': case 'G': case 'l': case 'L': if (lastnum > 0) gotopage(lastnum); else gotopage(32000); break; case '.': if (lastnum > 0) gotopage(lastnum); else changeall(); /* Force a redraw */ break; default: if (isdigit(e.u.character)) { num= e.u.character - '0'; if (lastnum > 0) num += 10*lastnum; } else { wfleep(); lastnum= 0; } } break; case WE_CLOSE: return; case WE_COMMAND: switch (e.u.command) { case WC_RETURN: if (lastnum > 0) gotopage(lastnum); else forwpage(1); break; case WC_DOWN: forwpage(lastnum); break; case WC_UP: case WC_BACKSPACE: backpage(lastnum); break; case WC_CLOSE: /* case WC_CANCEL: */ return; default: wfleep(); } break; } } } do_mainmenu(item) int item; { switch (item) { case FIRSTPAGE: gotopage(1); break; case PREVPAGE: backpage(1); break; case NEXTPAGE: forwpage(1); break; case LASTPAGE: gotopage(32000); break; case GOTOPAGE: { static char buf[10]; int num; char extra; if (!waskstr("Go to page:", buf, sizeof buf) || buf[0] == '\0') return; if (sscanf(buf, " %d %c", &num, &extra) != 1 || num <= 0) { wmessage("Invalid page number"); return; } gotopage(num); } break; } } do_printmenu(filename, item) char *filename; int item; { #ifdef DO_PRINTMENU char buf[256]; int sts; if (item < 0 || item >= nprint) return; if (!canprint(item)) { sprintf(buf, "Can't convert %s output to %s", devname == NULL ? "unspecified" : devname, printitems[item].device); wmessage(buf); return; } sprintf(buf, printitems[item].command, filename); sts= system(buf); if (sts != 0) { sprintf(buf, "Print command failed, exit status 0x%x", sts); wmessage(buf); } #endif } #ifdef DO_PRINTMENU static bool canprint(item) int item; { return printitems[item].device == NULL || devname != NULL && strcmp(printitems[item].device, devname) == 0; } #endif ed ; extern int state ; bool drawline = FALSE ; int beg_h ; int beg_v ; int end_h ; int end_v ; bool drawcircle = FALSE ; int cent_h ; int cent_v ; int c_dh ; int c_dv ; bool selrect = FALSE ; int sr_left ; int sr_top ; int srsmtalk43/stdwin/Appls/dpv/dpvdoc.h1006440003270021170000000466705434024277014325 037777777777 1 0 /* dpv -- ditroff previewer. Description of input language. */ /* This isn't really a source file but disguised as one it is more likely to be distributed with the rest of the source */ /****************************************************************************** output language from ditroff: all numbers are character strings (These comments should suffice to write my own ditroff output filter, but I'm lazy... Note that the parser expects its input to be error-free -- it contains unchecked fscanf calls all over. Also it is not clear whether relative motions may have negative numbers as parameters. For filters descending from BWK's prototype this works for 'v' but not for 'h', as 'v' uses fscan but 'h' reads characters until it finds a non-digit... GvR) { push environment (font, size, position) } pop environment #..\n comment sn size in points fn font as number from 1 to n cx ascii character x Cxyz funny char \(xyz. terminated by white space Hn go to absolute horizontal position n Vn go to absolute vertical position n (down is positive) hn go n units horizontally (relative) vn ditto vertically nnc move right nn, then print c (exactly 2 digits!) (this wart is an optimization that shrinks output file size about 35% and run-time about 15% while preserving ascii-ness) pn new page begins (number n) -- set v to 0 P spread ends -- output it. (Put in by vsort). nb a end of line (information only -- no action needed) b = space before line, a = after w paddable word space -- no action needed Dt ..\n draw operation 't': Dl x y line from here by x,y (drawing char .) (affects position by x, y -- GvR) Dc d circle of diameter d with left side here De x y ellipse of axes x,y with left side here Da x y x1 y1 arc; see drawarc in dpvoutput.c for description D~ x y x y ... B-spline curve by x,y then x,y ... x ..\n device control functions: x i init x T s name of device is s x r n h v resolution is n/inch h = min horizontal motion, v = min vert x p pause (can restart) x s stop -- done for ever x t generate trailer x f n s font position n contains font s (there appears to be some disagreement whether this also selects s as the current font -- GvR) x H n set character height to n x S n set slant to N Subcommands like "i" are often spelled out like "init". ******************************************************************************/ cent_h + h, cent_v - v, value) ; if (h) (*fp) (cent_h - h, cent_v + smtalk43/stdwin/Appls/dpv/dpvfonts.c1006440003270021170000002756705465303016014703 037777777777 1 0 /* dpv -- ditroff previewer. Font translation. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" /* Font translation table, to map ditroff font names to font names STDWIN (really the underlying window system) understands. This information should really be read from a configuration file. For now, we know to map some ditroff names for Harris and PostScript fonts to more or less equivalent X11 and Mac fonts. (The X fonts used are to be found in the Andrew distribution). Because the current font scheme in STDWIN for X doesn't know about wsetsize and wsetbold c.s., the translation process is different for X than for the Macintosh. */ #define NSIZES 10 #define R 0 #define B 1 #define I 2 #define BI 3 static struct _translate { char *harname; char *xname; int style; int sizes[NSIZES+1]; } default_translate[]= { #ifdef macintosh {"R", "Times", R}, {"I", "Times", I}, {"B", "Times", B}, {"BI", "Times", BI}, {"H", "Helvetica", R}, {"HO", "Helvetica", I}, {"HB", "Helvetica", B}, {"HD", "Helvetica", BI}, {"C", "Courier", R}, {"CO", "Courier", I}, {"CB", "Courier", B}, {"CD", "Courier", BI}, {"lp", "Courier", R}, {"Vl", "Helvetica", R}, {"vl", "Helvetica", R}, {"V", "Helvetica", R}, {"v", "Helvetica", R}, /* Font used by funny character translation */ {"Symbol", "Symbol", R}, #else #ifdef X11R2 /* X11 Release 2, using fonts from Andrew */ /* PostScript font names */ {"R", "times%d", R, 8, 10, 12, 16, 22, 0}, {"I", "times%di", R, 8, 10, 12, 16, 22, 0}, {"B", "times%db", R, 8, 10, 12, 16, 22, 0}, {"BI", "times%dbi", R, 8, 10, 12, 16, 22, 0}, {"H", "helvetica%d", R, 8, 10, 12, 16, 22, 0}, {"HO", "helvetica%di", R, 8, 10, 12, 16, 22, 0}, {"HB", "helvetica%db", R, 8, 10, 12, 16, 22, 0}, {"HD", "helvetica%dbi",R, 8, 10, 12, 16, 22, 0}, {"C", "courier%df", R, 8, 10, 12, 16, 22, 0}, {"CO", "courier%dif", R, 8, 10, 12, 16, 22, 0}, {"CB", "courier%dbf", R, 8, 10, 12, 16, 22, 0}, {"CD", "courier%dbif", R, 8, 10, 12, 16, 22, 0}, /* CWI Harris font names (also R, I, B, BI) */ /* Vega light, Vega, Vega medium (Helvetica look-alike) */ {"Vl", "helvetica%d", R, 8, 10, 12, 16, 22, 0}, {"vl", "helvetica%di", R, 8, 10, 12, 16, 22, 0}, {"V", "helvetica%d", R, 8, 10, 12, 16, 22, 0}, {"v", "helvetica%di", R, 8, 10, 12, 16, 22, 0}, {"Vm", "helvetica%db", R, 8, 10, 12, 16, 22, 0,}, {"vm", "helvetica%dbi",R, 8, 10, 12, 16, 22, 0,}, /* Baskerville (see also small caps) */ {"br", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"bi", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"bb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"bI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Century Schoolbook */ {"cr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"ci", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"cb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"cI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Laurel */ {"lr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"li", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"lb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"lI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Funny fonts mapped to Helvetica, at least they differ from Times */ {"G3", "helvetica%d", R, 8, 10, 12, 16, 22, 0,}, /* German no 3 */ {"fs", "helvetica%d", R, 8, 10, 12, 16, 22, 0,}, /* French Script */ {"RS", "helvetica%di", R, 8, 10, 12, 16, 22, 0,}, /* Rose Script */ {"SO", "helvetica%db", R, 8, 10, 12, 16, 22, 0,}, /* Scitype Open */ /* OCR-B (line printer font) */ {"lp", "courier%dbf", R, 8, 10, 12, 0}, /* Small caps fonts mapped to normal fonts */ {"Rs", "times%d", R, 8, 10, 12, 16, 22, 0,}, /* Times */ {"Bs", "times%db", R, 8, 10, 12, 16, 22, 0,}, /* Times bold */ {"bs", "times%d", R, 8, 10, 12, 16, 22, 0,}, /* Baskerville */ {"bS", "times%db", R, 8, 10, 12, 16, 22, 0,}, /* Baskerv. bold */ /* Fonts used by funny character translation */ {"symbol", "symbol%d", R, 8, 10, 12, 16, 22, 0}, {"symbola","symbola%d", R, 8, 10, 12, 16, 22, 0}, #else /* ! X11R3 */ /* X11 Release 3 fonts */ /* Also works for Release 4 */ /* PostScript font names */ {"R", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"I", "-*-times-medium-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"B", "-*-times-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"BI", "-*-times-bold-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"H", "-*-helvetica-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"HO", "-*-helvetica-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"HB", "-*-helvetica-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"HD", "-*-helvetica-bold-o-*--%d-*",R, 8, 10, 12, 14, 18, 24, 0}, {"C", "-*-courier-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"CO", "-*-courier-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"CB", "-*-courier-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"CD", "-*-courier-bold-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, /* CW is a common alias for C */ {"CW", "-*-courier-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, /* CWI Harris font names (also R, I, B, BI) */ /* Vega light, Vega, Vega medium (Helvetica look-alike) */ {"Vl", "-*-helvetica-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"vl", "-*-helvetica-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"V", "-*-helvetica-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"v", "-*-helvetica-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, {"Vm", "-*-helvetica-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"vm", "-*-helvetica-bold-o-*--%d-*",R, 8, 10, 12, 14, 18, 24, 0,}, /* Baskerville (see also small caps) */ {"br", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"bi", "-*-times-medium-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"bb", "-*-times-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"bI", "-*-times-bold-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Century Schoolbook */ {"cr", "-*-new century schoolbook-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"ci", "-*-new century schoolbook-medium-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"cb", "-*-new century schoolbook-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"cI", "-*-new century schoolbook-bold-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Laurel */ {"lr", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"li", "-*-times-medium-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"lb", "-*-times-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, {"lI", "-*-times-bold-i-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Funny fonts mapped to Helvetica, at least they differ from Times */ {"G3", "-*-helvetica-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* German no 3 */ {"fs", "-*-helvetica-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* French Script */ {"RS", "-*-helvetica-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Rose Script */ {"SO", "-*-helvetica-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Scitype Open */ /* OCR-B (line printer font) */ {"lp", "-*-courier-bold-r-*--%d-*", R, 8, 10, 12, 0}, /* Small caps fonts mapped to normal fonts */ {"Rs", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Times */ {"Bs", "-*-times-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Times bold */ {"bs", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Baskerville */ {"bS", "-*-times-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Baskerville bold */ /* Fonts used by funny character translation */ {"r3symbol", "*-*-symbol-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0}, #endif /* ! X11R2 */ #endif /* ! macintosh */ {NULL, NULL} }; static struct _translate *translate = default_translate; /* Tell STDWIN to use the desired font and size. Call at start of page and after each font or size change. */ usefont() { char *fontname; if (showpage != ipage) return; fontname= fonts.name[font]; if (fontname != NULL) fonthack(fontname); /* Else, font not loaded -- assume in initialization phase */ baseline= wbaseline(); lineheight= wlineheight(); recheck(); } fonthack(fontname) char *fontname; { int i; int havesize; char *harname; char buf[256]; struct _translate *t; for (t= translate; t->harname != NULL; ++t) { if (strcmp(t->harname, fontname) == 0) break; } if (t->harname == NULL) { fontwarning(fontname); } else { #ifdef macintosh wsetfont(t->xname); wsetsize(size); wsetplain(); switch (t->style) { case I: wsetitalic(); break; case B: wsetbold(); break; case BI: wsetbolditalic(); break; } #else havesize= size; for (i= 0; ; ++i) { if (t->sizes[i] >= havesize || t->sizes[i+1] == 0) { havesize= t->sizes[i]; break; } } sprintf(buf, t->xname, havesize); wsetfont(buf); #endif } } /* Issue a warning. Avoid warning many times in a row about the same font. */ fontwarning(fontname) char *fontname; { static char lastwarning[200]; char buf[256]; if (strncmp(lastwarning, fontname, sizeof lastwarning) != 0) { strncpy(lastwarning, fontname, sizeof lastwarning); sprintf(buf, "mapping for font %s unknown", fontname); error(WARNING, buf); } } /* Get a token */ static char * gettok(pp) char **pp; { char *p = *pp; char *start; char c; while (isspace(c = *p++)) /* Skip to start of token */ ; if (c == '\0' || c == '\n' || c == '#') { if (dbg > 2) if (c == '#') fprintf(stderr, "next token is comment\n"); else if (c == '\n') fprintf(stderr, "next token is newline\n"); else fprintf(stderr, "next token is EOS\n"); return NULL; /* End of line of comment */ } start = p-1; /* Remember start of token */ while (!isspace(c = *p++) && c != '\0') /* Skip to end of token */ ; if (c == '\0') p--; else p[-1] = '\0'; /* Zero-terminate token */ *pp = p; /* Start point for next token */ if (dbg > 2) fprintf(stderr, "next token: %s\n", start); return start; } static void addtrans(pnt, pt, harname, xname, style, sizes) int *pnt; struct _translate **pt; char *harname; char *xname; int style; int sizes[]; { int i = (*pnt)++; struct _translate *t = *pt; if (i == 0) t = (struct _translate *) malloc(sizeof(struct _translate)); else t = (struct _translate *) realloc((char *)t, sizeof(struct _translate) * *pnt); if (t == NULL) error(FATAL, "not enough memory for font translations"); *pt = t; t += i; t->harname = strdup(harname); t->xname = strdup(xname); t->style = style; for (i = 0; i <= NSIZES; i++) t->sizes[i] = sizes[i]; } /* Read a file of alternative font translations. */ readtrans(filename) char *filename; { struct _translate *t; int nt; FILE *fp; int line; char buf[1000]; char *p; char *harname; char *xname; char *sizetemp; int sizes[NSIZES+1]; static int defsizes[NSIZES+1] = {8, 10, 12, 14, 18, 24, 0}; int nsizes; fp = fopen(filename, "r"); if (fp == NULL) error(FATAL, "can't find font translations file %s", filename); if (dbg > 0) fprintf(stderr, "reading translations from %s\n", filename); t = NULL; nt = 0; line = 0; while (fgets(buf, sizeof buf, fp) != NULL) { line++; if (dbg > 1) fprintf(stderr, "line %d: %s\n", line, buf); p = buf; harname = gettok(&p); if (harname == NULL) continue; /* Blank line or comment */ xname = gettok(&p); if (xname == NULL) { error(WARNING, "%s(%d): incomplete line (only '%s')", filename, line, harname); continue; } /* Style is always R */ nsizes = 0; while (nsizes < NSIZES && (sizetemp = gettok(&p)) != NULL) { sizes[nsizes] = atoi(sizetemp); if (sizes[nsizes] <= 0 || nsizes > 0 && sizes[nsizes] <= sizes[nsizes-1]) { error(WARNING, "%s(%d): bad or non-increasing size '%s'", filename, line, sizetemp); } else nsizes++; } if (nsizes > 0) while (nsizes <= NSIZES) sizes[nsizes++] = 0; addtrans(&nt, &t, harname, xname, R, nsizes == 0 ? defsizes : sizes); } if (dbg > 0) fprintf(stderr, "done reading translations.\n"); fclose(fp); if (nt == 0) error(FATAL, "%s: no valid font translations", filename); addtrans(&nt, &t, (char *)NULL, (char *)NULL, R, defsizes); translate = t; } smtalk43/stdwin/Appls/dpv/dpvfunny.c1006440003270021170000001143205465303016014671 037777777777 1 0 /* dpv -- ditroff previewer. Funny character translation. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" char *funnyfile; /* File to read table from */ char *funnytries[]= { /* Alternative files to try */ "funnytab", "/usr/local/lib/funnytab", "/userfs3/amoeba/lib/funnytab", "/ufs/guido/lib/funnytab", NULL }; /* Funny character translation table. The table implies that character 'name' (the ditroff input name, e.g. "bu" for bullet, which is input as "\(bu") must be translated the string 'trans' drawn in font 'font', or in the current font if 'font' is NULL. 'Trans' is a string because some characters need several real characters to print them (e.g., ligatures). For higher-quality output, the table should be extended to include a point size increment/decrement and possibly a (dh, dv) translation; but what the heck, this is only a previewer! */ static struct _funny { char name[4]; char trans[4]; char *fontname; }; /* Read funny character translation table. File format: name fontname translation where: name is the ditroff character name, e.g., bs for \(bs fontname is the font name, or - if the translation uses the current font translation is one or more hexadecimal numbers, or a string enclosed in double quotes In any case the string may be no more than 3 characters long */ readfunnytab(filename) char *filename; { char buf[BUFSIZ]; FILE *fp= fopen(filename, "r"); if (fp == NULL) { if (dbg > 0) fprintf(stderr, "Can't open funnytab %s\n", filename); return FALSE; } if (dbg > 0) fprintf(stderr, "Reading funnytab from %s\n", filename); while (fgets(buf, sizeof buf, fp) != NULL) { char *name; char *fontname; char *trans; char ctrans[4]; char *p= buf; while (*p != EOS && isspace(*p)) ++p; if (*p == EOS) continue; name= p; while (*p != EOS && !isspace(*p)) ++p; if (*p == EOS) continue; *p++ = EOS; while (*p != EOS && isspace(*p)) ++p; if (*p == EOS) continue; fontname= p; while (*p != EOS && !isspace(*p)) ++p; if (*p == EOS) continue; *p++ = EOS; while (*p != EOS && isspace(*p)) ++p; if (*p == EOS) continue; if (*p == '"') { trans= ++p; while (*p != EOS && *p != EOL && *p != '"') ++p; *p= EOS; } else if (*p == '0' && p[1] == 'x') { int a= 0, b= 0, c= 0; (void) sscanf(p, "0x%x 0x%x 0x%x", &a, &b, &c); ctrans[0]= a; ctrans[1]= b; ctrans[2]= c; ctrans[3]= EOS; trans= ctrans; } else error(WARNING, "almost-match in funnytab"); addtranslation(name, fontname, trans); } fclose(fp); sorttranslations(); return TRUE; } int nfunny; struct _funny *funnytab; static addtranslation(name, fontname, trans) char *name, *fontname, *trans; { struct _funny f; strncpy(f.name, name, 4); f.name[3]= EOS; strncpy(f.trans, trans, 4); f.trans[3]= EOS; if (fontname == NULL || fontname[0] == EOS || fontname[0] == '-' && fontname[1] == EOS) f.fontname= NULL; else { static char *lastfontname; if (lastfontname == NULL || strcmp(fontname, lastfontname) != 0) lastfontname= strdup(fontname); f.fontname= lastfontname; } L_APPEND(nfunny, funnytab, struct _funny, f); if (funnytab == NULL) error(FATAL, "out of mem for funnytab"); } static funnycmp(p, q) struct _funny *p, *q; { return strcmp(p->name, q->name); } static sorttranslations() { /* Don't sort -- the lookup algorithm depends on the order */ #if 0 if (nfunny > 1) qsort(funnytab, nfunny, sizeof(struct _funny), funnycmp); #endif } /* Draw a funny character. Called from put1s. */ drawfunny(name) register char *name; { register struct _funny *f; TEXTATTR save; static bool inited; if (!inited) { if (funnyfile != NULL) { /* Explicitly specified funnyfile -- must exist */ if (!readfunnytab(funnyfile)) error(FATAL, "can't find funnytab file %s", funnyfile); } else { /* Try to find default funnyfile */ int i= 0; while ((funnyfile= funnytries[i++]) != NULL) { if (readfunnytab(funnyfile)) break; } /* If not found, limp ahead... */ if (funnyfile == NULL) error(WARNING, "can't find default funnytab"); } inited= TRUE; } /* If this is too slow, could use binary search and/or replace the strcmp by an explicit comparison of two characters. But spend your time on the program's main loop (especially, 'put1') first! */ for (f= funnytab; f < &funnytab[nfunny]; ++f) { /* Assume names are always 1 or 2 chars */ if (f->name[0] == name[0] && f->name[1] == name[1]) break; } if (f >= &funnytab[nfunny]) return; /* Unknown character -- don't draw it */ if (f->fontname != NULL) { char buf[256]; wgettextattr(&save); fonthack(f->fontname); } wdrawtext(HWINDOW, VWINDOW - wbaseline(), f->trans, -1); if (f->fontname != NULL) wsettextattr(&save); } smtalk43/stdwin/Appls/dpv/dpvmachine.c1006440003270021170000000565505465303016015150 037777777777 1 0 /* dpv -- ditroff previewer. Ditroff virtual machine. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" /* Basic state */ int size; /* current point size */ int font; /* current font */ int hpos; /* horizontal position we are to be at next; left=0 */ int vpos; /* current vertical position (down positive) */ /* Environment */ struct state state[MAXSTATE]; struct state *statep = state; /* Mounted font table */ fontinfo fonts; int nfonts = 0; /* start with no fonts mounted */ /* Page info */ int ipage; /* internal page number */ /* Global info */ int res = 432; /* resolution for which input was prepared */ /* default is old troff resolution */ /* Load font info for font s on position n; optional file name s1 */ loadfont(n, s, s1) int n; char *s, *s1; { if (n < 0 || n > NFONTS) error(FATAL, "can't load font %d", n); fonts.name[n]= strdup(s); } /* Initialize device */ t_init() { /* Start somewhere */ hpos = vpos = 0; size= 10; font= 1; usefont(); } /* Begin a new block */ t_push() { if (statep >= state+MAXSTATE) error(FATAL, "{ nested too deep"); statep->ssize = size; statep->sfont = font; statep->shpos = hpos; statep->svpos = vpos; ++statep; } /* Pop to previous state */ t_pop() { if (--statep < state) error(FATAL, "extra }"); size = statep->ssize; font = statep->sfont; hpos = statep->shpos; vpos = statep->svpos; usefont(); } /* Called at the start of a new page. Returns < 0 if it is time to stop. */ int t_page(n) int n; { if (nextpage(n) < 0) return -1; vpos = hpos = 0; usefont(); return 0; } /* Do whatever for the end of a line */ t_newline() { hpos = 0; /* because we're now back at the left margin */ } /* Convert integer to internal size number */ t_size(n) int n; { return n; } /* Set character height to n */ /*ARGSUSED*/ t_charht(n) int n; { static bool warned; if (!warned) { error(WARNING, "Setting character height not implemented"); warned= TRUE; } } /* Set slant to n */ /*ARGSUSED*/ t_slant(n) int n; { static bool warned; if (!warned) { error(WARNING, "Setting slant not implemented"); warned= TRUE; } } /* Convert string to font number */ t_font(s) char *s; { return atoi(s); } /* Print string s as text */ t_text(s) char *s; { int c; char str[100]; /* XXX This function doesn't work any more since lastw is not set */ while (c = *s++) { if (c == '\\') { switch (c = *s++) { case '\\': case 'e': put1('\\'); break; case '(': str[0] = *s++; str[1] = *s++; str[2] = EOS; put1s(str); break; } } else { put1(c); } /*hmot(lastw);*/ } } /* Reset; argument is 'p' for pause, 's' for start */ t_reset(c) int c; { if (c == 's') lastpage(); } /* Absolute vertical motion to position n */ vgoto(n) int n; { vpos = n; recheck(); } /* Set point size to n */ setsize(n) int n; { size = n; usefont(); } /* Set font to n */ setfont(n) int n; { font = n; usefont(); } ph/ncols + 1) * ncols - 1; #endif /* Compute remaining variables */ nrows= (lassmtalk43/stdwin/Appls/dpv/dpvmachine.h1006440003270021170000000451705434024300015141 037777777777 1 0 /* dpv -- ditroff previewer. Definitions for ditroff virtual machine. */ /* The ditroff machine has the following state information: Basic state: - hpos, vpos print head position on current page - size current point size - font current font number (range 0..NFONTS-1) Environment: - a stack containing up to MAXSTATE copies of the basic state Mounted font table: - a mapping from font number to (ditroff) font names (i.e., which font is mounted on which logical position) Page info: - current page number Global info (not used much): - typesetter name - resolution assumed when preparing - page dimensions - etc.? To restart the machine at a given page, we need to save and restore the basic state, environment and mounted font table. It could be argued that at page boundaries the environment stack should be empty, and that the mounted font table should be initialized once and for ever. The latter isn't the case in practice; ".fp" requests can be and are used anywhere in ditroff source files. Because the environment pushes the (page-relative) position, it is unlikely that restoring an environment on a different page makes any sense, so we could assume this (and check that the input conforms). */ /* Array dimensions */ #define NFONTS 65 /* total number of fonts usable */ #define MAXSTATE 6 /* number of environments rememberable */ /* Basic state */ extern int hpos; /* horizontal position we are to be at next; left=0 */ extern int vpos; /* current vertical position (down positive) */ extern int size; /* current point size */ extern int font; /* current font */ #define hmot(n) hpos += n #define hgoto(n) hpos = n #define vmot(n) vgoto(vpos + (n)) extern vgoto(); /* Environment */ struct state { int ssize; int sfont; int shpos; int svpos; }; extern struct state state[MAXSTATE]; extern struct state *statep; extern t_push(); extern t_pop(); /* Mounted font table */ typedef struct _fontinfo { char *name[NFONTS]; } fontinfo; extern fontinfo fonts; /* current mounted font table */ extern int nfonts; /* number of used entries (0..nfonts-1) */ /* Page info */ extern int ipage; /* internal page number */ /* Global typesetter info */ extern int res; /* resolution for which input was prepared */ /* default is old troff resolution */ || i < firstglyph || i > lastglyph || wcharwidth(i) == 0) i= -1; if (i != selected) { wbegindrawing(win); if (selected >= 0) { cellbounds(selected, &left, &top, &rsmtalk43/stdwin/Appls/dpv/dpvoutput.c1006440003270021170000001350205465303016015072 037777777777 1 0 /* dpv -- ditroff previewer. Output functions. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" WINDOW *win; /* output window */ /* Scale factors (must be longs to avoid overflow) */ long hscale, hdiv; /* Horizontal scaling factors */ long vscale, vdiv; /* Vertical scaling factors */ int paperwidth, paperheight; /* Paper dimenmsions */ /* Variables used to make put1(c) as fast as possible */ int topdraw, botdraw; /* Top, bottom of rect to redraw */ int baseline; /* Caches wbaseline() */ int lineheight; /* Caches wlineheight() */ int doit; /* Set if output makes sense */ int vwindow; /* Caches VWINDOW - baseline */ extern void drawproc(); /* Draw procedore, in dpvcontrol.c */ /* Create the window */ initoutput(filename) char *filename; { int winwidth, winheight; int hmargin, vmargin; setscale(); wsetdefwinsize(paperwidth, paperheight); win= wopen(filename, drawproc); wsetdocsize(win, paperwidth, paperheight); wsetwincursor(win, wfetchcursor("arrow")); /* Center the window in the document */ wgetwinsize(win, &winwidth, &winheight); hmargin = (paperwidth - winwidth) / 2; if (hmargin < 0) hmargin = 0; vmargin = (paperheight - winheight) / 2; if (vmargin < 0) vmargin = 0; wshow(win, hmargin, vmargin, paperwidth - hmargin, paperheight - hmargin); } /* Compute scale factors from screen dimensions and device resolution. Call before outputting anything, but after input device resolution is known. */ static setscale() { int scrwidth, scrheight, mmwidth, mmheight; int hdpi, vdpi; wgetscrsize(&scrwidth, &scrheight); wgetscrmm(&mmwidth, &mmheight); hdpi = scrwidth * 254L / 10 / mmwidth; vdpi = scrheight * 254L / 10 / mmwidth; if (dbg) { printf("screen %dx%d pixels, %dx%d mm.\n", scrwidth, scrheight, mmwidth, mmheight); printf("dots per inch %dx%d\n", hdpi, vdpi); } /* Adjust mm sizes to 75x75 dpi if a resolution less than 75 dpi is reported (some servers lie!) */ if (hdpi < 75) { fprintf(stderr, "Adjusting horizontal resolution to 75 dpi\n"); mmwidth = scrwidth * 254L / 750; } if (vdpi < 75) { fprintf(stderr, "dpv: Adjusting vertical resolution to 75 dpi\n"); mmheight = scrheight * 254L / 750; } /* Dots/mm == scrwidth/mmwidth, etc.; there are 25.4 mm/inch */ hscale= 254L * scrwidth / 10; hdiv= mmwidth * res; vscale= 254L * scrheight / 10; vdiv= mmheight * res; /* Set desired width & height of paper */ paperwidth= 210 * scrwidth / mmwidth; paperheight= 297 * scrheight / mmheight; if (dbg) { printf("hscale=%d, hdiv=%d, vscale=%d, vdiv=%d\n", hscale, hdiv, vscale, vdiv); printf("paper %dx%d\n", paperwidth, paperheight); } } /* Force a redraw event for the entire window. Used after a new page is made current. */ changeall() { wchange(win, 0, 0, paperwidth, paperheight); } /* Recompute doit & vwindow. Call after each font change and each vertical move. Assumes topdraw and botdraw are set by drawproc(), and lineheight and baseline are set by usefont(). */ recheck() { if (ipage != showpage) doit= FALSE; else { vwindow= VWINDOW - baseline; doit= vwindow < botdraw && vwindow+lineheight > topdraw; } } /* Output a funny character, called in response to 'Cxx' input. Don't rely on 'doit'; the character might be in a different font, invalidating the clipping computations in recheck(). */ put1s(s) char *s; { if (ipage == showpage) drawfunny(s); } /* Line drawing functions. There really do some of the work that belongs in dpvmachine.c, and even dpvparse.c. */ drawline(dh, dv) int dh, dv; { if (ipage == showpage) wdrawline(HWINDOW, VWINDOW, HWIN(hpos+dh), VWIN(vpos+dv)); hpos += dh; vpos += dv; } drawcirc(diameter) int diameter; { if (ipage == showpage) wdrawcircle(HWIN(hpos+diameter/2), VWINDOW, (int)(diameter/2*hscale/hdiv)); /* I assume hpos, vpos remain unchanged here */ } drawellip(haxis, vaxis) int haxis, vaxis; { if (ipage == showpage) { wdrawelarc(HWIN(hpos+haxis/2), VWIN(vpos), (int) (haxis*hscale/hdiv/2), (int) (vaxis*vscale/vdiv/2), 0, 360); } } #define PI 3.1415726 drawarc(n, m, n1, m1) /* current position is start of arc * n,m is position of center relative to current * n1,m1 is intersection point of tangents at start- and endpoints * of the arc */ { double rad, angle1, angle2, sqrt(), atan2(), c; int iang1, iang2; c = 180.0/PI; rad = sqrt((double)((n*n)+(m*m))); angle1 = c*atan2((double)m,(double)-n); angle2 = -2 * (angle1 + c * atan2((double)(m1-m),(double)(n1-n))); iang1 = (int) (angle1 + 0.5); iang2 = (int) (angle2 + 0.5); while (iang1 < 0) iang1 += 360; while (iang2 < 0) iang2 += 360; while (iang1 >= 360) iang1 -= 360; while (iang2 >= 360) iang2 -= 360; /* params for wdrawelarc are * x,y for center, * horizontal and vertical radii (different for ellipses) * start angle in degrees and number of degrees to draw. * angles measured anticlockwise from positive x-axis */ if (ipage == showpage) wdrawelarc(HWIN(hpos+n), VWIN(vpos+m), (int)(rad*hscale/hdiv), (int)(rad*vscale/vdiv), iang1, iang2); } drawwig(buf, fp, flag) char *buf; FILE *fp; { int dh, dv, x = hpos, y = vpos; while (getint(&buf, &dh) && getint(&buf, &dv)) if (ipage == showpage) { /* HIRO: should always do this (for side effects)? */ drawline(x + dh/4 - hpos, y + dv/4 - vpos); drawline(dh / 2, dv / 2); x += dh; y += dv; } drawline(dh / 4, dv / 4); if (index(buf, EOL) == NULL) { int c; /* HIRO: don't know how to do handle this */ error(WARNING, "rest of very long wiggly line ignored"); do { c = getc(fp); } while (c != EOL && c != EOF); } } static bool getint(pbuf, px) char **pbuf; int *px; { char *buf= *pbuf; while (*buf != EOS && isspace(*buf)) ++buf; if (*buf == EOS || *buf != '-' && !isdigit(*buf)) return FALSE; *px= atoi(buf); while (*buf != EOS && !isspace(*buf)) ++buf; *pbuf= buf; return TRUE; } output wanted */ extern char *progname; /* program name, for error messages */ extern char *funnyfile; /* alternate funnytab filename */ map_height * sqrsize) ; wsetdocsize (win, map_wsmtalk43/stdwin/Appls/dpv/dpvoutput.h1006440003270021170000000206405434024300015070 037777777777 1 0 /* dpv -- ditroff previewer. Definitions for output. */ extern char *devname; /* Device for which output is prepared */ extern WINDOW *win; /* output window */ extern int showpage; /* internal page to show in window */ /* defined in dpvcontrol.c */ extern int prevpage; /* previous page shown (for '-' command) */ extern long hscale, hdiv; /* Horizontal scaling factors */ extern long vscale, vdiv; /* Vertical scaling factors */ /* Scaling method */ #define HWIN(h) ((int)(((h)*hscale+hdiv/2)/hdiv)) #define VWIN(v) ((int)(((v)*vscale+vdiv/2)/vdiv)) #define HWINDOW HWIN(hpos) #define VWINDOW VWIN(vpos) /* Variables used by put1 macro below, and by recheck function */ extern int doit; /* nonzero if output makes sense */ extern int vwindow; /* precomputed vpos*vscale/vdiv - baseline */ extern int baseline; /* wbaseline() of current font */ extern int lineheight; /* wlineheight() of current font */ extern int topdraw, botdraw; /* window area to draw */ /* Macro to output one character */ #define put1(c) if (!doit) ; else wdrawchar(HWINDOW, vwindow, c) c", "lpr -Poce -n %s"}, {"Print on PostScript", "psc", "lpr -Ppsc -n %s"}, {"Print on Agfa", "psc", "lpr -Pagfa -n %s"}, }; int nprint; int countprintmenu() { while (nprint < MAXNPRINT && printitems[nprint].text != NULL) nprint++; } int addprinter(name) char *name; { char buf[100]; countprintmenu(); if (nprint >= MAXNPRINT) { error(WARNING, "too many printer definitions, rest igonred"); return; } sprintf(buf, "Print on %s", name); prinsmtalk43/stdwin/Appls/dpv/dpvparse.c1006440003270021170000001105005465303016014640 037777777777 1 0 /* dpv -- ditroff previewer. Parser for ditroff output. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" #include "dpvdoc.h" /* Descripton of ditroff output format */ /* Parser main loop. Read input from fp. Stop when EOF hit, 'x stop' found, or nextpage returns < 0. This makes calls to the machine module to update the virtual machine's state, and to the output module to perform actual output. Code derived from a (not very robust) ditroff filter by BWK. */ parse(fp) register FILE *fp; { register int c, k; int m, n, n1, m1; char str[100], buf[300]; while ((c = getc(fp)) != EOF) { switch (c) { case '\n': /* when input is text */ case '\0': /* occasional noise creeps in */ case '\t': case ' ': break; case '{': /* push down current environment */ t_push(); break; case '}': t_pop(); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': /* two motion digits plus a character */ k= (c-'0')*10; c= getc(fp); k += c-'0'; hmot(k); c= getc(fp); put1(c); break; case 'c': /* single ascii character */ c= getc(fp); put1(c); break; case 'C': fscanf(fp, "%s", str); put1s(str); break; case 't': /* straight text */ if (fgets(buf, sizeof(buf), fp) == NULL) error(FATAL, "unexpected end of input"); t_text(buf); break; case 'D': /* draw function */ if (fgets(buf, sizeof(buf), fp) == NULL) error(FATAL, "unexpected end of input"); switch (buf[0]) { case 'l': /* draw a line */ sscanf(buf+1, "%d %d", &n, &m); drawline(n, m); break; case 'c': /* circle */ sscanf(buf+1, "%d", &n); drawcirc(n); break; case 'e': /* ellipse */ sscanf(buf+1, "%d %d", &m, &n); drawellip(m, n); break; case 'a': /* arc */ sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1); drawarc(n, m, n1, m1); break; case '~': /* wiggly line */ /* HIRO: how to scan? */ drawwig(buf+1, fp, 1); break; default: error(FATAL, "unknown drawing function %s", buf); break; } recheck(); break; case 's': fscanf(fp, "%d", &n); setsize(t_size(n)); break; case 'f': fscanf(fp, "%s", str); setfont(t_font(str)); break; case 'H': /* absolute horizontal motion */ while ((c = getc(fp)) == ' ') ; k = 0; do { k = 10 * k + c - '0'; } while (isdigit(c = getc(fp))); ungetc(c, fp); hgoto(k); break; case 'h': /* relative horizontal motion */ while ((c = getc(fp)) == ' ') ; k = 0; do { k = 10 * k + c - '0'; } while (isdigit(c = getc(fp))); ungetc(c, fp); hmot(k); break; case 'w': /* word space */ break; case 'V': fscanf(fp, "%d", &n); vgoto(n); break; case 'v': fscanf(fp, "%d", &n); vmot(n); break; case 'P': /* new spread (Versatec hack) */ break; case 'p': /* new page */ fscanf(fp, "%d", &n); if (t_page(n) < 0) return; break; case 'n': /* end of line */ t_newline(); /* Fall through */ case '#': /* comment */ do { c = getc(fp); } while (c != EOL && c != EOF); break; case 'x': /* device control */ if (devcntrl(fp) < 0) return; break; default: error(FATAL, "unknown input character %o %c", c, c); } } error(WARNING, "read till EOF"); } /* Parse rest of device control line. Returns -1 upon receiving EOF or "stop" command. */ static int devcntrl(fp) FILE *fp; { char str[20], str1[50], buf[50]; extern char *namemap(); /* ??? */ int c, n; fscanf(fp, "%s", str); switch (str[0]) { /* crude for now */ case 'i': /* initialize */ t_init(); break; case 't': /* trailer */ break; case 'p': /* pause -- can restart */ t_reset('p'); break; case 's': /* stop */ t_reset('s'); return -1; case 'r': /* resolution assumed when prepared */ fscanf(fp, "%d", &res); break; case 'f': /* font used */ fscanf(fp, "%d %s", &n, str); (void) fgets(buf, sizeof buf, fp); /* in case of filename */ ungetc(EOL, fp); /* fgets goes too far */ str1[0] = 0; /* in case nothing comes in */ (void) sscanf(buf, "%s", str1); loadfont(n, str, str1); break; case 'H': /* char height */ fscanf(fp, "%d", &n); t_charht(n); break; case 'S': /* slant */ fscanf(fp, "%d", &n); t_slant(n); break; case 'T': /* device name */ buf[0]= EOS; fscanf(fp, "%s", buf); if (buf[0] != EOS) devname= strdup(buf); break; } while ((c = getc(fp)) != EOL) { /* skip rest of input line */ if (c == EOF) return -1; } return 0; } Also it is not clear whether relative motions may have negative numbers as parameters. For filters descending from BWK's prototype this works for 'v' but not for 'h', as 'v' uses fscan but 'h' reads characters until it finds a non-digit... GvR) { push environment (font, size, position) } pop environment #..\n comment sn size in points fn font as number from 1 to n cx ascii character x Cxyz funny char \(xyz. terminated by white space Hn go to absolusmtalk43/stdwin/Appls/dpv/dpvrestart.c1006440003270021170000001020405465303017015213 037777777777 1 0 /* dpv -- ditroff previewer. Functions to restart anywhere in the file. */ #include "dpv.h" #include "dpvmachine.h" #include "dpvoutput.h" typedef struct _restartinfo { long filepos; /* File position for fseek */ int pageno; /* External page number */ fontinfo fonts; /* Mounted font table */ int font, size; /* Current font and size */ } restartinfo; int npages; /* Number of pages so far */ bool nomore; /* Set when the last page has been seen */ restartinfo *pagelist; /* State needed to start each page */ int ipage; /* Internal page in file */ int showpage; /* Internal page displayed in window */ int prevpage; /* Last page visited (for '-' command) */ int stoppage; /* Internal page where to stop */ FILE *ifile; /* The input file */ /* In order to avoid passing the file pointer around from parse() via t_page() to nextpage(), the input file is made available as a global variable. */ /* Initialize everything in the right order. Tricky! */ initialize(filename, firstpage) char *filename; int firstpage; { ifile= fopen(filename, "r"); if (ifile == NULL) error(ABORT, "%s: cannot open", filename); setpageinfo(ftell(ifile), 0); /* Page 0 (== header) starts here */ showpage= -1; /* Show no pages */ stoppage= 1; /* Stop at beginning of page 1 */ parse(ifile); /* Read the header */ initoutput(filename); /* Create the window */ showpage= 1; skiptopage(firstpage); } /* Close the file */ cleanup() { fclose(ifile); } /* Skip n pages forward, default 1 */ forwpage(n) int n; { if (n <= 0) n= 1; gotopage(showpage+n); } /* Skip n pages back, default 1 */ backpage(n) int n; { if (n <= 0) n= 1; gotopage(showpage-n); } /* Go to internal page number n, and force a redraw */ gotopage(n) int n; { int saveshowpage= showpage; skiptopage(n); if (showpage != saveshowpage) prevpage= saveshowpage; changeall(); } /* Skip to internal page number n -- don't force a redraw */ static skiptopage(n) int n; { int orign= n; if (n <= 0) n= 1; if (n == showpage) { if (orign < n) wfleep(); return; } if (n >= npages) { if (nomore) { n= npages-1; if (n == showpage) { wfleep(); return; } showpage= n; } else { backtopage(npages-1); showpage= -1; stoppage= n; parse(ifile); showpage= npages-1; } } else showpage= n; } /* Draw procedure */ void drawproc(drawwin, left, top, right, bottom) WINDOW *drawwin; int left, top, right, bottom; { topdraw= top; botdraw= bottom; backtopage(showpage); stoppage= showpage+1; parse(ifile); } /* Record the current file position as the start of the page with (external) page number 'pageno'. Note that the 'p' command has already been consumed by the parser. Return < 0 if the parser can stop parsing. */ int nextpage(pageno) int pageno; { ++ipage; setpageinfo(ftell(ifile), pageno); if (ipage >= stoppage) return -1; /* Stop parsing */ else return 0; } /* Indicate that the end of the input has been reached. No more new pages will be accepted. */ lastpage() { nomore= TRUE; } /* Store info about coming page. Called at start of file and after 'p' command processed */ static setpageinfo(filepos, pageno) long filepos; int pageno; { if (statep != state) error(FATAL, "setpageinfo: {} stack not empty"); if (ipage < npages) { /* We've been here already. Might as well check consistency. */ /* HIRO */ } else if (ipage > npages) error(ABORT, "setpageinfo: ipage>npages (can't happen)"); else { restartinfo r; r.filepos= filepos; r.pageno= pageno; r.fonts= fonts; r.font= font; r.size= size; L_APPEND(npages, pagelist, restartinfo, r); if (pagelist == NULL) error(FATAL, "out of mem for pagelist"); } } /* Position the input stream at the start of internal page i and restore the machine state to the state remembered for that page */ static backtopage(i) int i; { restartinfo *p; if (i < 0 || i >= npages) error(ABORT, "backtopage: called with wrong arg"); p= &pagelist[i]; if (fseek(ifile, p->filepos, 0) < 0) error(FATAL, "backtopage: can't fseek"); ipage= i; fonts= p->fonts; font= p->font; size= p->size; hpos= 0; vpos= 0; statep= state; usefont(); } tury Schoolbook */ {"cr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"ci", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"cb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"cI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Laurel */ {"lr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"li", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"lb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"lI", "times%dbsmtalk43/stdwin/Appls/dpv/figtest1006440003270021170000000611005434024301014232 037777777777 1 0 .lf 1 fstree.fig .\" fstree.fig 1.4 88/03/25 ... -2 -2.375 1.75 0.125 ... 0.000i 2.500i 3.750i 0.000i .nr 00 \n(.u .nf .PS 2.500i 3.750i .lf 28 \h'2.375i'\v'0.125i'\v'.2m'\h'-\w'/'u/2u'/\h'-\w'/'u/2u' .sp -1 \h'2.000i'\v'0.125i'\D'e0.750i 0.250i' .sp -1 \h'3.375i'\v'0.875i'\v'.2m'\h'-\w'vmunix'u/2u'vmunix\h'-\w'vmunix'u/2u' .sp -1 \h'3.000i'\v'1.000i'\D'l0.000i -0.250i' .sp -1 \h'3.000i'\v'0.750i'\D'l0.750i 0.000i' .sp -1 \h'3.750i'\v'0.750i'\D'l0.000i 0.250i' .sp -1 \h'3.750i'\v'1.000i'\D'l-0.750i 0.000i' .sp -1 \h'2.640i'\v'0.213i'\D'l0.734i 0.536i' .sp -1 \h'3.279i'\v'0.711i'\D'l0.095i 0.038i' .sp -1 \h'3.309i'\v'0.670i'\D'l0.066i 0.079i' .sp -1 \h'1.375i'\v'0.875i'\v'.2m'\h'-\w'usr'u/2u'usr\h'-\w'usr'u/2u' .sp -1 \h'1.000i'\v'0.875i'\D'e0.750i 0.250i' .sp -1 \h'2.109i'\v'0.213i'\D'l-0.734i 0.536i' .sp -1 \h'1.441i'\v'0.670i'\D'l-0.066i 0.079i' .sp -1 \h'1.470i'\v'0.711i'\D'l-0.095i 0.038i' .sp -1 \h'0.375i'\v'1.625i'\v'.2m'\h'-\w'foo'u/2u'foo\h'-\w'foo'u/2u' .sp -1 \v'1.750i'\D'l0.000i -0.250i' .sp -1 \v'1.500i'\D'l0.750i 0.000i' .sp -1 \h'0.750i'\v'1.500i'\D'l0.000i 0.250i' .sp -1 \h'0.750i'\v'1.750i'\D'l-0.750i 0.000i' .sp -1 \h'1.109i'\v'0.963i'\D'l-0.734i 0.536i' .sp -1 \h'0.441i'\v'1.420i'\D'l-0.066i 0.079i' .sp -1 \h'0.470i'\v'1.461i'\D'l-0.095i 0.038i' .sp -1 \h'1.375i'\v'1.625i'\v'.2m'\h'-\w'bin'u/2u'bin\h'-\w'bin'u/2u' .sp -1 \h'1.000i'\v'1.625i'\D'e0.750i 0.250i' .sp -1 \h'1.375i'\v'1.000i'\D'l0.000i 0.500i' .sp -1 \h'1.350i'\v'1.400i'\D'l0.025i 0.100i' .sp -1 \h'1.400i'\v'1.400i'\D'l-0.025i 0.100i' .sp -1 \h'0.375i'\v'2.375i'\v'.2m'\h'-\w'ls'u/2u'ls\h'-\w'ls'u/2u' .sp -1 \v'2.500i'\D'l0.000i -0.250i' .sp -1 \v'2.250i'\D'l0.750i 0.000i' .sp -1 \h'0.750i'\v'2.250i'\D'l0.000i 0.250i' .sp -1 \h'0.750i'\v'2.500i'\D'l-0.750i 0.000i' .sp -1 \h'1.109i'\v'1.713i'\D'l-0.734i 0.536i' .sp -1 \h'0.441i'\v'2.170i'\D'l-0.066i 0.079i' .sp -1 \h'0.470i'\v'2.211i'\D'l-0.095i 0.038i' .sp -1 \h'1.375i'\v'2.375i'\v'.2m'\h'-\w'vi'u/2u'vi\h'-\w'vi'u/2u' .sp -1 \h'1.000i'\v'2.500i'\D'l0.000i -0.250i' .sp -1 \h'1.000i'\v'2.250i'\D'l0.750i 0.000i' .sp -1 \h'1.750i'\v'2.250i'\D'l0.000i 0.250i' .sp -1 \h'1.750i'\v'2.500i'\D'l-0.750i 0.000i' .sp -1 \h'1.375i'\v'1.750i'\D'l0.000i 0.500i' .sp -1 \h'1.350i'\v'2.150i'\D'l0.025i 0.100i' .sp -1 \h'1.400i'\v'2.150i'\D'l-0.025i 0.100i' .sp -1 \h'2.375i'\v'1.625i'\v'.2m'\h'-\w'staff'u/2u'staff\h'-\w'staff'u/2u' .sp -1 \h'2.000i'\v'1.625i'\D'e0.750i 0.250i' .sp -1 \h'1.640i'\v'0.963i'\D'l0.734i 0.536i' .sp -1 \h'2.279i'\v'1.461i'\D'l0.095i 0.038i' .sp -1 \h'2.309i'\v'1.420i'\D'l0.066i 0.079i' .sp -1 \h'2.375i'\v'2.375i'\v'.2m'\h'-\w'mckusick'u/2u'mckusick\h'-\w'mckusick'u/2u' .sp -1 \h'2.000i'\v'2.375i'\D'e0.750i 0.250i' .sp -1 \h'2.375i'\v'1.750i'\D'l0.000i 0.500i' .sp -1 \h'2.350i'\v'2.150i'\D'l0.025i 0.100i' .sp -1 \h'2.400i'\v'2.150i'\D'l-0.025i 0.100i' .sp -1 \h'3.375i'\v'2.375i'\v'.2m'\h'-\w'karels'u/2u'karels\h'-\w'karels'u/2u' .sp -1 \h'3.000i'\v'2.375i'\D'e0.750i 0.250i' .sp -1 \h'2.640i'\v'1.713i'\D'l0.734i 0.536i' .sp -1 \h'3.279i'\v'2.211i'\D'l0.095i 0.038i' .sp -1 \h'3.309i'\v'2.170i'\D'l0.066i 0.079i' .sp -1 .sp 1+2.500i .PE .if \n(00 .fi .lf 28 0, 12, 14, 18, 24, 0,}, /* French Script */ {"RS", "-*-helvetica-medium-o-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Rose Script */ {"SO", "-*-helvetica-bold-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Scitype Open */ /* OCR-B (line printer font) */ {"lp", "-*-courier-bold-r-*--%d-*", R, 8, 10, 12, 0}, /* Small caps fonts mapped to normal fonts */ {"Rs", "-*-times-medium-r-*--%d-*", R, 8, 10, 12, 14, 18, 24, 0,}, /* Timsmtalk43/stdwin/Appls/dpv/funnyproto1006440003270021170000000024405434024301015012 037777777777 1 0 ff - "ff" fi - "fi" fl - "fl" Fi - "ffi" Fl - "ffl" AE - "AE" OE - "OE" ae - "ae" oe - "oe" \- - "-" \_ - "_" hy - "-" ru - "_" em - "-" aa - "'" ga - "`" ct - "c" e != ipage) return; fontname= fonts.name[font]; if (fontname != NULL) fonthack(fontname); /* Else, font not loaded -- assume in initialization phase */ baseline= wbaseline(); lineheight= wlineheight(); recheck(); } fonthack(fontname) char *fontname; { int i; int havesize; char *harname; char buf[256]; struct _translate *t; fsmtalk43/stdwin/Appls/dpv/funnytab1006440003270021170000000440305434024301014416 037777777777 1 0 oA r3symbol 0x22 oE r3symbol 0x24 cn r3symbol 0x27 ** r3symbol 0x2A pl r3symbol 0x2B mi r3symbol 0x2D sl r3symbol 0x2F eq r3symbol 0x3D =~ r3symbol 0x40 *A r3symbol 0x41 *B r3symbol 0x42 *X r3symbol 0x43 *D r3symbol 0x44 *E r3symbol 0x45 *F r3symbol 0x46 *G r3symbol 0x47 *Y r3symbol 0x48 *I r3symbol 0x49 *K r3symbol 0x4B *L r3symbol 0x4C *M r3symbol 0x4D *N r3symbol 0x4E *O r3symbol 0x4F *P r3symbol 0x50 *H r3symbol 0x51 *R r3symbol 0x52 *S r3symbol 0x53 *T r3symbol 0x54 *U r3symbol 0x55 ts r3symbol 0x56 *W r3symbol 0x57 *C r3symbol 0x58 *Q r3symbol 0x59 *Z r3symbol 0x5A ul r3symbol 0x5F rn r3symbol 0x60 *a r3symbol 0x61 *b r3symbol 0x62 *x r3symbol 0x63 *d r3symbol 0x64 *e r3symbol 0x65 *f r3symbol 0x66 *g r3symbol 0x67 *y r3symbol 0x68 *i r3symbol 0x69 *f r3symbol 0x6A *k r3symbol 0x6B *l r3symbol 0x6C *m r3symbol 0x6D *n r3symbol 0x6E *o r3symbol 0x6F *p r3symbol 0x70 *h r3symbol 0x71 *r r3symbol 0x72 *s r3symbol 0x73 *t r3symbol 0x74 *u r3symbol 0x75 *w r3symbol 0x77 *c r3symbol 0x78 *q r3symbol 0x79 *z r3symbol 0x7A or r3symbol 0x7C ap r3symbol 0x7E fm r3symbol 0xa2 <= r3symbol 0xa3 sl r3symbol 0xa4 if r3symbol 0xa5 $D r3symbol 0xa6 bs r3symbol 0xa9 lr r3symbol 0xaB <- r3symbol 0xaC ua r3symbol 0xaD -> r3symbol 0xaE da r3symbol 0xaF de r3symbol 0xb0 +- r3symbol 0xb1 >= r3symbol 0xb3 mu r3symbol 0xb4 pt r3symbol 0xb5 pd r3symbol 0xb6 bu r3symbol 0xb7 di r3symbol 0xb8 != r3symbol 0xb9 == r3symbol 0xbA ~= r3symbol 0xbB br r3symbol 0xbD Ah r3symbol 0xc0 c* r3symbol 0xc4 c+ r3symbol 0xc5 es r3symbol 0xc6 ca r3symbol 0xc7 cu r3symbol 0xc8 sp r3symbol 0xc9 ip r3symbol 0xcA sb r3symbol 0xcC ib r3symbol 0xcD mo r3symbol 0xcE nm r3symbol 0xcF an r3symbol 0xd0 gr r3symbol 0xd1 rg r3symbol 0xd2 co r3symbol 0xd3 sr r3symbol 0xd6 no r3symbol 0xd8 AN r3symbol 0xd9 OR r3symbol 0xdA <> r3symbol 0xdB Dl r3symbol 0xdC Du r3symbol 0xdD Dr r3symbol 0xdE Dd r3symbol 0xdF fo r3symbol 0xe1 lc r3symbol 0xe9 lf r3symbol 0xeB lt r3symbol 0xeC lk r3symbol 0xeD lb r3symbol 0xeE bv r3symbol 0xeF bs r3symbol 0xf0 fc r3symbol 0xf1 is r3symbol 0xf2 rc r3symbol 0xf9 rf r3symbol 0xfB rt r3symbol 0xfC rk r3symbol 0xfD rb r3symbol 0xfE ff - "ff" fi - "fi" fl - "fl" Fi - "ffi" Fl - "ffl" AE - "AE" OE - "OE" ae - "ae" oe - "oe" \- - "-" \_ - "_" hy - "-" ru - "_" em - "-" aa - "'" ga - "`" ct - "c" = NULL; nt = 0; line = 0; while (fgets(buf, sizeof buf, fp) != NULL) { line++; if (dbg > 1) fprintf(stderr, "line %d: %s\n", line, buf); p = buf; harname = gettok(&p); if (harname == NULL) continue; /* Blank line or comment */ xnamesmtalk43/stdwin/Appls/dpv/makefunny1007550003270021170000000015505434024301014570 037777777777 1 0 #!/bin/sh # Make funny character translation tables for file do sed "s/ - / `basename $file` /" $file done sizes == 0 ? defsizes : sizes); } if (dbg > 0) fprintf(stderr, "done reading translations.\n"); fclose(fp); if (nt == 0) error(FATAL, "%s: no valid font translations", filename); addtrans(&nt, &t, (char *)NULL, (char *)NULL, R, defsizes); translate = t; } smtalk43/stdwin/Appls/dpv/r3symbol1006440003270021170000000235505434024301014346 037777777777 1 0 oA - 0x22 oE - 0x24 cn - 0x27 ** - 0x2A pl - 0x2B mi - 0x2D sl - 0x2F eq - 0x3D =~ - 0x40 *A - 0x41 *B - 0x42 *X - 0x43 *D - 0x44 *E - 0x45 *F - 0x46 *G - 0x47 *Y - 0x48 *I - 0x49 *K - 0x4B *L - 0x4C *M - 0x4D *N - 0x4E *O - 0x4F *P - 0x50 *H - 0x51 *R - 0x52 *S - 0x53 *T - 0x54 *U - 0x55 ts - 0x56 *W - 0x57 *C - 0x58 *Q - 0x59 *Z - 0x5A ul - 0x5F rn - 0x60 *a - 0x61 *b - 0x62 *x - 0x63 *d - 0x64 *e - 0x65 *f - 0x66 *g - 0x67 *y - 0x68 *i - 0x69 *f - 0x6A *k - 0x6B *l - 0x6C *m - 0x6D *n - 0x6E *o - 0x6F *p - 0x70 *h - 0x71 *r - 0x72 *s - 0x73 *t - 0x74 *u - 0x75 *w - 0x77 *c - 0x78 *q - 0x79 *z - 0x7A or - 0x7C ap - 0x7E fm - 0xa2 <= - 0xa3 sl - 0xa4 if - 0xa5 $D - 0xa6 bs - 0xa9 lr - 0xaB <- - 0xaC ua - 0xaD -> - 0xaE da - 0xaF de - 0xb0 +- - 0xb1 >= - 0xb3 mu - 0xb4 pt - 0xb5 pd - 0xb6 bu - 0xb7 di - 0xb8 != - 0xb9 == - 0xbA ~= - 0xbB br - 0xbD Ah - 0xc0 c* - 0xc4 c+ - 0xc5 es - 0xc6 ca - 0xc7 cu - 0xc8 sp - 0xc9 ip - 0xcA sb - 0xcC ib - 0xcD mo - 0xcE nm - 0xcF an - 0xd0 gr - 0xd1 rg - 0xd2 co - 0xd3 sr - 0xd6 no - 0xd8 AN - 0xd9 OR - 0xdA <> - 0xdB Dl - 0xdC Du - 0xdD Dr - 0xdE Dd - 0xdF fo - 0xe1 lc - 0xe9 lf - 0xeB lt - 0xeC lk - 0xeD lb - 0xeE bv - 0xeF bs - 0xf0 fc - 0xf1 is - 0xf2 rc - 0xf9 rf - 0xfB rt - 0xfC rk - 0xfD rb - 0xfE decimal numbers, or a string enclosed in double quotes In any case the string may be no more than 3 characters long */ readfunnytab(filename) char *filename; { char buf[BUFSIZ]; FILE *fp= fopen(filename, "r"); if (fp == NULL) { if (dbg > 0) fprintf(stderr, smtalk43/stdwin/Appls/dpv/symbol1006440003270021170000000116605434024302014101 037777777777 1 0 oA - 0x22 oE - 0x24 cn - 0x27 ** - 0x2A pl - 0x2B mi - 0x2D sl - 0x2F eq - 0x3D =~ - 0x40 *A - 0x41 *B - 0x42 *X - 0x43 *D - 0x44 *E - 0x45 *F - 0x46 *G - 0x47 *Y - 0x48 *I - 0x49 *K - 0x4B *L - 0x4C *M - 0x4D *N - 0x4E *O - 0x4F *P - 0x50 *H - 0x51 *R - 0x52 *S - 0x53 *T - 0x54 *U - 0x55 ts - 0x56 *W - 0x57 *C - 0x58 *Q - 0x59 *Z - 0x5A ul - 0x5F rn - 0x60 *a - 0x61 *b - 0x62 *x - 0x63 *d - 0x64 *e - 0x65 *f - 0x66 *g - 0x67 *y - 0x68 *i - 0x69 *f - 0x6A *k - 0x6B *l - 0x6C *m - 0x6D *n - 0x6E *o - 0x6F *p - 0x70 *h - 0x71 *r - 0x72 *s - 0x73 *t - 0x74 *u - 0x75 *w - 0x77 *c - 0x78 *q - 0x79 *z - 0x7A or - 0x7C ap - 0x7E nt nfunny; struct _funny *funnytab; static addtranslation(name, fontname, trans) char *name, *fontname, *trans; { struct _funny f; strncpy(f.name, name, 4); f.name[3]= EOS; strncpy(f.trans, trans, 4); f.trans[3]= EOS; if (fontname == NULL || fontname[0] == EOS || fontname[0] == '-' && fontname[1] == EOS) f.fontname= NULL; else { static char *lastfontname; if (lastfontname ==smtalk43/stdwin/Appls/dpv/symbola1006440003270021170000000116605434024302014242 037777777777 1 0 fm - 0x22 <= - 0x23 sl - 0x24 if - 0x25 $D - 0x26 bs - 0x29 lr - 0x2B <- - 0x2C ua - 0x2D -> - 0x2E da - 0x2F de - 0x30 +- - 0x31 >= - 0x33 mu - 0x34 pt - 0x35 pd - 0x36 bu - 0x37 di - 0x38 != - 0x39 == - 0x3A ~= - 0x3B br - 0x3D Ah - 0x40 c* - 0x44 c+ - 0x45 es - 0x46 ca - 0x47 cu - 0x48 sp - 0x49 ip - 0x4A sb - 0x4C ib - 0x4D mo - 0x4E nm - 0x4F an - 0x50 gr - 0x51 rg - 0x52 co - 0x53 sr - 0x56 no - 0x58 AN - 0x59 OR - 0x5A <> - 0x5B Dl - 0x5C Du - 0x5D Dr - 0x5E Dd - 0x5F fo - 0x61 lc - 0x69 lf - 0x6B lt - 0x6C lk - 0x6D lb - 0x6E bv - 0x6F bs - 0x70 fc - 0x71 is - 0x72 rc - 0x79 rf - 0x7B rt - 0x7C rk - 0x7D rb - 0x7E inited= TRUE; } /* If this is too slow, could use binary search and/or replace the strcmp by an explicit comparison of two characters. But spend your time on the program's main loop (especially, 'put1') first! */ for (f= funnytab; f < &funnytab[nfunny]; ++f) { /* Assume names are always 1 or 2 chars */ if (f->name[0] == name[0] && f->name[1] == name[1]) break; } ifsmtalk43/stdwin/Appls/dpv/trans1006440003270021170000000411705434024302013722 037777777777 1 0 # Font translation tables for dpv for X11 R3 and R4 # ------------------------------------------------- # This will work for both -Tpsc and -Thar. # PostScript font names # --------------------- R -*-times-medium-r-*--%d-* I -*-times-medium-i-*--%d-* B -*-times-bold-r-*--%d-* BI -*-times-bold-i-*--%d-* H -*-helvetica-medium-r-*--%d-* HO -*-helvetica-medium-o-*--%d-* HB -*-helvetica-bold-r-*--%d-* HD -*-helvetica-bold-o-*--%d-* C -*-courier-medium-r-*--%d-* CO -*-courier-medium-o-*--%d-* CB -*-courier-bold-r-*--%d-* CD -*-courier-bold-o-*--%d-* # CW is a common alias for C CW -*-courier-medium-r-*--%d-* # CWI Harris font names (also R, I, B, BI) # ---------------------------------------- # Vega light, Vega, Vega medium (Helvetica look-alike) Vl -*-helvetica-medium-r-*--%d-* vl -*-helvetica-medium-o-*--%d-* V -*-helvetica-medium-r-*--%d-* v -*-helvetica-medium-o-*--%d-* Vm -*-helvetica-bold-r-*--%d-* vm -*-helvetica-bold-o-*--%d-* # Baskerville (see also small caps) br -*-times-medium-r-*--%d-* bi -*-times-medium-i-*--%d-* bb -*-times-bold-r-*--%d-* bI -*-times-bold-i-*--%d-* # Century Schoolbook cr -*-new?century?schoolbook-medium-r-*--%d-* ci -*-new?century?schoolbook-medium-i-*--%d-* cb -*-new?century?schoolbook-bold-r-*--%d-* cI -*-new?century?schoolbook-bold-i-*--%d-* # Laurel lr -*-times-medium-r-*--%d-* li -*-times-medium-i-*--%d-* lb -*-times-bold-r-*--%d-* lI -*-times-bold-i-*--%d-* # Funny fonts mapped to Helvetica, so at least they differ from Times G3 -*-helvetica-medium-r-*--%d-* # German no 3 fs -*-helvetica-medium-r-*--%d-* # French Script RS -*-helvetica-medium-o-*--%d-* # Rose Script SO -*-helvetica-bold-r-*--%d-* # Scitype Open # OCR-B (line printer font, only available in a few sizes) lp -*-courier-bold-r-*--%d-* 8 10 12 # Small caps fonts mapped to normal fonts Rs -*-times-medium-r-*--%d-* # Times Bs -*-times-bold-r-*--%d-* # Times bold bs -*-times-medium-r-*--%d-* # Baskerville bS -*-times-bold-r-*--%d-* # Baskerville bold # Font used by funny character translation # ---------------------------------------- r3symbol *-*-symbol-medium-r-*--%d-* for the end of a line */ t_newline() { hpos = 0; /* because we're now back at the left margin */ } /* Convert integer to internal size number */ t_size(n) int n; { return n; } /* Set character height to n */ /*ARGSUSED*/ t_charht(n) int n; { static bool warned; if (!warned) { error(WARNING, "Setting character height not implemented"); warned= TRUE; } } /* Set slant to n */ /*ARGSUSED*/ t_slant(n) int n; { stasmtalk43/stdwin/Appls/klok/0407550003270021170000000000005477556051012230 5 0 1 0 smtalk43/stdwin/Appls/klok/Make.proto1006440003270021170000000027205434024303014760 037777777777 1 0 # # Makefile prototype for klok application # KLOK= $(APPLS)/klok SRCS= \ $(KLOK)/klok.c \ $(KLOK)/bsdsetdate.c SRCLIBS= -lm all: klok _bootstrap: @putprogmf klok $(SRCS) 37777777777 1 0 smtalk43/stdwin/Appls/klok/amsetdate.c1006440003270021170000000117605465303017015143 037777777777 1 0 /* Set the date and time -- Amoeba version */ #include #include #include #include /* Set the date and time from a struct tm. The input time is in local time. If 'minchange' is zero, minutes and seconds are not taken from the input but from the current system time. */ int setdatetime(tp, minchange) struct tm *tp; int minchange; /* nonzero if we must reset minutes and seconds, too */ { time_t new; errstat err; new = mktime(tp); if (!minchange) new = new/3600*3600 + time((time_t *)0)%3600; if (tod_settime(new, 0) != STD_OK) { return -1; } else return 0; } osition, it is unlikely that restoring an environment on a different page makes any sense, so we could assume this (and check that the input conforms). */ /* Array dimensions */ #define NFONTS 65 /* total number of fonts usable */ #define MAXSTATE 6 /* number of environments rememberable */ /* Basic state */ extern int hpos; /* horizontal position we are to be at next; lesmtalk43/stdwin/Appls/klok/bsdsetdate.c1006440003270021170000000333305465303017015313 037777777777 1 0 /* Set the date and time -- 4.3 BSD Unix version */ #ifndef sun /* This is not needed on SunOS 4.03 (what about higher SunOS'es?). */ #include #endif #include #define isleap(y) ((y)%4 == 0 && ((y)%100 != 0 || (y)%400 == 0)) /* Convert a struct tm to seconds since Jan. 1, 1970. This knows nothing about time zones or daylight saving time. */ static unsigned long tm2tv(tp) struct tm *tp; { static short mdays[12]= {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; unsigned long s= 0; int y, m, d; for (y= 1970; y < tp->tm_year + 1900; ++y) { s += 365; if (isleap(y)) ++s; } mdays[1]= 28 + isleap(y); /* Months have origin 0 */ for (m= 0; m < tp->tm_mon; ++m) s += mdays[m]; s += tp->tm_mday - 1; return ((s*24 + tp->tm_hour)*60 + tp->tm_min)*60 /*+ tp->tm_sec*/; } /* Set the date and time from a struct tm. The Input time is in local time. If 'minchange' is zero, minutes and seconds are not taken from the input but from the current system time. */ setdatetime(tp, minchange) struct tm *tp; int minchange; /* nonzero if we must reset minutes and seconds, too */ { struct timeval tv; struct timezone tz; unsigned long t; t= tm2tv(tp); /* t is local time */ if (gettimeofday(&tv, &tz) != 0) return -1; if (tp->tm_isdst) t -= 3600; /* t is local time less DST */ t += tz.tz_minuteswest*60; /* t is GMT time */ if (minchange) t= t/60 * 60; /* Clear seconds */ else t= t/3600 * 3600 + tv.tv_sec % 3600; /* Use current min/sec */ tv.tv_sec= t; if (settimeofday(&tv, &tz) != 0) return -1; return 0; } #ifdef SYSV /* XXX How do you set the date/time on system V? */ int settimeofday(ptv, ptz) struct timeval *ptv; struct timezone *ptz; { return -1; } #endif the window */ initoutput(filename) char *filename; { int winwidth, winheight; int hmargin, vmargin; setscale(); wsetdefwinsize(paperwidth, paperheight); win= wopen(filename, drawproc); wsetdocsize(win, paperwidth, paperheight); wsetwincursor(win, wfetchcursor("arrow")); /* Centesmtalk43/stdwin/Appls/klok/klok.c1006440003270021170000004125005465303017014131 037777777777 1 0 /* Analog clock with alarm. Displays the date at the top, a circular clock in the middle, and the alarm time at the bottom of the window. The clock has two hands. Resizing the window recomputes the items' positions and sizes. When the alarm goes off, the clock window is made current, the clock face is inverted for 5 minutes, and a beep is emitted each minute. The alarm can be acknowledged explicitly, which silences it until the next time the alarm goes off. Dragging the hands of the clock can be used to set the time (and the date, if you care to drag around several times). The alarm is currently set through a dialog only. TO DO: - make the display prettier (how??? everything I design gets ugly :-( ) - display alarm time as tick mark? - improve the alarm setting procedure - add more general 'nag' and 'calendar'-like facilities - add a button to allow/disallow setting the time - add a way to change the date directly - turn it into a subroutine package like VT or editwin - organize the code top-down instead of bottom-up */ #include "tools.h" #include "stdwin.h" #include #include #include #include /* For time_t, on some systems */ #ifndef PI #define PI 3.14159265359 #endif /* Alarm parametrizations */ #ifndef DEF_ALARM #define DEF_ALARM -1 /* Initial setting of alarm */ #endif #ifndef ALARMTIME #define ALARMTIME 5 /* Alarm goes for this many minutes */ #endif /* Relative hand sizes */ #define LITPERC 60 /* Little hand size (percent of radius) */ #define BIGPERC 80 /* Big hand size */ #define SECPERC 100 /* Seconds hand size */ /* Menu items */ #define SETALARM 0 #define CLEARALARM 1 #define OKALARM 2 #define SECONDSHAND 4 #define QUIT 6 /* Global variables */ char *progname = "klok"; /* Program name (for error messages) */ char *title; /* Menu title (default capitalized progname) */ WINDOW *win; /* Clock window */ MENU *mp; /* Menu pointer */ int centh, centv; /* Clock center */ int radius; /* Clock radius */ struct tm curtime; /* Current time/date */ int alarm = DEF_ALARM; /* Alarm time (hh*60 + mm); -1 if off */ bool alarmed; /* Is it alarm time? */ bool okayed; /* Has the current alarm been OK'ed? */ bool excited; /* == (alarmed && !okayed) */ bool do_seconds; /* Set if drawing 'seconds' hand */ /* Force a redraw of the entire window */ changeall() { wchange(win, 0, 0, 10000, 10000); } /* Compute the sine of an angle given in clock units (zero at 12 o'clock, full circle is 60). We cache the sine values in a table, since calling sin is too slow on some systems. */ double sine(i) int i; { static double sines[15+1]; static bool inited; if (!inited) { int k; inited = TRUE; for (k = 0; k <= 15; ++k) sines[k] = sin(k * PI/30); } i = i % 60; if (i < 0) i += 60; if (i <= 15) return sines[i]; if (i <= 30) return sines[30-i]; if (i <= 45) return -sines[i-30]; return -sines[60-i]; } /* Compute the cosine (from the sine) */ double cosine(i) int i; { return sine(i+15); } /* Compute the absolute position of the endpoint of a line drawn at i minutes, whose length is a certain percentage of the radius */ void endpoint(i, perc, ph, pv) int i; /* Minutes */ int perc; /* Percentage of length */ int *ph, *pv; /* Return values */ { double s = sine(i), c = cosine(i); *ph = centh + s*perc*radius/100 + 0.5; *pv = centv - c*perc*radius/100 + 0.5; } /* Draw a mark at i minutes. Marks at hour positions are longer, every 3 hours even longer. */ void drawmark(i) int i; { int begh, begv; int endh, endv; int len; endpoint(i, 100, &endh, &endv); if (i % 5 != 0) len = 3; else if (i % 15 != 0) len = 8; else len = 19; endpoint(i, 100-len, &begh, &begv); wdrawline(begh, begv, endh, endv); } /* Draw a hand at i minutes, whose length is a given percentage of the radius */ void drawhand(i, perc) int i; int perc; { int endh, endv; endpoint(i, perc, &endh, &endv); wdrawline(centh, centv, endh, endv); } /* Draw a hand in XOR mode */ void xorhand(i, perc) int i; int perc; { int endh, endv; endpoint(i, perc, &endh, &endv); wxorline(centh, centv, endh, endv); } /* Draw the date in the top left corner */ void drawdate(tp) struct tm *tp; { char buf[100]; sprintf(buf, "%02d/%02d/%02d", tp->tm_year % 100, tp->tm_mon+1, tp->tm_mday); werase(0, 0, 10000, centv - radius); wdrawtext(0, centv - radius - wlineheight(), buf, -1); } /* Draw the alarm time in the bottom left corner */ void drawalarm() { char buf[100]; sprintf(buf, "*%02d:%02d", alarm/60, alarm%60); wdrawtext(0, centv + radius, buf, -1); } /* Compute the AM/MP/Noon/Midnight indicator character */ int ampm(tp) struct tm *tp; { if (tp->tm_min == 0 && tp->tm_hour%12 == 0) { if (tp->tm_hour == 12) return 'N'; else return 'M'; } else if (tp->tm_hour < 12) return 'A'; else return 'P'; } /* Draw the AM/PM/Noon/Midnight indicator in the top right corner */ void drawampm(c) int c; { int dh = wcharwidth('M'); int dv = wlineheight(); int h = centh + radius - dh; int v = centv - radius - dv; werase(h, v, h+dh, v+dv); wdrawchar(h, v, c); } #ifdef UGLY /* Draw a shaded square around the clock */ #define SHOFF 4 void drawborder() { int d = radius * 10/9; int left = centh-d, top = centv-d, right = centh+d, bottom = centv+d; wdrawbox(left, top, right, bottom); wshade(right, top+4, right+4, bottom+4, 50); wshade(left+4, bottom, right, bottom+4, 50); } /* Draw a shaded circle around the clock's face; the shadow is on the top left side, so the face appeares to be slightly *lower* than the surrounding material. Also a thin vertical line to indicate 6 and 12 o'clock. */ void drawoutline() { wdrawcircle(centh-1, centv-1, radius+2); wdrawelarc(centh-1, centv-1, radius+1, radius+1, 45-10, 45+180+10); wdrawelarc(centh-1, centv-1, radius , radius , 45+10, 45+180-10); wdrawline(centh, centv-radius, centh, centv+radius); } #endif /*UGLY*/ /* Compute the little hand position from hour, min */ int littlehand(hour, min) int hour, min; { return (hour*5 + (min+6)/12) % 60; } /* Draw procedure */ void drawproc(win, left, top, right, bottom) WINDOW *win; { int i; /* Draw the fixed elements of the clock */ #ifdef UGLY drawborder(); drawoutline(); #else #ifdef macintosh wdrawcircle(centh+1, centv+1, radius+1); #else wdrawcircle(centh, centv, radius); #endif for (i = 0; i < 12; ++i) drawmark(i*5); /* Hour marks */ #endif /* Draw the hands */ drawhand(curtime.tm_min, BIGPERC); i = littlehand(curtime.tm_hour, curtime.tm_min); if (i != curtime.tm_min) xorhand(i, LITPERC); if (do_seconds) xorhand(curtime.tm_sec, SECPERC); /* Draw the other elements */ drawdate(&curtime); drawampm(ampm(&curtime)); if (alarm >= 0) drawalarm(); /* Invert if the alarm is going */ if (excited) winvert(0, 0, 10000, 10000); } /* Compute the nearest clock angle corresponding to absolute position (h, v) */ int whereis(h, v) int h, v; { double dnew; h -= centh; v -= centv; if (h == 0 && v == 0) return 0; dnew = atan2((double)h, (double)(-v)) * 30.0 / PI; if (dnew < 0) dnew += 60.0; return ((int)(dnew + 0.5)) % 60; } /* Show a change in time with minimal redrawing */ showchange(old, new) struct tm *old, *new; { int litold = littlehand(old->tm_hour, old->tm_min); int litnew = littlehand(new->tm_hour, new->tm_min); int newampm = ampm(new); wbegindrawing(win); if (do_seconds && old->tm_sec != new->tm_sec) { xorhand(old->tm_sec, SECPERC); xorhand(new->tm_sec, SECPERC); } if (old->tm_min != new->tm_min) { xorhand(old->tm_min, BIGPERC); xorhand(new->tm_min, BIGPERC); } if (litold != litnew || litold == old->tm_min || litnew == new->tm_min) { if (litold != old->tm_min) xorhand(litold, LITPERC); if (litnew != new->tm_min) xorhand(litnew, LITPERC); } if (old->tm_mday != new->tm_mday) drawdate(new); if (newampm != ampm(old)) drawampm(newampm); wenddrawing(win); } /* Leap year calculation. Input is year - 1900 (but may be >= 100). */ int isleap(year) int year; { year += 1900; return year%4 == 0 && (year%100 != 0 || year%400 == 0); } /* Increment a time variable in minutes, and show the change */ void incrshowtime(tp, incr) struct tm *tp; int incr; { struct tm old; static int mdays[12]= {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; mdays[1] = 28 + isleap(tp->tm_year); old = *tp; tp->tm_min += incr; while (tp->tm_min >= 60) { tp->tm_min -= 60; tp->tm_hour++; if (tp->tm_hour >= 24) { tp->tm_hour -= 24; tp->tm_mday++; tp->tm_wday = (tp->tm_wday + 1) % 7; if (tp->tm_mday > mdays[tp->tm_mon]) { tp->tm_mday = 1; tp->tm_mon++; if (tp->tm_mon >= 12) { tp->tm_mon = 0; tp->tm_year++; mdays[1] = 28 + isleap(tp->tm_year); } } } } while (tp->tm_min < 0) { tp->tm_min += 60; tp->tm_hour--; if (tp->tm_hour < 0) { tp->tm_hour += 24; tp->tm_mday--; tp->tm_wday = (tp->tm_wday + 6) % 7; if (tp->tm_mday < 1) { tp->tm_mon--; if (tp->tm_mon < 0) { tp->tm_mon = 11; tp->tm_year--; mdays[1] = 28 + isleap(tp->tm_year); } tp->tm_mday = mdays[tp->tm_mon]; } } } showchange(&old, tp); } /* Drag the little hand */ void draglittlehand(h, v) int h, v; { EVENT e; struct tm newtime; int i; newtime = curtime; wsettimer(win, 0); do { wgetevent(&e); if (e.type != WE_MOUSE_MOVE && e.type != WE_MOUSE_UP) { showchange(&newtime, &curtime); wungetevent(&e); return; } i = whereis(e.u.where.h, e.u.where.v) / 5; if ((i - newtime.tm_hour) % 12 != 0) { int diff = i - newtime.tm_hour; while (diff > 6) diff -= 12; while (diff < -6) diff += 12; incrshowtime(&newtime, diff*60); } } while (e.type != WE_MOUSE_UP); setdatetime(&newtime, FALSE); curtime = newtime; } /* Drag the big hand */ void dragbighand(h, v) int h, v; { EVENT e; struct tm newtime; int i; newtime = curtime; wsettimer(win, 0); do { wgetevent(&e); if (e.type != WE_MOUSE_MOVE && e.type != WE_MOUSE_UP) { showchange(&newtime, &curtime); wungetevent(&e); return; } i = whereis(e.u.where.h, e.u.where.v); if (i != newtime.tm_min) { int diff = i - newtime.tm_min; if (diff > 30) diff -= 60; else if (diff < -30) diff += 60; incrshowtime(&newtime, diff); } } while (e.type != WE_MOUSE_UP); setdatetime(&newtime, TRUE); curtime = newtime; } /* Test whether the given position lies on the hand at the given clock angle with the given length percentage */ bool testhand(h, v, pos, perc) int h, v; int pos; int perc; { long dist2 = (h-centh)*(h-centh)+ (v-centv)*(v-centv); long length2 = ((long)radius*perc/100) * ((long)radius*perc/100); if (dist2 > length2) return FALSE; if ((whereis(h, v) - pos) % 60 != 0) return FALSE; return TRUE; } /* Recompute the time and the alarm parameters. Called every minute, and when other parameters may have changed. */ void newtime(flash) bool flash; { struct tm oldtime; time_t now; bool wasalarmed; /* Save the old time displayed */ oldtime = curtime; /* Get the current time */ time(&now); curtime = *localtime(&now); /* Set the window timer to go off at the next tick */ if (do_seconds) { wsettimer(win, 10); } else { if (curtime.tm_sec >= 59) { /* When we wake up just at the end of the minute, (which may happen if STDWIN isn't very precise), pretend it's a bit later, to avoid waking up again in a second */ curtime.tm_sec -= 60; curtime.tm_min += 1; } wsettimer(win, 10 * (60 - curtime.tm_sec)); } /* Check whether the alarm should go off */ wasalarmed = alarmed; if (!wasalarmed) okayed = FALSE; if (alarm >= 0) { int a = alarm; int hhmm = curtime.tm_hour*60 + curtime.tm_min; if (hhmm < 60 && a >= 23*60) hhmm += 24*60; /* Correct for wrap-around */ alarmed = hhmm >= a && hhmm < a+ALARMTIME; } else { alarmed = okayed = FALSE; } excited = alarmed && !okayed; if (excited) { if (!wasalarmed) wsetactive(win); wfleep(); } if (excited || wasalarmed && !okayed) flash = TRUE; wmenuenable(mp, OKALARM, excited); /* Redraw the clock face or schedule a redraw */ if (flash) { changeall(); } else { showchange(&oldtime, &curtime); } } /* Time-setting procedure by dragging the hands around */ void changehand(h, v) int h, v; { /* Test the little hand first, so that if the hands overlap, a click near the center implies the little hand and a click further away implies the big hand */ if (testhand(h, v, littlehand(curtime.tm_hour, curtime.tm_min), LITPERC)) { /* Drag the little hand -- minutes stay unchanged */ draglittlehand(h, v); } else if (testhand(h, v, curtime.tm_min, BIGPERC)) { /* Drag the big hand -- hours may change, too */ dragbighand(h, v); } else { /* No hit -- make some noise */ wfleep(); } newtime(FALSE); } /* Recompute the clock size and position and the time/alarm information. Called initially and when the window is resized. */ void getallinfo() { int width, height; wgetwinsize(win, &width, &height); centh = width/2; centv = height/2; radius = centv - wlineheight(); CLIPMAX(radius, centh); newtime(TRUE); } /* Set the alarm time from a string formatted as hhmm */ bool setalarm(str) char *str; { int al; if (str[0] == EOS || str[0] == '-' && str[1] == EOS) { alarm = -1; wmenuenable(mp, CLEARALARM, FALSE); return TRUE; } al = atoi(str); if (al < 0 || al > 2400 || al%60 >= 60) return FALSE; if (al == 2400) al = 0; alarm = (al/100)*60 + al%100; wmenuenable(mp, CLEARALARM, TRUE); return TRUE; } /* Set up the menu */ void buildmenu() { wmenusetdeflocal(TRUE); mp = wmenucreate(1, "Klok"); wmenuadditem(mp, "Set alarm...", 'S'); wmenuadditem(mp, "Clear alarm", 'C'); wmenuadditem(mp, "OK alarm", 'O'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Seconds Hand", 'H'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Quit", 'Q'); wmenuenable(mp, CLEARALARM, alarm >= 0); wmenucheck(mp, SECONDSHAND, do_seconds); } /* Handle a menu selection */ void domenu(item) int item; { bool flash = FALSE; switch (item) { case SETALARM: { char buf[6]; if (alarm < 0) buf[0] = EOS; else sprintf(buf, "%02d%02d", alarm/60, alarm%60); if (!waskstr("Set alarm:", buf, sizeof buf)) return; if (!setalarm(buf)) wmessage("Invalid alarm (must be hhmm)"); okayed = FALSE; flash = TRUE; break; } case CLEARALARM: if (alarm >= 0) { setalarm(""); flash = TRUE; } break; case OKALARM: if (excited) { flash = okayed = TRUE; } break; case SECONDSHAND: do_seconds = !do_seconds; wmenucheck(mp, SECONDSHAND, do_seconds); wbegindrawing(win); xorhand(curtime.tm_sec, SECPERC); wenddrawing(win); break; case QUIT: wclose(win); wdone(); exit(0); break; } newtime(flash); } #ifndef macintosh /* Print usage message and exit; called for command line errors */ void usage() { wdone(); fprintf(stderr, "usage: %s [-s] [-m] [-a hhmm] [-t title]\n", progname); exit(2); } #endif /* Main program */ main(argc, argv) int argc; char **argv; { /* Initialize */ winitargs(&argc, &argv); buildmenu(); /* Must be done before setalarm is called */ /* Find out program name */ if (argc > 0) { progname = strrchr(argv[0], '/'); if (progname == NULL) progname = argv[0]; else ++progname; } #ifndef macintosh /* Parse command line */ for (;;) { int c = getopt(argc, argv, "msa:t:"); if (c == EOF) break; switch (c) { case 's': do_seconds = TRUE; break; case 'm': do_seconds = FALSE; break; case 'a': if (!setalarm(optarg)) usage(); break; case 't': title = optarg; break; default: usage(); /*NOTREACHED*/ } } wmenucheck(mp, SECONDSHAND, do_seconds); #endif /* Create the window */ wsetdefwinsize(120, 120); win = wopen(title == NULL ? progname : title, drawproc); wmenuattach(win, mp); /* Main loop */ getallinfo(); for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: if (excited) domenu(OKALARM); else changehand(e.u.where.h, e.u.where.v); break; case WE_MENU: if (e.u.m.id == 1) domenu(e.u.m.item); break; case WE_CHAR: if (excited) break; switch (e.u.character) { case 's': case 'S': domenu(SETALARM); break; case 'c': case 'C': domenu(CLEARALARM); break; case 'h': case 'H': domenu(SECONDSHAND); break; case 'q': case 'Q': domenu(QUIT); break; } break; case WE_COMMAND: switch (e.u.command) { case WC_RETURN: newtime(FALSE); break; case WC_CLOSE: case WC_CANCEL: domenu(QUIT); break; } break; case WE_CLOSE: domenu(QUIT); break; case WE_SIZE: getallinfo(); break; case WE_TIMER: newtime(FALSE); break; } } } , R, 8, 10, 12, 16, 22, 0,}, {"ci", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"cb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"cI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Laurel */ {"lr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"li", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"lb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"lI", "times%dbsmtalk43/stdwin/Appls/miniedit/0407550003270021170000000000005477556054013075 5 0 1 0 smtalk43/stdwin/Appls/miniedit/Make.proto1006440003270021170000000034005434024304015617 037777777777 1 0 # # Makefile prototype for miniedit application # MINIEDIT= $(APPLS)/miniedit SRCS= \ $(MINIEDIT)/miniedit.c \ $(MINIEDIT)/regexp.c \ $(MINIEDIT)/regsub.c all: miniedit _bootstrap: @putprogmf miniedit $(SRCS) i'\v'0.875i'\D'e0.750i 0.250i' .sp -1 \h'2.109i'\v'0.213i'\D'l-0.734i 0.536i' .sp -1 \h'1.441i'\v'0.670i'\D'l-0.066i 0.079i' .sp -1 \h'1.470i'\v'0.711i'\D'l-0.095i 0.038i' .sp -1 \h'0.375i'\v'1.625i'\v'.2m'\h'-\w'foo'u/2u'foo\h'-\w'foo'u/2u' .sp -1 \v'1.750i'\D'l0.000i -0.250i' .sp -1 \vsmtalk43/stdwin/Appls/miniedit/miniedit.c1006440003270021170000001512305465303017015635 037777777777 1 0 /* Mini-editor using editwin module */ #include "stdwin.h" #include "tools.h" #include "editwin.h" main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); menusetup(); openfiles(argc, argv); mainloop(); wdone(); exit(0); } MENU *filemenu, *editmenu, *findmenu; #define FILE_MENU 1 #define EDIT_MENU 2 #define FIND_MENU 3 /* File items */ #define NEW_ITEM 0 #define OPEN_ITEM 1 #define CLOSE_ITEM 3 #define SAVE_ITEM 4 #define SAVE_AS_ITEM 5 #define SAVE_COPY_ITEM 6 #define REVERT_ITEM 7 #define QUIT_ITEM 9 /* Edit items */ #define UNDO_ITEM 0 #define CUT_ITEM 2 #define COPY_ITEM 3 #define PASTE_ITEM 4 #define CLEAR_ITEM 5 #define SEL_ALL_ITEM 6 #define EXEC_ITEM 8 /* Find items */ #define FIND_ITEM 0 #define FIND_SAME_ITEM 1 #define REPL_ITEM 3 #define REPL_SAME_ITEM 4 #define REPL_ALL_ITEM 5 menusetup() { MENU *mp; filemenu= mp= wmenucreate(FILE_MENU, "File"); wmenuadditem(mp, "New", 'N'); wmenuadditem(mp, "Open...", 'o'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Close", 'K'); wmenuadditem(mp, "Save", 'S'); wmenuadditem(mp, "Save as...", -1); wmenuadditem(mp, "Save a Copy...", -1); wmenuadditem(mp, "Revert to Saved", -1); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Quit", 'Q'); editmenu= mp= wmenucreate(EDIT_MENU, "Edit"); wmenuadditem(mp, "Undo", 'Z'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Cut", 'X'); wmenuadditem(mp, "Copy", 'C'); wmenuadditem(mp, "Paste", 'V'); wmenuadditem(mp, "Clear", 'B'); wmenuadditem(mp, "Select All", 'A'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Execute", '\r'); findmenu= mp= wmenucreate(FIND_MENU, "Find"); wmenuadditem(mp, "Find...", 'F'); wmenuadditem(mp, "Find Same", 'G'); wmenuadditem(mp, "", -1); wmenuadditem(mp, "Replace...", 'R'); wmenuadditem(mp, "Replace Same", 'T'); wmenuadditem(mp, "Replace All", -1); } fixmenus(ew) EDITWIN *ew; { bool focus; if (ew == NULL) return; wmenuenable(filemenu, SAVE_ITEM, !ew->saved); wmenuenable(filemenu, REVERT_ITEM, !ew->saved); wmenuenable(editmenu, UNDO_ITEM, FALSE); wmenuenable(editmenu, EXEC_ITEM, FALSE); focus= tegetfoc1(ew->tp) < tegetfoc2(ew->tp); wmenuenable(editmenu, CUT_ITEM, focus); wmenuenable(editmenu, COPY_ITEM, focus); wmenuenable(editmenu, CLEAR_ITEM, focus); } openfiles(argc, argv) int argc; char **argv; { int i; for (i= 1; i < argc; ++i) { (void) ewcreate(argv[i]); } if (ewcount() == 0) { if (ewopen() == NULL && ewnew() == NULL) { wdone(); fprintf(stderr, "Can't open any windows\n"); exit(1); } } } mainloop() { for (;;) { EVENT e; EDITWIN *ew; wgetevent(&e); ew= ewfind(e.window); switch (e.type) { case WE_MENU: switch (e.u.m.id) { case FILE_MENU: switch (e.u.m.item) { case NEW_ITEM: (void) ewnew(); break; case OPEN_ITEM: (void) ewopen(); break; case CLOSE_ITEM: if (ew != NULL) { ewclose(ew); if (ewcount() == 0) return; } break; case SAVE_ITEM: if (ew != NULL) ewsave(ew); break; case SAVE_AS_ITEM: if (ew != NULL) ewsaveas(ew); break; case SAVE_COPY_ITEM: if (ew != NULL) ewsavecopy(ew); break; case REVERT_ITEM: if (ew != NULL) ewrevert(ew); break; case QUIT_ITEM: if (ewcloseall()) return; break; } break; case EDIT_MENU: if (ew == NULL) { wfleep(); break; } switch (e.u.m.item) { case UNDO_ITEM: ewundo(ew); break; case CUT_ITEM: ewcopy(ew); ewreplace(ew, ""); break; case COPY_ITEM: ewcopy(ew); break; case PASTE_ITEM: ewpaste(ew); break; case CLEAR_ITEM: ewreplace(ew, ""); break; case SEL_ALL_ITEM: tesetfocus(ew->tp, 0, tegetlen(ew->tp)); break; case EXEC_ITEM: wfleep(); break; } break; case FIND_MENU: switch (e.u.m.item) { case FIND_ITEM: find(ew, TRUE); break; case FIND_SAME_ITEM: find(ew, FALSE); break; case REPL_ITEM: replace(ew, TRUE); break; case REPL_SAME_ITEM: replace(ew, FALSE); break; case REPL_ALL_ITEM: replall(ew); break; } break; } break; default: if (ew != NULL) { bool closed; ewevent(ew, &e, &closed); if (closed && ewcount() == 0) return; } break; } fixmenus(ew); } } #include "regexp.h" char whatbuf[256]; /* Last regular expression typed */ regexp *prog; /* Compiled regular expression */ char replbuf[256]; /* Last replacement string */ bool find(ew, dodialog) EDITWIN *ew; bool dodialog; { return finddialog(ew, dodialog, "Find regular expression:") && findit(ew, FALSE); } bool replace(ew, dodialog) EDITWIN *ew; bool dodialog; { if (!finddialog(ew, dodialog, "Replace regular expression:") || !findit(ew, TRUE)) return FALSE; wupdate(ew->win); /* Show what we've found */ return repldialog(ew, dodialog) && replit(ew); } replall(ew) EDITWIN *ew; { if (!replace(ew, TRUE)) return FALSE; while (findit(ew, TRUE)) { wupdate(ew->win); replit(ew); wupdate(ew->win); /* What if it takes forever? */ } return TRUE; } bool finddialog(ew, dodialog, prompt) EDITWIN *ew; bool dodialog; char *prompt; { if (ew == NULL) return FALSE; if (dodialog || prog == NULL) { if (!waskstr(prompt, whatbuf, sizeof whatbuf)) return FALSE; if (prog != NULL) free((char*)prog); prog= regcomp(whatbuf); if (prog == NULL) return FALSE; } return TRUE; } bool repldialog(ew, dodialog) EDITWIN *ew; bool dodialog; { if (!dodialog) return TRUE; return waskstr("Replacement string:", replbuf, sizeof replbuf); } bool findit(ew, begin) EDITWIN *ew; bool begin; /* TRUE if must start at foc1 */ { int foc1= tegetfoc1(ew->tp); int foc2= tegetfoc2(ew->tp); int len= tegetlen(ew->tp); char *text= tegettext(ew->tp); if (!reglexec(prog, text, begin ? foc1 : foc2)) { wfleep(); return FALSE; } if (!begin && prog->startp[0] == text+foc2 && foc1 == foc2 && prog->startp[0] == prog->endp[0]) { /* Found empty string at empty focus; try again at next position (if in range) */ if (++foc2 > len) return FALSE; if (!reglexec(prog, text, foc2)) { wfleep(); return FALSE; } } tesetfocus(ew->tp, (int)(prog->startp[0] - text), (int)(prog->endp[0] - text)); return TRUE; } bool replit(ew) EDITWIN *ew; { char substbuf[1024]; /* Should be bigger -- what if the entire file matches? */ regsub(prog, replbuf, substbuf); ewreplace(ew, substbuf); return TRUE; } void regerror(str) char *str; { char buf[256]; sprintf(buf, "Regular expression error: %s", str); wmessage(buf); } name $file` /" $file done sizes == 0 ? defsizes : sizes); } if (dbg > 0) fprintf(stderr, "done reading translations.\n"); fclose(fp); if (nt == 0) error(FATAL, "%s: no valid font translations", filename); addtrans(&nt, &t, (char *)NULL, (char *)NULL, R, defsizes); translate = t; } smtalk43/stdwin/Appls/miniedit/regexp.c1006440003270021170000007443005465303017015333 037777777777 1 0 /* * regcomp and regexec -- regsub and regerror are elsewhere * * Copyright (c) 1986 by University of Toronto. * Written by Henry Spencer. Not derived from licensed software. #ifdef MULTILINE * Changed by Guido van Rossum, CWI, Amsterdam * for multi-line support. #endif * * Permission is granted to anyone to use this software for any * purpose on any computer system, and to redistribute it freely, * subject to the following restrictions: * * 1. The author is not responsible for the consequences of use of * this software, no matter how awful, even if they arise * from defects in it. * * 2. The origin of this software must not be misrepresented, either * by explicit claim or by omission. * * 3. Altered versions must be plainly marked as such, and must not * be misrepresented as being the original software. * * Beware that some of this code is subtly aware of the way operator * precedence is structured in regular expressions. Serious changes in * regular-expression syntax might require a total rethink. */ #include #include "regexp.h" #include "regmagic.h" #ifdef MULTILINE /* * Defining MULTILINE turns on the following changes in the semantics: * 1. The '.' operator matches all characters except a newline. * 2. The '^' operator matches at the beginning of the string or after * a newline. (Anchored matches are retried after each newline.) * 3. The '$' operator matches at the end of the string or before * a newline. * 4. A '\' followed by an 'n' matches a newline. (This is an * unfortunate exception to the rule that '\' followed by a * character matches that character...) * * Also, there is a new function reglexec(prog, string, offset) * which searches for a match starting at 'string+offset'; * it differs from regexec(prog, string+offset) in assuming * that the line begins at 'string'. */ #endif /* * The "internal use only" fields in regexp.h are present to pass info from * compile to execute that permits the execute phase to run lots faster on * simple cases. They are: * * regstart char that must begin a match; '\0' if none obvious * reganch is the match anchored (at beginning-of-line only)? * regmust string (pointer into program) that match must include, or NULL * regmlen length of regmust string * * Regstart and reganch permit very fast decisions on suitable starting points * for a match, cutting down the work a lot. Regmust permits fast rejection * of lines that cannot possibly match. The regmust tests are costly enough * that regcomp() supplies a regmust only if the r.e. contains something * potentially expensive (at present, the only such thing detected is * or + * at the start of the r.e., which can involve a lot of backup). Regmlen is * supplied because the test in regexec() needs it and regcomp() is computing * it anyway. */ /* * Structure for regexp "program". This is essentially a linear encoding * of a nondeterministic finite-state machine (aka syntax charts or * "railroad normal form" in parsing technology). Each node is an opcode * plus a "next" pointer, possibly plus an operand. "Next" pointers of * all nodes except BRANCH implement concatenation; a "next" pointer with * a BRANCH on both ends of it is connecting two alternatives. (Here we * have one of the subtle syntax dependencies: an individual BRANCH (as * opposed to a collection of them) is never concatenated with anything * because of operator precedence.) The operand of some types of node is * a literal string; for others, it is a node leading into a sub-FSM. In * particular, the operand of a BRANCH node is the first node of the branch. * (NB this is *not* a tree structure: the tail of the branch connects * to the thing following the set of BRANCHes.) The opcodes are: */ /* definition number opnd? meaning */ #define END 0 /* no End of program. */ #define BOL 1 /* no Match "" at beginning of line. */ #define EOL 2 /* no Match "" at end of line. */ #define ANY 3 /* no Match any one character. */ #define ANYOF 4 /* str Match any character in this string. */ #define ANYBUT 5 /* str Match any character not in this string. */ #define BRANCH 6 /* node Match this alternative, or the next... */ #define BACK 7 /* no Match "", "next" ptr points backward. */ #define EXACTLY 8 /* str Match this string. */ #define NOTHING 9 /* no Match empty string. */ #define STAR 10 /* node Match this (simple) thing 0 or more times. */ #define PLUS 11 /* node Match this (simple) thing 1 or more times. */ #define OPEN 20 /* no Mark this point in input as start of #n. */ /* OPEN+1 is number 1, etc. */ #define CLOSE 30 /* no Analogous to OPEN. */ /* * Opcode notes: * * BRANCH The set of branches constituting a single choice are hooked * together with their "next" pointers, since precedence prevents * anything being concatenated to any individual branch. The * "next" pointer of the last BRANCH in a choice points to the * thing following the whole choice. This is also where the * final "next" pointer of each individual branch points; each * branch starts with the operand node of a BRANCH node. * * BACK Normal "next" pointers all implicitly point forward; BACK * exists to make loop structures possible. * * STAR,PLUS '?', and complex '*' and '+', are implemented as circular * BRANCH structures using BACK. Simple cases (one character * per match) are implemented with STAR and PLUS for speed * and to minimize recursive plunges. * * OPEN,CLOSE ...are numbered at compile time. */ /* * A node is one char of opcode followed by two chars of "next" pointer. * "Next" pointers are stored as two 8-bit pieces, high order first. The * value is a positive offset from the opcode of the node containing it. * An operand, if any, simply follows the node. (Note that much of the * code generation knows about this implicit relationship.) * * Using two bytes for the "next" pointer is vast overkill for most things, * but allows patterns to get big without disasters. */ #define OP(p) (*(p)) #define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377)) #define OPERAND(p) ((p) + 3) /* * See regmagic.h for one further detail of program structure. */ /* * Utility definitions. */ #ifndef CHARBITS #define UCHARAT(p) ((int)*(unsigned char *)(p)) #else #define UCHARAT(p) ((int)*(p)&CHARBITS) #endif #define FAIL(m) { regerror(m); return(NULL); } #define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?') #define META "^$.[()|?+*\\" /* * Flags to be passed up and down. */ #define HASWIDTH 01 /* Known never to match null string. */ #define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */ #define SPSTART 04 /* Starts with * or +. */ #define WORST 0 /* Worst case. */ /* * Global work variables for regcomp(). */ static char *regparse; /* Input-scan pointer. */ static int regnpar; /* () count. */ static char regdummy; static char *regcode; /* Code-emit pointer; ®dummy = don't. */ static long regsize; /* Code size. */ #ifdef MULTILINE static int regnl; /* '\n' detected. */ #endif /* * Forward declarations for regcomp()'s friends. */ #ifndef STATIC #define STATIC static #endif STATIC char *reg(); STATIC char *regbranch(); STATIC char *regpiece(); STATIC char *regatom(); STATIC char *regnode(); STATIC char *regnext(); STATIC void regc(); STATIC void reginsert(); STATIC void regtail(); STATIC void regoptail(); #ifdef STRCSPN STATIC int strcspn(); #endif /* - regcomp - compile a regular expression into internal code * * We can't allocate space until we know how big the compiled form will be, * but we can't compile it (and thus know how big it is) until we've got a * place to put the code. So we cheat: we compile it twice, once with code * generation turned off and size counting turned on, and once "for real". * This also means that we don't allocate space until we are sure that the * thing really will compile successfully, and we never have to move the * code and thus invalidate pointers into it. (Note that it has to be in * one piece because free() must be able to free it all.) * * Beware that the optimization-preparation code in here knows about some * of the structure of the compiled regexp. */ regexp * regcomp(exp) char *exp; { register regexp *r; register char *scan; register char *longest; register int len; int flags; extern char *malloc(); if (exp == NULL) FAIL("NULL argument"); /* First pass: determine size, legality. */ regparse = exp; regnpar = 1; regsize = 0L; regcode = ®dummy; #ifdef MULTILINE regnl = 0; #endif regc(MAGIC); if (reg(0, &flags) == NULL) return(NULL); /* Small enough for pointer-storage convention? */ if (regsize >= 32767L) /* Probably could be 65535L. */ FAIL("regexp too big"); /* Allocate space. */ r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize); if (r == NULL) FAIL("out of space"); /* Second pass: emit code. */ regparse = exp; regnpar = 1; regcode = r->program; regc(MAGIC); if (reg(0, &flags) == NULL) return(NULL); /* Dig out information for optimizations. */ r->regstart = '\0'; /* Worst-case defaults. */ r->reganch = 0; r->regmust = NULL; r->regmlen = 0; scan = r->program+1; /* First BRANCH. */ if (OP(regnext(scan)) == END) { /* Only one top-level choice. */ scan = OPERAND(scan); /* Starting-point info. */ if (OP(scan) == EXACTLY) r->regstart = *OPERAND(scan); else if (OP(scan) == BOL) r->reganch++; /* * If there's something expensive in the r.e., find the * longest literal string that must appear and make it the * regmust. Resolve ties in favor of later strings, since * the regstart check works with the beginning of the r.e. * and avoiding duplication strengthens checking. Not a * strong reason, but sufficient in the absence of others. */ #ifdef MULTILINE if ((flags&SPSTART) && !regnl) { #else if (flags&SPSTART) { #endif longest = NULL; len = 0; for (; scan != NULL; scan = regnext(scan)) if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) { longest = OPERAND(scan); len = strlen(OPERAND(scan)); } r->regmust = longest; r->regmlen = len; } } return(r); } /* - reg - regular expression, i.e. main body or parenthesized thing * * Caller must absorb opening parenthesis. * * Combining parenthesis handling with the base level of regular expression * is a trifle forced, but the need to tie the tails of the branches to what * follows makes it hard to avoid. */ static char * reg(paren, flagp) int paren; /* Parenthesized? */ int *flagp; { register char *ret; register char *br; register char *ender; register int parno; int flags; *flagp = HASWIDTH; /* Tentatively. */ /* Make an OPEN node, if parenthesized. */ if (paren) { if (regnpar >= NSUBEXP) FAIL("too many ()"); parno = regnpar; regnpar++; ret = regnode(OPEN+parno); } else ret = NULL; /* Pick up the branches, linking them together. */ br = regbranch(&flags); if (br == NULL) return(NULL); if (ret != NULL) regtail(ret, br); /* OPEN -> first. */ else ret = br; if (!(flags&HASWIDTH)) *flagp &= ~HASWIDTH; *flagp |= flags&SPSTART; while (*regparse == '|') { regparse++; br = regbranch(&flags); if (br == NULL) return(NULL); regtail(ret, br); /* BRANCH -> BRANCH. */ if (!(flags&HASWIDTH)) *flagp &= ~HASWIDTH; *flagp |= flags&SPSTART; } /* Make a closing node, and hook it on the end. */ ender = regnode((paren) ? CLOSE+parno : END); regtail(ret, ender); /* Hook the tails of the branches to the closing node. */ for (br = ret; br != NULL; br = regnext(br)) regoptail(br, ender); /* Check for proper termination. */ if (paren && *regparse++ != ')') { FAIL("unmatched ()"); } else if (!paren && *regparse != '\0') { if (*regparse == ')') { FAIL("unmatched ()"); } else FAIL("junk on end"); /* "Can't happen". */ /* NOTREACHED */ } return(ret); } /* - regbranch - one alternative of an | operator * * Implements the concatenation operator. */ static char * regbranch(flagp) int *flagp; { register char *ret; register char *chain; register char *latest; int flags; *flagp = WORST; /* Tentatively. */ ret = regnode(BRANCH); chain = NULL; while (*regparse != '\0' && *regparse != '|' && *regparse != ')') { latest = regpiece(&flags); if (latest == NULL) return(NULL); *flagp |= flags&HASWIDTH; if (chain == NULL) /* First piece. */ *flagp |= flags&SPSTART; else regtail(chain, latest); chain = latest; } if (chain == NULL) /* Loop ran zero times. */ (void) regnode(NOTHING); return(ret); } /* - regpiece - something followed by possible [*+?] * * Note that the branching code sequences used for ? and the general cases * of * and + are somewhat optimized: they use the same NOTHING node as * both the endmarker for their branch list and the body of the last branch. * It might seem that this node could be dispensed with entirely, but the * endmarker role is not redundant. */ static char * regpiece(flagp) int *flagp; { register char *ret; register char op; register char *next; int flags; ret = regatom(&flags); if (ret == NULL) return(NULL); op = *regparse; if (!ISMULT(op)) { *flagp = flags; return(ret); } if (!(flags&HASWIDTH) && op != '?') FAIL("*+ operand could be empty"); *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH); if (op == '*' && (flags&SIMPLE)) reginsert(STAR, ret); else if (op == '*') { /* Emit x* as (x&|), where & means "self". */ reginsert(BRANCH, ret); /* Either x */ regoptail(ret, regnode(BACK)); /* and loop */ regoptail(ret, ret); /* back */ regtail(ret, regnode(BRANCH)); /* or */ regtail(ret, regnode(NOTHING)); /* null. */ } else if (op == '+' && (flags&SIMPLE)) reginsert(PLUS, ret); else if (op == '+') { /* Emit x+ as x(&|), where & means "self". */ next = regnode(BRANCH); /* Either */ regtail(ret, next); regtail(regnode(BACK), ret); /* loop back */ regtail(next, regnode(BRANCH)); /* or */ regtail(ret, regnode(NOTHING)); /* null. */ } else if (op == '?') { /* Emit x? as (x|) */ reginsert(BRANCH, ret); /* Either x */ regtail(ret, regnode(BRANCH)); /* or */ next = regnode(NOTHING); /* null. */ regtail(ret, next); regoptail(ret, next); } regparse++; if (ISMULT(*regparse)) FAIL("nested *?+"); return(ret); } /* - regatom - the lowest level * * Optimization: gobbles an entire sequence of ordinary characters so that * it can turn them into a single node, which is smaller to store and * faster to run. Backslashed characters are exceptions, each becoming a * separate node; the code is simpler that way and it's not worth fixing. */ static char * regatom(flagp) int *flagp; { register char *ret; int flags; *flagp = WORST; /* Tentatively. */ switch (*regparse++) { case '^': ret = regnode(BOL); break; case '$': ret = regnode(EOL); break; case '.': ret = regnode(ANY); *flagp |= HASWIDTH|SIMPLE; break; case '[': { register int class; register int classend; if (*regparse == '^') { /* Complement of range. */ ret = regnode(ANYBUT); regparse++; } else ret = regnode(ANYOF); if (*regparse == ']' || *regparse == '-') regc(*regparse++); while (*regparse != '\0' && *regparse != ']') { if (*regparse == '-') { regparse++; if (*regparse == ']' || *regparse == '\0') regc('-'); else { class = UCHARAT(regparse-2)+1; classend = UCHARAT(regparse); if (class > classend+1) FAIL("invalid [] range"); for (; class <= classend; class++) regc(class); regparse++; } } else regc(*regparse++); } regc('\0'); if (*regparse != ']') FAIL("unmatched []"); regparse++; *flagp |= HASWIDTH|SIMPLE; } break; case '(': ret = reg(1, &flags); if (ret == NULL) return(NULL); *flagp |= flags&(HASWIDTH|SPSTART); break; case '\0': case '|': case ')': FAIL("internal urp"); /* Supposed to be caught earlier. */ break; case '?': case '+': case '*': FAIL("?+* follows nothing"); break; case '\\': if (*regparse == '\0') FAIL("trailing \\"); ret = regnode(EXACTLY); #ifdef MULTILINE if (*regparse == 'n') { regc('\n'); regparse++; regnl++; } else #endif regc(*regparse++); regc('\0'); *flagp |= HASWIDTH|SIMPLE; break; default: { register int len; register char ender; regparse--; len = strcspn(regparse, META); if (len <= 0) FAIL("internal disaster"); ender = *(regparse+len); if (len > 1 && ISMULT(ender)) len--; /* Back off clear of ?+* operand. */ *flagp |= HASWIDTH; if (len == 1) *flagp |= SIMPLE; ret = regnode(EXACTLY); while (len > 0) { #ifdef MULTILINE if (*regparse == '\n') regnl++; #endif regc(*regparse++); len--; } regc('\0'); } break; } return(ret); } /* - regnode - emit a node */ static char * /* Location. */ regnode(op) char op; { register char *ret; register char *ptr; ret = regcode; if (ret == ®dummy) { regsize += 3; return(ret); } ptr = ret; *ptr++ = op; *ptr++ = '\0'; /* Null "next" pointer. */ *ptr++ = '\0'; regcode = ptr; return(ret); } /* - regc - emit (if appropriate) a byte of code */ static void regc(b) char b; { if (regcode != ®dummy) *regcode++ = b; else regsize++; } /* - reginsert - insert an operator in front of already-emitted operand * * Means relocating the operand. */ static void reginsert(op, opnd) char op; char *opnd; { register char *src; register char *dst; register char *place; if (regcode == ®dummy) { regsize += 3; return; } src = regcode; regcode += 3; dst = regcode; while (src > opnd) *--dst = *--src; place = opnd; /* Op node, where operand used to be. */ *place++ = op; *place++ = '\0'; *place++ = '\0'; } /* - regtail - set the next-pointer at the end of a node chain */ static void regtail(p, val) char *p; char *val; { register char *scan; register char *temp; register int offset; if (p == ®dummy) return; /* Find last node. */ scan = p; for (;;) { temp = regnext(scan); if (temp == NULL) break; scan = temp; } if (OP(scan) == BACK) offset = scan - val; else offset = val - scan; *(scan+1) = (offset>>8)&0377; *(scan+2) = offset&0377; } /* - regoptail - regtail on operand of first argument; nop if operandless */ static void regoptail(p, val) char *p; char *val; { /* "Operandless" and "op != BRANCH" are synonymous in practice. */ if (p == NULL || p == ®dummy || OP(p) != BRANCH) return; regtail(OPERAND(p), val); } /* * regexec and friends */ /* * Global work variables for regexec(). */ static char *reginput; /* String-input pointer. */ static char *regbol; /* Beginning of input, for ^ check. */ static char **regstartp; /* Pointer to startp array. */ static char **regendp; /* Ditto for endp. */ /* * Forwards. */ STATIC int regtry(); STATIC int regmatch(); STATIC int regrepeat(); #ifdef DEBUG int regnarrate = 0; void regdump(); STATIC char *regprop(); #endif /* - regexec - match a regexp against a string */ int regexec(prog, string) register regexp *prog; register char *string; { register char *s; extern char *strchr(); /* Be paranoid... */ if (prog == NULL || string == NULL) { regerror("NULL parameter"); return(0); } #ifdef MULTILINE /* Check for \n in string, and if so, call the more general routine. */ if (strchr(string, '\n') != NULL) return reglexec(prog, string, 0); #endif /* Check validity of program. */ if (UCHARAT(prog->program) != MAGIC) { regerror("corrupted program"); return(0); } /* If there is a "must appear" string, look for it. */ if (prog->regmust != NULL) { s = string; while ((s = strchr(s, prog->regmust[0])) != NULL) { if (strncmp(s, prog->regmust, prog->regmlen) == 0) break; /* Found it. */ s++; } if (s == NULL) /* Not present. */ return(0); } /* Mark beginning of line for ^ . */ regbol = string; /* Simplest case: anchored match need be tried only once. */ if (prog->reganch) return(regtry(prog, string)); /* Messy cases: unanchored match. */ s = string; if (prog->regstart != '\0') /* We know what char it must start with. */ while ((s = strchr(s, prog->regstart)) != NULL) { if (regtry(prog, s)) return(1); s++; } else /* We don't -- general case. */ do { if (regtry(prog, s)) return(1); } while (*s++ != '\0'); /* Failure. */ return(0); } #ifdef MULTILINE /* - reglexec - match a regexp against a long string buffer, starting at offset */ int reglexec(prog, string, offset) register regexp *prog; register char *string; { register char *s; extern char *strchr(); /* Be paranoid... */ if (prog == NULL || string == NULL) { regerror("NULL parameter"); return(0); } /* Check validity of program. */ if (UCHARAT(prog->program) != MAGIC) { regerror("corrupted program"); return(0); } /* (Don't look for "must appear" string -- string can be long.) */ /* Mark beginning of line for ^ . */ regbol = string; /* Apply offset. Assume 0 <= offset <= strlen(string), but don't check, as string can be long. */ s= string + offset; /* Anchored match need be tried only at line starts. */ if (prog->reganch) { while (!regtry(prog, s)) { s = strchr(s, '\n'); if (s == NULL) return(0); s++; } return(1); } /* Messy cases: unanchored match. */ if (prog->regstart != '\0') /* We know what char it must start with. */ while ((s = strchr(s, prog->regstart)) != NULL) { if (regtry(prog, s)) return(1); s++; } else /* We don't -- general case. */ do { if (regtry(prog, s)) return(1); } while (*s++ != '\0'); /* Failure. */ return(0); } #endif /* - regtry - try match at specific point */ static int /* 0 failure, 1 success */ regtry(prog, string) regexp *prog; char *string; { register int i; register char **sp; register char **ep; reginput = string; regstartp = prog->startp; regendp = prog->endp; sp = prog->startp; ep = prog->endp; for (i = NSUBEXP; i > 0; i--) { *sp++ = NULL; *ep++ = NULL; } if (regmatch(prog->program + 1)) { prog->startp[0] = string; prog->endp[0] = reginput; return(1); } else return(0); } /* - regmatch - main matching routine * * Conceptually the strategy is simple: check to see whether the current * node matches, call self recursively to see whether the rest matches, * and then act accordingly. In practice we make some effort to avoid * recursion, in particular by going through "ordinary" nodes (that don't * need to know whether the rest of the match failed) by a loop instead of * by recursion. */ static int /* 0 failure, 1 success */ regmatch(prog) char *prog; { register char *scan; /* Current node. */ char *next; /* Next node. */ extern char *strchr(); scan = prog; #ifdef DEBUG if (scan != NULL && regnarrate) fprintf(stderr, "%s(\n", regprop(scan)); #endif while (scan != NULL) { #ifdef DEBUG if (regnarrate) fprintf(stderr, "%s...\n", regprop(scan)); #endif next = regnext(scan); switch (OP(scan)) { case BOL: #ifdef MULTILINE if (!(reginput == regbol || reginput > regbol && *(reginput-1) == '\n')) #else if (reginput != regbol) #endif return(0); break; case EOL: #ifdef MULTILINE if (*reginput != '\0' && *reginput != '\n') #else if (*reginput != '\0') #endif return(0); break; case ANY: #ifdef MULTILINE if (*reginput == '\0' || *reginput == '\n') #else if (*reginput == '\0') #endif return(0); reginput++; break; case EXACTLY: { register int len; register char *opnd; opnd = OPERAND(scan); /* Inline the first character, for speed. */ if (*opnd != *reginput) return(0); len = strlen(opnd); if (len > 1 && strncmp(opnd, reginput, len) != 0) return(0); reginput += len; } break; case ANYOF: if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL) return(0); reginput++; break; case ANYBUT: #ifdef MULTILINE if (*reginput == '\0' || *reginput == '\n' || strchr(OPERAND(scan), *reginput) != NULL) #else if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL) #endif return(0); reginput++; break; case NOTHING: break; case BACK: break; case OPEN+1: case OPEN+2: case OPEN+3: case OPEN+4: case OPEN+5: case OPEN+6: case OPEN+7: case OPEN+8: case OPEN+9: { register int no; register char *save; no = OP(scan) - OPEN; save = reginput; if (regmatch(next)) { /* * Don't set startp if some later * invocation of the same parentheses * already has. */ if (regstartp[no] == NULL) regstartp[no] = save; return(1); } else return(0); } break; case CLOSE+1: case CLOSE+2: case CLOSE+3: case CLOSE+4: case CLOSE+5: case CLOSE+6: case CLOSE+7: case CLOSE+8: case CLOSE+9: { register int no; register char *save; no = OP(scan) - CLOSE; save = reginput; if (regmatch(next)) { /* * Don't set endp if some later * invocation of the same parentheses * already has. */ if (regendp[no] == NULL) regendp[no] = save; return(1); } else return(0); } break; case BRANCH: { register char *save; if (OP(next) != BRANCH) /* No choice. */ next = OPERAND(scan); /* Avoid recursion. */ else { do { save = reginput; if (regmatch(OPERAND(scan))) return(1); reginput = save; scan = regnext(scan); } while (scan != NULL && OP(scan) == BRANCH); return(0); /* NOTREACHED */ } } break; case STAR: case PLUS: { register char nextch; register int no; register char *save; register int min; /* * Lookahead to avoid useless match attempts * when we know what character comes next. */ nextch = '\0'; if (OP(next) == EXACTLY) nextch = *OPERAND(next); min = (OP(scan) == STAR) ? 0 : 1; save = reginput; no = regrepeat(OPERAND(scan)); while (no >= min) { /* If it could work, try it. */ if (nextch == '\0' || *reginput == nextch) if (regmatch(next)) return(1); /* Couldn't or didn't -- back up. */ no--; reginput = save + no; } return(0); } break; case END: return(1); /* Success! */ break; default: regerror("memory corruption"); return(0); break; } scan = next; } /* * We get here only if there's trouble -- normally "case END" is * the terminating point. */ regerror("corrupted pointers"); return(0); } /* - regrepeat - repeatedly match something simple, report how many */ static int regrepeat(p) char *p; { register int count = 0; register char *scan; register char *opnd; #ifdef MULTILINE register char *eol; #endif scan = reginput; opnd = OPERAND(p); switch (OP(p)) { case ANY: #ifdef MULTILINE if ((eol = strchr(scan, '\n')) != NULL) { count += eol - scan; scan = eol; break; } #endif count = strlen(scan); scan += count; break; case EXACTLY: while (*opnd == *scan) { count++; scan++; } break; case ANYOF: while (*scan != '\0' && strchr(opnd, *scan) != NULL) { count++; scan++; } break; case ANYBUT: #ifdef MULTILINE while (*scan != '\0' && *scan != '\n' && strchr(opnd, *scan) == NULL) { #else while (*scan != '\0' && strchr(opnd, *scan) == NULL) { #endif count++; scan++; } break; default: /* Oh dear. Called inappropriately. */ regerror("internal foulup"); count = 0; /* Best compromise. */ break; } reginput = scan; return(count); } /* - regnext - dig the "next" pointer out of a node */ static char * regnext(p) register char *p; { register int offset; if (p == ®dummy) return(NULL); offset = NEXT(p); if (offset == 0) return(NULL); if (OP(p) == BACK) return(p-offset); else return(p+offset); } #ifdef DEBUG STATIC char *regprop(); /* - regdump - dump a regexp onto stdout in vaguely comprehensible form */ void regdump(r) regexp *r; { register char *s; register char op = EXACTLY; /* Arbitrary non-END op. */ register char *next; extern char *strchr(); s = r->program + 1; while (op != END) { /* While that wasn't END last time... */ op = OP(s); printf("%2d%s", s-r->program, regprop(s)); /* Where, what. */ next = regnext(s); if (next == NULL) /* Next ptr. */ printf("(0)"); else printf("(%d)", (s-r->program)+(next-s)); s += 3; if (op == ANYOF || op == ANYBUT || op == EXACTLY) { /* Literal string, where present. */ while (*s != '\0') { #ifdef MULTILINE if (*s == '\n') printf("\\n"); else #endif putchar(*s); s++; } s++; } putchar('\n'); } /* Header fields of interest. */ if (r->regstart != '\0') printf("start `%c' ", r->regstart); if (r->reganch) printf("anchored "); if (r->regmust != NULL) printf("must have \"%s\"", r->regmust); printf("\n"); } /* - regprop - printable representation of opcode */ static char * regprop(op) char *op; { register char *p; static char buf[50]; (void) strcpy(buf, ":"); switch (OP(op)) { case BOL: p = "BOL"; break; case EOL: p = "EOL"; break; case ANY: p = "ANY"; break; case ANYOF: p = "ANYOF"; break; case ANYBUT: p = "ANYBUT"; break; case BRANCH: p = "BRANCH"; break; case EXACTLY: p = "EXACTLY"; break; case NOTHING: p = "NOTHING"; break; case BACK: p = "BACK"; break; case END: p = "END"; break; case OPEN+1: case OPEN+2: case OPEN+3: case OPEN+4: case OPEN+5: case OPEN+6: case OPEN+7: case OPEN+8: case OPEN+9: sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN); p = NULL; break; case CLOSE+1: case CLOSE+2: case CLOSE+3: case CLOSE+4: case CLOSE+5: case CLOSE+6: case CLOSE+7: case CLOSE+8: case CLOSE+9: sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE); p = NULL; break; case STAR: p = "STAR"; break; case PLUS: p = "PLUS"; break; default: regerror("corrupted opcode"); break; } if (p != NULL) (void) strcat(buf, p); return(buf); } #endif /* * The following is provided for those people who do not have strcspn() in * their C libraries. They should get off their butts and do something * about it; at least one public-domain implementation of those (highly * useful) string routines has been published on Usenet. */ #ifdef STRCSPN /* * strcspn - find length of initial segment of s1 consisting entirely * of characters not from s2 */ static int strcspn(s1, s2) char *s1; char *s2; { register char *scan1; register char *scan2; register int count; count = 0; for (scan1 = s1; *scan1 != '\0'; scan1++) { for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */ if (*scan1 == *scan2++) return(count); count++; } return(count); } #endif , 22, 0,}, {"cI", "times%dbi", R, 8, 10, 12, 16, 22, 0,}, /* Laurel */ {"lr", "times%d", R, 8, 10, 12, 16, 22, 0,}, {"li", "times%di", R, 8, 10, 12, 16, 22, 0,}, {"lb", "times%db", R, 8, 10, 12, 16, 22, 0,}, {"lI", "times%dbsmtalk43/stdwin/Appls/miniedit/regexp.h1006440003270021170000000125305434024305015325 037777777777 1 0 /* * Definitions etc. for regexp(3) routines. * * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof], * not the System V one. */ #ifdef THINK_C #define STATIC /**/ #endif #define MULTILINE #define NSUBEXP 10 typedef struct regexp { char *startp[NSUBEXP]; char *endp[NSUBEXP]; char regstart; /* Internal use only. */ char reganch; /* Internal use only. */ char *regmust; /* Internal use only. */ int regmlen; /* Internal use only. */ char program[1]; /* Unwarranted chumminess with compiler. */ } regexp; extern regexp *regcomp(); extern int regexec(); #ifdef MULTILINE extern int reglexec(); #endif extern void regsub(); extern void regerror(); miniedit _bootstrap: @putprogmf miniedit $(SRCS) i'\v'0.875i'\D'e0.750i 0.250i' .sp -1 \h'2.109i'\v'0.213i'\D'l-0.734i 0.536i' .sp -1 \h'1.441i'\v'0.670i'\D'l-0.066i 0.079i' .sp -1 \h'1.470i'\v'0.711i'\D'l-0.095i 0.038i' .sp -1 \h'0.375i'\v'1.625i'\v'.2m'\h'-\w'foo'u/2u'foo\h'-\w'foo'u/2u' .sp -1 \v'1.750i'\D'l0.000i -0.250i' .sp -1 \vsmtalk43/stdwin/Appls/miniedit/regmagic.h1006440003270021170000000023105434024305015604 037777777777 1 0 /* * The first byte of the regexp internal "program" is actually this magic * number; the start node begins in the second byte. */ #define MAGIC 0234 gs(&argc, &argv); menusetup(); openfiles(argc, argv); mainloop(); wdone(); exit(0); } MENU *filemenu, *editmenu, *findmenu; #define FILE_MENU 1 #define EDIT_MENU 2 #define FIND_MENU 3 /* File items */ #define NEW_ITEM 0 #define OPEN_ITEM 1 #define CLOSE_ITEM 3 #define SAVE_ITEM 4 #define SAVE_AS_ITEM 5 #define SAVE_COPY_ITEM 6 #define REVERT_ITEM 7 smtalk43/stdwin/Appls/miniedit/regsub.c1006440003270021170000000414605465303017015325 037777777777 1 0 /* * regsub * * Copyright (c) 1986 by University of Toronto. * Written by Henry Spencer. Not derived from licensed software. #ifdef MULTILINE * Changed by Guido van Rossum, CWI, Amsterdam * for multi-line support. #endif * * Permission is granted to anyone to use this software for any * purpose on any computer system, and to redistribute it freely, * subject to the following restrictions: * * 1. The author is not responsible for the consequences of use of * this software, no matter how awful, even if they arise * from defects in it. * * 2. The origin of this software must not be misrepresented, either * by explicit claim or by omission. * * 3. Altered versions must be plainly marked as such, and must not * be misrepresented as being the original software. */ #include #include "regexp.h" #include "regmagic.h" #ifndef CHARBITS #define UCHARAT(p) ((int)*(unsigned char *)(p)) #else #define UCHARAT(p) ((int)*(p)&CHARBITS) #endif /* - regsub - perform substitutions after a regexp match */ void regsub(prog, source, dest) regexp *prog; char *source; char *dest; { register char *src; register char *dst; register char c; register int no; register int len; extern char *strncpy(); if (prog == NULL || source == NULL || dest == NULL) { regerror("NULL parm to regsub"); return; } if (UCHARAT(prog->program) != MAGIC) { regerror("damaged regexp fed to regsub"); return; } src = source; dst = dest; while ((c = *src++) != '\0') { if (c == '&') no = 0; else if (c == '\\' && '0' <= *src && *src <= '9') no = *src++ - '0'; else no = -1; if (no < 0) { /* Ordinary character. */ if (c == '\\' && (*src == '\\' || *src == '&')) c = *src++; #ifdef MULTILINE else if (c == '\\' && *src == 'n') { c = '\n'; src++; } #endif *dst++ = c; } else if (prog->startp[no] != NULL && prog->endp[no] != NULL) { len = prog->endp[no] - prog->startp[no]; (void) strncpy(dst, prog->startp[no], len); dst += len; if (len != 0 && *(dst-1) == '\0') { /* strncpy hit NUL. */ regerror("damaged match string"); return; } } } *dst++ = '\0'; } ) ewsavecopy(ew); break; case REVERT_ITEM: if (ew != NULL) ewrevert(ew); break; case QUIT_ITEM: if (ewcloseall()) return; break; } break; case EDIT_MENU: if (ew == NULL) { wfleep(); break; } switch (e.u.m.item) { case UNDO_ITEM: ewundo(ew); break; case CUT_ITEM: ewcopy(ew); ewreplace(ew, ""); smtalk43/stdwin/Appls/repeat/0407550003270021170000000000005477556054012553 5 0 1 0 smtalk43/stdwin/Appls/repeat/Make.proto1006440003270021170000000024105434024305015276 037777777777 1 0 # # Makefile prototype for repeat application # REPEAT= $(APPLS)/repeat SRCS= \ $(REPEAT)/repeat.c all: repeat _bootstrap: @putprogmf repeat $(SRCS) ool replace(ew, dodialog) EDITWIN *ew; bool dodialog; { if (!finddialog(ew, dodialog, "Replace regular expression:") || !findit(ew, TRUE)) return FALSE; wupdate(ew->win); /* Show what we've found */ return repldialog(ew, dodialog) && replit(ew); } replall(ew) EDITWIN *ew; { if (!replace(ew, TRUE)) return FALSE; while (findit(ew, TRUE)smtalk43/stdwin/Appls/repeat/repeat.c1006440003270021170000001512305465303017014771 037777777777 1 0 /* Repeat a command forever, displaying the output in a window. This is useful to have a continuously update from status programs like 'ps' or 'lpq'. Usage: repeat [-d delay] command [arg] ... To do: - adapt textedit width to window width? - allocate image buffer dynamically - more sensible error handling (allow to cancel) - add a menu option to change the delay - display the delay somehow - use d.ddd seconds notation instead of deciseconds - avoid flickering screen in X11 version (possibly by using tereplace on the smallest changed section, except need a way to turn the caret off???) */ #include #include #include extern char *malloc(); WINDOW *win; TEXTEDIT *tp; #define MAXSIZE 10000 #define DELAY 5 /* retry after success in 0.5 seconds */ #define ERRDELAY 50 /* retry after popen error in 5 seconds */ int delay = DELAY; /* normal delay */ int errdelay = ERRDELAY; /* delay after popen error */ int tflag = 0; /* Display time above output when set */ char *progname = "REPEAT"; void usage() { wdone(); fprintf(stderr, "usage: %s [-d ddd.d] [-e ddd.d] [-t] cmd [arg] ...\n", progname); fprintf(stderr, "-d ddd.d: delay N seconds after command\n"); fprintf(stderr, "-e ddd.d: delay N seconds after error\n"); fprintf(stderr, "-t : display current time above output\n"); exit(2); } extern int optind; extern char *optarg; void mainloop(); void rerun(); void drawproc(); char *mktitle(); long getfract(); int main(argc, argv) int argc; char **argv; { int c; winitargs(&argc, &argv); /* Must be first for X11 */ if (argc > 0 && argv[0] != NULL && argv[0][0] != '\0') progname = argv[0]; while ((c = getopt(argc, argv, "d:e:t")) != EOF) { switch (c) { case 'd': delay = getfract(&optarg, 10); if (*optarg != '\0') { fprintf(stderr, "-d argument format error\n"); usage(); } if (delay <= 0) delay = DELAY; break; case 'e': errdelay = getfract(&optarg, 10); if (*optarg != '\0') { fprintf(stderr, "-e argument format error\n"); usage(); } if (errdelay <= 0) errdelay = ERRDELAY; break; case 't': tflag = 1; break; default: usage(); /*NOTREACHED*/ } } if (optind >= argc) { usage(); /* NOTREACHED*/ } win = wopen(mktitle(argc-optind, argv+optind), drawproc); if (win == NULL) { wdone(); fprintf(stderr, "can't open window\n"); return 1; } tp = tecreate(win, 0, 0, 10000, 10000); if (tp == NULL) { wclose(win); wdone(); fprintf(stderr, "can't create textedit block\n"); return 1; } mainloop(argc-optind, argv+optind); wdone(); return 0; } void mainloop(argc, argv) int argc; char **argv; { rerun(argc, argv); for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_TIMER: rerun(argc, argv); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: case WC_CANCEL: return; case WC_RETURN: rerun(argc, argv); break; } break; case WE_CLOSE: return; } } } void rerun(argc, argv) int argc; char **argv; { int fd; char *image, *p; int left, n; if ((image = malloc(MAXSIZE)) == NULL) { wmessage("can't malloc output buffer"); wsettimer(win, errdelay); return; } if ((fd = readfrom(argc, argv)) < 0) { wmessage("can't start command"); wsettimer(win, errdelay); return; } left = MAXSIZE; p = image; if (tflag) { extern char *ctime(); extern long time(); long t; time(&t); strcpy(p, ctime(&t)); p = strchr(p, '\0'); } while (left > 0 && (n = read(fd, p, left)) > 0) { p += n; left -= n; } close(fd); (void) wait((int *)0); /* Get rid of child -- naively */ tesetbuf(tp, image, (int)(p - image)); wsetdocsize(win, 0, tegetbottom(tp)); wnocaret(win); /* Hack */ wsettimer(win, delay); } void drawproc(win, left, top, right, bottom) WINDOW *win; { tedrawnew(tp, left, top, right, bottom); } char *mktitle(argc, argv) int argc; char **argv; { static char buf[1000]; int i; char *p; p = buf; for (i = 0; i < argc; ++i) { if (i > 0) *p++ = ' '; strcpy(p, argv[i]); p = strchr(p, '\0'); } return buf; } /* Function to get a number of the form ddd.ddd from a string, without using floating point variables. Input is the address of a string pointer, which is incremented by the function to point after the last character that was part of the number. The function return value is X * scale, where X is the exact value read from the string, e.g., for input "3.14" and scale 1000, 3140 is returned. There is no provision for a leading sign or to leading spaces. Overflow goes undetected. */ long getfract(pstr, scale) char **pstr; long scale; { char *str = *pstr; long x = 0; int in_fraction = 0; char c; for (; (c = *str) != '\0'; str++) { if (c >= '0' && c <= '9') { if (in_fraction) { if (scale < 10) break; scale /= 10; } x = x*10 + (c - '0'); } else if (c == '.' && !in_fraction) in_fraction = 1; else break; } *pstr = str; return x*scale; } /* Copyright 1989 by Douglas A. Young All Rights Reserved Permission to use, copy, modify, and distribute this software for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The author disclaims all warranties with regard to this software, including all implied warranties of merchantability and fitness. Comments and additions may be sent the author at: dayoung@hplabs.hp.com Modified to resemble popen(..., "r"). Returns the file descriptor from which to read, or negative if an error occurred. (The pid is lost.) Name changed from talkto() to readfrom(). --Guido van Rossum, CWI */ int readfrom(argc, argv) int argc; char **argv; { int to_parent[2]; /* pipe descriptors from child->parent */ int pid; if (pipe(to_parent) < 0) { perror("pipe"); return -1; } pid = fork(); if (pid == 0) { /* in the child */ close(0); /* redirect stdin */ open("/dev/null", 0); close(1); /* redirect stdout */ dup(to_parent[1]); close(2); /* redirect stderr */ dup(to_parent[1]); close(to_parent[0]); close(to_parent[1]); execvp(argv[0], argv); /* exec the new cmd */ perror(argv[0]); /* error in child! */ _exit(127); } else if (pid > 0) { /* in the parent */ close(to_parent[1]); return to_parent[0]; } else { /* error! */ perror("vfork"); return -1; } } otes: * * BRANCH The set of branches constituting a single choice are hooked * together with their "next" pointers, since precedence prevents * anything being concatenated to any individual branch. The * "next" pointer of the last BRANCH in a choice points to the * thing following the whole choice. This is also where the * final "next" pointer of each individual branch points; each * branch starts with the opesmtalk43/stdwin/Appls/test/0407550003270021170000000000005477556060012247 5 0 1 0 smtalk43/stdwin/Appls/test/README1006440003270021170000000007705434024306013723 037777777777 1 0 This is a random collection of sometimes-useful test programs. structure. */ /* * Utility definitions. */ #ifndef CHARBITS #define UCHARAT(p) ((int)*(unsigned char *)(p)) #else #define UCHARAT(p) ((int)*(p)&CHARBITS) #endif #define FAIL(m) { regerror(m); return(NULL); } #define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?') #define META "^$.[()|?+*\\" /* * Flags to be passed up and down. */ #define HASWIDTH 01 /* Known never to match null string. */ #define SIMPLE 02 /* Simple enough to be STsmtalk43/stdwin/Appls/test/bike.c1006440003270021170000000534105465303017014123 037777777777 1 0 #include "stdwin.h" #include "tilist.h" #define NFRONT 3 #define NBACK 6 #define VSTEP 50 #define HSCALE 470 #define TIPWIDTH 40 int front[NFRONT] = {28, 38, 48}; int back[NBACK] = {28, 24, 20, 17, 15, 13}; double verzet[NFRONT][NBACK]; double lowest, highest; WINDOW *win; TILIST *til; TEXTITEM *fronttips[NFRONT]; TEXTITEM *backtips[NBACK]; calculate() { int f, b; double v; lowest = 1e10; highest = 0.0; for (f = 0; f < NFRONT; ++f) { for (b = 0; b < NBACK; ++b) { v = (double)front[f] / (double)back[b]; verzet[f][b] = v; if (v < lowest) lowest = v; if (v > highest) highest = v; } } } setuptil() { int f, b; int h, v; til = tilcreate(win); h = 0; v = 2; for (b = 0; b < NBACK; ++b) { backtips[b] = tiladd(til, h, v, h+TIPWIDTH-2, 0, 1); h += TIPWIDTH; } h = 0; v = 0; for (f = 0; f < NFRONT; ++f) { v += VSTEP; fronttips[f] = tiladd(til, h, v, h+TIPWIDTH-2, 0, 1); } settilvalues(); } settilvalues() { int f, b; char buf[100]; for (f = 0; f < NFRONT; ++f) { sprintf(buf, "%d", front[f]); tilsettext(fronttips[f], buf); } for (b = 0; b < NBACK; ++b) { sprintf(buf, "%d", back[b]); tilsettext(backtips[b], buf); } } gettilvalues() { int f, b; char *text; for (f = 0; f < NFRONT; ++f) { text = tilgettext(fronttips[f]); sscanf(text, "%d", &front[f]); } for (b = 0; b < NBACK; ++b) { text = tilgettext(backtips[b]); sscanf(text, "%d", &back[b]); } settilvalues(); calculate(); wchange(win, 0, 0, 30000, 30000); } void drawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { int f, b; int h, v; int lasth; tildraw(til, left, top, right, bottom); v = VSTEP; for (f = 0; f < NFRONT; ++f) { for (b = 0; b < NBACK; ++b) { h = (verzet[f][b] - lowest) * (HSCALE - 2*TIPWIDTH) / (highest - lowest); h += 2*TIPWIDTH; wcprintf(50, h, v-2-wlineheight(), "%d", back[b]); wdrawbox(h-2, v-2, h+2, v+2); wcprintf(50, h, v+2, "%.2f", verzet[f][b]); if (b > 0) { wpaint(lasth+2, v-1, h-2, v+1); } lasth = h; } v += VSTEP; } } main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); calculate(); wsetdefwinsize(HSCALE + 4*wcharwidth('0'), (NFRONT+1) * VSTEP); win = wopen("Bike", drawproc); wsetdocsize(win, HSCALE + 4*wcharwidth('0'), (NFRONT+1) * VSTEP); setuptil(); for (;;) { EVENT e; wgetevent(&e); if (tilevent(til, &e)) continue; switch (e.type) { case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: quit(); /*NOTREACHED*/ case WC_CANCEL: settilvalues(); break; case WC_RETURN: gettilvalues(); break; } break; case WE_CLOSE: quit(); /*NOTREACHED*/ } } } quit() { wclose(win); wdone(); exit(0); /*NOTREACHED*/ } ; len = 0; for (; scan != NULL; scan = regnext(scan)) if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) { longest = OPERAND(scan); len = strlen(OPERAND(scan)); } r->regmust = longest; r->regmlen = len; } } return(r); } /* - reg - regular expresmtalk43/stdwin/Appls/test/bits.c1006440003270021170000000520605465303017014152 037777777777 1 0 /* Here's a very simple bitmap editor. A window shows a magnified 64x64 bitmap which you can edit by clicking the mouse. Clicking on a bit that's off turns it on, clicking on one that's on turns it off. Drag the mouse to set or clear more bits. Additional facilities like saving to a file are left as exercises for the reader. */ #include "stdwin.h" /* Bitmap dimensions */ #define WIDTH 64 #define HEIGHT 64 /* The bitmap */ char bit[WIDTH][HEIGHT]; /* Magnification factors. (Should really be calculated from screen dimensions). */ int xscale= 5; int yscale= 5; /* The window */ WINDOW *win; /* Main program */ main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); setup(); mainloop(); wdone(); exit(0); } /* Create the window */ setup() { extern void drawproc(); /* Forward */ wsetdefwinsize(WIDTH*xscale, HEIGHT*yscale); win= wopen("Bitmap Editor Demo", drawproc); wsetdocsize(win, WIDTH*xscale, HEIGHT*yscale); } /* Main event loop */ mainloop() { int value= 0; for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: value= !getbit(e.u.where.h/xscale, e.u.where.v/yscale); /* Fall through to next cases */ case WE_MOUSE_MOVE: case WE_MOUSE_UP: setbit(e.u.where.h/xscale, e.u.where.v/yscale, value); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: case WC_CANCEL: return; } case WE_CLOSE: return; } } } /* Draw procedure */ void drawproc(win, left, top, right, bottom) WINDOW *win; { #ifdef UNOPTIMIZED int h, v; for (v= top/yscale; v*yscale < bottom; ++v) { for (h= left/xscale; h*xscale < right; ++h) { if (getbit(h, v)) wpaint(h*xscale, v*yscale, (h+1)*xscale, (v+1)*yscale); } } #else int h, v; int start; for (v= top/yscale; v*yscale < bottom; ++v) { start = -1; for (h= left/xscale; h*xscale < right; ++h) { if (getbit(h, v)) { if (start == -1) start = h; } else { if (start != -1) { wpaint(start*xscale, v*yscale, h*xscale, (v+1)*yscale); start = -1; } } } if (start != -1) wpaint(start*xscale, v*yscale, h*xscale, (v+1)*yscale); } #endif } /* Macro to test for bit coordinates in range */ #define INRANGE(h, v) ((v) >= 0 && (v) < HEIGHT && (h) >= 0 && (h) < WIDTH) /* Return a bit's value; return 0 if outside range */ int getbit(h, v) { if (INRANGE(h, v)) return bit[h][v]; else return 0; } /* Change a bit's value (if in range) and arrange for it to be drawn. */ setbit(h, v, value) { if (INRANGE(h, v) && bit[h][v] != value) { bit[h][v]= value; wchange(win, h*xscale, v*yscale, (h+1)*xscale, (v+1)*yscale); } } (flags&SIMPLE)) reginsert(STAR, ret); else if (op == '*') { /* Emit x* as (x&|), where & means "self". */ reginsert(BRANCH, ret); /* Either x */ regoptail(ret, regnode(BACK)); /* and loop */ regoptail(ret, ret); /* back */ regtail(ret, regnode(BRANCH)); /* or */ regtail(ret, regnode(NOTHING)); /* null. */ } else if (op == '+' && (flags&SIMPLE)) reginssmtalk43/stdwin/Appls/test/charset.c1006440003270021170000000561205465303017014643 037777777777 1 0 /* Display character set. usage: charset [-font font] [minchar [maxchar]] */ #include "tools.h" #include "stdwin.h" int minchar= 0; /* First char to draw */ int maxchar= 255; main(argc, argv) int argc; char **argv; { int *which= &minchar; int i; winitargs(&argc, &argv); for (i= 1; i < argc; ++i) { if (isnumeric(argv[i])) { *which= atoi(argv[i]); which= &maxchar; } else break; } if (i < argc) { wdone(); fprintf(stderr, "usage: %s [minchar [maxchar]]\n", argv[0]); exit(2); } if (maxchar < minchar) { wdone(); fprintf(stderr, "%s: maxchar < minchar\n", argv[0]); exit(2); } setup(); mainloop(); wdone(); exit(0); } bool isnumeric(str) char *str; { while (*str != EOS) { if (!isdigit(*str)) return FALSE; ++str; } return TRUE; } WINDOW *win; int ncols, nrows; int colwidth, rowheight; void drawproc(win, l, t, r, b) WINDOW *win; { int lineheight= wlineheight(); int i= (t/rowheight) * ncols; for (; i <= maxchar-minchar; ++i) { int c= minchar+i; int col= i%ncols; int row= i/ncols; int h= col*colwidth; int v= row*rowheight; int charwidth= wcharwidth(c); if (v >= b) break; wdrawchar(h + (colwidth - charwidth) / 2, v + (rowheight - lineheight) / 2, c); } } setup() { int scrwidth, scrheight; int maxwidth= 1; int i; wgetscrsize(&scrwidth, &scrheight); while (minchar <= maxchar && wcharwidth(minchar) == 0) ++minchar; while (maxchar >= minchar && wcharwidth(maxchar) == 0) --maxchar; if (minchar > maxchar) { wdone(); fprintf(stderr, "no chars in given range\n"); exit(1); } for (i= minchar; i <= maxchar; i++) { int w= wcharwidth(i); if (w > maxwidth) maxwidth= w; } colwidth= maxwidth * 2; rowheight= wlineheight() * 3 / 2; ncols= 16; if ((ncols+2) * colwidth > scrwidth) { ncols= scrwidth/colwidth - 2; if (ncols < 1) ncols= 1; } nrows= (maxchar - minchar + ncols) / ncols; if (nrows < 1) nrows= 1; wsetdefwinsize(ncols*colwidth, nrows*rowheight); wsetmaxwinsize(ncols*colwidth, nrows*rowheight); win= wopen("Character Set", drawproc); if (win == NULL) { wdone(); fprintf(stderr, "can't open window\n"); exit(1); } (void) wmenucreate(1, "Press q to quit"); } mainloop() { for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_CHAR: switch (e.u.character) { case 'q': case 'Q': return; } break; case WE_COMMAND: switch (e.u.command) { case WC_CANCEL: case WC_CLOSE: wclose(win); return; } break; case WE_CLOSE: wclose(win); return; case WE_MOUSE_DOWN: charinfo(e.u.where.h, e.u.where.v); break; } } } charinfo(h, v) int h, v; { int row= v/rowheight; int col= h/colwidth; int i= minchar + row*ncols + col; if (i >= minchar && i <= maxchar) { char buf[256]; sprintf(buf, "Char '%c' (%d. 0x%x), width %d", i>=' ' && i<0x7f ? i : '?', i, i, wcharwidth(i)); wmessage(buf); } else wfleep(); } emit (if appropriate) a byte of code */ static void regc(b) char b; { if (regcode != ®dummy) *regcode++ = b; esmtalk43/stdwin/Appls/test/dklok.c1006440003270021170000000477505465303017014327 037777777777 1 0 /* Digital clock */ #ifdef ns32000 #define void int #endif #include #include #include #include "stdwin.h" #include "sevenseg.h" extern long time(); int text_only; /* Non-zero on text-only device */ WINDOW *win; /* Our window */ #define NIMAGE 5 /* Number of chars in image */ char image[NIMAGE+1]; /* Text to draw, plus trailing \0 */ int aleft, atop, aright, abottom; /* Rect in which to draw */ getinfo() { wgetwinsize(win, &aright, &abottom); wsetdocsize(win, aright, abottom); newtime(); } newtime() { unsigned long now; struct tm *tp; wchange(win, aleft, atop, aright, abottom); time(&now); tp= localtime(&now); wsettimer(win, 10 * (60 - now%60)); sprintf(image, "%02d:%02d", tp->tm_hour, tp->tm_min); } void drawdigit(digit, left, top, right, bottom, dh, dv) int digit; int left, top, right, bottom; int dh, dv; /* Segment thickness */ { int bits= sevenseg[digit]; int mid= (top + bottom) / 2; void (*func)(); if (text_only) func= winvert; else func= wpaint; if (bits & (1<<6)) func(left, top, right, top+dv); if (bits & (1<<5)) func(left, top, left+dh, mid); if (bits & (1<<4)) func(right-dh, top, right, mid); if (bits & (1<<3)) func(left, mid-dv/2, right, mid+dv-dv/2); if (bits & (1<<2)) func(left, mid, left+dh, bottom); if (bits & (1<<1)) func(right-dh, mid, right, bottom); if (bits & (1<<0)) func(left, bottom-dv, right, bottom); } void drawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { int width= aright - aleft; int height= abottom - atop; int dh= width / (NIMAGE*6 + 1); int dv= height / 9; int spacing; int i; if (dh < 1) dh= 1; if (dv < 1) dv= 1; spacing= dh*6; for (i= 0; i < NIMAGE && image[i] != '\0'; ++i) { if (isdigit(image[i])) { drawdigit(image[i] - '0', aleft + dh + i*spacing, atop + dv, aleft + dh + (i+1)*spacing - dh, abottom - dv, dh, dv); } } } main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); setup(); mainloop(); wdone(); exit(0); } setup() { if (wlineheight() == 1) { text_only= 1; wmessage("Text-only version"); } win= wopen("DIGITAL CLOCK", drawproc); getinfo(); } mainloop() { for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: case WC_CANCEL: wclose(win); return 0; } break; case WE_CLOSE: wclose(win); return 0; case WE_SIZE: getinfo(); break; case WE_TIMER: newtime(); break; } } } egtsmtalk43/stdwin/Appls/test/faced.c1006440003270021170000001567505465303017014266 037777777777 1 0 /* Simple bitmap editor. Uses ".face" file format (48x48). TO DO: - fix row/col confusion - connect dots given by mouse move? - optimize drawing of consequtive black squares - add open... command - add flexible input format - support X bitmap format */ #include #include "stdwin.h" #define ROWS 48 #define COLS 48 #define SIZE (ROWS < COLS ? ROWS : COLS) #define BITS 16 /* Bits per word */ char bit[ROWS][COLS]; int xscale= 5; int yscale= 5; WINDOW *win; int changed= 0; main(argc, argv) int argc; char **argv; { FILE *fp; winitargs(&argc, &argv); if (argc > 1) { fp= fopen(argv[1], "r"); if (fp == NULL) { wdone(); perror(argv[1]); exit(1); } input(fp); fclose(fp); } setup(); for (;;) { editing(); if (changed) { switch (waskync("Save changes?", 1)) { case 1: if (!save(argc > 1 ? argv[1] : NULL)) continue; break; case -1: continue; } } break; /* Out of loop */ } wdone(); exit(0); } save(name) char *name; { FILE *fp; char namebuf[256]; namebuf[0]= '\0'; if (name == NULL) { if (!waskfile("Save as", namebuf, sizeof namebuf, 1)) return 0; name= namebuf; } fp= fopen(name, "w"); if (fp == NULL) { wperror(name); return 0; } output(fp); fclose(fp); return 1; } #define MAIN_MENU 1 #define QUIT_ITEM 0 #define OP_MENU 2 #define CLEAR_ITEM 0 #define SET_ITEM 1 #define INVERT_ITEM 2 #define TRANS_MAJ_ITEM 3 #define TRANS_MIN_ITEM 4 #define ROT_LEFT_ITEM 5 #define ROT_RIGHT_ITEM 6 #define FLIP_HOR_ITEM 7 #define FLIP_VERT_ITEM 8 #define NOPS 9 extern int (*oplist[])(); /* Forward */ drawproc(); /* Forward */ int text_only; setup() { MENU *mp; int width, height; if (wlineheight() == 1) text_only= xscale= yscale= 1; wsetdefwinsize(COLS*xscale, ROWS*yscale); mp= wmenucreate(MAIN_MENU, "Faced"); wmenuadditem(mp, "Quit", 'Q'); mp= wmenucreate(OP_MENU, "Operations"); wmenuadditem(mp, "Clear all", -1); wmenuadditem(mp, "Set all", -1); wmenuadditem(mp, "Invert", -1); wmenuadditem(mp, "Transpose major", -1); wmenuadditem(mp, "Transpose minor", -1); wmenuadditem(mp, "Rotate left", -1); wmenuadditem(mp, "Rotate right", -1); wmenuadditem(mp, "Flip horizontal", -1); wmenuadditem(mp, "Flip vertical", -1); win= wopen("faced", drawproc); if (win == NULL) { wmessage("Can't open window"); return; } wsetdocsize(win, COLS*xscale, ROWS*yscale); } editing() { int value= 0; for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: value= !getbit(e.u.where.h/xscale, e.u.where.v/yscale); case WE_MOUSE_MOVE: case WE_MOUSE_UP: setbit(e.u.where.h/xscale, e.u.where.v/yscale, value); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: return; case WC_CANCEL: changed= 0; return; } case WE_CLOSE: return; case WE_MENU: switch (e.u.m.id) { case MAIN_MENU: switch (e.u.m.item) { case QUIT_ITEM: return; } break; case OP_MENU: if (e.u.m.item >= 0 && e.u.m.item < NOPS) { (*oplist[e.u.m.item])(); wchange(win, 0, 0, COLS*xscale, ROWS*yscale); changed= 1; } break; } } } } int getbit(col, row) { if (row >= 0 && row < ROWS && col >= 0 && col < COLS) return bit[row][col]; else return 0; } setbit(col, row, value) { if (row >= 0 && row < ROWS && col >= 0 && col < COLS && bit[row][col] != value) { changed= 1; bit[row][col]= value; wchange(win, col*xscale, row*yscale, (col+1)*xscale, (row+1)*yscale); } } drawproc(win, left, top, right, bottom) WINDOW *win; { int row, col; if (left < 0) left= 0; if (right > COLS*xscale) right= COLS*xscale; if (top < 0) top= 0; if (bottom > ROWS*yscale) bottom= ROWS*yscale; for (row= top/yscale; row*yscale < bottom; ++row) { for (col= left/xscale; col*xscale < right; ++col) { if (bit[row][col]) { if (text_only) wdrawchar(col, row, 'x'); else wpaint(col*xscale, row*yscale, (col+1)*xscale, (row+1)*yscale); } } } } /* File I/O routines */ input(fp) FILE *fp; { int row; for (row= 0; row < ROWS; ++row) { read_row(fp, row); } } read_row(fp, row) FILE *fp; int row; { int left= 0; long ibuf; int col; for (col= 0; col < COLS; ++col) { if (left <= 0) { if (fscanf(fp, " 0x%4lx,", &ibuf) != 1) { wdone(); fprintf(stderr, "Bad input format, row %d\n", row); exit(1); } left= BITS; } --left; bit[row][col]= (ibuf >> left) & 1; } } output(fp) FILE *fp; { int row; for (row= 0; row < ROWS; ++row) write_row(fp, row); } write_row(fp, row) FILE *fp; int row; { int col; int left= BITS; long ibuf= 0; for (col= 0; col < COLS; ++col) { if (left <= 0) { fprintf(fp, "0x%04lX,", ibuf); ibuf= 0; left= BITS; } --left; if (bit[row][col]) { ibuf |= 1< 0); for (row = 0; row < size; ++row) { sum = 0; for (col = 0; col < size; ++col) sum += sq[row][col]; rowsum[row] = sum; if (ok) ok = (sum == diagsum); } for (col = 0; col < size; ++col) { sum = 0; for (row = 0; row < size; ++row) sum += sq[row][col]; colsum[col] = sum; if (ok) ok = (sum == diagsum); } } center(h, v, n) int h, v; int n; { char buf[25]; int width; if (n == 0) return; sprintf(buf, "%d", n); width = wtextwidth(buf, -1); wdrawtext(h + (colwidth - width)/2, v + wlineheight()/2, buf, -1); } void drawproc(win, left, top, right, bottom) WINDOW *win; { int h, v; int row, col; v = origtop; for (row = 0; row < size; ++row) { h = origleft; wdrawline(h, v, h+size*colwidth, v); for (col = 0; col < size; ++col) { center(h, v, sq[row][col]); h += colwidth; } center(h+3, v, rowsum[row]); v += rowheight; } wdrawline(origleft, v, origleft + size*colwidth, v); center(origleft - colwidth, v, secdiagsum); h = origleft; for (col = 0; col < size; ++col) { wdrawline(h, origtop, h, v); center(h, v, colsum[col]); h += colwidth; } wdrawline(h, origtop, h, v); center(h+3, v, diagsum); wdrawbox(origleft-1, origtop-1, h+2, v+2); if (last > 0 && ok) wdrawbox(origleft-3, origtop-3, h+4, v+4); } reset(newsize) int newsize; { int row, col; char buf[100]; size = newsize; for (row = 0; row < size; ++row) for (col = 0; col < size; ++col) sq[row][col] = 0; evaluate(); last = 0; sprintf(buf, "%dx%d Magic Square", size, size); wsettitle(win, buf); wsetdocsize(win, origleft + (size+1)*colwidth + 3, origtop + (size+1)*rowheight); wchange(win, 0, 0, FARAWAY, FARAWAY); } init() { colwidth = wtextwidth(" 000 ", -1); rowheight = wlineheight() * 2; origleft = colwidth; origtop = rowheight; } click(h, v) int h, v; { int row, col; int oldok; if (last >= size*size) { wfleep(); return; } if (h < origleft || v < origtop) return; col = (h - origleft) / colwidth; row = (v - origtop) / rowheight; if (row >= size || col >= size) return; if (sq[row][col] != 0) { wfleep(); return; } sq[row][col] = ++last; oldok = ok; evaluate(); if (ok != oldok) wchange(win, 0, 0, FARAWAY, FARAWAY); else change(row, col); } change(row, col) int row, col; { wchange(win, origleft + col*colwidth + 1, origtop + row*rowheight + 1, origleft + (col+1)*colwidth, origtop + (row+1)*rowheight); wchange(win, 0, origtop + size*rowheight + 2, FARAWAY, FARAWAY); wchange(win, origleft + size*colwidth + 2, 0, FARAWAY, FARAWAY); } undo() { int row, col; int oldok; if (last == 0) { wfleep(); return; } for (row = 0; row < size; ++row) { for (col = 0; col < size; ++col) { if (sq[row][col] == last) { sq[row][col] = 0; --last; oldok = ok; evaluate(); if (ok != oldok) wchange(win, 0, 0, FARAWAY, FARAWAY); else change(row, col); return; } } } /* Shouldn't get here */ wfleep(); wfleep(); } main(argc, argv) int argc; char **argv; { EVENT e; winitargs(&argc, &argv); init(); wsetdefwinsize(origleft + (DEFSIZE+2)*colwidth, origtop + (DEFSIZE+2)*rowheight); win = wopen("Magic Square", drawproc); reset(DEFSIZE); for (;;) { wgetevent(&e); switch (e.type) { case WE_MOUSE_UP: click(e.u.where.h, e.u.where.v); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: wdone(); exit(0); case WC_CANCEL: reset(size); break; case WC_BACKSPACE: undo(); break; } break; case WE_CLOSE: wdone(); exit(0); case WE_CHAR: if (e.u.character >= '1' && e.u.character <= '9') reset(e.u.character - '0'); else if (e.u.character == '0') reset(size); else if (e.u.character == 'q') { wdone(); exit(0); } else wfleep(); break; } } } ewundo(ew); break; case CUT_ITEM: ewcopy(ew); ewreplace(ew, ""); smtalk43/stdwin/Appls/test/multiwin.c1006440003270021170000000414105465303017015056 037777777777 1 0 /* Multiple windows, menus */ #include "stdwin.h" #define NW 10 /* Max # of windows */ struct { WINDOW *win; TEXTEDIT *tb; int bottom; } wlist[NW]; /* Window list */ drawproc(win, l, tl, r, b) WINDOW *win; { int i= wgettag(win); tedraw(wlist[i].tb); } newwin() { int i; for (i= 0; i < NW; ++i) { if (wlist[i].win == 0) { char title[20]; int width, height; WINDOW *win; sprintf(title, "Untitled-%d", i); wlist[i].win= win= wopen(title, drawproc); wsettag(win, i); wgetwinsize(win, &width, &height); wlist[i].tb= tealloc(win, 0, 0, width); wlist[i].bottom= tegetbottom(wlist[i].tb); wsetdocsize(win, width, wlist[i].bottom); return; } } wmessage("Can't open another window"); } closewin(win) WINDOW *win; { int i= wgettag(win); tefree(wlist[i].tb); wclose(wlist[i].win); wlist[i].win= 0; } main(argc, argv) int argc; char **argv; { MENU *mp; int inew, iquit; int stop= 0; winitargs(&argc, &argv); mp= wmenucreate(1, "File"); inew= wmenuadditem(mp, "New", 'N'); (void) wmenuadditem(mp, "", -1); iquit= wmenuadditem(mp, "Quit", 'Q'); newwin(); /* Initial window */ while (!stop) { EVENT e; wgetevent(&e); if (e.window != 0) { int i= wgettag(e.window); if (teevent(wlist[i].tb, &e)) { /*if (tegetbottom(wlist[i].tb) != wlist[i].bottom)*/ wsetdocsize(wlist[i].win, tegetright(wlist[i].tb), tegetbottom(wlist[i].tb)); continue; } } switch (e.type) { case WE_MENU: switch (e.u.m.id) { case 1: if (e.u.m.item == inew) newwin(); else if (e.u.m.item == iquit) stop= 1; break; } break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: closewin(e.window); break; } break; case WE_CLOSE: closewin(e.window); break; case WE_SIZE: { int i= wgettag(e.window); int width, height; wgetwinsize(e.window, &width, &height); temove(wlist[i].tb, 0, 0, width); wlist[i].bottom= tegetbottom(wlist[i].tb); wsetdocsize(wlist[i].win, width, wlist[i].bottom); } break; } } wdone(); exit(0); } e caret off???) */ #include #include #include extern char *malloc(); WINDOW *win; TEXTEDIT *tp; #define MAXSIZE 10000 #define DELAY 5 /* retry after success in 0.5 seconds */ #define ERRDELAY 50 /* retry after popen error in 5 seconds */ int delay = DELAY; /* normal delay */ int errdelay = ERRDELAY; /* delay after popen error */ int tflag = 0; /* Display time above output whsmtalk43/stdwin/Appls/test/sevenseg.h1006440003270021170000000113505434024310015022 037777777777 1 0 /* 7-segment digit definitions */ #define __ <<1) | 1) #define _ <<1) | 0) #define I __ #define i _ #define AA ((((((((((((((0 short sevenseg[10]= { AA __ I I _ I I __ , /* 0 */ AA _ i I _ i I _ , /* 1 */ AA __ i I __ I i __ , /* 2 */ AA __ i I __ i I __ , /* 3 */ AA _ I I __ i I _ , /* 4 */ AA __ I i __ i I __ , /* 5 */ AA __ I i __ I I __ , /* 6 */ AA __ i I _ i I _ , /* 7 */ AA __ I I __ I I __ , /* 8 */ AA __ I I __ i I __ /* 9 */ }; #undef __ #undef _ #undef I #undef i #undef AA break; case 't': tflag = 1; break; default: usage(); /*NOTREACHED*/ } } if (optind >= argc) { usage(); /* NOTREACHED*/ } win = wopen(mktitle(argc-optind, argv+optind), drawproc); if (win == NULL) { wdone(); fprintf(stderr, "can't open window\n"); return 1; } tp = tecreate(win, 0, 0, 10000, 10000); if (tp == NULL) { wclose(win); wdone(); fprintf(stderr, "can't create textedismtalk43/stdwin/Appls/test/test0.c1006440003270021170000000024705465303017014250 037777777777 1 0 /* Minimal test -- just call winit() and wdone(). */ #include "stdwin.h" main(argc, argv) int argc; char **argv; { winitargs(&argc, &argv); wdone(); exit(0); } return; } if ((fd = readfrom(argc, argv)) < 0) { wmessage("can't start command"); wsettimer(win, errdelay); return; } left = MAXSIZE; p = image; if (tflag) { extern char *ctime(); extern long time(); long t; time(&t); strcpy(p, ctime(&t)); p = strchr(p, '\0'); } while (left > 0 && (n = read(fd, p, left)) > 0) { p +smtalk43/stdwin/Appls/test/test1.c1006440003270021170000000037305465303017014251 037777777777 1 0 /* Basic test -- open and close a window; no output or events. */ #include "stdwin.h" main(argc, argv) int argc; char **argv; { WINDOW *win; winitargs(&argc, &argv); win= wopen("Basic test", (void (*)()) 0); wclose(win); wdone(); exit(0); } last character that was part of the number. The function return value is X * scale, where X is the exact value read from the string, e.g., for input "3.14" and scale 1000, 3140 is returned. There is no provision for a leading sign or to leading smtalk43/stdwin/Appls/test/test2.c1006440003270021170000000104005465303017014242 037777777777 1 0 /* Typical test -- a window saying Hello, world. */ #include "stdwin.h" void drawproc(win, l, t, r, b) WINDOW *win; { wdrawtext(0, 0, "Hello, world", -1); } main(argc, argv) int argc; char **argv; { WINDOW *win; winitargs(&argc, &argv); win= wopen("Hello test", drawproc); for (;;) { EVENT e; wgetevent(&e); if (e.type == WE_CHAR && e.u.character == 'q') break; if (e.type == WE_CLOSE || e.type == WE_COMMAND && (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL)) break; } wclose(win); wdone(); exit(0); } .com Modified to resemble popen(..., "r"). Returns the file descriptor from which to read, or negative if an error occurred. (The pid is lost.) Name changed from talkto() to readfrom(). --Guido van Rossum, CWI */ int readfrom(argc, argv) int argc; char **argv; { int to_parent[2]; /* pipe descriptors from child->parent */ int pid; if (pipe(to_parent) < 0) { perror("pipe"); return -1; } pid = fork(); if (pid == 0) { /* in the childsmtalk43/stdwin/Appls/test/test3.c1006440003270021170000000140105465303017014244 037777777777 1 0 /* Text-edit test -- a text-edit window. */ #include "stdwin.h" TEXTEDIT *tb; void drawproc(win, l, t, r, b) WINDOW *win; { tedraw(tb); } main(argc, argv) int argc; char **argv; { WINDOW *win; int width, height; winitargs(&argc, &argv); if (argc >= 3) { int h= atoi(argv[1]), v= atoi(argv[2]); wsetdefwinpos(h, v); } win= wopen("Textedit", drawproc); wgetwinsize(win, &width, &height); wsetdocsize(win, width, height); tb= tealloc(win, 0, 0, width); tereplace(tb, "Hello, world\n--Guido van Rossum"); for (;;) { EVENT e; wgetevent(&e); if (e.type == WE_CLOSE || e.type == WE_COMMAND && (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL)) break; (void) teevent(tb, &e); } tefree(tb); wclose(win); wdone(); exit(0); } 0 1 0 smtalk43/stdwin/Appls/test/test4.c1006440003270021170000000211105465303017014244 037777777777 1 0 /* Menu test - a text-edit window */ #include "stdwin.h" TEXTEDIT *tb; void drawproc(win, l, t, r, b) WINDOW *win; { tedraw(tb); } main(argc, argv) int argc; char **argv; { WINDOW *win; MENU *mp; int width, height; int stop= 0; winitargs(&argc, &argv); if (argc >= 3) { int h= atoi(argv[1]), v= atoi(argv[2]); wsetdefwinpos(h, v); } mp= wmenucreate(1, "File"); wmenuadditem(mp, "Quit", 'Q'); win= wopen("Menu+textedit", drawproc); wgetwinsize(win, &width, &height); wsetdocsize(win, width, height); tb= tealloc(win, 0, 0, width); tereplace(tb, "Hello, world\n--Guido van Rossum"); do { EVENT e; wgetevent(&e); if (teevent(tb, &e)) { wsetdocsize(win, width, height= tegetbottom(tb)); continue; } switch (e.type) { case WE_COMMAND: if (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL) stop= 1; break; case WE_CLOSE: stop= 1; break; case WE_MENU: if (e.u.m.id == 1 && e.u.m.item == 0) stop= 1; break; } } while (!stop); tefree(tb); wclose(win); wmenudelete(mp); wdone(); exit(0); } #define VSTEP 50 #define HSCALE 470 #define TIPWIDTH 40 int front[NFRONT] = {28, 38, 48}; int back[NBACK] = {28, 24, 20, 17, 15, 13}; double verzet[NFRONT][NBACK]; double lowest, highest; WINDOW *win; TILIST *til; TEXTITEM *fronttips[NFRONT]; TEXTITEM *backtips[NBACK]; calculate() { int f, b; double v; lowest = 1e10; highest = 0.0; for (f = 0; f < NFRONT; ++f) { for (b = 0; b < NBACK; ++b) { v = (double)front[f] / smtalk43/stdwin/Appls/test/test5.c1006440003270021170000000247105465303017014256 037777777777 1 0 /* Debugging test -- print events and details */ #include "stdwin.h" void drawproc(win, l, t, r, b) WINDOW *win; { printf("drawproc called\n"); wdrawtext(0, 0, "Hello, world", -1); } char *evname[] = { "null", "activate", "char", "command", "mouse_down", "mouse_move", "mouse_up", "menu", "size", "(move)", "draw", "timer", "deactivate", 0 }; char *cmname[] = { "(null)", "close", "left", "right", "up", "down", "cancel", "backspace", "tab", "return", 0 }; main(argc, argv) int argc; char **argv; { WINDOW *win; winitargs(&argc, &argv); win= wopen("Hello test", drawproc); for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: printf("%s event: b=%d, h=%d, v=%d\n", evname[e.type], e.u.where.button, e.u.where.h, e.u.where.v); break; case WE_COMMAND: printf("command event (%s)\n", cmname[e.u.command]); break; case WE_CHAR: printf("char event ('%c', 0x%02x)\n", e.u.character, e.u.character & 0xff); break; default: printf("%s event\n", evname[e.type]); break; } if (e.type == WE_CHAR && e.u.character == 'q') break; if (e.type == WE_CLOSE || e.type == WE_COMMAND && (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL)) break; } wclose(win); wdone(); exit(0); } for (;;) { EVENT e; wgetevent(&e); if (tilevent(til, &e)) continue; switch (e.type) { case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: quit(); /*NOTREACHED*/ casesmtalk43/stdwin/Appls/test/testlocalmenus.c1006440003270021170000000175205465303017016255 037777777777 1 0 #include "stdwin.h" #include main(argc, argv) char **argv; { winit(&argc, &argv); showargs(argc, argv); localtest(); wdone(); } showargs(argc, argv) char **argv; { char buf[100]; char *p; int i; sprintf(buf, "argc=%d", argc); p = buf; for (i = 0; i < argc; ++i) { p = strchr(p, '\0'); sprintf(p, " argv[%d]=\"%s\"", i, argv[i]); } wmessage(buf); } localtest() { WINDOW *u, *v, *w; MENU *m, *n, *o; int wincount = 3; wmenusetdeflocal(1); m = wmenucreate(1, "Menu1"); wmenuadditem(m, "Item1", -1); n = wmenucreate(2, "Menu2"); wmenuadditem(n, "Item2", -1); o = wmenucreate(3, "Menu3"); wmenuadditem(o, "Item3", -1); u = wopen("Win1", 0L); v = wopen("Win2", 0L); w = wopen("Win3", 0L); wmenuattach(u, m); wmenuattach(v, n); wmenuattach(w, o); for (;;) { EVENT e; wgetevent(&e); if (e.type == WE_CLOSE || e.type == WE_COMMAND && e.u.command == WC_CLOSE) { wclose(e.window); --wincount; if (wincount == 0) break; } } } tion factors. (Shousmtalk43/stdwin/Appls/test/testpollevent.c1006440003270021170000000227005465303017016117 037777777777 1 0 #include #include "stdwin.h" void drawproc(); /* Forward */ EVENT ev; main(argc, argv) int argc; char **argv; { WINDOW *win; winitargs(&argc, &argv); win = wopen("Test poll event", drawproc); for (;;) { if (wpollevent(&ev)) { if (ev.type == WE_CLOSE || ev.type == WE_COMMAND && ev.u.command == WC_CLOSE) break; wbegindrawing(win); werase(0, 0, 1000, 1000); drawproc(win, 0, 0, 1000, 1000); wenddrawing(win); } else { wbegindrawing(win); animate(); wenddrawing(win); } } wdone(); exit(0); } void drawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { char buf[100]; switch (ev.type) { case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: sprintf(buf, "MOUSE EVENT %d, h=%d, v=%d, button=%d, clicks=%d", ev.type, ev.u.where.h, ev.u.where.v, ev.u.where.button, ev.u.where.clicks); break; case WE_CHAR: sprintf(buf, "CHAR '%c' (%d)", ev.u.character, ev.u.character); break; default: sprintf(buf, "TYPE %d", ev.type); break; } wdrawtext(0, 0, buf, -1); } animate() { static int h; int v = 20; werase(h, v, h+5, v+5); h = (h+1) % 400; wpaint(h, v, h+5, v+5); } dinates in range */ #define INRANGE(h, v) ((v) >= 0 && (v) < HEIGHT && (h) >= 0 && (h) < WIDTH) /* Return a bit's value; return 0 if outside range */ int getbit(h, v) { if (INRANGE(h, v)) return bit[h][v]; else return 0; } /* Change a bit's value (if in range) and arrange for it to be drawn. */ setbit(h, v, value) {smtalk43/stdwin/Appls/test/thand.c1006440003270021170000000201105465303017014276 037777777777 1 0 /* Test wungetevent from signal handler */ #include "stdwin.h" #include #define SPECIAL 1000 TEXTEDIT *tb; void drawproc(win, l, t, r, b) WINDOW *win; { tedraw(tb); } int handler() { EVENT e; e.type= WE_COMMAND; e.u.command= SPECIAL; wungetevent(&e); } main(argc, argv) int argc; char **argv; { WINDOW *win; int width, height; winit(); signal(SIGINT, handler); if (argc >= 3) { int h= atoi(argv[1]), v= atoi(argv[2]); wsetdefwinpos(h, v); } win= wopen("Textedit", drawproc); wgetwinsize(win, &width, &height); wsetdocsize(win, width, height); tb= tealloc(win, 0, 0, width); tereplace(tb, "Hello, world\n--Guido van Rossum"); for (;;) { EVENT e; wgetevent(&e); if (e.type == WE_CLOSE) break; if (e.type == WE_COMMAND) { if (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL) break; else if (e.u.command == SPECIAL) { wmessage("Got event from handler"); continue; } } (void) teevent(tb, &e); } tefree(tb); wclose(win); wdone(); exit(0); } if (maxchar < minchar) { wdone(); fprintf(stderr, "%s: maxchar < minchar\n", argv[0]); exit(2); } setup(); mainloop(); wdone(); exit(0); } bool isnumeric(str) char *str; { while (*str != EOS) { if (!isdigit(*str)) return FALSE; ++str; } return TRUE; } WINDOW *win; int ncols, nrows; int colwidth, rowheight; void drawproc(win, l, t, r, b) WINDOW *win; { int lineheight= wlineheight(); int i= (t/rowheight) * ncols; for (; i <= maxchar-minchar; ++i) { int c= minchar+i;smtalk43/stdwin/Appls/test/vtdemo.c1006440003270021170000000200305465303017014477 037777777777 1 0 #include "stdwin.h" #include "vt.h" main() { VT *vt; winit(); wsetdefwinsize(80*wcharwidth('0'), 24*wlineheight()); vt= vtopen("VT", 24, 80, 100); /* Should check outcome */ vtautosize(vt); vtsetnlcr(vt, 1); /* Map LF ro CR LF */ vtansiputs(vt, "Hello, world\n", -1); eventloop(); wdone(); exit(0); } eventloop(vt) VT *vt; { for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_SIZE: vtautosize(vt); /* Should check outcome */ break; case WE_CHAR: { char buf[2]; buf[0]= e.u.character; vtansiputs(vt, buf, 1); break; } case WE_MOUSE_DOWN: vtsetcursor(vt, e.u.where.v / vtcheight(vt), e.u.where.h / vtcwidth(vt)); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: return; case WC_RETURN: vtansiputs(vt, "\n", 1); break; case WC_BACKSPACE: vtansiputs(vt, "\b", 1); break; case WC_TAB: vtansiputs(vt, "\t", 1); break; } break; case WE_CLOSE: return; } } } turn; case WE_MOUSE_DOWN: charinfo(e.u.where.h, e.u.where.v); break; } } } charinfo(h, v) int h, v; { int row= v/rowheight; int col= h/colwidth; int i= minchar + row*ncols + col; if (i >= minchar && i <= maxchar) { char buf[256]; sprintf(buf, "Char '%c' (%d. 0x%x), width %d", i>=' ' && i<0x7f ? i : '?', i, i, wcharwidth(i)); wmessage(buf); } else wfleep(); } emit (if appropriate) a byte of code */ static void regc(b) char b; { if (regcode != ®dummy) *regcode++ = b; esmtalk43/stdwin/Appls/tetris/0407550003270021170000000000005477556061012603 5 0 1 0 smtalk43/stdwin/Appls/tetris/Make.proto1006440003270021170000000024105434024313015327 037777777777 1 0 # # Makefile prototype for tetris application # TETRIS= $(APPLS)/tetris SRCS= \ $(TETRIS)/tetris.c all: tetris _bootstrap: @putprogmf tetris $(SRCS) w); wsettimer(win, 10 * (60 - now%60)); sprintf(image, "%02d:%02d", tp->tm_hour, tp->tm_min); } void drawdigit(digit, left, top, right, bottom, dh, dv) int digit; int left, top, right, bottom; int dh, dv; /* Segment thickness */ { int bits= sevenseg[digit]; int mid= (top + bottom) / 2; void (*func)(); if (text_only) func= winvert; esmtalk43/stdwin/Appls/tetris/tetris.c1006440003270021170000003736505465303017015071 037777777777 1 0 /* Tetris. A simple but challenging game where pieces of different shapes falling with a constant speed must be manoeuvered to a final docking position. Piece shapes are randomly chosen from all possible ways to connect four squares. The manipulations allowed are moving the piece left or right and rotating it; every clock tick it moves down one step, until it cannot move further, or the player decides to "drop" it to earn more points. The game is made more or less challenging by making the clock tick faster or slower. A score is kept. Points earned per piece depend on the height where it is dropped or stopped; extra points are awarded for choosing a higher speed ("level"). To allow the play to continue indefinitely, complete rows (i.e., horizontal rows where all squares are filled) are removed from the board and its contents above that row shifted down. The user interface uses mostly the left, right and up keys, for moving the piece left and right and rotating it. For Unix adepts, 'h'=left, 'k'=up and 'l'=right also work. Space bar or Return drops the piece. The Cancel key (Command-Period on the Mac, Control-C on most other systems) restarts the game; close the window or type 'q' to quit the game. The origin of the game appears to be in the East Block; I've heard that the (original?) Macintosh version was by a Hungarian programmer. This code is hereby put in the public domain, but the package STDWIN used as portable window interface is copyrighted. STDWIN is available from me, too, provided you respect the copyright etc. Guido van Rossum, CWI, Kruislaan 413, 1098 SJ Amsterdam, The Netherlands Internet e-mail address: guido@cwi.nl April 1989 */ /* TO DO: - show next piece coming up in a side window - change chance distribution of pieces? (too few bars) - advanced level (what should it do? just faster?) - rethink level <--> delay relation - improve "game over" behavior - display high score - score and status display next to the board - statistics - cute graphics */ /* Standard include files */ #include "stdwin.h" #include /* Parametrizations */ /* Piece size. It only makes sense to change this if you also change the initialization of the 'shapes' array. Since we rotate pieces, their max size must always be square. */ #define PSIZE 4 /* Game dimensions. Traditionally it is played on a 10x20 board. */ #ifndef BWIDTH #define BWIDTH 10 #endif #ifndef BHEIGHT #define BHEIGHT 20 #endif /* Initial timer delay. This affects initial difficulty and scoring. The current value is kept in variable 'delay'. */ #ifndef DELAY #define DELAY 10 #endif /* Individual 'square' sizes. These can be adjusted according to taste and the size of pixels on your screen. (You can also fine-tune window and document size in main() below.) For the alfa version of STDWIN, where pixel size == character size, a fixed size of 2x1 is forced later. */ #ifndef SQWIDTH #define SQWIDTH 12 #endif #ifndef SQHEIGHT #define SQHEIGHT 12 #endif /* Left, top of board image in window */ #ifndef BLEFT #define BLEFT 0 #endif #ifndef BTOP #define BTOP 4 #endif /* Some useful macros (predefined on some but not all systems) */ #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif #ifndef MAX #define MAX(a, b) ((a) > (b) ? (a) : (b)) #endif /* Available shapes. Relnext is the offset to the next piece after rotation. The pieces are aligned with the bottom so their scoring values are comparable, and the delay before their start is minimal; they are centered horizontally so the random placement appears even. Remember C's aggregate initialization rules; the initializer below is completely bracketed, but trailing zeros are sometimes elided. */ struct shapedef { int relnext; char piece[PSIZE][PSIZE]; } shapes[] = { /* "Four in a row" (2 orientations) */ {1, {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {1, 1, 1, 1}}}, {-1, {{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}}}, /* "L shape" (4 orientations) */ {1, {{0, 0, 0}, {0, 1, 0}, {0, 1, 0}, {0, 1, 1}}}, {1, {{0, 0, 0}, {0, 0, 0}, {0, 0, 1}, {1, 1, 1}}}, {1, {{0, 0, 0}, {0, 1, 1}, {0, 0, 1}, {0, 0, 1}}}, {-3, {{0, 0, 0}, {0, 0, 0}, {1, 1, 1}, {1, 0, 0}}}, /* "Inverse L shape" (4 orientations) */ {1, {{0, 0, 0}, {0, 1, 1}, {0, 1, 0}, {0, 1, 0}}}, {1, {{0, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 1, 1}}}, {1, {{0, 0, 0}, {0, 0, 1}, {0, 0, 1}, {0, 1, 1}}}, {-3, {{0, 0, 0}, {0, 0, 0}, {1, 1, 1}, {0, 0, 1}}}, /* "Z shape" (2 orientations) */ {1, {{0, 0, 0}, {0, 0, 0}, {1, 1, 0}, {0, 1, 1}}}, {-1, {{0, 0, 0}, {0, 0, 1}, {0, 1, 1}, {0, 1, 0}}}, /* "S shape" (2 orientations) */ {1, {{0, 0, 0}, {0, 1, 0}, {0, 1, 1}, {0, 0, 1}}}, {-1, {{0, 0, 0}, {0, 0, 0}, {0, 1, 1}, {1, 1, 0}}}, /* "T shape" (4 orientations) */ {1, {{0, 0, 0}, {0, 0, 0}, {1, 1, 1}, {0, 1, 0}}}, {1, {{0, 0, 0}, {0, 1, 0}, {0, 1, 1}, {0, 1, 0}}}, {1, {{0, 0, 0}, {0, 0, 0}, {0, 1, 0}, {1, 1, 1}}}, {-3, {{0, 0, 0}, {0, 0, 1}, {0, 1, 1}, {0, 0, 1}}}, /* "Block" (1 orientation) */ {0, {{0, 0, 0}, {0, 0, 0}, {0, 1, 1}, {0, 1, 1}}}, }; /* Global variables */ int alfa; /* Nonzero if using alfa STDWIN */ int sqwidth = SQWIDTH; /* Width of squares, in pixels */ int sqheight = SQHEIGHT; /* Height */ int bleft = BLEFT; int btop = BTOP; WINDOW *win; /* The window where we do our drawing */ int delay; /* Current delay */ /* NB: level = MAX(0, DELAY-delay) */ char board[BHEIGHT][BWIDTH]; /* Contents of board, except current piece */ char (*piece)[PSIZE]; /* Piece currently being manoeuvered */ int pindex; /* Index in the shape array of current piece */ int pleft, ptop; /* Position of current piece */ long score; /* Score of current game */ /* Generate an informative title from level and/or score. (By putting it in the title bar we don't need an info window.) */ settitle() { char buf[100]; int level = MAX(0, DELAY-delay); if (level == 0) { if (score == 0) strcpy(buf, "Tetris"); else sprintf(buf, "Score %ld", score); } else { if (score == 0) sprintf(buf, "Level %d", level); else sprintf(buf, "Sc %ld Lv %d", score, level); } wsettitle(win, buf); } /* Erase a portion of the board on the screen. Call only within wbegin/enddrawing. */ eraseboard(ileft, itop, iright, ibottom) int ileft, itop, iright, ibottom; { werase(bleft + ileft*sqwidth, btop + itop*sqheight, bleft + iright*sqwidth, btop + ibottom*sqheight); } /* Draw a portion of the board, and a border around it. Call only within wbegin/enddrawing. This may be called with out-of-range parameters. Draw those squares of the game that lie (partly) in the rectangle given by the parameters. Assume the background is blank. This contains #ifdef'ed code for the alfa version of STDWIN, which only supports text output. */ drawboard(ileft, itop, iright, ibottom) int ileft, itop, iright, ibottom; { int ih, iv; int h, v; int flag; ileft = MAX(0, ileft); itop = MAX(0, itop); iright = MIN(BWIDTH, iright); ibottom = MIN(BHEIGHT, ibottom); for (iv = itop, v = btop + iv*sqheight; iv < ibottom; ++iv, v += sqheight) { for (ih = ileft, h = bleft + ih*sqwidth; ih < iright; ++ih, h += sqwidth) { flag = board[iv][ih]; if (!flag && pleft <= ih && ih < pleft+PSIZE && ptop <= iv && iv < ptop+PSIZE) flag = piece[iv-ptop][ih-pleft]; if (flag) { if (alfa) wdrawchar(h, v, '#'); else wshade(h+1, v+1, h+sqwidth, v+sqheight, 50); } } } if (alfa) { /* Draw markers at the right margin */ wdrawchar(bleft + BWIDTH*sqwidth, btop, '|'); wdrawchar(bleft + BWIDTH*sqwidth, btop + (BHEIGHT-1)*sqheight, '|'); } else { /* Draw a box around the board */ wdrawbox(bleft - 1, btop - 1, bleft + BWIDTH*sqwidth + 2, btop + BHEIGHT*sqheight + 2); } } /* Erase and redraw part of the board. Unlike eraseboard and drawboard above, this includes calls to wbegin/enddrawing. */ redrawboard(ileft, itop, iright, ibottom) int ileft, itop, iright, ibottom; { wbegindrawing(win); eraseboard(ileft, itop, iright, ibottom); drawboard(ileft, itop, iright, ibottom); wenddrawing(win); } /* Draw procedure, passed to STDWIN's wopen */ void drawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { drawboard((left-bleft)/sqwidth, (top-btop)/sqheight, (right-bleft+sqwidth-1)/sqwidth, (bottom-btop+sqheight-1)/sqheight); } /* Check if the piece can be at (dh, dv). This is used to check for legal moves. No part of the piece can be on a filled spot in the board or be outside it, but it can stick out above the top. */ int allowed(dh, dv) int dh, dv; { int ih, iv; for (iv = 0; iv < PSIZE; ++iv) { for (ih = 0; ih < PSIZE; ++ih) { if (piece[iv][ih]) { if (ih+dh < 0 || ih+dh >= BWIDTH) return 0; if (iv+dv < 0) continue; if (iv+dv >= BHEIGHT) return 0; if (board[iv+dv][ih+dh]) return 0; } } } return 1; } /* Return a random integer in the range [0..n-1] */ int uniform(n) int n; { return rand() % n; } /* Rotate the piece 90 degrees counterclockwise. No drawing is done. The implementation is trivial: just take the "next" element from the shape array. */ leftrotate() { pindex += shapes[pindex].relnext; piece = shapes[pindex].piece; } /* Move the piece by the given vector (dh, dv), if this is a legal move.. Return 1 if moved, 0 if not (then no changes were made). */ int moveby(dh, dv) int dh, dv; { int ileft, itop, iright, ibottom; if (!allowed(pleft+dh, ptop+dv)) { return 0; } ileft = pleft + MIN(dh, 0); itop = ptop + MIN(dv, 0); iright = pleft + PSIZE + MAX(dh, 0); ibottom = ptop + PSIZE + MAX(dv, 0); pleft += dh; ptop += dv; redrawboard(ileft, itop, iright, ibottom); return 1; } /* Rotate the piece n quarter left turns, if this is a legal move. Return 1 if moved, 0 if not (then no changes were made). */ int rotateby(n) int n; { int i; for (i = 0; i < n; ++i) leftrotate(); if (!allowed(pleft, ptop)) { for (i = 0; i < 4-n; ++i) leftrotate(); return 0; } redrawboard(pleft, ptop, (pleft+PSIZE), (ptop+PSIZE)); return 1; } /* Trivial routines to implement the commands. */ left() { (void) moveby(-1, 0); } right() { (void) moveby(1, 0); } rot() { (void) rotateby(1); } /* Generate a new piece. Its initial position is just above the top of the board, so that a single move down will show its bottom row. (This is one reason why the pieces are aligned with the bottom in the 'shapes' array.) */ generate() { pindex = uniform(sizeof shapes / sizeof shapes[0]); piece = shapes[pindex].piece; pleft = (BWIDTH-PSIZE) / 2; ptop = -PSIZE; } /* Start a new game. Reset deley/level, score, board and title; generate a new piece. The game is not restarted immediately. */ reset() { int ih, iv; wsettimer(win, 0); delay = DELAY; score = 0; for (iv = 0; iv < BHEIGHT; ++iv) { for (ih = 0; ih < BWIDTH; ++ih) board[iv][ih] = 0; } generate(); redrawboard(0, 0, BWIDTH, BHEIGHT); settitle(); } /* Remove any full rows found, shifting the board above down */ removerows() { int ih, iv; int jv; for (iv = 0; iv < BHEIGHT; ++iv) { for (ih = 0; ih < BWIDTH; ++ih) { if (!board[iv][ih]) goto next; /* Two-level continue */ } for (jv = iv; jv > 0; --jv) { for (ih = 0; ih < BWIDTH; ++ih) board[jv][ih] = board[jv-1][ih]; } for (ih = 0; ih < BWIDTH; ++ih) board[jv][ih] = 0; wscroll(win, bleft, btop, bleft + BWIDTH*sqwidth, btop + (iv+1)*sqheight, 0, sqheight); next: ; } } /* Add the score for the current piece to the total score. The title is not regenerated; that is done later in finish(). */ addscore() { int level = MAX(0, DELAY-delay); int height = MAX(0, BHEIGHT-ptop); score += height + 2*level /* *(advanced?2:1) */ ; } /* Finish a piece off by dropping it; score and generate a new one. Called by the user and from timer of the piece can't move down. This also contains a hack to detect the end of the game: if the new piece can't move one step, it is over. */ finish() { int ih, iv; addscore(); while (moveby(0, 1)) ; for (iv = 0; iv < PSIZE; ++iv) { for (ih = 0; ih < PSIZE; ++ih) { if (piece[iv][ih] && iv+ptop >= 0) board[iv+ptop][ih+pleft] = 1; } } removerows(); generate(); settitle(); if (moveby(0, 1)) wsettimer(win, delay); else { if (alfa) { /* Alfa STDWIN's wmessage doesn't wait for an OK */ char buffer[10]; strcpy(buffer, "Game over"); (void) waskstr("", buffer, strlen(buffer)); } else wmessage("Game over"); reset(); } } /* The clock has ticked. Try to move down; if it can't, finish it off and start a new one. */ timer() { if (moveby(0, 1)) wsettimer(win, delay); else finish(); } /* Make the clock tick faster (increase level) */ faster() { if (delay > 1) --delay; settitle(); } /* Make the clock tick slower (decrease level) */ slower() { ++delay; settitle(); } /* Quit the program. Note that wdone() MUST be called before a STDWIN application exits. */ quit() { wdone(); exit(0); } /* Main event loop. React on commands, ignoring illegal ones, and react to clock ticks. Call various routines to execute the commands. Never return; calls quit() to exit. */ mainloop() { EVENT e; for (;;) { wgetevent(&e); switch (e.type) { case WE_TIMER: timer(); break; case WE_CHAR: switch (e.u.character) { case '+': faster(); break; case '-': slower(); break; case 'g': timer(); break; case ' ': finish(); break; case 'h': left(); break; case 'k': rot(); break; case 'l': right(); break; case 'q': quit(); break; case 'r': reset(); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': delay = DELAY-(e.u.character-'0'); delay = MAX(1, delay); settitle(); break; } break; case WE_CLOSE: quit(); break; case WE_COMMAND: switch (e.u.command) { case WC_RETURN: timer(); break; case WC_CANCEL: reset(); break; case WC_CLOSE: quit(); break; case WC_LEFT: left(); break; case WC_UP: rot(); break; case WC_RIGHT: right(); break; } break; } } /*NOTREACHED*/ } /* Add a menu, only used as a cheap way to display some help */ addhelpmenu() { MENU *mp; mp = wmenucreate(1, "Help"); wmenuadditem(mp, "g or return starts the game", -1); wmenuadditem(mp, "", -1); wmenuadditem(mp, "h or left arrow moves left", -1); wmenuadditem(mp, "l or right arrow moves right", -1); wmenuadditem(mp, "k or up arrow rotates", -1); wmenuadditem(mp, "space drops", -1); wmenuadditem(mp, "", -1); wmenuadditem(mp, "+/- increases/decreases level (speed)", -1); wmenuadditem(mp, "0-9 chooses level directly", -1); wmenuadditem(mp, "", -1); wmenuadditem(mp, "r or cancel restarts", -1); wmenuadditem(mp, "close or q quits the game", -1); } /* Main program. Initialize STDWIN, create the window and the help menu, reset the game and call 'mainloop()' to play it. */ main(argc, argv) int argc; char **argv; { long t; time(&t); srand((short)t ^ (short)(t>>16)); winitargs(&argc, &argv); if (wlineheight() == 1) { alfa = 1; sqwidth = 2; sqheight = 1; bleft = btop = 0; } wsetdefwinsize(bleft + BWIDTH*sqwidth + 1, btop + BHEIGHT*sqheight + 5); win = wopen("Tetris", drawproc); if (win == NULL) { printf("Can't create window\n"); wdone(); exit(1); } wsetdocsize(win, bleft + BWIDTH*sqwidth + 1, btop + BHEIGHT*sqheight + 1); addhelpmenu(); reset(); mainloop(); /*NOTREACHED*/ } return; } for (row = 0; row < size; ++row) { for (col = 0; col < size; ++col) { if (sq[row][col] == last) { sq[row][col] = 0; --last; oldok = ok; evaluate(); if (ok != oldok) wchange(win, 0, 0, FARAWAY, FARAWAY); else chansmtalk43/stdwin/Conf/0407550003270021170000000000005477556065011103 5 0 1 0 smtalk43/stdwin/Conf/README1006440003270021170000001221305434024314012544 037777777777 1 0 Conf subdirectory ----------------- This directory contains tools (scrips) and data (Makefile fragments) used to build various ports of stdwin and applications that use it on various UNIX-based platforms. An explanation of some of the terms used may be in order: A "port" of stdwin consists of code that implements the portable stdwin interface on top of a particular lower-level interface, e.g., there is a port for X11, called "x11", and a port for ASCII terminals using the termcap library, called "alfa"; there are also ports to the Macintosh and the Atari ST, etc. Ports can share code; in particular, some library packages built on top of stdwin (like "textedit") are used with all ports, and some low-level routines (like "strdup") are used by all ports. Ports are structured as libraries that must be linked with applications. A "platform" is a combination of operating system and machine architecture on which you might want to use stdwin. The x11 and alfa ports work on many platforms, and most of those platforms support both ports. The current set-up identifies platforms with architectures; while several operating systems are used on multiple architectures (e.g., SunOS on sun3 and sun4 architectures), few architectures offer a choice of operating system. (If this simplification becomes a real problem, we'll simply change the maning of architecture identifiers into platform identifiers, so we might have platforms "ultvax" and "bsdvax" for a VAX under Ultrix and a VAX under BSD, respectively.) A "component" is either a port library, a package library, or an application program. Components are the smallest units that have Makefiles. There is one set of sources for a particular component, used on all platforms. Package and application components are also used with different ports, again using the same set of sources. Objects live in a different part of the stdwin tree than sources. This subtree is rooted at the Build subdirectory of the tree. We certainly need a subtree per port, since two or more ports can co-exist on most platforms; but we also need a subtree per platform, since, through the wonders of NFS, a single file system containing the stdwin tree may be mounted on totally different systems. Hence, the Build subtree has two levels of subdirectories before we are getting to business, one per architecture (really per platform), one per port. The scripts have a few provisions to create build trees in nonstandard places if you need more freedom. The subtree structure under Build is as follows: Build// subtree for a particular architecture or platform ( can be sun3, sun4, vax etc.) Build/// subtree for a particular port ( can be alfa or x11) Build///lib/ the main library component for the port is built here Build///lib/lib.a library file to link with applications Build//// Build//// each application or package library component is built in its own subdirectory The Makefiles are all generated automatically by scripts that live in the Conf subdirectory. They are created from four sources: a) The concatenation of Makefile fragments that contain definitions specific to: - the port - the architecture (or platform) - the operating system These fragments live in the Conf subdirectory. Fragments for all supported ports, and platforms are provided, as well as templates that can be used to create new fragments. These serve as documentation for the fragments as well. b) A Makefile fragment specific to the component being built. It defines which sources are needed and how they must be combined. The sources can come form any number of directories besides the component's main source directory. The object names are derived from the source names. There are two methods of combining objects right now: libraries are created with "ar" (and optionally "ranlib"), applications are created by linking all objects together. These Makefile fragments live in the main source directory of the component (library or application) being built. The actual rules for building and creating the objects are not contained in the fragments; rather, a bit of "bootstrap magic" is used. c) The bootstrap magic consists of a Make rule in the component-specific fragment. This rule calls a program "putprogmf" or "putlibmf" (depending on the component type) with the list of source files used; the output is concatenated with the Makefile fragments listed previously to produce a Makefile that can build the component on the given platform using the given port library (in case of an application). d) Full dependencies are added to the Makefile later. Each Makefile contains a rule "depend" which updates the Makefile (in place!) with the current dependencies. This should be run once after the Makefile is built, and later when the dependency structure of the sources is changed. The dependencies are not added when the Makefile is created initially, since the script that computes dependencies *must* run on the platform where the component is actually being built, while the Makefile can be created (through NFS) from another platform. rgv); wdone(); exit(0); } return; } if ((fd = readfrom(argc, argv)) < 0) { wmessage("can't start command"); wsettimer(win, errdelay); return; } left = MAXSIZE; p = image; if (tflag) { extern char *ctime(); extern long time(); long t; time(&t); strcpy(p, ctime(&t)); p = strchr(p, '\0'); } while (left > 0 && (n = read(fd, p, left)) > 0) { p +smtalk43/stdwin/Conf/fastmkdep1007550003270021170000000046005434024314013571 037777777777 1 0 #! /bin/sh # Update the dependencies of the Makefile in place. # usage: $0 $(CFLAGS) $(SRCS) { sed '/^# DO NOT DELETE THIS LINE/,$d' Makefile && echo && echo '# DO NOT DELETE THIS LINE -- make depend depends on it.' && echo && cc -M $* } >>Mf.dep && mv Makefile Makefile.bak && mv Mf.dep Makefile e function return value is X * scale, where X is the exact value read from the string, e.g., for input "3.14" and scale 1000, 3140 is returned. There is no provision for a leading sign or to leading smtalk43/stdwin/Conf/makemakefile1007550003270021170000000424505434024314014233 037777777777 1 0 #!/bin/sh # makemakefile - create a Makefile PROGNAME=`basename $0` USAGE="usage: $PROGNAME topdir os arch port srcdir builddir" # Check and get arguments # case $# in 6) ;; *) echo "$USAGE" 1>&2 echo ' may be relative to ' 1>&2 echo ' may be relative to /Build//' 1>&2 exit 2 ;; esac TOPDIR=$1; shift OS=$1; shift ARCH=$1; shift PORT=$1; shift SRCDIR=$1; shift BLDDIR=$1; shift # Set derived pathnames CONFDIR=$TOPDIR/Conf case $SRCDIR in /*) ;; *) SRCDIR=$TOPDIR/$SRCDIR;; esac case $BLDDIR in /*) ;; *) BLDDIR=$TOPDIR/Build/$ARCH/$PORT/$BLDDIR;; esac OSPROTO=$CONFDIR/proto.os.$OS ARCHPROTO=$CONFDIR/proto.arch.$ARCH PORTPROTO=$CONFDIR/proto.port.$PORT CONFPROTO=$CONFDIR/proto.conf SRCPROTO=$SRCDIR/Make.proto # Make sure the source prototype exists, else there's no use in proceeding. # This test is made to avoid creating junk build directories. # (Missing other files are detected by the cat command.) if test ! -f $SRCPROTO then echo "$PROGNAME: can't find Makefile prototype $SRCPROTO" 1>&2 exit 1 fi # Make sure the build directory exists, create it if necessary # (only one level deep though!) # if test -d $BLDDIR then : else echo "$PROGNAME: creating new build directory $BLDDIR" 1>&2 mkdir $BLDDIR || { echo "$PROGNAME: can't create build directory $BLDDIR" 1>&2; exit 1;} fi # Now begin doing the real work # PRELUDE="$OSPROTO $ARCHPROTO $PORTPROTO $CONFPROTO $SRCPROTO" BOOTMAKE=$BLDDIR/Mf.boot echo "$PROGNAME: creating bootstrap Makefile ..." 1>&2 { echo "TOP=$TOPDIR" && cat $PRELUDE; } >$BOOTMAKE || { echo "$PROGNAME: can't create bootstrap Makefile $BOOTMAKE" 1>&2; exit 1; } TEMPMAKE=$BLDDIR/Mf.temp echo "$PROGNAME: creating temp Makefile ..." 1>&2 { echo "TOP=$TOPDIR" && cat $PRELUDE && make -f $BOOTMAKE _bootstrap; } >$TEMPMAKE || { echo "$PROGNAME: can't create temp Makefile $TEMPMAKE" 1>&2; exit 1; } MAKEFILE=$BLDDIR/Makefile echo "$PROGNAME: moving temp Makefile to Makefile ..." 1>&2 if test -f $MAKEFILE then BACKUP=$MAKEFILE.bak echo "$PROGNAME: NB: moving previous Makefile to backup" 1>&2 rm -f $BACKUP mv $MAKEFILE $BACKUP fi mv $TEMPMAKE $MAKEFILE && echo "$PROGNAME: done." 1>&2 L)) break; (void) teevent(tb, &e); } tefree(tb); wclose(win); wdone(); exit(0); } 0 1 0 smtalk43/stdwin/Conf/mkall1007550003270021170000000021405434024314012710 037777777777 1 0 echo + mkmf $* mkmf $* for dir in `ls ../Appls` do if test -f ../Appls/$dir/Make.proto then echo + mkmf $* $dir mkmf $* $dir fi done in(argc, argv) int argc; char **argv; { WINDOW *win; MENU *mp; int width, height; int stop= 0; winitargs(&argc, &argv); if (argc >= 3) { int h= atoi(argv[1]), v= atoi(argv[2]); wsetdefwinpos(h, v); } mp= wmenucreate(1, "File"); wmenuadditem(mp, "Quit", 'Q'); win= wopen("Menu+textedit", drawproc); wgetwinsize(win, &width, &height); wsetdocsize(winsmtalk43/stdwin/Conf/mkmf1007550003270021170000000303705434024314012550 037777777777 1 0 #! /bin/sh # mkmf - friendly interface to makemakefile PROGNAME=`basename $0` USAGE="usage: $PROGNAME [-a arch] [-o os] [-t topdir] [-p port] [application]; if no application specified, a port makefile is created, else an application makefile is created." TOP=`(cd ..; pwd)` PORT=x11 if ARCH=`(arch) 2>/dev/null` then case $ARCH in sun[34]) OS=sunos;; sgi) OS=sysv;; esac elif ARCH=`(machine) 2>/dev/null` then case $ARCH in vax|mips) OS=ultrix;; tahoe) OS=bsd;; esac fi while : do case $1 in -a) ARCH=$2; shift; shift;; -o) OS=$2; shift; shift;; -p) PORT=$2; shift; shift;; -t) TOP=$2; shift; shift;; -*) echo "$USAGE" 1>&2; exit 2;; *) break;; esac done case $OS in '') echo "Sorry, can't guess operating system, use -o"; exit 2;; esac case $ARCH in '') echo "Sorry, can't guess architecture, use -a" 1>&2; exit 2;; esac # Create top level in the Build tree if necessary if test ! -d $TOP/Build then echo "Create $TOP/Build? [ny]" read reply case $reply in [yY]*) mkdir $TOP/Build || exit;; *) exit;; esac fi if test ! -d $TOP/Build/$ARCH then echo "Create $TOP/Build/$ARCH? [ny]" read reply case $reply in [yY]*) mkdir $TOP/Build/$ARCH || exit;; *) exit;; esac fi if test ! -d $TOP/Build/$ARCH/$PORT then echo "Create $TOP/Build/$ARCH/$PORT? [ny]" read reply case $reply in [yY]*) mkdir $TOP/Build/$ARCH/$PORT || exit;; *) exit;; esac fi case $# in 0) set -x; makemakefile $TOP $OS $ARCH $PORT Ports/$PORT lib;; 1) set -x; makemakefile $TOP $OS $ARCH $PORT Appls/$1 $1;; *) echo "$USAGE" 1>&2; exit 2;; esac win; winitargs(&argc, &argv); win= wopen("Hello test", drawproc); for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: printf("%s event: b=%d, h=%d, v=%d\n", evname[e.type], e.u.where.button, e.u.where.h, e.u.where.v); break; case WE_COMMAND: printf("command event (%s)\n", cmname[e.u.command]); break; case WE_CHAR: printf("char event ('%c', 0x%02x)\n", e.u.character, e.u.chasmtalk43/stdwin/Conf/proto.arch.680001006440003270021170000000171505434024315014350 037777777777 1 0 # # Definitions for 68000 architecture # # Define the name of this architecture here. # This is used as a subdirectory name where all the objects for this # architecture live: $(TOP)/Build/$(ARCH) # # Note that there is the silent assumption that there is only one O.S. # per architecture. We'll have to invent composite architecture names, # or insert an extra level in the build tree, if this becomes false... # ARCH= 68000 # Define the name of the script used to update the dependencies in # the Makefile. # Choices are: # slowmkdep -- always works (as far as I know) # fastmkdep -- used cc -M, which isn't always available # makedepend -- Todd Brunhoff's superfast tool (comes with X11) # (This needs -Dunix because of configure.h) # You may also place this definition in the proto.os.* file if you # know a method works for every architecture supported by that OS. # #MKDEP= $(CONF)/slowmkdep #MKDEP= $(CONF)/fastmkdep #MKDEP= makedepend -Dunix nusetdeflocal(1); m = wmenucreate(1, "Menu1"); smtalk43/stdwin/Conf/proto.arch.mips1006440003270021170000000025405434024315014640 037777777777 1 0 # # Definitions pertaining to the DEC mips architecture # # The name of this architecture ARCH= mips # Script to add dependencies to Makefile MKDEP= $(CONF)/fastmkdep 37777777777 1 0 smtalk43/stdwin/Conf/proto.arch.sgi1006440003270021170000000076405434024315014460 037777777777 1 0 # # Definitions pertaining to architecture SGI (Silicon Graphics) # # Define the name of this architecture here. # This is used as a subdirectory name where all the objects for this # architecture live: $(TOP)/Build/$(ARCH) # ARCH= sgi # The system libraries to link with programs that use termcap and X11 # LIBTERMCAP= -ltermcap LIBX11= -lX11 -lbsd # Pretend it's an ANSI compiler (not quite true but close) # This assumes IRIX 3.3 or higher # ARCHOPTS= -prototypes -acpp ARCHDEFS= -D__STDC__ lt: sprintsmtalk43/stdwin/Conf/proto.arch.sun31006440003270021170000000041605434024315014560 037777777777 1 0 # # Definitions pertaining to Sun3 (mc680x0) architecture # # Define the name of this architecture here. # This is used as a subdirectory name where all the objects for this # architecture live: $(TOP)/Build/$(ARCH) # ARCH= sun3 OSINCLS= -I/usr/local/X/usr/include 1 0 smtalk43/stdwin/Conf/proto.arch.sun41006440003270021170000000034705434024315014564 037777777777 1 0 # # Definitions pertaining to Sun4 (SPARC) architecture # # Define the name of this architecture here. # This is used as a subdirectory name where all the objects for this # architecture live: $(TOP)/Build/$(ARCH) # ARCH= sun4 reak; if (e.type == WE_COMMAND) { if (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL) break; else if (e.u.command == SPECIAL) { wmessage("Got event from handler"); continue; } } (void) teevent(tb, &e); } tefree(tb); wclose(win); wdone(); exsmtalk43/stdwin/Conf/proto.arch.tahoe1006440003270021170000000025605434024315014772 037777777777 1 0 # # Definitions pertaining to the TAHOE architecture # # The name of this architecture ARCH= tahoe # Program to update Makefile dependencies # MKDEP= $(CONF)/slowmkdep 37777777777 1 0 smtalk43/stdwin/Conf/proto.arch.vax1006440003270021170000000025605434024316014471 037777777777 1 0 # # Definitions pertaining to the DEC VAX architecture # # The name of this architecture ARCH= vax # Program to update Makefile dependencies # MKDEP= $(CONF)/slowmkdep / vtcwidth(vt)); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: return; case WC_RETURN: vtansiputs(vt, "\n", 1); break; case WC_BACKSPACE: vtansiputs(vt, "\b", 1); break; case WC_TAB: vtansiputs(vt, "\t", 1); break; } break; case WE_CLOSE: return; } }smtalk43/stdwin/Conf/proto.arch.xxx1006440003270021170000000172005434024316014517 037777777777 1 0 # # Definitions pertaining to architecture XXX # # Define the name of this architecture here. # This is used as a subdirectory name where all the objects for this # architecture live: $(TOP)/Build/$(ARCH) # # Note that there is the silent assumption that there is only one O.S. # per architecture. We'll have to invent composite architecture names, # or insert an extra level in the build tree, if this becomes false... # ARCH= XXX # Define the name of the script used to update the dependencies in # the Makefile. # Choices are: # slowmkdep -- always works (as far as I know) # fastmkdep -- used cc -M, which isn't always available # makedepend -- Todd Brunhoff's superfast tool (comes with X11) # (This needs -Dunix because of configure.h) # You may also place this definition in the proto.os.* file if you # know a method works for every architecture supported by that OS. # MKDEP= $(CONF)/slowmkdep MKDEP= $(CONF)/fastmkdep MKDEP= makedepend -Dunix smtalk43/stdwin/Conf/proto.conf1006440003270021170000000316705466263647013731 037777777777 1 0 # # Definitions pertaining to all configurations # # Names for all the top-level subdirectories of the stdwin tree APPLS= $(TOP)/Appls BUILD= $(TOP)/Build CONF= $(TOP)/Conf H= $(TOP)/H PACKS= $(TOP)/Packs PORTS= $(TOP)/Ports TOOLS= $(TOP)/Tools # Names for subdirectories of $(PORTS) ALFA= $(PORTS)/alfa X11= $(PORTS)/x11 GEN= $(TOP)/Gen VTRM= $(PORTS)/vtrm VTRM_ALL= $(PORTS)/vtrm/uxtty.c $(PORTS)/vtrm/vtrm.c # Names for subdirectories of $(PACKS) TEXTEDIT= $(TOP)/Packs/textedit VT= $(TOP)/Packs/vt # Names for all sources files to the textedit package -- # this is used to include them in each port's library TEXTEDIT_PACK= $(TEXTEDIT)/*.c VT_PACK= $(VT)/vt*.c # Build directory -- one for each port PORTBUILD= $(TOP)/Build/$(ARCH)/$(PORT) # C flags (include directories, definitions, options) used at all times CONFINCLS= -I$(H) CONFDEFS= CONFOPTS= # XXX should be OS or arch specific! CONFLIBS= # Construct CFLAGS from various sources # XXX does the order matter? INCLS= $(OSINCLS) $(ARCHINCLS) $(PORTINCLS) $(CONFINCLS) $(SRCINCLS) DEFS= $(OSDEFS) $(ARCHDEFS) $(PORTDEFS) $(CONFDEFS) $(SRCDEFS) OPTS= $(OSOPTS) $(ARCHOPTS) $(PORTOPTS) $(CONFOPTS) $(SRCOPTS) CPPFLAGS= $(INCLS) $(DEFS) CFLAGS= $(CPPFLAGS) $(OPTS) # Construct LIBS to link application with from various sources # XXX what is the right order? LIBS= $(SRCLIBS) $(PORTLIBS) $(OSLIBS) $(ARCHLIBS) $(CONFLIBS) # Ensure that "all" is the first target defined in this Makefile all: # Standard targets # Target to add dependency rules to the Makefile (in place!) depend: $(MKDEP) $(CFLAGS) $(SRCS) # XXX There should be standard targets tags, clean, etc. The Cancel key (Command-Period on the Mac, Control-C on most other systems) restarts the game; close the window or type 'q' to quit the game. The origin of the game appears to be in the East Block; I've heard that the (original?) Macintosh version was by a Hungarian programmer. This code is hereby put in the public domain, but the package STDWIN used as portable wismtalk43/stdwin/Conf/proto.os.amoeba1006440003270021170000000231605434024316014622 037777777777 1 0 # # Definitions for operating system Amoeba # # Define the name of this O.S. here. # OS= amoeba # Choose ONE of the following definitions of RANLIB. # BSD-based systems will need ranlib to be called after a library is # changed. # SYSV-based systems don't have ranlib; the value 'true' makes Make happy. # RANLIB= ranlib # for BSD #RANLIB= true # for SYSV # Define the name of the script used to update the dependencies in # the Makefile. # Choices are: # slowmkdep -- always works (as far as I know) # fastmkdep -- uses cc -M, which isn't always available # makedepend -- Todd Brunhoff's superfast tool (comes with X11) # (This needs -Dunix because of configure.h) # You may also place this definition in the proto.arch.* file if no # method works for every architecture supported by this OS. # #MKDEP= $(CONF)/slowmkdep #MKDEP= $(CONF)/fastmkdep #MKDEP= makedepend -Dunix # Define the system libraries to link with programs that use termcap and X11 # (In some cases these are architecture-dependent) # #LIBTERMCAP= -ltermcap #LIBX11= -lX11 # Other OS-specific choices (-I flags, -D flags, compiler options) # OSINCLS= -I/usr/amoeba/src/h -I/usr/amoeba/src/h/posix OSDEFS= -DAMOEBA -DSYSV OSOPTS= ome but not all systems) */ #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif #ifndef MAX #define MAX(a, b) ((a) > (b) ? (a) : (b)) #endif /* Available shapes. Relnext is the offset to the next piece after rotation. The pieces are aligned with the bottom so their scoring values are smtalk43/stdwin/Conf/proto.os.bsd1006440003270021170000000021705434024316014144 037777777777 1 0 # # Definitions pertaining to BSD (4.3) # OS= bsd RANLIB= ranlib # MKDEP is defined in proto.arch.* LIBTERMCAP= -ltermcap LIBX11= -lX11 , {0, 0, 0}, {0, 0, 1}, {1, 1, 1}}}, {1, {{0, 0, 0}, {0, 1, 1}, {0, 0, 1}, {0, 0, 1}}}, {-3, {{0, 0, 0}, {0, 0, 0}, {1, 1, 1}, {1, 0, 0}}}, /* "Inverse L shape" (4 orientations) */ {1, {{0, 0, 0}, {0, 1, 1}, {0, 1, 0}, {0, 1, 0}}}, {1, {{0, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 1, 1}}}, {1, {{0, 0, 0}, {0, smtalk43/stdwin/Conf/proto.os.sony1006440003270021170000000203105434024317014361 037777777777 1 0 # # Definitions for Sony News workstation # # The name of this O.S. # OS= sony # Choose ONE of the following definitions of RANLIB. # BSD-based systems will need ranlib to be called after a library is # changed. # RANLIB= ranlib # for BSD # Define the name of the script used to update the dependencies in # the Makefile. # Choices are: # slowmkdep -- always works (as far as I know) # fastmkdep -- uses cc -M, which isn't always available # makedepend -- Todd Brunhoff's superfast tool (comes with X11) # (This needs -Dunix because of configure.h) # You may also place this definition in the proto.arch.* file if no # method works for every architecture supported by this OS. # #MKDEP= $(CONF)/slowmkdep MKDEP= $(CONF)/fastmkdep #MKDEP= makedepend -Dunix # Define the system libraries to link with programs that use termcap and X11 # (In some cases these are architecture-dependent) # LIBTERMCAP= -ltermcap LIBX11= -lX11 # Other OS-specific choices (-I flags, -D flags, compiler options) # OSINCLS= OSDEFS= OSOPTS= ndow.) */ settitle() { char buf[100]; int level = MAX(0, DELAY-delay); if (level == 0) { if (score == 0) strcpy(buf, "Tetris"); else sprintf(buf, "Score %ld", score); } else { if (score == 0) sprintf(buf, "Level %d", level); else sprintf(buf, "Sc %ld Lv %d", score, level); } wsettitle(win, buf); } /* Erase a portion of the board on the screen. Call only within wbegin/enddrawing. */ eraseboard(ileft, itop, iright, ibottom) int ileft, itop, iright, smtalk43/stdwin/Conf/proto.os.sunos1006440003270021170000000067405434024317014553 037777777777 1 0 # # Definitions pertaining to SunOS (hopefully all versions) # # Define the name of this O.S. here. # OS= sunos # BSD-based systems will need ranlib to be called after a library is # changed. # RANLIB= ranlib # for BSD-based systems # The mkdep using cc -M will work for any architecture (I hope) # MKDEP= $(CONF)/fastmkdep # The system libraries to link with programs that use termcap and X11 # LIBTERMCAP= -ltermcap LIBX11= -lX11 h < pleft+PSIZE && ptop <= iv && iv < ptop+PSIZE) flag = pismtalk43/stdwin/Conf/proto.os.sysv1006440003270021170000000136405434024317014405 037777777777 1 0 # # Definitions pertaining to (modern versions of) System V # # Disclaimer: this was only tested on a Silicon Graphics under IRIX 3.2 # # The name of this O.S. # OS= sysv # SYSV-based systems don't have ranlib; the value 'true' makes Make happy. # RANLIB= true # for SYSV # Defines to make various bits of code happy: # -DSYSV is the general test for System V. # -Datt is used at least by some X internal headers (and what else?) # And, of course, index and rindex are called strchr and strrchr. # OSDEFS= -DSYSV -Datt -Dindex=strchr -Drindex=strrchr # The mkdep using cc -M will work for any architecture (I hope) # MKDEP= $(CONF)/fastmkdep # The system libraries to link with programs that use termcap and X11 # are in proto.arch.* instead. can stick out above the top. */ int allowed(dh, dv) int dh, dv; { int ih, iv; for (iv = 0; iv < PSIZE; ++iv) { for (ih = 0; ih < PSIZE; ++ih) { if (piece[iv][ih]) { if (ih+dh < 0 || ih+dh >= BWIDTH) return 0; if (iv+dv < 0) continue; ismtalk43/stdwin/Conf/proto.os.ultrix1006440003270021170000000026605434024317014730 037777777777 1 0 # # Definitions pertaining to DEC Ultrix (tested with 2.2 or 3.0) # OS= ultrix RANLIB= ranlib # MKDEP is defined in proto.arch.{vax,mips} LIBTERMCAP= -ltermcap LIBX11= -lX11 ) { return 0; } ileft = pleft + MIN(dh, 0); itop = ptop + MIN(dv, 0); iright = pleft + PSIZE + MAX(dh, 0); ibottom = ptop + PSIZE + MAX(dv, 0); pleft += dh; ptop += dv; redrawboard(ileft, itop, iright, ibottom); return 1; } /* Rotate the piece n quarter left turns, if this is a legal move. Return 1 if movesmtalk43/stdwin/Conf/proto.os.xxx1006440003270021170000000222205434024317014222 037777777777 1 0 # # Definitions pertaining to operating system XXX # # Define the name of this O.S. here. # OS= XXX # Choose ONE of the following definitions of RANLIB. # BSD-based systems will need ranlib to be called after a library is # changed. # SYSV-based systems don't have ranlib; the value 'true' makes Make happy. # RANLIB= ranlib # for BSD RANLIB= true # for SYSV # Define the name of the script used to update the dependencies in # the Makefile. # Choices are: # slowmkdep -- always works (as far as I know) # fastmkdep -- uses cc -M, which isn't always available # makedepend -- Todd Brunhoff's superfast tool (comes with X11) # (This needs -Dunix because of configure.h) # You may also place this definition in the proto.arch.* file if no # method works for every architecture supported by this OS. # MKDEP= $(CONF)/slowmkdep MKDEP= $(CONF)/fastmkdep MKDEP= makedepend -Dunix # Define the system libraries to link with programs that use termcap and X11 # (In some cases these are architecture-dependent) # LIBTERMCAP= -ltermcap LIBX11= -lX11 # Other OS-specific choices (-I flags, -D flags, compiler options) # OSINCLS= OSDEFS= OSOPTS= sqheight); next: ; } } /* Add the score for the current piece to the total score. The title is not regenerated; that is done later in finish(). */ addscore() { int level = MAX(0, DELAY-delay); int height = MAX(0, BHEIGHT-ptop); score += height + 2*level /* *(advanced?2:1) */ ; } /* Finish a piece off by dropping it; score and generate a new one. Csmtalk43/stdwin/Conf/proto.port.alfa1006440003270021170000000104005434024320014630 037777777777 1 0 # # Definitions pertaining to the alphanumeric port (using termcap) # # Define the name of this port. # This is used as a subdirectory name where all the objects for this # port for a given architecture live: $(TOP)/Build/$(ARCH)/$(PORT) # PORT= alfa # Libraries to link with for the X11 port. # The first part is boilerplate, the rest depends on which other # libraries your port needs. # PORTOWNLIBS= $(PORTBUILD)/lib/lib.a PORTSYSLIBS= $(LIBTERMCAP) PORTLIBS= $(PORTOWNLIBS) $(PORTSYSLIBS) # NB: -ltermcap is really OS-specific, sigh. ; settitle(); } /* Quit the program. Note that wdone() MUST be called before a STDWIN application exits. */ quit() { wdone(); exit(0); } /* Main event loop. React on commands, ignoring illegal ones, and react to clock ticks. Call various routines to execute the commands. Never return; calls quit() to exit. */ mainloop() { EVENT e; for (;;) { wgetevent(&e); switch (e.type) { case WE_TIMER: timer(); break; case WE_CHAR: switch (esmtalk43/stdwin/Conf/proto.port.x111006440003270021170000000031505464612765014365 037777777777 1 0 # # Definitions pertaining to the X11 port # PORT= x11 # Libraries to link with for the X11 port PORTOWNLIBS= $(PORTBUILD)/lib/libstdw.a PORTSYSLIBS= $(LIBX11) PORTLIBS= $(PORTOWNLIBS) $(PORTSYSLIBS) reset(); break; case WC_CLOSE: quit(); break; case WC_LEFT: left(); break; case WC_UP: rot(); break; case WC_RIGHT: right(); break; } break; } } /*NOTREACHED*/ } /* Add a menu, only used as a cheap way to display some help */ addhelpmenu() { Msmtalk43/stdwin/Conf/proto.port.xxx1006440003270021170000000201005434024320014552 037777777777 1 0 # # Definitions pertaining to the port to the XXX window system # # NB: You are not expected to port STDWIN -- this has already been done. # This prototype file is provided mostly to document the definitions # exported from the various proto.port.* files, and as a template for # the STDWIN implementer. And, of course, if you really WANT to port # stdwin to a new window system or look-and-feel (NeWS, or SunTools, or # OpenLook), you're welcome -- just check with the author of STDWIN # first to see if somebody else isn't planning to do the same. # Define the name of this port. # This is used as a subdirectory name where all the objects for this # port for a given architecture live: $(TOP)/Build/$(ARCH)/$(PORT) # PORT= XXX # Libraries to link with for the X11 port. # Most of this is boilerplate, only the PORTSYSLIBS part depends on # what your system requires. # PORTOWNLIBS= $(PORTBUILD)/lib/lib.a PORTSYSLIBS= -lXXX PORTLIBS= $(PORTOWNLIBS) $(PORTSYSLIBS) # NB: -lXXX is really OS- or site-specific as well, sigh. /stdwin/Conf/0407550003270021170000000000005477556065011103 5 0 1 0 smtalk43/stdwin/Conf/putlibmf1007550003270021170000000104405434024320013431 037777777777 1 0 #!/bin/sh # Construct a segment of a Makefile for a library. # Writes to stdout. # # usage: putlibmf target $(SRCS) # Check that we have enough arguments # case $# in 0|1) echo "usage: $0 target $(SRCS)" 1>&2; exit 2;; esac # Extract arguments; remaining arguments are source files # TARGET=$1; shift putobjs "OBJS" $* # Construct rule to build target # echo echo "$TARGET: \$(OBJS)" echo " ar cr @$TARGET \$(OBJS)" echo " \$(RANLIB) @$TARGET" echo " mv @$TARGET $TARGET" # ^^these are tabs! echo echo ".PRECIOUS: $TARGET" puttargets $* h and the Atari ST, etc. Ports can share code; in particular, some library packages built on top of stdwin (like "textedit") are used with all ports, and some low-level routines (like "strdup") are used by all ports. Ports are structured as libraries that must be linked with applications. A "platform" is a combination of operating system and machine architecture on which you might want to use stdwin. The x11 and alfa ports work on many platforms, and most of those plasmtalk43/stdwin/Conf/putobjs1007550003270021170000000046605434024320013304 037777777777 1 0 #! /bin/sh # # Construct OBJS macro definition # usage: putobjs macroname sourcefile ... # Find out which echo we have, sigh case `echo -n` in -n) N=; C='\c';; *) N=-n; C=;; esac echo echo $N "$1=$C" shift for file do case $file in *.c) echo " \\"; echo $N " `basename $file .c`.o$C";; esac done echo ources. Objects live in a different part of the stdwin tree than sources. This subtree is rooted at the Build subdirectory of the tree. We certainly need a subtree per port, since two or more ports csmtalk43/stdwin/Conf/putprogmf1007550003270021170000000107705434024321013641 037777777777 1 0 #!/bin/sh # Construct a segment of a Makefile for a program. # # usage: putprogmf target "$(CFLAGS)" $(SRCS) # Check that we have enough arguments # case $# in 0|1) echo "usage: $0 target $(SRCS)" 1>&2; exit 2;; esac # Extract arguments; remaining arguments are source files # TARGET=$1; shift putobjs "OBJS_$TARGET" $* # Construct rule to build target # echo echo "$TARGET: \$(OBJS_$TARGET) $(PORTOWNLIBS)" echo " \$(CC) \$(CFLAGS) \$(OBJS_$TARGET) \$(LIBS) -o @$TARGET" echo " mv @$TARGET $TARGET" # ^^these are tabs! echo echo ".PRECIOUS: $TARGET" puttargets $* rectory. They are created from four sources: a) The concatenation of Makefile fragments that contain definitions specific to: - the port - the architecture (or platform) - the operating system These fragments live in the Conf subdirectory. Fragments for all supported ports, and platforms are provided, as well as templates that can be used to create new fragments. These serve as documentation for the fragments as well. b) A Makefismtalk43/stdwin/Conf/puttargets1007550003270021170000000037605434024321014021 037777777777 1 0 #! /bin/sh # # Construct rules to build individual .o files # usage: puttargets $(SRCS) for file do case $file in *.c) obj=`basename $file .c`.o echo echo "$obj: $file" echo " \$(CC) -c \$(CFLAGS) $file" # ^^this is a tab! ;; esac done nent-specific fragment. This rule calls a program "putprogmf" or "putlibmf" (depending on the component type) with the list of source files used; the output is concatenated with the Makefile fragments listed previously to produce a Makefile that can buismtalk43/stdwin/Conf/slowmkdep1007550003270021170000000023405434024321013615 037777777777 1 0 #! /bin/sh # This script should eventually update the Makefile to contain # dependencies. For now, call Todd Brunhoff's makedepend. makedepend -Dunix $* exit(0); } return; } if ((fd = readfrom(argc, argv)) < 0) { wmessage("can't start command"); wsettimer(win, errdelay); return; } left = MAXSIZE; p = image; if (tflag) { extern char *ctime(); extern long time(); long t; time(&t); strcpy(p, ctime(&t)); p = strchr(p, '\0'); } while (left > 0 && (n = read(fd, p, left)) > 0) { p +smtalk43/stdwin/Doc/0407550003270021170000000000005477556071010720 5 0 1 0 smtalk43/stdwin/Doc/ABOUT1006440003270021170000003671705434024322012317 037777777777 1 0 [Last modified on Sat Apr 15 20:19:00 MET DST 1989 by guido] 0. Copyright Notice STDWIN is copyrighted: Copyright (c) 1988, 1989 by Stichting Mathematisch Centrum, Amsterdam, The Netherlands. STDWIN is available for noncommercial use only, free of charge, and with no guarantees. It can be freely used and distributed provided these restrictions are honoured. 1. Target systems STDWIN is aimed at C programs. It consists of a few header files (of which only one is visible to the user) and a library. In most cases some system-provided libraries must also be used in the linking phase. Currently, full STDWIN is available for the following environments: (Note that in all cases the code is in beta test state; there may be bugs, functionality may change slightly in the future and new functionality may be added, but the basic framework isn't going to change much.) * X version 11, release 3 (should still work with release 2) * Apple Macintosh, using either THINK C (3.01) or MPW C (2.02) * Atari ST, using Mark Williams C (2.1) You may volunteer to create a version for your favourite system, or to port it to your favourite C compiler for one of the mentioned micros. (The micro versions are rather compiler-dependent, due to the many differences between compilers and especially libraries. Expect difficulties if you have another compiler or version than the ones mentioned. Especially the Atari version is flakey.) A subset, emulating most of STDWIN's functionality on an alphanumeric display (excluding line drawing, but including multiple (non-overlapping) windows, menus, text editing etc.) is available for: * Any decent Unix that has termcap (tested with 4.{2,3} BSD) * MS-DOS, using the Microsoft C compiler (4.0) Sorry, there are no versions yet for SunTools, SunView, NeWS, X10, MS-Windows, Presentation Manager or the Amiga. A hacker might be able to turn the Atari ST version into a general GEM version. The code is remarkably portable to different processor types and various Unix flavors, as long as they are derived from 4.xBSD. 2. Getting the full scoop I have written a paper about STDWIN which has been published as a CWI report (Guido van Rossum: STDWIN -- A Standard Window System Interface. Centre for Mathematics and Computer Science, report CS-R8817. Amsterdam, 1988). You can also get a source version for any or all of the above-mentioned systems. This is essentially a directory dump of my working version, until I have the time or get some help to prepare a real distribution. It is available through anonymous ftp access from uunet.uu.net. The directory is amiga-sources/stdwin (thanks to the moderator, Peter da Silva) get the file README.txt for further instructions. A version of this file is in ABOUT.txt. (The version on gatekeeper no longer exists, although it may be revived in the near future). Distribution to to non-ftp-users is solely by electronic mail. Be prepared to receive up to half a megabyte (in 32K pieces in "shar" format). If you're interested, write to guido@cwi.nl. 3. Basic functionality STDWIN allows multiple "full-function" windows, roughly in Macintosh style (title bar, grow box, close box, scroll bars). The appearance of windows is determined by the default of the underlying window manager, and so are other limitations (e.g., overlapping, maximum size, etc.). Windows are dynamically created and destroyed by the application, never directly by the user or the window manager. STDWIN uses a coordinate system derived from the display's coordinate system: (0, 0) is top left, with X pointing right and Y pointing down (these are actually called h and v). Pixel size is that of the display. There are enquiry functions to ask for the display size in pixels and in millimeters. The application is responsible for redrawing the window contents when it is exposed. This is done by associating a "draw procedure" with each window, which knows how to draw the entire window's contents. It gets passed a pointer to the window and the coordinates of the rectangle that needs to be redrawn, so it can (although it needn't) restrict itself to that area. STDWIN guarantees that a window's redraw procedure is only called while the application is waiting for an input event (most implementations simply turn exposure events into calls to the draw procedure). If the application wants to change part of the graphics it is displaying, this is usually done in a two-phase process: first, STDWIN is told that a particular area of the screen must be changed; later, when the application starts waiting for input events again, the draw procedure is called to update the indicated area (and any other area that was exposed or damaged in some way). The application defines the width and height of the area it wants to draw; this needn't bear any relation to the window or screen size. This area is called the "document" although you may also think of it as a virtual window. The actual window generally displays a sub-area of the document; the window's scroll bars indicate the position of the window with respect to the document. The application always uses the coordinates of its document; STDWIN performs the translation to window or screen coordinates are required by the window manager, and ensures clipping of all output to the window. STDWIN is event-based. An application is expected to have a main loop containing a "get event" call followed by a switch on the event type. There is no event mask; an application can simply ignore events it isn't interested in. The most important event types are: ACTIVATE: A window becomes active (keyboard attached and/or topmost) CHAR: ASCII character key pressed (except BS, TAB, CR) COMMAND: special key or function (CLOSE, TAB, RETURN, BS, CANCEL, arrow keys etc.) MOUSE: MOUSE DOWN, MOUSE MOVE (only while down), MOUSE UP; fields in the event record indicate the h, v position, the number of the button, and the "click number" if the event is potentially part of a multiple-click sequence MENU: menu id and item number of a menu selection SIZE: user has resized the window TIMER: the window's timer went off; each window has one programmable timer which can be set to go off at N/10 seconds in the future. When the timer goes off a TIMER event is returned. Normally, STDWIN draws text in a single font. The actual font used depends on the underlying window manager (and can sometimes be influenced by the application programmer and/or the end user in a system-dependent manner). The font may be proportionally spaced, and there are enquiry functions to find out the dimensions of characters and strings. There are also functions to change the font name and point size dynamically; but these work different in different systems, especially the allowed font names differ drastically. This feature is used with some success in the ditroff previewer that is supplied as a demo. There are functions to draw text and simple lines, rectangles and circles, and ways to erase, shade or invert rectangular areas. There is no way (yet) to do general bitblt operations, or to influence the pen shape. 4. Higher level functionality STDWIN provides a blinking vertical bar which can be used to indicate the text insertion point, so the application needn't use TIMER events to do the blinking. STDWIN provides Macintosh-style menus. Each window has its own set of menus, although by default all menus apply to all windows. A reasonably number of menus per window is allowed, each with a reasonable number of (textual) menu items. Menus can be changed dynamically. Items can be enabled or disabled, and a 'tick mark' can be placed in front of an item. Each menu item may have a shortcut character, which, when typed in combination with some system-defined meta key (e.g., ALT or an ESC- prefix) selects the menu item (if enabled). Menu selection is done completely "underwater"; all the application notices are MENU events. STDWIN has a few simple routines to display Mac-style "dialog boxes", e.g., to show an error message, or to ask a yes/no question or to ask for a string to be typed. There is also a predefined function to ask for a file name, which may allow the user to browse the file system in some implementations. STDWIN comes with a package built on top of the basic functionality, to edit arbitrary blocks of text (cf. Macintosh TEXTEDIT). In the future, more packages will be provided, e.g., a package to provide a simple file editor (available now!), a package to display a scrolling list of items, a package to define a list of arbitrary labeled "buttons", and a package to simplify the binding of menus to functions somewhat, and a VT100 emulator (available now!). 5. Function definitions Here follows a slightly edited listing of the header file, which more or less documents all available functions and data structures. Note that the argument lists are given here as ANSI C prototypes (untested). #define bool int void winit(); void wdone(); void wsetdefwinsize(int width, int height); void wsetdefwinpos(int h, int v); #define MENU struct menu /* The contents of a text attributes struct are disclosed here because the interface allows the programmer to declare objects of this type. (I'm not so sure anymore that this is the right thing to do!) */ struct textattr { short font; unsigned char size; unsigned char style; }; #define TEXTATTR struct textattr #ifndef WINDOW struct window { short tag; }; #define WINDOW struct window #endif WINDOW *wopen(char *title, void drawproc(); void wclose(WINDOW *win); #define wgettag(win) ((win)->tag) #define wsettag(win, newtag) ((win)->tag= newtag) void wsetactive(WINDOW *win); WINDOW *wgetactive(); void wgetwinsize(WINDOW *win, int *width, int *height); void wsetdocsize(WINDOW *win, int width, int height); void wsettitle(WINDOW *win, char *title); void wsetorigin(WINDOW *win, int h, int v); void wshow(WINDOW *win, int left, int top, int right, int bottom); void wchange(WINDOW *win, int left, int top, int right, int bottom); void wscroll(WINDOW *win, int left, int top, int right, int bottom, int dh, int dv); void wfleep(); void wmessage(char *str); void wperror(char *name); bool waskstr(char *prompt, char *buf, int buflen); int waskync(char *question, int dflt); bool waskfile(char *prompt, char *buf, int buflen, bool new); void wsetcaret(WINDOW *win, int h, int v); void wnocaret(WINDOW *win); void wsettimer(WINDOW *win, int deciseconds); MENU *wmenucreate(int id, char *title); void wmenudelete(MENU *mp); int wmenuadditem(MENU *mp, char *text, char shortcut); void wmenusetitem(MENU *mp, int i, char *text); void wmenusetdeflocal(bool local); void wmenuattach(WINDOW *win, MENU *mp); void wmenudetach(WINDOW *win, MENU *mp); /* EVENT STRUCT DEFINITION */ struct event { int type; WINDOW *window; union { /* case WE_CHAR: */ int character; /* case WE_COMMAND: */ int command; /* case WE_MENU: */ struct { int id; int item; } m; /* case WE_DRAW: */ struct { int left, top, right, bottom; } area; /* case WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP: */ struct { int v; int h; int clicks; int button; int mask; } where; } u; }; #define EVENT struct event /* Event types */ #define WE_NULL 0 /* (Used internally) */ #define WE_ACTIVATE 1 /* Window became active */ #define WE_CHAR 2 /* Character typed at keyboard */ #define WE_COMMAND 3 /* Special command, function key etc. */ #define WE_MOUSE_DOWN 4 /* Mouse button pressed */ #define WE_MOUSE_MOVE 5 /* Mouse moved with button down */ #define WE_MOUSE_UP 6 /* Mouse button released */ #define WE_MENU 7 /* Menu item selected */ #define WE_SIZE 8 /* Window size changed */ #define WE_MOVE 9 /* (Reserved) */ #define WE_DRAW 10 /* Request to redraw part of window */ #define WE_TIMER 11 /* Window's timer went off */ #define WE_DEACTIVATE 12 /* Window became inactive */ /* Command codes for WE_COMMAND. Special ways of entering these are usually available, such as clicking icons, standard menu items or special keys. Some ASCII keys are also passed back as commands since they more often than not need special processing. */ #define WC_CLOSE 1 /* Should become a separate event! */ /* The following four are arrow keys */ #define WC_LEFT 2 #define WC_RIGHT 3 #define WC_UP 4 #define WC_DOWN 5 /* ASCII keys */ #define WC_CANCEL 6 #define WC_BACKSPACE 7 #define WC_TAB 8 #define WC_RETURN 9 void wgetevent(EVENT *ep); void wungetevent(EVENT *ep); void wupdate(WINDOW *win); void wbegindrawing(WINDOW *win); void wenddrawing(WINDOW *win); void wflush(); void wdrawline(int h1, int v1, int h2, int v2); void wxorline(int h1, int v1, int h2, int v2); void wdrawcircle(int h, int v, int radius); void wdrawelarc(int h, int v, int radh, int radv, int angle1, int angle2); void wdrawbox(int left, int top, int right, int bottom); void werase(int left, int top, int right, int bottom); void wpaint(int left, int top, int right, int bottom); void winvert(int left, int top, int right, int bottom); void wshade(int left, int top, int right, int bottom, int percent); int wdrawtext(int h, int v, char *str, int len); int wdrawchar(int h, int v, char c); int wlineheight(); int wtextwidth(char *str, int len); int wcharwidth(char c); int wtextbreak(char *str, int len, int width); void wgettextattr(TEXTATTR *attr); void wsettextattr(TEXTATTR *attr); void wgetwintextattr(WINDOW *win, TEXTATTR *attr); void wsetwintextattr(WINDOW *win, TEXTATTR *attr); void wsetplain(); void wsethilite(); void wsetinverse(); void wsetitalic(); void wsetbold(); void wsetbolditalic(); void wsetunderline(); /* TEXTEDIT PACKAGE DEFINITIONS */ #define TEXTEDIT struct _textedit TEXTEDIT *tealloc(WINDOW *win, int left, int top, int width); TEXTEDIT *tecreate(WINDOW *win, int left, int top, int right, int bottom); void tefree(TEXTEDIT *tp); void tedestroy(TEXTEDIT *tp); void tedraw(TEXTEDIT *tp); void tedrawnew(TEXTEDIT *tp, int left, int top, int right, int bottom); void temove(TEXTEDIT *tp, int left, int top, int width); void temovenew(TEXTEDIT *tp, int left, int top, int right, int bottom); void tesetfocus(TEXTEDIT *tp, int foc1, int foc2); void tereplace(TEXTEDIT *tp, char *str); void tesetbuf(TEXTEDIT *tp, char *buf, int buflen); void tearrow(TEXTEDIT *tp, int code); void tebackspace(TEXTEDIT *tp); bool teclicknew(TEXTEDIT *tp, int h, int v, bool extend); bool tedoubleclick(TEXTEDIT *tp, int h, int v); bool teevent(TEXTEDIT *tp, EVENT *ep); #define teclick(tp, h, v) teclicknew(tp, h, v, FALSE) #define teclickextend(tp, h, v) teclicknew(tp, h, v, TRUE) char *tegettext(TEXTEDIT *tp); int tegetlen(TEXTEDIT *tp); int tegetnlines(TEXTEDIT *tp); int tegetfoc1(TEXTEDIT *tp); int tegetfoc2(TEXTEDIT *tp); int tegetleft(TEXTEDIT *tp); int tegettop(TEXTEDIT *tp); int tegetright(TEXTEDIT *tp); int tegetbottom(TEXTEDIT *tp); /* Text paragraph drawing functions: */ int wdrawpar(int h, int v, char *text, int width); /* Returns new v coord. */ int wparheight(char *text, int width); /* Returns height */ smtalk43/stdwin/Doc/README1006440003270021170000000074705434024322012374 037777777777 1 0 Unfortunately the documentation for STDWIN is in a sorry state. There is nothing here that even remotely resembles a user manual; "paper.ms" comes closest to a full description. ABOUT the old STDWIN blurb that I used to mail out paper.ms the original STDWIN report seldoc.ms describes using X11 Selections and Cut Buffers in STDWIN macros.ms macrose used by seldoc.ms vtrmdoc.ms describes the VTRM package used by ../Ports/alfa man/ manpages for dpv, packages and X11 stdwin --Guido /textedit VT= $(TOP)/Pacsmtalk43/stdwin/Doc/macros.ms1006440003270021170000000206205434024322013331 037777777777 1 0 .\" .\" Macro definitions and other settings .\" ------------------------------------ .\" .\" The Constant Width font is whatever is mounted at font position 5. .\" XXX This is not effective, -ms overrides it (in .TL?), .\" but the effect is the same. .\" .fp 5 CW .\" .\" Constant width font - use .cW like .I or .R or .B .\" When using nroff this translates to .I. .\" .de cW .if t \{\ . ie \\n(.$ \&\f5\\$1\fP\\$2 . el .ft 5 .\} .if n .I \\$1 \\$2 .. .\" .\" Inline constant width macros -- use like \* to get a .\" word or two in constant width. Equivalent to .cW. .\" .ds < \&\f5 .ds > \fP .\" .\" Code segment macros -- use .sC to start a code segment and .eC .\" to end it. Argument to .sC (L, I or B) is passed on to .DS. .\" Tabs are set 8 spaces apart. .\" .de sC .DS \\$1 \\$2 .cW .ta \w'\0\0\0\0\0\0\0\0'u +\w'\0\0\0\0\0\0\0\0'u .. .de eC .R .DE .. .\" .\" Change the point size and spacing to something more radable: .\" .nr PS 12 .nr VS 14 .\" .\" Some string definitions specific to Python documents: .\" .ds Py \f2Python\fP .ds Ux \s-2UNIX\s0 1006440003270021170000000231605434024316014622 037777777777 1 0 smtalk43/stdwin/Doc/man/0407550003270021170000000000005477556067011500 5 0 1 0 smtalk43/stdwin/Doc/man/dpv.man1006440003270021170000000660205434024322013551 037777777777 1 0 .TH DPV 1 .SH NAME dpv \- ditroff output previewer .SH SYNOPSIS .B dpv [ .B \-d ] [ .BI + page ] .I file .SH DESCRIPTION .I Dpv is a previewer for .IR ditroff (1) output. There must be exactly one file argument, specifying a file produced by ditroff. The .B \-d option turns some debugging output on (if compiled in). The .BI + page option selects the initial page to display (default 1). .SH MENUS There are two menus. The .B Control menu contains commands to move around in the file, and a Quit command to leave the program. The .B Print menu contains commands to spool the file to various printers queues. Some checks are made that the file is compatible with the printer. .SH KEYBOARD CONTROL The following characters typed at the keyboard are interpreted as commands. A number .I N followed by a Carriage Return moves to page .I N. Carriage Return without preceding number moves one page forward. `.' with preceding number is equivalent to Carriage Return; without preceding number it redraws the current page. `N' moves to the next page, `P' moves to the previous page. A number .I N followed by `N' or `P' moves .I N pages forward or backward. Up arrow and backspace are equivalent to `P'; `+', down arrow and space are equivalent to `N'. `-' is a toggle: it jumps to the previous page that was shown. `^' or `F' moves to the first page; `$' or `L' to the last. `G' without preceding number also moves to the last page; with a preceding number .I N it moves to page .I N. `Q' quits from the program. Lower case letters are equivalent to their upper case counterparts. .SH DIAGNOSTICS Complaints about missing files, unknown fonts and what have you are written to stderr. .SH FILES funnytab, /usr/local/lib/funnytab, /userfs3/amoeba/lib/funnytab \- funny character translation table search path .SH SEE ALSO ditroff(1) .SH AUTHOR Guido van Rossum .SH BUGS May crash on malformed input (not generated by ditroff). .br Arcs and splines are replaced by straight lines (because I don't have the necessary mathematics at hand), so output from .IR pic (1) or other graphics preprocessors may be unrecognizable. .br Doesn't know all funny characters. Unknown characters are silently suppressed. .br Doesn't know all fonts, or all sizes. Unknown fonts and sizes are replaced by known ones. .br The current X11 version uses Adobe bitmap fonts which don't match very well with the width tables for the Harris. .br Character and line spacing are scaled, but it believes that it should use characters in the point sizes specified in the input. This may cause the output to look a bit cramped. .br It assumes page numbers always start at 1; it doesn't know about the true page numbers (even though these are present in the ditroff output). .br There should be an argument to specify an alternate funny character translation table file. .br The font translation table should be read from a file as well. .br If it can't find the funny character translation table file, it should fall back on a reasonable default. .br The Print menu is very CWI-specific; it, too should be customizable instead of being wired in. .br Errors in the input are handled ungracefully. .br STDWIN prints a warning to stderr for every font change if a font in the translation table doesn't exist (e.g., if you are using the X11 Release 3 version of dpv with a Release 2 server, or vice versa; or if you have botched your font directory or font path). needless to say this can be annoying. on the screen. Call only within wbegin/enddrawing. */ eraseboard(ileft, itop, iright, ibottom) int ileft, itop, iright, smtalk43/stdwin/Doc/man/editwin.man1006440003270021170000002112705434024323014423 037777777777 1 0 .TH EDITWIN 3 .SH NAME Editwin \- editing windows package for STDWIN .SH SYNOPSIS .nf .ft C #include "stdwin.h" #include "editwin.h" typedef struct editwin { WINDOW *win; TEXTEDIT *tp; char *filename; char saved; } EDITWIN; EDITWIN *ewcreate(char *filename); EDITWIN *ewnew(); EDITWIN *ewopen(); bool ewsave(EDITWIN *ew); bool ewsaveas(EDITWIN *ew); bool ewsavecopy(EDITWIN *ew); bool ewsaveall(); bool ewrevert(EDITWIN *ew); bool ewclose(EDITWIN *ew); bool ewcloseall(); bool ewwritefile(EDITWIN *ew, char *filename); bool ewreadfile(EDITWIN *ew, char *filename); bool ewevent(EDITWIN *ew, EVENT *e, int *closed_return); void ewreplace(EDITWIN *ew, char *str); void ewundo(EDITWIN *ew); /* Not implemented */ void ewcopy(EDITWIN *ew); void ewpaste(EDITWIN *ew); EDITWIN *ewfind(WINDOW *win); int ewcount(); .ft 1 .fi .SH DESCRIPTION .I Editwin is a package built on top of the .I textedit package, to ease the construction of views on text files etc. Many calls exist to make it extremely simple to respond to standard menus of .B File operations (New, Open..., Save, etc.) and .B Edit operations (Cut, Copy, Paste). .PP Below are descriptions of the individual functions. Note that when a reference is made to a window's contents, the entire contents of the edit buffer belonging to the window is meant, not just the part of it visible in the window. .IP ewcreate If .I filename is a nil pointer, this call creates an ``Untitled'' edit window. Otherwise, the specified file must exist, and an edit window showing its contents is created. In both cases, the window's `saved' flag is set initially. A pointer to a newly allocated EDITWIN struct is returned. If something went wrong (e.g., insufficient memory, or an unreadable file was specified), a nil pointer is returned. .IP ewnew This function can be called in response to the selection of the .B New menu item. It is equivalent to a call to .I ewcreate((char*)0). .IP ewopen Call this function for the .B Open... menu item. It asks the user for an existing file name (using .IR waskfile ), and then calls .I ewcreate with that file name as parameter. It returns nil if the dialog was cancelled or .I ewcreate returns nil. .IP ewsave Call this function for the .B Save menu item. If the window's contents were modified since they were last read or saved, the function attempts to save the window to its file. If the window was still ``Untitled'', the user is first asked to specify a file name. The function returns true (nonzero) if the contents were actually saved, or didn't need saving. .IP ewsaveas Call this function for the .B Save As... menu item. It asks the user for a new file name to save the window's contents, and if the saving succeeds, sets this to be the file name to which future save operations are directed. .IP ewsavecopy Call this function for the .B Save a Copy... menu item. Like .IR ewsaveas , this function asks file a new file name and saves the window's contents to that file; but it does not change the file name used for future save operations. .IP ewsaveall Calls .I ewsave for all windows. If any call returns false (zero), .I ewsaveall skips further calls and returns false. .IP ewrevert Call this function for the .B Revert... menu item. It attempts to undo any changes since the window was last read or saved, by re-reading the corresponding file. If this is at all possible, the user is asked to confirm the operation first (since it may destroy valuable changes). The function returns true if the file was actually read back, or if the window was unchanged with respect to the file. .IP ewclose Closes the window. If the window was changed since it was last read or saved, the user is first asked whether it should be saved, and if the answer is Yes, .I ewsave is called. Cancelling the dialog will prevent closing the window. Returns true if the window was actually closed. .IP ewcloseall Calls .I ewclose for all windows. If any call returns false, .I ewcloseall skips further calls and returns false. .IP ewwritefile Writes the contents of the edit window to the specified file. Returns true if the operation succeeded. This does .I not set the `saved' flag for the window (because it is used internally be .IR ewsavecopy ). .IP ewreadfile Reads the contents of the given file into the edit window, discarding its previous contents. Returns true if the operation succeeded. This .I does set the `saved' flag for the window. .IP ewevent Call this function in response to .I any event returned by .I wgetevent. If the event is a non-menu event applicable to the specified window, it is handled and the function returns true; otherwise nothing is done and the function returns false. (Menu events cannot be handled this way because the editwin package doesn't create its own menus, and thus cannot know the menu IDs or the numbers of the menu items.) If the first parameter is a nil pointer, the event is checked against any edit window; otherwise, only events applying to the given window are handled. The third parameter must be a pointer to an integer variable, which is cleared normally when an event was handled, but set to true when a window was closed as a consequence of the event (it is unchanged when the event was nbot handled at all). In the latter case, the caller should check whether any windows are still open (see .IR ewcount ), and if this is not the case, it should either exit or open a new window. This function clears a window's `saved' flag whenever its contents are modified by the event's handling. .IP ewreplace Replaces the current text selection in the window by the given (null-terminated) string. This will insert text if the text selection was an insert point. .IP ewundo Reserved for future extension of the package with an Undo facility. .IP ewcopy Call this function for the .B Copy menu item. It retrieves the contents of the window's text selection, if non-null, and copies it in into the clipboard through a call to .I wsetclip. It beeps if the text selection is empty. (To implement the .B Cut menu item, call .I ewcopy followed by .IR "ewreplace(ew, ``'')" .) .IP ewpaste Call this function for the .B Paste menu item. It retrieves the contents of the clipboard, if non-null, and pastes it into the window through a call to .I ewreplace. It beeps (and does not change the window's contents) if the clipboard is empty. .IP ewfind Returns a pointer to the EDITWIN struct containing the given WINDOW pointer; returns nil if none exists. .IP ewcount Returns the number of open edit windows. .SH EXAMPLE The following program is a trivial but almost usable single-file text editor. Usage is ``program [file]''. .nf .ft C #include "stdwin.h" #include "editwin.h" main(argc, argv) int argc; char **argv; { EDITWIN *ew; winitnew(&argc, &argv); if (argc <= 1) ewnew(); else ewcreate(argv[1]); for (;;) { EVENT e; int closed; wgetevent(&e); if (ewevent(ew, &e, &b) && closed) break; } wdone(); exit(0); } .ft 1 .fi .SH HINTS The members of the EDITWIN data structure are explicitly intended to be accessible to the caller. Functionality which is not provided directly but which is available for plain windows or for textedit data structures can be implemented by applying it to the .I win or .I tp members. Note that the .I filename member, when non-nil, points to memory allocated with .IR malloc (3). .PP Changes to the window's contents should preferably be made with .I ewreplace, since it manages the `saved' flag. .PP To control the text attributes used in an EDITWIN window, you can set them globally before creating the window. .SH DIAGNOSTICS .I Ewcreate, ewnew and .I ewopen return nil when the user cancelled the operation or when they could not get all the necessary memory. The save, revert, close and read/write family of functions return FALSE if the operation was canceled by the user or if the file I/O failed. .I Ewevent returns TRUE when it has processed the event. .PP .I Ewcreate and .I ewopen warn the user if a file is larger than about 30K; the textedit package was not designed to operate on big files, and may be intolerably slow. .SH SEE ALSO STDWIN documentation .br textedit(3) .SH AUTHOR Guido van Rossum .SH BUGS .I Editwin inherits some bugs from the .I textedit package. .br The package doesn't detect the situation where the user opens the same file twice, edits both copies, and saves them, thus losing the changes to the copy saved first. .br If the height of the document gets over 32K scan lines, you are in trouble: most window systems limit coordinates to short integers. .br Missing functionality: a way to specify an alternate title for an untitled window; a way to create a non-file window, which isn't saved when closed. (These should be easy to add, given the simplicity of the source.) d as a subdirectory name where all the objects for this # port for a given architecture live: $(TOP)/Build/$(ARCH)/$(PORT) # PORT= XXX # Libraries to link with for the X11 port. # Most of this is boilerplate, only the PORTSYSLIBS part depends on # what your system requires. # PORTOWNLIBS= $(PORTBUILD)/lib/lib.a PORTSYSLIBS= -lXXX PORTLIBS= $(PORTOWNLIBS) $(PORTSYSLIBS) # NB: -lXXX is really OS- or site-specific as wellsmtalk43/stdwin/Doc/man/textedit.man1006440003270021170000001440605434024323014614 037777777777 1 0 .TH TEXTEDIT 3 .SH NAME Textedit \- text-editing package for STDWIN .SH SYNOPSIS .nf .ft C #include "stdwin.h" TEXTEDIT *tealloc(WINDOW *win, int left, int top, int width); TEXTEDIT *tecreate(WINDOW *win, int left, int top, int right, int bottom); void tefree(TEXTEDIT *tp); void tedestroy(TEXTEDIT *tp); void tedraw(TEXTEDIT *tp); void tedrawnew(TEXTEDIT *tp, int left, int top, int right, int bottom); void temove(TEXTEDIT *tp, int left, int top, int width); void temovenew(TEXTEDIT *tp, int left, int top, int right, int bottom); void tesetfocus(TEXTEDIT *tp, int foc1, int foc2); void tereplace(TEXTEDIT *tp, char *str); void tesetbuf(TEXTEDIT *tp, char *buf, int buflen); void tearrow(TEXTEDIT *tp, int code); void tebackspace(TEXTEDIT *tp); bool teclicknew(TEXTEDIT *tp, int h, int v, bool extend); bool tedoubleclick(TEXTEDIT *tp, int h, int v); bool teevent(TEXTEDIT *tp, EVENT *ep); #define teclick(tp, h, v) teclicknew(tp, h, v, FALSE) #define teclickextend(tp, h, v) teclicknew(tp, h, v, TRUE) char *tegettext(TEXTEDIT *tp); int tegetlen(TEXTEDIT *tp); int tegetnlines(TEXTEDIT *tp); int tegetfoc1(TEXTEDIT *tp); int tegetfoc2(TEXTEDIT *tp); int tegetleft(TEXTEDIT *tp); int tegettop(TEXTEDIT *tp); int tegetright(TEXTEDIT *tp); int tegetbottom(TEXTEDIT *tp); int wdrawpar(int h, int v, char *text, int width); int wparheight(char *text, int width); .ft 1 .fi .SH DESCRIPTION .I Textedit is the standard text-editing package for STDWIN. It allows you to designate any part of a window as a ``text-editing'' area, in which the user can see or edit arbitrary text. Until I find the time and the mental rest to write a decent manual, you'll have to do with the example and hints on this man page. .PP A textedit area need not occupy an entire window, and there can be more than one textedit area in a given window. Consequently, textedit areas are not resized automatically when their window is resized, and the document size is not set automatically when the textedit area's size changes. If you want to use a single textedit area in a window, and want them to be coupled more tightly, use the .I editwin package instead. .PP The functions .I wdrawpar and .I wparheight draw a paragraph of text exactly like the .I textedit routines would draw it, without the need to allocate a textedit data structure for it. .I Wdrawpar returns the ``v'' coordinate of the bottom of the paragraph drawn, and .I wparheight returns its height. .PP Available routines are: .IP tealloc .IP tecreate .IP tefree .IP tedestroy .IP tedraw .IP tedrawnew .IP temove .IP temovenew .IP tesetfocus .IP tereplace .IP tesetbuf .IP tearrow .IP tebackspace .IP teclicknew .IP tedoubleclick .IP teevent .IP teclick .IP teclickextend .IP tegettext .IP tegetlen .IP tegetnlines .IP tegetfoc1 .IP tegetfoc2 .IP tegetleft .IP tegettop .IP tegetright .IP tegetbottom .IP wdrawpar .IP wparheight .SH EXAMPLE .nf .ft C #include "stdwin.h" WINDOW *win; TEXTEDIT *tp; void drawproc(win, left, top, right, bottom) WINDOW *win; { tedrawnew(tp,left, top, right, bottom); } main() { winit(); win= wopen("Hello world", &drawproc); tp= tecreate(win, 20, 20, 200, 200); tereplace(tp, "Guido is gek"); for (;;) { EVENT e; wgetevent(&e); if (teevent(tp, &e)) continue; /* Event has been handled */ if (e.type == WE_COMMAND && e.u.command == WC_CLOSE) break; } wdone(); exit(0); } .ft 1 .fi .SH HINTS .I Tedestroy calls .I wchange for the area occupied by the textedit area, and then calls .IR tefree ; .I tefree gets rid of the data structures allocated for it. .PP .I Tesetbuf ``gives the buffer away.'' That is, you should have allocated the buffer using .IR malloc (3), but you shouldn't call .I free to get rid of it \- a pointer to the buffer is incorporated in the textedit data structures, and it will be freed later by .I tefree. Don't pass a buffer that wasn't allocated through .IR malloc (3)! .PP .I Tegettext returns a pointer to the internal buffer used to represent the text. Subsequent calls to textedit routines that modify the buffer may invalidate this pointer. You shouldn't modify the text found there. To get the text selected in the focus, copy the substring found between positions .I tegetfoc1 and .I tegetfoc2, for example: .nf .ft C /* Copy focus text into buffer, whose size is len */ getfocus(tp, buf, len) TEXTEDIT *tp; char *buf; { int f1= tegetfoc1(tp), f2= tegetfoc2(tp); char *text= tegettext(tp); if (f2-f1 < len) len= f2-f1+1; strncpy(buf, len-1, text+f1); buf[len-1]= '\0'; } .ft 1 .fi .SH DIAGNOSTICS .I Tealloc and .I tecreate return NULL when they could not get all the necessary memory. The other routines may fail but there is no way to find out. .SH SEE ALSO STDWIN documentation .br editwin(3) .SH AUTHOR Guido van Rossum .SH BUGS Textedit areas always grow and shrunk automaticatically at the bottom. Therefore, .I tecreate ignores the bottom coordinate. .br When a textedit area shrinks more than a line at a time, garbage may remain on the screen between the old and the new bottom position. .br The text attributes (font, size and style) in effect when any of the textedit routines are called must be those that were in effect when the textedit area was created. (The routines should save and restore the text attributes, but currently they don't.) .br The constants TRUE and FALSE used in the #include file are not defined there, even though the typedef bool is. .br Beware that the last argument to .I tealloc and .I temove is the width of the textedit area on the screen, not its right coordinate! .br It is a pain that there are ``new'' and ``old'' versions of routines like tealloc, tedraw, temove and teclick. The old routines should not be used any more, and the new ones should be renamed to the old names. .br .I Wdrawpar and .I wparheight are easy to use but not particularly efficient; they allocate a textedit data structure, call internal textedit routines to do the work, and then deallocate the data structure again. .br Missing functionality: a way to affect the line breaking algorithm; a way to display text centered or with justified margins; a way to disable changes while still passing events (for selection, etc.); more keyboard editing functions (begin/end of line/file, etc.); a way to suppress the automatic growing of the textedit area; a way to specify a margin around the textedit area where mouse clicks are still accepted by .I teevent. 0 1 0 smtalk43/stdwin/Doc/man/vt.man1006440003270021170000001636005434024323013414 037777777777 1 0 .TH VT 3 .SH NAME VT \- virtual terminal package for STDWIN .SH SYNOPSIS .nf .ft C #include "stdwin.h" #include "vt.h" VT *vtopen(char *title, int rows, int cols, int saverows); void vtclose(VT *vt); void vtansiputs(VT *vt, char *text, int len); void vtsetcursor(VT *vt, int row, int col); void vtreset(VT *vt); bool vtresize(VT *vt, int rows, int cols, int saverows); bool vtautosize(VT *vt); VT *vtfind(WINDOW *win); void vtsend(VT *vt, char *text, int buf); .ft 1 /* The following functions are actually macros */ .ft C WINDOW *vtwindow(VT *vt); int vtcwidth(VT *vt); int vtcheight(VT *vt); void vtsetnlcr(VT *vt, bool nlcr); void vtsetlazy(VT *vt, bool lazy); .ft 1 .fi .SH DESCRIPTION .I VT is a package which emulates one or more virtual terminals in STDWIN windows. A VT structure contains a WINDOW pointer and data structures to save the screen contents, cursor position, etc. Such a virtual terminal may be used to implement a terminal emulation program on a micro-computer (which was the original goal of this programming exercise), or as a tool to simplify interfacing a program using printf-style output to STDWIN. The virtual terminal's cursor position is indicated by STDWIN's standard text caret, appearing to the left of the character at the cursor position. This actually feels very natural in most cases. .PP The functions you might want to know about are: .IP vtopen Creates the window and returns a pointer to a VT struct. .I Rows and .I cols specify the size of the virtual terminal; .I saverows specifies the number of rows saved after they have scrolled off the top of the terminal. If something went wrong, a nil pointer is returned. .IP vtclose Closes the window and deallocates the data contained in the VT struct. .IP vtansiputs Sends an output string to the virtual terminal. .I Len specifies the length of the string; if it is negative, the string is terminated by a null character. Control character and escape sequence processing is done in the style of ANSI terminals, with some limitations and extensions. Warning: unless .I "vtsetnlcr(vt, 1)" has been called, both a CR and LF character must be sent to properly start a new line. .IP vtsetcursor Moves the terminal's cursor to the indicated position. The top left corner of the virtual terminal is position (0, 0). .IP vtreset Completely resets the virtual terminal to its initial state. The cursor is moved to position (0, 0). The .I lazy and .I nlcr flags are not changed. .IP vtresize Changes the dimensions of the virtual terminal to explicitly given numbers. In case of memory shortage, this function may fail irrecoverably, leaving the VT struct in an unusable state (except to .IR vtclose ). .IP vtautosize Changes the dimensions of the virtual terminal to conform to the new window size. If possible, the sum of rows and saverows is kept constant. The same limitations as for .I vtresize apply. .IP vtfind Given a window pointer, returns a pointer to the VT struct containing that window. Returns a nil pointer if no such VT struct exists. .IP vtsend This function is defined in the library, but you might want to write your own version. It is called by the library for cases where the virtual terminal must send a reply back to the computer system. (This happens in response to certain ANSI escape sequences, in particular ESC-[-6-n or ESC-[-c.) You may want to ignore this output, or actually send it down a serial line if you are implementing a terminal emulator program for a micro-computer. The library's default version calls .I vtansiputs with the same parameters as passed to .I vtsend. .IP vtwindow Returns a pointer to the window contained in the VT struct. .IP vtcwidth Returns the width of characters drawn in the VT's window. .IP vtcheight Returns the height of characters drawn in the VT's window. .IP vtsetnlcr Turns the .I nlcr option on or off. When on, every LF character received is translated into a CR plus LF. This is useful if you want to perform C style output to a VT window, where lines are terminated by a single LF. Initially this option is off. .IP vtsetlazy Turns the .I lazy option on or off. When on, actual output to the terminal is delayed until the window's draw procedure is called; when off, all output is drawn immediately. Initially this option is off. .SH ANSI ESCAPE SEQUENCES The termcap entries for xterm, vt100, vt100em and versaterm would all work with the emulated terminal (if you could somehow translate the output intended for a Unix terminal into calls to .IR vtansiputs ). Unrecognized escape sequences and control characters are ignored. .PP *** List all implemented escape sequences here. *** .SH EXAMPLE .nf .ft C #include "stdwin.h" #include "vt.h" main() { VT *vt; winit(); wsetdefwinsize(80*wcharwidth('0'), 24*wlineheight()); vt= vtopen("VT", 24, 80, 100); /* Should check outcome */ vtautosize(vt); vtsetnlcr(vt, 1); /* Map LF to CR LF */ vtansiputs(vt, "Hello, world\en", -1); eventloop(); wdone(); exit(0); } eventloop(vt) VT *vt; { for (;;) { EVENT e; wgetevent(&e); switch (e.type) { case WE_SIZE: vtautosize(vt); /* Should check outcome */ break; case WE_CHAR: { char buf[2]; buf[0]= e.u.character; vtansiputs(vt, buf, 1); break; } case WE_MOUSE_DOWN: vtsetcursor(vt, e.u.where.v / vtcheight(vt), e.u.where.h / vtcwidth(vt)); break; case WE_COMMAND: switch (e.u.command) { case WC_CLOSE: return; case WC_RETURN: vtansiputs(vt, "\en", 1); break; case WC_BACKSPACE: vtansiputs(vt, "\eb", 1); break; case WC_TAB: vtansiputs(vt, "\et", 1); break; } break; } } } .ft 1 .fi .SH DIAGNOSTICS .I Vtopen returns a nil pointer if it can't allocate all the required memory or if the call to .I wopen it makes fails. .br .I Vtresize and .I vtautosize return false (zero) if they can't allocate the extra memory required; in this case the VT struct has been damaged beyond repair. .SH SEE ALSO STDWIN documentation .SH AUTHOR Guido van Rossum .SH BUGS In some versions of STDWIN, the scroll bars won't appear and some other functionality won't be available unless the program calls .I wgetevent. .br Unless the application calls .I vtautosize at all the right moments, it is quite possible that the window size doesn't match the size of the virtual terminal. When the window is too small, STDWIN's automatic scrolling will cause the text to jump around; when it is too large, portions of the scrolled-away text will remain visible but unreachable by the cursor. .br The ANSI terminal implementation is incomplete. It certainly isn't a full-fledged VT100. .br The behaviour of the cursor at the right margin is slightly unconventional. .br Bold output only works on the Macintosh, and requires that a font called ``Bold'' (9 points) be available in the system file. This font can be found in the resources for (some versions of) VersaTerm(TM). .br The package makes the assumption that all characters have the same width. .br The order of parameters indicating rows and columns is internally consistent, but reversed with respect to order used for h and v coordinates in the rest of STDWIN. .br The origin of cursor coordinates passed to .I vtsetcursor is (0, 0), even though the origin used by ANSI escape sequences is (1, 1). .br The header file defines functions that aren't really part of the public interface. g vertical bar which can be used to indicate the text insertion point, so the application needn't use TIMER events to do the blinking. STDWIN provides Macintosh-style menus. Each window has its own set of menus, although by default all menus apply to all windows. A reasmtalk43/stdwin/Doc/man/x11stdwin.man1006440003270021170000002017505434024323014624 037777777777 1 0 .TH X11-STDWIN 1 .SH NAME X11-STDWIN \- a Standard Window System Interface, X11 version .SH SYNOPSIS .I application [ .B \-display .I display-name ] [ .B \-name .I program-name ] [ .B \-geometry .I geometry-spec ] [ .B \-font .I font-name ] [ .B \-menufont .I font-name ] [ .B \-iconic ] [ .B \-icongeometry .I geometry-spec ] [ .B \-foreground .I color-spec ] [ .B \-background .I color-spec ] [ .B \-menuforeground .I color-spec ] [ .B \-menubackground .I color-spec ] [ .B \-reverse ] [ .B \-xrm .I string ] [ .B \-debuglevel .I number ] [ .B \-synchronous ] [ .I option ] ... .SH DESCRIPTION .I STDWIN is a standard interface available for several window systems. This man page describes the common aspects of applications written using STDWIN when run under MIT's X Window System, Version 11. .SH COMMAND LINE OPTIONS Most applications (to be precise, those that use the .I winitnew call to initialize STDWIN) will accept all options shown in the synopsis. For most options there can also be a corresponding .I resource (option string stored in the X server or in ~/.Xdefaults). Command line options override resources; resources override defaults built in the application; application defaults override library defaults. Unless otherwise stated, the resources have the same name as the command line options (all in lower case), prefixed with ``.stdwin''. For example, the full name of the resource corresponding to the ``\-font'' option is named .IR program .stdwin.font. Since most options have a standard meaning for most X applications, they are not explained in great length here. Options with a specific meaning for STDWIN are: .TP .BI \-font " font-name" Specifies the font to be used by default in text drawn by the application. Both proportional and fixed-width fonts are acceptable (except that some old applications look nicer with a fixed-width font). The library default is to use the X server's default (usually 8x13). .TP .BI \-menufont " font-name" Specifies the font to be used in menus and dialog boxes. The library default is to use the same font as for normal text. .TP .BI \-foreground " color-spec, " \-background " color-spec" Specify the colors to be used in the application's part of the window. The defaults are black and white. .TP .BI \-menuforeground " color-spec, " \-menubackground " color-spec" Specify the colors to be used in the menu bar, the scroll bars, dialog boxes and for the window border (the foreground color). By default the same values are used as for .B \-foreground and .BR \-background . .TP .B \-reverse Reverses the uses of foreground and background colors. .TP .BI \-debuglevel " number" Specifies the amount of debugging output you want; the higher the number, the more output you have to wade through. The library default is wisely 0. .TP .B \-synchronous Specifies that you want the connection with the X server to be maintained in synchronous mode (each request immediately sent and a reply waited for). This is sometimes useful while debugging. Note that synchronous mode can tremendously reduce drawing efficiency. Synchronous mode is not set automatically when the debugging level is nonzero, since some bugs go away when it is turned on! This option has no corresponding resource. .SH SCROLL BARS All STDWIN applications have two scroll bars (which may be inactive), one to the left of the window and one at the bottom. Operation and interpretation of the scroll bars is intended to be identical to the scroll bars of applications using the X toolkit (e.g., xterm). Summarizing: the left button click scrolls forward, the amount varying with the position of the click in the bar (for the vertical bar, remember ``line to top''); the right button similarly scrolls back (``top to line''); the middle button moves the beginning of the position indicator (the gray block) to the position where the button is pressed. .SH MENUS All STDWIN applications display one or more menu titles in a ``menu bar'' at the top of the window. Pressing and holding a mouse button in a menu title ``pulls down'' a menu containing text items. Sliding the mouse cursor over the text items inverts (highlights) the item over which the cursor is currently; releasing the mouse button when an item is highlighted causes the corresponding command th be executed by the application. Releasing the mouse button outside the menu selects no item. Sliding the mouse horizontally over the menu titles pulls down the other menus; at most one menu will be visible at any time. .PP One menu, labeled .BR X , is present in all windows. Its only item, named .BR Close , is the standard way to close the window; for single-window applications, selecting this also quits the application. The application is free to refuse closing its window, or to ask confirmation first, or to do whatever when this item is selected; it is merely a hint that you would like the window to go away, not a request. .PP Menu items may be marked (``checked'') with a `*' in the left margin; this an indicator that the function selected by the menu item is currently ``active''. The check mark can be set and cleared by the application for each menu item; the use should be apparent from the application's documentation. Menu items may be inactive (``disabled''); such items cannot be selected and will not be highlighted. Disabled items are currently indicated by a `\-' in the left margin. .PP Menu items may be selectable via a keyboard shortcut. The existence of a keyboard shortcut is shown in the menu item by the presence of the string .RI ``M- c '' in the right margin, where .I c can be any character. The M stands for ``Meta''. Holding a ``Meta'' key (possibly labeled Alt, Command, Compose, Left or some such name on your keyboard, but definitely not Control or Shift) while typing a character, usually a letter, will be equivalent to selecting the corresponding menu item with the mouse. Shortcuts are defined by the application. Some shortcuts are conventional in many applications: M-Q for Quit, M-S for Save, M-O for Open. Also M-Z for Undo, M-X for Cut, M-C for Copy and M-V for Paste (reminiscent of the Macintosh commands). Upper and lower case characters are equivalent, unless the application uses the same letter in lower and upper case as shortcuts for different menu items. .\"SH DIALOG BOXES .\"SH TEXT EDITING .\" selecting, button-2 selecting, double-click, cut/paste, delete, arrows. .SH EXAMPLE Here are some lines you could put in your resource input file: *stdwin*font:courier12f .br dpv*geometry:700x850 .br klok*geometry:-1+1 This sets the font for all STDWIN applications, the initial size for .I dpv and the initial position for .I klok. Note the use of `*' for separators; extra levels of names may be inserted in the future. .SH DIAGNOSTICS .I STDWIN can issue complaints about various error conditions, e.g., font not found; these are intended to be self-explanatory. Some messages indicate STDWIN has found an inconsistency in itself or in the X server. These should be reported to the author if the cause isn't obvious. .\"SH FILES .SH SEE ALSO The X documentation (especially the chapters on command line arguments and resources). .br STDWIN \- A Standard Window System Interface, by Guido van Rossum (CWI Report number CS-R8817, April 1988). .SH AUTHOR Guido van Rossum .SH BUGS I could be sued by Apple for stealing the ``look and feel'' of some aspects of the Macintosh. :-) .br The .B \-reverse option doesn't affect the use of colors in dialog boxes. .br Like so many other window systems, X11 limits the size of windows to 64Kx64K. .br Since a STDWIN document is represented as an X11 window (scrolled inside another X11 window), applications that create really big windows (~32K pixels wide or high) may crash due to a server bug. .br When an application does no window output for some time after a menu item has been selected, the menu stays visible in its pulled-down state. .br The conventional shortcuts for Undo, Cut and Paste aren't very mnemonic. (But Apple never thought that was a problem.) .br The standard X-STDWIN command line options are best given before all application-specific options. .br If you are running an application in the background and have .I "stty tostop" turned on, warnings or errors from STDWIN may cause the program to block. ual; "paper.ms" comes closest to a full description. ABOUT the old STDWIN blurb that I used to mail out paper.ms the original STDWIN report seldoc.ms describes using X11 Selections and Cut Buffers in STDWIN macros.ms macrose used by seldoc.ms vtrmdoc.ms describes the VTRM package used by ../Ports/alfa man/ manpages for dpv, packages and X11 stdwin --Guido /textedit VT= $(TOP)/Pacsmtalk43/stdwin/Doc/paper.ms1006440003270021170000014357405434024324013174 037777777777 1 0 .\" Typeset using refer -e -n | (di)troff -ms. .\" You may have to change the CW (Constant Width) macro define below .\" if you aren't typesetting on a PostScript printer. .\" Your best bet is to change ".ft C" by ".ft I" and "\fC" by "\fI". .\" Each occurs exactly once in the macro definition. .de CW .if t .if "\\$1"" .ft C .if t .if !"\\$1"" \fC\\$1\fP\\$2 .if n .B "\\$1" "\\$2" .. .TL .nr PD 0 .nr PI 2n .ft H .ps 14 STDWIN \- A Standard Window System Interface .ps .ft .AU .ft H Guido van Rossum .ft .AI .ft HO .ps 8 .vs 10 Center for Mathematics and Computer Science P.O. Box 4079, 1009 AB Amsterdam, The Netherlands E-mail: guido@cwi.nl or mcvax!guido .vs .ps .ft .AB .LP STDWIN is an interface layer placed between an application written in C and arbitrary window system, making the use of windows both easier and more portable. For applications using STDWIN for their window management requirements, adaptation to a different window system is as easy as linking with an appropriate version of the STDWIN library. So far, STDWIN libraries are available for the Apple Macintosh, for the Whitechapel MG-1 (running Oriel), for MIT's X Window System version 11, for the Atari ST, and (subsets) for alphanumeric terminals on .UX and MS-DOS. .FS .ft H .sp Report CS-R8817 .br Centre for Mathematics and Computer Science .br P.O. Box 4079, 1009 AB Amsterdam, The Netherlands .ft .FE New implementations are easily written. .PP Like STDIO, C's Standard I/O library, STDWIN's aim is to give a simple interface, high-level functionality, and portability. It does not attempt to allow access to all possible features of window management systems; rather, it provides the programmer with a model which allows easy construction of that part of the program which is concerned with window management. .PP STDWIN's high-level operations include automatic window positioning and resizing, scrolling, menus, keyboard shortcuts, and multiple-click detection. .sp .ps 8 .vs 10 .ft HO 1980 Mathematics Subject Classification: .ft .ft H 68B20. .ft .br .ft HO 1982 CR Categories: .ft .ft H D.2.2, I.3.4, I.3.6. .ft .br .ft HO Key Words & Phrases: .ft .ft H window systems, user interfaces, portability. .ft .br .ft HO Note: .ft .ft H This paper has been submitted for publication elsewhere. .ft .vs .ps .AE .LP .NH Introduction .LP First, some history. STDWIN's conception was motivated by the desire to add a more modern user interface (i.e., one using windows and a mouse) to the programming environment for the language ABC, developed here at CWI. .[ %A Leo Geurts, Lambert Meertens, Steven Pemberton %T The ABC Programmer's Handbook %I CWI %C Amsterdam %D to be published in 1988 .] The ABC programming environment, consisting of a syntax-directed editor, an interpreter and a source file manager, is a large body of C code which, through careful isolation of system-dependent modules, has proven to be quite portable, both to different versions of .UX and to non-\c .UX systems such as MS-DOS and the Apple Macintosh. Naturally, we did not want to lose its portability by tying it closely to one particular window system. .PP Only after having looked closely at a few existing window systems, we became fully aware of the problems. Most window systems offer a large range of facilities, apparently intended to enable programmers to create beautiful user interfaces, but often resulting in total chaos. .[ %A Mike O'Dell %B EUUG Conference Proceedings, September 1987, Dublin, Ireland %T What They Don't Tell You About Window Systems .] One of the problems appears to be the low level of most window system interfaces. For example, on the Apple Macintosh, all tools are provided to work with scroll bars (bit-scrolling operations, routines to draw scroll bars, routines to detect user interaction with a scroll bar), but the amount of code needed to glue these together and create a scrollable view on a document is horrendous. .[ %T Inside Macintosh %A Apple Computer %I Addison-Wesley %C Reading, Mass. %D 1985 .] Similarly, again on the Macintosh, double-clicking the mouse button is a frequent form of user input, but there is no library routine available to detects double-clicks, leading to much code duplication and gratuitous differences between programs.* .FS * In all fairness it should be said that the Macintosh is still miles ahead of most of its competitors, simply because there are at least standards for many aspects of the interaction between application and user, such as the placement of scroll bars, the use of double clicks or the shape of the mouse cursor. .FE .PP With these considerations in mind, we set out to design a `generic' window system interface. .sp .IP \(bu The interface should be general enough to suit the needs of many different programs. Thus, it should be reasonably rich in functionality, e.g., provide both textual and graphical output, handle keyboard, mouse and menu-based input, support multiple windows, etc. .IP \(bu It should be simple to use. Including one header file and calling a small number of routines (with not too many parameters!) should suffice for the creation of a full-function window and the definition of its contents. As much as possible, the programmer should only be bothered with issues that matter from the program's point of view. In other words, the interface should be `high level'. .IP \(bu And most of all, it should be realistically portable; each potential feature should be weighed in the light of its implementability using different systems, including several popular micros. .sp .LP The requirement of portability is necessarily both good and bad. It is bad because it can sometimes make an elegant solution unfeasible, imposing seemingly random restrictions. But it is good because it makes the design stick to reality, and limits it to the `essence' of window systems, rather than allowing the designers to invent yet another incompatible paradigm. And sometimes the `helicopter view' gained from looking at solutions chosen by vastly different window systems for a particular problem has shown the way to an entirely new view, simplifying it by generalization. .sp .LP A large part of the paper is devoted to a detailed description of STDWIN's functionality from a programmer's point of view. First the `core' of the package is described, explaining the basic output and input facilities; then some extra facilities are briefly discussed. Interspersed are comments on the rationale for particular solutions, some hints on the implementation, and warnings about non-portable uses. At the end the paper returns to the more philosophical issues: experiences, future developments, food for thought. .NH Description .LP .NH 2 Header file .LP Applications wishing to use STDWIN must place a line saying .CW "#include " near the top of their source file(s). All user-visible external names defined in this header file start with .CW w or .CW W . external names used internally by implementations begin with .CW _w or .CW _W . .NH 2 Initialization and clean-up .LP Before starting to use STDWIN, the initialization routine .CW "winit()" must be called. Before exiting, the application should call .CW "wdone()" to perform any necessary clean-up operations. .PP These calls can't be repeated; after .CW "wdone()" has been called the application cannot call .CW "winit()" again and `return to life'. .NH 2 Creating and destroying windows .LP A new window is created by calling .CW "wopen(title, drawproc)" . .I Title is a string identifying the window to the user; it is usually displayed by STDWIN in the window's border, e.g., in a title bar. .I Drawproc is the address of the window's draw procedure (see next section), or NULL if the window is not to have a draw procedure. STDWIN windows look like windows in the usual style of the underlying window system, usually with a title bar, scroll bars etc. Position, size and other characteristics of the new window are determined by STDWIN (but see below). .PP .CW "Wopen" returns a .I "window pointer" , of type .CW "WINDOW *" , to be used to identify the window in subsequent operations. If creation of the window failed, a NULL pointer is returned. .PP STDWIN allows an application to have multiple windows open simultaneously. Implementations usually impose a limit on the number of open windows; when this limit is reached, .CW "wopen" returns NULL, and the application should try to close other windows (or prompt the end user to close them). .PP A window is deleted permanently by calling .CW "wclose(win)" . Windows can be deleted only by the application. The end user can send a request to the application to close a window, but the application may ignore the request or postpone its execution. .PP There is no explicit way to iconize a window (i.e., to temporarily close it, leaving an icon in its place). On systems where window iconization is built into the window system, STDWIN may support it silently; all the application notices is that no input is received for iconized windows. .NH 3 Changing defaults .LP When a window is opened STDWIN determines a default size and position for it. Usually this is convenient for the application (which needn't have its own algorithm for placing multiple windows, for example), but sometimes finer control is desirable. Therefore, a number of default-setting routines are provided: .LP .CW "wsetdefwinsize(width, height)" .IP Changes the default window size. This sets the net size, excluding borders, scroll bars etc. .LP .CW "wsetdefwinpos(h, v)" .IP Changes the default window position. This default is usually not a constant but a dynamically computed value. The next opened window will be placed at .I "(h, v)" ; the position of windows opened after that may be a more complicated function of .I h and .I v . .LP These routines may be called at any time; they affect only windows opened after their call. A negative or zero parameter restores the default for that dimension. Other values are clipped or rounded to reasonable and implementable values; these routines are best seen as giving hints to STDWIN, which may be ignored by some implementations. .NH 2 The output model .LP A STDWIN window is a view on a possibly much larger area, a rectangle referred to as its .I document , in which the application draws its output. The document's size is chosen by the application, and can be changed at any time by calling .CW "wsetdocsize(win, width, height)" . It is not limited by window or screen size, nor indeed by available memory; the entire document's contents are not stored directly. The end user has the freedom to `pan' the window over the document's surface, using scroll bars or a similar mechanism. When a particular part of the document is to be visible in the window, STDWIN asks the application to repaint that area. It is not forbidden to draw outside the document, but the end user normally can't pan outside the document (unless the window is larger than the document). .PP There are two mechanisms for repainting: a low-level mechanism using DRAW events, and a higher-level mechanism using a .I "draw procedure" . .PP DRAW events are merged with the general event stream (see below); when no other events are in the event queue, STDWIN looks to see if there is any window needing a repaint, and if so, it passes a DRAW event for that window to the application. A DRAW event includes as additional information the rectangle that is to be repainted. The application should react by erasing and repainting that rectangle (or a larger part of the document). .PP Normally, however, windows have an associated .I "draw procedure" . This is a procedure (defined by the application) which knows how to draw the entire document, or any sub-rectangle of it. When STDWIN is about to generate a DRAW event for a window with a draw procedure, it prepares the window for drawing, erases the rectangle that needs repainting, and calls the draw procedure with the window and the rectangle as parameters. The advantage of this mechanism over DRAW events is the possibility for certain STDWIN implementations to clip the output to a smaller, non-rectangular area that really needs a repaint; also somewhat simpler event decoding logic for the application. .PP Usually, the end user controls which part of the document is visible in the window (by manipulating the scroll bars). However, there are times when an application wants to display a particular part of the document, e.g. to show the effect of a search operation. It can then call .CW "wshow(win, )" to indicate that the given rectangle should be visible, if at all possible. STDWIN will check whether this is already the case, and if not, move the window with respect to the document to make it visible. There is also a lower-level call, .CW "wsetorigin(win, )" which makes the given point in the document the top left corner of the window. .PP When the application wants to change part of the document, it can directly paint the changes (after preparing for drawing in that particular window). However, it is often more appropriate to delay the actual painting until after other input has been processed. It is possible to tell STDWIN that a particular area of the document needs repainting by calling .CW "wchange(win, )" . At the appropriate time, a DRAW event for this rectangle (possibly merged with other areas that need repainting) will be generated, or the window's draw procedure will be called. .PP When the repaint area is non-rectangular (e.g., it is the union of several rectangles), the application is asked to repaint the smallest rectangle that encloses the repaint area. This may occasionally cause more repainting than absolutely necessary, resulting in extra delays; since the repainting is limited to the window size, however, the costs won't be excessive in most cases. The choice was made here for a simple interface to the draw procedure, avoiding dynamic data structures. For the needs of the highest-demanding applications, an enquiry routine returning the exact repaint area may have to be be added (or a function telling whether a particular rectangle intersects the repaint area). .NH 2 Drawing in a document .NH 3 The coordinate system .LP STDWIN provides a single coordinate system per window. Coordinates are integers, with the X axis pointing right and the Y axis pointing down. In order to avoid confusion with other conventions, the axes are never called X and Y axis but h and v axis. H coordinates are always listed first. The origin (0, 0) is the top left corner of the document. Unit size equals pixel size on the screen; thus, documents inherit the screen's aspect ratio. Pixels on different machines can vastly differ in size; e.g., on alphanumerical terminals, pixel size might well equal character cell size. Therefore, applications should scale their drawings accordingly. STDWIN provides enquiry functions to tell the physical size of a pixel. An alternative approach, suitable for applications that display mostly text, is to scale the drawing accordingly to the dimensions of characters drawn on the screen. Text measuring functions are available for this purpose (see below). .NH 3 Preparation for drawing .LP Since a picture is usually built out of a large number of calls to primitive drawing operations, it would be annoying to have to specify a window parameter on each call. STDWIN requires the application to say in which window it wants to draw before using any drawing primitives, by calling .CW "wbegin\%draw\%ing(win)" . After the drawing is done, the application should call .CW "wend\%draw\%ing(win)" , telling STDWIN to flush the output to the screen. .PP In a draw procedure these calls are unnecessary; there, all drawing operations apply to the given window, and output is flushed when the draw procedure returns. .NH 3 Graphical primitives .LP STDWIN currently provides a small set of graphical primitives. This set will be extended when the need arises. All primitives except .CW werase and .CW winvert draw in OR mode, i.e., they only add black pixels to the drawing and never erase pixels. Note that points are actually given as two integer parameters, h and v; rectangles are given as four integer parameters: left, top, right and bottom. Rectangles always refer to the area enclosed by infinitely thin boundary lines; e.g., the rectangle (0, 0, 1, 1) encloses a 1 by 1 square whose top left corner is the origin (0, 0). .PP Functions currently defined are: .LP .CW "wdrawline(, )" .IP Draws a line from point1 to point2. .LP .CW "wdrawbox()" .IP Draws a box (i.e., a rectangle) inside the given rectangle. .LP .CW "wdrawcircle(, radius)" .IP Draws a circle with the specified radius around the given point as center. .LP .CW "wpaint()" .IP Paints the area inside the given rectangle black. .LP .CW "werase()" .IP Erases the area inside the given rectangle. .LP .CW "winvert()" .IP Inverts the pixels in the given rectangle. .LP .CW "wshade(, percentage)" .IP Adds a shading pattern to the given rectangle, approximately making the given percentage of all pixels black. Thus, a percentage of 0 has no effect; a percentage of 50 sets every other pixel; a percentage of 100 is equivalent to .CW "wpaint(, character)" draws the given character with its top left corner at the given point. It returns the h coordinate of the right edge of the box in which the character is drawn; this is the `natural' h coordinate for a character to be drawn next to it. .PP The call .CW "wdrawtext(, string, length)" draws the characters of the given string starting with the top left corner at the given point. .I Length indicates the number of characters in the string; if negative, the string ends with a NUL character. .CW Wdrawtext returns the h coordinate of the right edge of the box in which the last character is drawn. Note that no special interpretation is given to characters like .CW \&'\en' or .CW \&'\et' ; they may be displayed as spaces or funny graphics. .NH 3 Text measuring primitives .LP The dimensions of characters drawn by the above functions depend on the font used. Future versions may implement font and size changes under application control; currently these are fixed by the implementation. For applications that want to know in advance how big the strings they are drawing will be, there are functions to measure text dimensions. Unlike the drawing primitives, the text measuring primitives and the style-changing primitives described in the next section can be called anywhere. .PP The following text-measuring functions are defined: .LP .CW "wlineheight()" .IP Gives the vertical height of the boxes in which characters are drawn. This is the same for all characters, and the value delivered gives a `natural-looking' line spacing when lines are drawn at v coordinates with increments of this value. .LP .CW "wcharwidth(character)" .IP Computes the width of the box in which the given character will be drawn. .LP .CW "wtextwidth(string, length)" .IP Computes the width of the box in which the string will be drawn. .I Length indicates the number of characters in the string; if negative, the string ends with a NUL character. .LP .CW "wtextbreak(string, length, width)" .IP Computes the number of characters from the string that will fit in a box of the given width (in pixels). .I Length is interpreted as above. .NH 3 Text style .LP Future versions of STDWIN will have to worry about mixing fonts, type sizes and text styles. Currently applications have no control over the font and size used, and can only control one aspect of text style; different window systems differ so much in their support of font names, font scaling, style combinations and so on, that it seemed wise to avoid these issues in the first version (however, some implementations have a way to influence the font, size or style used at initialization time). The only calls currently available are those to change between normal, black on white characters and inverse, white on black characters; this is needed to display the focus in the text-editing package (see below). .PP The call .CW "wsetinverse()" sets the text style to inverse characters; the call .CW "wsetplain()" reverts the text style back to normal. The text style is a global attribute, so draw procedures that change it should reset it to normal before leaving. .NH 3 Scrolling .LP Applications like text editors often have a need for deleting a horizontal or vertical slice from their document; e.g., after a text editor has deleted a couple of lines, the remaining lines must be moved up in the document. Although it is theoretically possible to do this by calling .CW "wchange" for the remaining part of the document (assuming the draw procedure knows that the v coordinates of the affected lines have changed), this often involves a lot of drawing which could have been avoided by applying a `bit copy' operation as available in many systems, combined with only a little bit of redrawing (e.g., for lines `scrolled in' from below the window border). .PP The call .CW "wscroll(win, , dh, dv)" is provided to help in situation. It should be called outside the drawing procedure, where the call to .CW wchange would otherwise be placed. If the particular STDWIN implementation supports the requested type of bit scroll operation, it will scroll the bits inside the given rectangle by an amount of .I dh to the right and by .I dv downward. (Negative values mean scrolling to the left or upward, respectively.) No bits outside the given rectangle are affected or used: bits `scrolled out' of the rectangle will simply be thrown away; for the area that is to be `scrolled in' from outside the rectangle, .CW wchange is called internally. If the particular form of bit scrolling required isn't supported, the entire call is equivalent to .CW "wchange(win, )" , relying on the normal repaint mechanism to update the window. .NH 2 The input model .LP Interactive input is presented to the application in the form of .I events . Examples of events are `a character has been typed' or `the mouse button has been pressed'. Some other information generated asynchronously by STDWIN is also passed in the form of events. .PP Events are queued internally; the routine .CW "wgetevent" gets the next event from the queue and passes it to the application. If the queue is empty, it waits until an event arrives first. (Certain events, like DRAW events, are not really queued but constructed on the fly when the queue is empty.) .PP Some applications don't want to wait when no event is ready, but do want to process events that are already queued. For such cases there is the alternative routine .CW "wpollevent" which acts like .CW "wgetevent" when an event is available from the queue, but returns immediately with a dummy NULL event when the queue is empty. .PP An event always applies to a particular window. This means that an application which has no window open is blind and deaf. When an application calls .CW "wgetevent" in this state, it is terminated. Therefore, applications should make sure to always open a window before calling .CW wgetevent . .PP STDWIN implementations may limit the size of the event queue; when the queue is filled up events may get lost without notification. (There is no way to prevent this, since the problem usually occurs in the underlying operating system.) .NH 2 Events .LP Events are typically read in a `main event loop', which might look something like this: .DS .CW int stop= 0; while (!stop) { EVENT e; wgetevent(&e); switch (e.type) { ... } } .R .DE The variable .CW e is called the .I "event record" . The information placed in the event record depends on the event type. For all event types, the type is available as .CW "e.type" , and the window to which the event applies as .CW "e.window" ; additional information is listed with the individual event descriptions. This additional information is stored in a union named .CW e.u , e.g., .CW e.u.character for character input events. .PP For clarity, events are always referred to by their `informal' names in this paper, e.g., MOUSE DOWN. The actual constants defined by STDWIN are derived from the informal name by prepending .CW WE_ and replacing spaces by underscores, yielding, e.g., .CW WE_MOUSE_DOWN . .PP Events can be classified as mouse events, other user input events and STDWIN-generated events. .NH 3 Mouse events .LP Mouse events are generated when the user presses a mouse button inside the visible part of a document displayed in a window. There are separate event types for a press of a button, moves while a button is held down, and a release of a button. The position of the mouse cursor at the time the event was generated is reported in (\c .CW e.u.where.h , .CW e.u.where.v ). The button number (1, 2 or 3 on a three-button mouse; always 1 on a one-button mouse) is reported in .CW e.u.where.button . .PP Mouse events allows easy detection of .I "multiple clicks" , to which many applications want to assign a special meaning. Successive presses on a mouse button are considered to be part of a click sequence if they are `close together' in space and time. When a mouse button is pressed, STDWIN checks whether it is close enough to the previous press to be considered a continuation of the same click sequence, and if so, notes the number of the current click in .CW e.u.where.click . A click that is unrelated to previous clicks has click number 1; a following related click has click number 2, the next one has number 3, and so on, until the mouse is moved too far away or the user waits too long, in which case the click number is reset to 1 at the next mouse event. This way of reporting multiple clicks requires no delay to see whether a click is part of a multiple-click sequence; mouse events are reported as soon as they happen. .PP Not all STDWIN implementations run on machines whose mouse has more than one button; it is therefore unwise to write an application which can perform certain operations only through buttons 2 or 3. If multiple buttons are held down simultaneously, only events for the button pressed first are generated. .PP The mouse event types are MOUSE DOWN for a button press, MOUSE MOVE for a move of the mouse cursor while a button is still depressed, and MOUSE UP for a button release. The click number for MOUSE MOVE events is always zero. In order to prevent filling up the event queue, multiple MOUSE MOVE events may be collapsed to a single event, giving only the last mouse position. When the user moves the mouse outside the window with a button held down, the mouse remains associated with the window, and its position is reported relative to the origin of the window's document. The click number for a MOUSE UP event is the same as that of the corresponding MOUSE DOWN event if the mouse wasn't moved too far from its original position, or zero if it was moved further (and in this case this event is the end of its click sequence). .NH 3 Other user input events .IP CHAR .br The user has typed a character at the keyboard. Its ASCII value is reported in .CW e.u.character . Note that some special keys (like RETURN, TAB, BACKSPACE) do not send CHAR events but COMMAND events. .IP COMMAND .br .RS This event is sent for special keys on the keyboard, and for certain special actions recognized by STDWIN. Some keys do not generate CHAR events but COMMAND events, because they do not send the same ASCII code on all keyboards (e.g., Enter), or because there are no standard ASCII codes for them (e.g., arrows and function keys). A code telling which special command was meant is reported in .CW e.u.command . Possible values represent the following keys and standard actions: CANCEL, TAB, RETURN, BACKSPACE, LEFT, RIGHT, UP, DOWN and CLOSE; this list may be extended in the future. The constants are actually called .CW WC_CANCEL etc. .PP CLOSE is to be interpreted as a request to close the window; the key or other action that generates it is system-dependent. The application should close the window, possibly after verifying that any changes the user has made to the file displayed in the window have been saved, in which case it may ignore the request, or put up a dialogue box asking what should be done to the file. .RE .IP MENU .br .RS A menu item was selected. The menu id and item number of the selected item are reported in .CW e.u.m.id and .CW e.u.m.item ; menu items are numbered starting at 0 (see below for the definition of menus). .PP The interaction technique used to select menu items is not defined by STDWIN; a suitable technique is chosen by each implementation, e.g. pop-up, push-down or permanently present menus. Keyboard shortcuts are usually also available. The application cannot distinguish between the various ways of selecting a particular menu item; all it sees is which item is selected. .RE .NH 3 STDWIN-generated events .IP NULL .br Nothing happened. This is a dummy event reported only by .CW "wpollevent" when the event queue is empty. .IP ACTIVATE .br A window has been `activated'. This is usually caused by the end user selecting an inactive window with the mouse. Only one window can be active at any time. This usually means that all subsequent keyboard input applies to the active window; some applications want to change the highlighting of selected objects in a document when its window is active. (Highlighting of the window's title, etc. is done automatically by STDWIN.) After a window is opened, the first event applying to it is usually an ACTIVATE event (because windows are opened in an unactivated state). Applications needn't monitor ACTIVATE events if all they want is determining to which window keyboard input applies; the relevant window is reported with each event in .CW e.window . .IP DEACTIVATE .br A window has been `deactivated'. This usually occurs just before another window is activated. In many implementations of STDWIN it is possible for the user to activate a window not belonging to the current application; in this case the current application receives only a DEACTIVATE event until one of its windows is reactivated. Note that closing a window does not generate a DEACTIVATE event for it, since the window has already disappeared by the time the application can call .CW "wgetevent" . .IP SIZE .br .RS A window's size has changed. This is usually done by the user explicitly resizing the window; in some (`tiling') STDWIN implementations it can also be caused by opening or closing other windows. .PP Some applications want to format their documents to fit exactly in the window. SIZE events make it possible for such applications to monitor window size changes. The new window size is not reported in the event record; the application can use the enquiry function .CW wgetwinzize for this purpose (see below). .PP Note that window moves don't generate events (except possibly DRAW events). .RE .IP DRAW .br This event is reported only for windows without an associated draw procedure. It means that part of the window needs to be repainted. The smallest rectangle enclosing the area to be repainted is reported in .CW e.u.area , a struct with four fields .CW left , .CW top , .CW right and .CW bottom . .IP TIMER .br The window's alarm timer has gone off. For each window, an alarm may be set with the call .CW "wsettimer(win, dsecs)" . The alarm will go off, causing a TIMER event, aproximately .I dsecs/10 seconds in the future (\c .I dsecs meaning deciseconds). Only one alarm per window is maintained; a new call overrides the previously set alarm. A value of 0 cancels the alarm. Timer values may be rounded up to whole seconds by some implementations. The maximum timer value that is guaranteed to be supported is 32000 dsecs. .NH 2 Pushing events back .LP Occasionally, an application may want to postpone processing of an event till later. E.g., a subroutine may be getting events in a loop until it receives an event which shouldn't be handled locally but in the main event loop. The routine .CW "wungetevent(&eventrecord)" allows an event to be pushed back onto the event queue; the next call to .CW wgetevent or .CW wpollevent will report the event just pushed back. Only a single event can be pushed back (some implementations save the pushed back event in a separate buffer). It is possible to modify the event before pushing it back, or to synthesize events entirely. .NH 2 Getting and setting the active window .LP A pointer to the active window is returned by the function .CW "wactive()" . The application can also make a different window active by calling .CW "wsetactive(win)" . This call does not take effect immediately; some time in the future, a DEACTIVATE event for the currently active window and an ACTIVATE event for the newly activated will be received. .NH 2 Menus .LP Most window systems provide a simple way to set up and manipulate menus, in their simplest form lists of text strings which can be selected by the user by clicking on a string with the mouse. Menus may `pop up' when a particular mouse button is pressed in a particular screen area, or be `pulled down' from a `menu bar', etc. STDWIN provides a consistent, simple way for the application to interface with standard menus, or with menus defined entirely by the STDWIN library (if the window system provides no usable menus). .PP A .I menu contains a number of .I items , numbered starting at 0. A menu has a .I title , a text string displayed to identify the menu to the user, and a .I "menu id" , a small positive integer identifying the menu to the application. Each item contains a text string, an optional .I "check mark" (which may be set by the application to indicate whether an option controlled by a menu item is active), and can be .I enabled or .I disabled . Only enabled items are selectable. When the user selects an enabled item, a MENU event is queued containing the menu id and item number in the event record. Because of the way events are queued, it is possible to receive MENU events for disabled menu items (if the selection was made before the menu item was disabled); applications should be prepared to receive spurious menu selection events. .PP A menu is created by a call to .CW "wmenucreate(id, title)" ; this returns a .I "menu pointer" which must be used for all further manipulations with the menu. .I Id is the menu id, which should be in the range [1..255]. Menu ids should be unique within an application. .PP Initially, a menu contains no items. Items are added by calling .CW "wmenuadditem(mp, text, shortcut)" . The new item's number equals the number of items in the menu before this call; it is returned as the function value. .I Mp is the menu pointer; .I text is the item text. The item is initially enabled and unchecked. .I Shortcut is a character used to construct a `keyboard shortcut' for the menu item; \-1 means the item is not to have a shortcut. (The interpretation of keyboard shortcuts is implementation-dependent. In a typical STDWIN implementation, a menu item with shortcut `X' might be selected by typing ESC-X or Meta-X (but not Control-X). All printable characters are acceptable as shortcuts, but on some systems lower case and upper case are indistinguishable.) Adding an item with an empty string as text adds a disabled `separator' item. .PP The text of an existing menu item can be changed by calling .CW "wmenusetitem(mp, number, text)" . Items can be enabled or disabled by calling .CW "wmenuenable(mp, number, flag)" . The check mark for an item can be set or cleared by calling .CW "wmenucheck(mp, number, flag)" . .PP A menu can be deleted by calling .CW "wmenudelete(mp)" . Note that individual menu items, once added, cannot be removed, nor can new items be inserted in the middle. This is due to restrictions in many window systems' menu interfaces; usually menus are sufficiently static that it doesn't matter. .PP For a menu's items to be selectable, the menu must be attached to a window and the window must be activated. Normally, STDWIN automatically attaches all menus to all windows, so all menus become selectable as soon as the first window is activated. To change this behaviour, the call .CW "wmenusetdeflocal(TRUE)" causes subsequently created menus to be `local', requiring explicit attachment and detachment. The call .CW "wmenuattach(win, mp)" attaches the menu .I mp to the window .I win . The call .CW "wmenudetach(win, mp)" reverses this effect. A menu may be attached to multiple windows; multiple menus may be attached to a window. After calling .CW "wmenusetdeflocal(FALSE)" , future menus will be `global' again, i.e., automatically attached to all (existing and new) windows. .NH Additional facilities .LP .NH 2 Enquiry functions .LP Some enquiry functions are available to interrogate the system state. .LP .CW "wgetscrsize(&width, &height)" .IP Returns the screen size measured in pixels into the integer variables whose addresses are passed. .LP .CW "wgetscrmm(&mmwidth, &mmheight)" .IP Returns the approximate screen size measured in millimeters. By combining this information with the outcome of .CW wgetscrsize , pixel size and aspect ratio can conveniently be computed. In some (most?) implementations, the numbers returned may be approximations or guesses. .LP .CW "wgetwinsize(win, &width, &height)" .IP Returns the size of the drawable area of a window, measured in pixels. (Due to the presence of borders, a maximally-sized window is usually smaller than the screen.) .NH 2 The text caret .LP In documents that deal with text it is often useful to have some form of `text cursor', indicating the position where characters typed at the keyboard will be inserted. The call .CW "wsetcaret(win, h, v)" causes a `caret' to appear just to the left of the character position (\c .I h , .I v ) in the document. The caret appears immediately before any character that would be drawn by .CW "wdrawtext(h, v, ...)" . The caret has a system-defined shape; it is often a blinking vertical bar. .PP Each window has its own caret; the caret in the active window may be the only one that is visible, or it may blink while the carets in other windows are static. At any time a window has at most one caret; the old caret is removed when a new one is specified. The caret can be removed altogether with the call .CW "wnocaret(win)" . .NH 2 Dialogue tools .LP A .I "dialogue box" is a `mini-window' containing a simple message or question, and requiring the user to respond, e.g. by pressing a key or clicking the mouse in a particular area. As long as the dialogue box is present, the application is blocked. After answering the question or acknowledging the message, the dialogue box disappears and normal interaction with the application continues. Dialogue boxes may be presented even when no windows are open yet. The following calls put up dialogue boxes and wait for a response: .sp .LP .CW "wmessage(string)" .IP Displays a message and waits until the user acknowledges it. The precise form of acknowledgement required is implementation-dependent; it could be pressing the Return key or clicking an `OK button' with the mouse. .LP .CW "waskstr(question, replybuf, buflength)" .IP Displays a question and waits until the user has finished typing a reply. The initial contents of the reply buffer are used as a default reply. The function normally returns TRUE; if the user aborts the dialogue (e.g., by pressing the CANCEL button) it returns FALSE. .LP .CW "waskync(question, dflt)" .IP Displays a question which gives the user the possibility to answer with Yes, No or Cancel only. The return value is 1 (Yes), 0 (No) or -1 (Cancel). .I Dflt is the suggested (default) return value. .LP .CW "waskfile(prompt, replybuf, buflength, new)" .IP Displays a dialogue box asking for a file name. .I Replybuf initially contains a default or suggested file name. The boolean parameter .I new specifies whether a new (not yet existing) or old (existing) file is required. When a new file is asked for, the user may specify an existing file, but in this case explicit permission is asked to overwrite it. The function returns TRUE, or FALSE if the user aborts the dialogue. The file name is returned in a form acceptable to the STDIO function .CW fopen . STDWIN implementations may provide additional support, e.g. file name completion or file system browsing; the fact that some systems provide elaborate standard file-selection dialogues (which is highly appreciated by the end users) was a strong motivation to include this function in STDWIN. .LP .CW "wperror(string)" .IP Displays an error message similar to that printed by the standard C function .I perror (3), and waits for an acknowledgement as for .CW wmessage . .sp .LP It should be noted that .CW "waskstr" is the most general of the above functions; in theory, versions of the others can be implemented with the help of .CW "waskstr" and other existing tools. .NH 2 The text-editing package .LP The .I text-editing package is a set of routines implemented entirely `on top of' STDWIN, without using any implementation-dependent functions or data structures. The availability of this package is important because it provides a standard way to tackle the non-trivial problem of editing multi-line text blocks. It is clearly influenced by the TextEdit routines available in the Apple Macintosh's ROM Toolbox (but contains only original code). .PP The text-editing package displays a paragraph of text in a rectangle of a given width, breaking the lines at spaces between words as necessary. It gives the application complete control over what happens to the text, but provides an easy way to handle user input intended to edit it. .PP The call .CW "tecreate(win, )" returns a pointer to a text-editing block at the specified position in the given window's document. (A text-editing block is not a portion of the document but a data structure.) Any number of text-editing blocks may be created, although usually at most one block per window should be editable at any time. .PP Initially, the block contains no text. The call .CW "tesettext(tp, string)" sets the text to be edited, replacing any existing text in the block. The call .CW "tegettext(tp)" returns a pointer to the text string (which remains valid only until the next call to a text-editing routine). .PP The text block is not automatically drawn. When a text-editing routine changes the edited text (or other aspects of its appearance), it calls .CW wchange for the appropriate area of the window; the window's draw procedure should call .CW "tedraw(tp)" for each block which overlaps the repaint area. .PP Besides the edited string, a text-editing block contains a .I focus , indicating which text is selected for deletion or at which position new text will be inserted. The focus can be set by the application with the call .CW "tesetfocus(tp, first, last)" , telling that the characters in the range [first..last-1] are selected, or, if first equals last, that the text insertion point is at that position (characters are counted starting at 0). If the focus is an insert position, the window's caret is set at that position in the document. Text can be inserted at the focus (replacing its previous contents) by calling .CW "tereplace(tp, string)" ; specifying an empty string deletes any text in the focus. .PP The simplest way to let the user edit the text in a text-editing block is to call .CW "teevent(tp, &event\%record)" for each event. This call returns TRUE if the event is applicable to the text-editing block (e.g., it is a CHAR event, or a mouse click within the block's bounding rectangle), and in that case the event is processed by the text-editing package (e.g., a character is inserted, or the focus is moved to the point where the mouse was clicked). If the event is not applicable to the particular block, the function does nothing and returns FALSE; in this case the application should further decide what to do to the event. Of course, the application is free to decide whether to offer an event to a text-editing block at all; e.g., it might have a different interpretation for the Return key (for which the text-editing package inserts a new-line character in the text string). .PP There are more text-editing calls, e.g. to move a text-editing block to a new position, to enquire about the focus, to perform individual editing operations, to ask for the height of the rectangle minimally needed to display the text entirely, etc. .PP The following call displays a text string in exactly the same way as the text-editing package would do (breaking it into lines at the same places, etc.), but without creating a text-editing block, and thus without a focus: .CW "wdrawpar(, string, width)" . It returns the v coordinate of the bottom of the text paragraph. To compute the height of a text paragraph thus drawn without actually drawing it, one can call .CW "wparheight(string, width)" . .NH A complete example .LP The program below is a complete STDWIN application. It is presented here to give a feel for the use of some of the routines described above. The program displays a window in which a text-edit block is placed; all events recognized by the text-edit package are handled correctly, and so are several ways of quitting. Other events are ignored. .if t .sp .5v .DS L .CW #include TEXTEDIT *tp; /* Global so drawproc can reference it */ void drawproc(w, left, top, right, bottom) WINDOW *w; int left, top, right, bottom; { tedraw(tp); } .R .DE .DS L .CW main() { MENU *m; WINDOW *w; int stop; int width, height; .R .DE .DS L .CW winit(); m= wmenucreate(1, "Sample"); wmenuadditem(m, "Quit", 'Q'); /* Item 0 */ w= wopen("Sample window", drawproc); wgetwinsize(w, &width, &height); tp= tecreate(w, 0, 0, width, height); .R .DE .DS L .CW stop= 0; while (!stop) { EVENT e; wgetevent(&e); if (teevent(tp, &e)) wsetdocsize(w, width, tegetbottom(tp)); else { switch (e.type) { case WE_COMMAND: if (e.u.command == WC_CLOSE || e.u.command == WC_CANCEL) stop= 1; break; case WE_MENU: if (e.u.m.id == 1 && e.u.m.item == 0) /* Quit */ stop= 1; break; } } } .R .DE .DS L .CW wclose(w); wdone(); exit(0); } .R .DE .if t .sp -.5v .NH Experiences .LP Five distinct STDWIN implementations have been created so far: for the Apple Macintosh, for the Whitechapel MG-1, for X version 11, for the Atari ST, and a subset for alphanumeric displays (which runs both under Unix and MS-DOS). .PP Once a STDWIN version for a target system is available, application portability is high. Most portability problems that crop up (besides the usual problems like word size, byte order, data alignment or following NULL pointers) have to do with differences in other parts of the operating system interface, e.g. use of the file system. One portability problem encountered with the STDWIN interface was that some programs developed for alphanumeric terminals expected a fixed-width font; in general most problems were caused by insufficiently precise specification of STDWIN. .PP The time needed to create a STDWIN version for a particular target system is moderate. An experienced C programmer who did not know anything about STDWIN or the Atari ST in advance created a working Atari ST version in two months. So far, each version has been created more or less from scratch (except for the common parts like the textedit package). We have now gained enough experience with different target systems to be able to create an intermediate layer containing code which remains more or less constant between target systems. .NH Future developments .LP To date, the applications that use STDWIN have been mostly text-based. Undoubtedly, this has influenced the direction of development of drawing facilities in STDWIN. It is sufficiently easy to add graphical primitives to an implementation, though, that we expect to add several as demand grows, e.g., bitblt, clipping, line styles, filling. The existing facilities set a sort of standard for the form of future ones. The requirement that they be implementable on top of a large variety of window systems will ensure that only more or less generally accepted primitives will be included in STDWIN; a useful sort of conservatism for a package that wants to enhance application portability. .PP Besides the need to add more drawing primitives, there are several areas where STDWIN requires, and will probably get, extensions: fonts, sizes and styles; the mouse cursor; drawing in off-screen bitmaps (not associated with a window); error handling (which is currently virtually absent); event queue manipulations and an `event mask'; `clipboard' or `cut buffer' operations. .PP A development in a different direction, independent of the addition of graphical primitives, may be the addition of more toolboxes built on top of the exiting facilities, like the text editing package. Tools are needed to manipulate higher-order graphical objects, to implement specific interaction techniques, to provide `canned applications' like text-editing windows, etc. .PP A third, potentially very useful, extension would be the addition of drawable `borders' to the window that aren't scrolled together with the document. In such borders, interaction tools could be placed like palettes and buttons, or rulers around the document. The design of such an extension should be the topic of further research, in order to achieve the largest possible generality. .\" Filter troff input through refer -e -n .[ $LIST$ .] red by some implementations. .NH 2 The output model .LP A STDWIN window is a view on a possibly much larger area, a rectangle referrsmtalk43/stdwin/Doc/seldoc.ms1006440003270021170000002746105434024324013332 037777777777 1 0 .\" To format, use (di)troff -ms; and make sure macros.ms is around! .so macros.ms .SH Using X11 Selections and Cut Buffers in STDWIN .LP The C STDWIN interface has been extended to support the .I selection mechanism used by X11. Support for the ring of 8 cut buffers is also provided. .PP This document assumes you are familiar with STDWIN as a programmer and with X11 as an end user (at least xterm experience and some idea of the client-server model). .NH What are Selections? .LP X11 supports an arbitrary number of selections, but version 1.0 of the ICCCM (Inter-Client Communication Conventions Manual, by David Rosenthal) requires only that clients support three selections called PRIMARY, SECONDARY and CLIPBOARD. I will further reference these in lower case. .PP The .I "primary selection" is the mechanism you normally use to transfer data interactively between clients (or within one client). In xterm and text-oriented toolkit clients, you make a primary selection by dragging with the left mouse button. The contents of the selection are highlighted using inverse video. The contents of the primary selection can be pasted into the same or another (toolkit) client by pressing the middle mouse button. .PP Conventions for use of the .I "secondary selection" are less well-known. It is used as the second argument of operations with two arguments, such as swap or replace operations. There is no default support for it in the toolkit, but it is possible to customize toolkit clients to use it. .PP The .I clipboard is intended to hold data that the user has deleted and wants to insert somewhere later. It is supported by the standard X11 client .I xclipboard , which displays the current contents of the clipboard. Other toolkit clients can be customized to use it. .NH Selections From the Client's Point of View .LP It is important to realize that the contents of selections are transferred between clients at the time they are pasted; selections are not normally stored by the server. At any time, a selection is ``owned'' by at most one client, the .I "selection owner" . Different selections may be owned by different clients. The server keeps track of selection owners. When a client wants to become owner of a particular selection, it tells the server so, and the server will send the previous owner an event to tell it that it no longer owns the selection. .PP The protocol to transfer the contents of a selection between clients is fairly involved. Somewhat simplified, it works as follows: .IP \(bu A client requests the contents of a selection from the server. .IP \(bu 2 The server sends the owner an event asking ``please give me this selection.'' .IP \(bu 2 The owner stores the contents of the selection as a .I property\(dg .FS \(dg A window .I property is a named arbitrary piece of data associated with a window, stored by the server. .FE on the requestor's window, and sends an event back (via the server) telling the requestor that the selection is stored. .IP \(bu 2 The requestor fetches the contents of the property, and deletes the property. .PP Various complications are possible: .IP \(bu 2 Race conditions: a client may be slow to respond to a mouse click, and the impatient user may have clicked again in another client's window. When the first client finally decides it wants to become selection owner, the second client may already own it. .IP \(bu Crashes: a selection owner may crash before it has responded to a request for the selection's contents. .IP \(bu Space limitations on the server. .IP \(bu Negotiations about the type of the selection: a string could be stored in simple ASCII or in a special format that retains font information, and in fact a selection may contain a picture or an arbitrarily complicated data structure that only a few clients know about. .NH The STDWIN Interface to Selections .LP STDWIN simplifies the concept of a selection somewhat and takes care of most details of communicating with other clients. In STDWIN, selections are always ASCII strings and only the three standard selections are supported. The strings are null-terminated but may also contain embedded null characters, so a length is always provided. .PP The header .cW defines constants that identify the selections: .cW WS_PRIMARY , .cW WS_SECONDARY , and .cW WS_CLIPBOARD . The application calls the function .cW wsetselection() to become owner of a selection. It may later receive an event of type .cW WE_LOST_SEL telling it that it lost ownership again. It is also possible to voluntarily give up selection ownership by calling .cW wresetselection() . To access the contents of a selection, whether you own it or not, call the function .cW wgetselection() . Transfer of selection contents to other clients is done automatically by .cW wgetevent() and .cW wpollevent() . Detailed descriptions of the new functions follow: .NH 2 Function \* .LP .sC L bool wsetselection(win, sel, data, len) WINDOW *win; int sel; char *data; int len; .eC .LP Parameters: .IP \* 6n Specifies a window that will be associated with the selection. This has no other meaning that limiting the lifetime of the selection to the lifetime of the window. It will not be reported in .cW WE_LOST_SEL events. .IP \* Specifies which selection should be set. It should be one of the codes .cW WS_PRIMARY , .cW WS_SECONDARY , or .cW WS_CLIPBOARD . .IP \* Specifies the data comprising the selection's contents. This need not be null-terminated. It is copied to a safe place by the function so it can be sent to other clients later. .IP \* Specifies the length of the data, not including a terminating null byte. .LP This function attempts to acquirpe ownership of the specified selection. This may fail because of race conditions. The function returns nonzero if it succeeds. If it fails, the application should give the user visual feedback of the failure, .I e.g. , by not inverting the selected text. .NH 2 Function \* .LP .sC L void wresetselection(sel) int sel; .eC .LP Parameters: .IP \* 6n Specifies which selection should be reset. It should be one of the codes .cW WS_PRIMARY , .cW WS_SECONDARY , or .cW WS_CLIPBOARD . .LP If the application owns the specified selection, this function cancels ownership. No .cW WE_LOST_SEL events are generated for the selection. .NH 2 Function \* .LP .sC L char *wgetselection(sel, plen) int sel; int *plen; .eC Parameters: .IP \* 6n Specifies which selection should be retrieved. It should be one of the codes .cW WS_PRIMARY , .cW WS_SECONDARY , or .cW WS_CLIPBOARD . .IP \* Into this parameter, the length of the data is returned, excluding the terminating null byte. .LP This function retrieves the contents of the specified selection. If it succeeds, a pointer to its data is returned. The data is terminated by a null byte but may contain null bytes, so the length is returned separately. The data pointer points to space internal to the STDWIN library. It remains valid until the next call involving selections. If the selection could not be retrieved somehow, a NULL pointer is returned. Selections longer that 32K may be truncated. Since the transfer mechanism requires the use of a window, a NULL pointer is returned when the application currently has no windows open. .NH 2 The \* event type .LP A STDWIN application receives this event type when it owns a selection (a call to .cW wsetselection() has succeeded) and another client has become the new owner. The .cW window member of the .cW EVENT is set to .cW NULL . The .cW u.sel union member is set to the code for the selection. This event is not generated when selection ownership is given up by calling .cW wresetselection() or by deleting its window. .NH The STDWIN Interface to Cut Buffers .LP For compatibility with old STDWIN or X11 clients and Andrew clients, an interface to the cut buffer interface is also provided. This is a ring of 8 buffers maintained at the server. The following functions are available: .NH 2 Function \* .LP .sC L void wsetcutbuffer(ibuffer, data, len) int ibuffer; char *data; int len; .eC .LP Parameters: .IP \* 10n Specifies which buffer should be set, in the range [0 ... 7]. .IP \* Specifies the data. It need not be null-terminated. .IP \* Specifies the length of the data, excluding a terminating null byte. .LP This function sets the contents of the specified cut buffer to the given data. No indication of success or failure is given. .NH 2 Function \* .LP .sC L char *wgetcutbuffer(ibuffer, plen) int ibuffer; int *plen; .eC .LP Parameters: .IP \* 10n Specifies which buffer should be retrieved, in the range [0 ... 7]. .IP \* Returns the length of the data, excluding the terminating null byte. .LP This function returns the contents of the specified cut buffer, terminated by a null byte. If the cut buffer is not accessible, it returns .cW NULL . .NH 2 Function \* .LP .sC L void wrotatecutbuffers(n) int n; .eC .LP Parameters: .IP \* 4n Specifies the amount of rotation. This may be negative. .LP The cut buffers are rotated as follows: buffer n gets the contents of buffer 0, buffer n+1 (mod 8) gets the contents of buffer 1, etc. .NH 2 Function \* .LP .sC L void wsetclip(data, len) char *data; int len; .eC This function is equivalent to .sC wsetcutbuffer(0, data, len); wrotatecutbuffers(1); .eC .NH 2 Function \* .LP .sC L char *wgetclip() .eC This function is equivalent to .sC int len; return wgetcutbuffer(0, &len); .eC (It throws away the length.) .NH Suggested Usage .LP To conform to X11 conventions, STDWIN applications should normally use the primary selection, but use the cut buffers as a ``fall-back'' mechanism. .PP When the user has selected some text, the application should transfer the text to cut buffer 0 and rotate the buffers (the easiest way to do this is to call .cW wsetclip() ), and then call .cW wsetselection() to set the primary selection to the text. If the latter call fails, the inverse video on the selected text should be removed. The inverse video should also be removed when a .cW WE_LOST_SEL event is received. If there is a text insertion point associated with the selection, it should be left at the position indicated by the last mouse click, or to the beginning of the selected text. .PP When the user desires to paste some text, the applcation should first get the contents of the primary selection, and if this returns a NULL pointer, it should get the contents of cut buffer 0. If this returns a NULL pointer as well, the paste request should be refused (with a beep, or something similar). .PP The conventions for selecting and pasting text are: .IP \(bu 2 Dragging with the left (first) mouse button is used to make a selection. Double-clicking selects ``words.'' .IP \(bu Clicking with the middle mouse button requests a ``paste'' operation. It does not move the insert point to the position of the click. .IP \(bu Clicking with the right mouse button extends the selection at the end closest to the button click. .NH Selections and Macintosh STDWIN .LP The Macintosh user interface standards prescribe only a single cut buffer, called the Clipboard. For source compatibility with STDWIN applications developed for X11, dummy versions of the selection functions are provided: .cW wsetselection() and .cW wgetselection() always fail, and .cW wresetselection() is ignored. Versions of the cut buffer functions are provided that identify cut buffer 0 with the Macintosh Clipboard and ignore the other cut buffers. .PP The net effect is that STDWIN applications written for X11 selections that use the cut buffers as a fall-back mechanism will support the Macintosh Clipboard, albeit with an X11-like interface. Macintosh applications are encouraged to provide a standard Edit menu with the operations Cut, Copy and Paste and the standard shortcuts for them: Command-X, Command-C and Command-V. ut' of the rectangle will simply be thrown away; for the area that is to be `scrolled in' from outside the rectangle, .CW wchange is called internally. If the particular form of bit scrolling required isn't smtalk43/stdwin/Doc/vtrmdoc.ms1006440003270021170000003327705434024324013541 037777777777 1 0 .TL .if n .po 0 .if n .ll 72 .if n .nr LL 72n .if t .po 3.5c \" For LaserWriter only Interfacing to Keyboard and Screen with VTRM .br (Draft) .AU Guido van Rossum .AB Since both groups of `interns' at the ABC project will soon need to interface their editors to a terminal, here is a description of the VTRM package, together with some hints on writing a simple displayer using this package. Footnotes are used to indicate portions of the interface that may change in the future. .AE .SH 1. Introduction .LP The VTRM package can significantly ease terminal-independent input and output for a screen-oriented program like a text editor, written in C. There are about a dozen routines, with few and simple parameters, that allow optimized output to almost any ASCII terminal designed in the Western hemisphere, and input of single characters without echoing. Features include adaptation to any screen size, scrolling, and inverse video or a similar `stand-out' mode of displaying selected characters. Screen refreshes use available terminal features such as character insert or delete to minimize the number of characters actually output to the terminal, thus obtaining reasonable performance even at low baud rates. .PP Implementations of the VTRM package are available for .UX , MS-DOS and the Apple Macintosh, and the package can be ported to other similar micro-computers. It is also possible to write an interface to windowing systems like those found on Sun or Whitechapel workstations. .SH 2. Theory of operation .LP VTRM is a set of subroutines callable from a C program. There is a certain discipline required in calling these routines; there are an initialization call, several data manipulation and input calls, and a clean-up call. The C program that is making the calls to VTRM is further referred to as `the application'. In fact, on different systems, different soubroutines are used; but they all conform to the same interface, which is what is described in this document. .PP VTRM has a simple model for a terminal screen: there are YMAX lines, each consisting XMAX characters. YMAX and XMAX are not constants, but remain constant during one particular program run.* .FS *This causes problems with resizable windows as currently available under 4.3 BSD. It is possible that future versions can adapt themselves to changing window sizes, but this will require adaptation of the programs calling VTRM. .FE .PP The coordinate system used by VTRM is different from that normally used in geometry, but more convenient for referencing screen positions: whereever a position on the screen is referenced, it has the form (Y, X) where Y is the line number and X is the column number. The top line is line 0, the bottom line is YMAX\-1. Likewise, the leftmost column is column 0, the rightmost is XMAX\-1. (Note how this is compatible with array indexing practices in C.) ** .FS ** This will get us into trouble with bit-mapped displays, where often the preferred character set or `font' has characters of different widths, so that the number of characters displayable on a line is not a constant. This issue is ignored by VTRM; implementations on such systems currently use a `fixed-width' font. .FE .PP Each character position contains one character, which is in the ASCII range SPACE to `~', i.e., SPACE and all printable characters. Each character can be displayed in one of two modes: normal or `stand-out', which is usually inverse video or underlined (this is a choice made by the VTRM package). `Empty' parts of the screen contain spaces in normal mode. *** .FS *** Eventually the character set allowed will have to be extended to all or most characters in the machine's standard character set that can be displayed. There is a tendency for systems to extend the 7-bit ASCII code to an 8-bit code, where the characters in the range 128-255 are used for special graphics, accented characters etc. VTRM currently uses the 8th bit to indicate stand-out mode; this will have to be changed in the interface. Applications are discouraged to use the 8th bit of characters as a `stand-out' flag except in the immediate interface with VTRM. .FE .PP VTRM is strongly line-oriented. The application must offer data to VTRM in chunks of one or more lines, and scrolling operations can only be applied to entire lines. This is not likely to change in the near future. VTRM does not necessarily send whole lines to the screen: only changed parts of a line are actually transmitted. VTRM recognizes most cases of insertion or deletion of small strings in a line, which can often be handled with character insertions and/or deletions. .PP VTRM may buffer its output. There is one routine which flushes the buffer and moves the terminal's cursor to a given (Y, X) position; during the screen update process the screen contents and cursor position may temporarily be undefined. Not all implementations actually buffer their output; micro-computer screen operations are often fast enough. In all cases, the cursor position is undefined during the screen update. .PP VTRM does not automatically clear the screen when first called; it allows an application to be written in such a manner that its output appears at the bottom of the screen and gradually scrolls upwards, mimicking the behaviour of older programs, if it so wishes. On the other hand, it is trivial to clear the screen after the first call. .PP On .UX , VTRM sets the terminal in a special mode (formally: cbreak, no echo, no cr to nl mapping). This makes it necessary that an application takes measures to call the VTRM clean-up routine whenever it exits. .PP On .UX , VTRM uses the `termcap' database to find out the terminal's capabilities. It requires that the <:TERM:> environment variable is set, and optionally acknowledges the <:TERMCAP:> variable. Information on the proper use of these variables should be readily accessible to all users of the application. .SH 3. Description of the interface .SH 3.1 Set-up and clean-up calls .SH TRMSTART .LP .DS <:int trmstart(p_lines, p_columns, p_flags) int *p_lines, *p_columns; int *p_flags;:> .DE This call must be made before any of the other calls are allowed. The function result is 0 if initialization is successful, nonzero if an error occurred. In the latter case the applications should usually print an error message and exit; the terminal state has not been altered. The meaning of the error codes is described in the appendix. .PP The three arguments must be the addresses of three integer variables (call as, e.g., <:trmstart(&lines, &columns, &flags):>). In <:*p_lines:> and <:*p_columns:>, YMAX and XMAX are returned. In <:*p_flags:>, some flag bits are returned, but these can usually be ignored by the applications (some flag bits are defined but never used). .SH TRMEND .LP .DS <:trmend();:> .DE This function cleans up before the application exits. If it is not called (when <:trmstart:> has been called), the application may leave the terminal in a weird mode, from which it is hard to recover for the user (on .UX -systems non- other weird things may happen). .PP So that it can be safely called from within an interrupt handler, <:trmend:> may be called at any time, before or even during a call to <:trmstart:>. Calls at any other time than after a successful call to <:trmstart:> are ignored. After a call to <:trmend:>, as before a call to <:trmstart:>, calls to all other routines of VTRM are forbidden (this is not enforced by all implementations \- but your program may crash). .PP An application may engage in a sequence of interactive sessions, each bracketed between calls to <:trmstart:> and <:trmend:>. Outside these sessions, normal print-style output can safely be used, thusly: .DS <:trmstart(...); \fIVTRM interaction 1\fP trmend(); printf("Hello, world\\n"); /* Etc. */ trmstart(...); \fIVTRM interaction 2\fP trmend(); :><:...:> .DE .SH 3.2 Output calls .SH TRMPUTDATA .LP .DS <:trmputdata(y0, y1, x, data) int y0, y1; int x; char *data;:> .DE The characters in `data' are placed on the screen, starting at line y0, position x, and continuing up to the last position of line y1. If data is shorter than this space, the remaining positions are filled with spaces; if tdata is too long, it is truncated. The positions 0 through x\-1 on line y0 are left unchanged. .PP Characters with their 8th bit on (or-ed with 0200 octal or 0x80 hex) are displayed in `stand-out' mode. .PP The following is an easy way of clearing the screen: .DS <:trmputdata(0, YMAX-1, 0, "");:> .DE .SH TRMSCROLLUP .LP .DS <:trmscrollup(y0, y1, n) int y0, y1; int n;:> .DE Scrolls the screen lines y0 to y1, inclusive, up by n lines. If n is negative, it scrolls down. When scrolling up, the top n lines starting at y0 disappear, the lines from y0+n to y1 move up n lines, and n blank lines are `shifted in' at and above line y1. Scrolling down is similar. If abs(n) > y1\-y0, lines y0 to y1 are blanked. .SH TRMSYNC .LP .DS <:trmsync(y, x) int y, x;:> .DE Completes any pending operations, flushes the output buffer, and moves the cursor to position (y, x) on the screen. .SH TRMUNDEFINED .LP .DS <:trmundefined();:> .DE Tells VTRM to forget whatever it has remembered about the current screen contents. This is necessary before doing a complete screen refresh in response to a user command like control-L, since such a refresh is usually intended to correct the effect of transmission errors or other processes clobbering the screen. .SH TRMBELL .LP .DS <:trmbell();:> .DE Issues an alarm to the user in a way most appropriate to the output device being used. This may either be an audible bell or beep, or a `visible bell', meaning a flash of (part of) the screen. .PP (On .UX , a control-G is sent to the terminal, unless the termcap entry specifies the `vb' property (visible bell). On MS-DOS, the bell is sounded unconditionally. On the Macintosh, `SysBeep' is called, which gives a beep with a level determined by the volume control on the Control Panel, or flashes the menu bar if the volume is set to 0.) .SH 3.3 Input calls .SH TRMINPUT .LP .DS <:int trminput();:> .DE Returns the next input character typed at the keyboard, waiting if necessary until one is typed. When an error occurs, \-1 is returned; this is usually permanent, so further input would be futile. This could happen, for example, when the user `hangs up'. .SH TRMAVAIL .LP .DS <:int trmavail();:> .DE Returns 1 if an input character is immediately available for <:trminput:>; 0 if no such character is available; and \-1 if the system can't find out (this is not an error condition; it means that the system cannot do a `non-blocking read'). .SH TRMSENSE .LP .DS <:int trmsense(p_y, p_x) int *p_y, *p_x;:> .DE Senses the current cursor or mouse position, and returns its position, converted to screen coordinates, in <:*p_y:> and <:*p_x:>. If the terminal is not capable of sensing the cursor position, both values are set to \-1 and the functions returns 0; after a successful sense, the function returns 1. .SH 3.4 Interrupt handling calls .SH TRMINTERRUPT .LP .DS <:int trminterrupt();:> .DE Checks for keyboard-generated interrupt. Returns 1 if one is found, 0 if not. This may set a signal handler for <:SIGINT:>, so it may interfere with the application's signal handling.* It may also flush type-ahead and (unfortunately enough) discard output buffers. .FS * This is an experimental feature. Use at own risk. Check the source code to see if its actually implemented, and how. .FE .SH TRMSUSPEND .LP .DS <:trmsuspend();:> .DE This call does nothing except on Berkeley .UX supporting job control. Because the terminal state and screen contents are not restored when a process is suspended or resumed, programs using VTRM must be aware of suspension. The character control-Z is received as a normal input character by <:trminput:>, because <:trmstart:> turns off most special character processing. When a control-Z is received, the application should react as follows: .DS <:trmend(); trmsuspend(); trmstart(...); \fIrepaint the screen\fR:> .DE The <:trmsuspend:> call suspends the application and its `process group'; this includes any subprocesses, and possibly parent processes (if the application was run from a shell script or from another program, maybe using a `shell escape'). It only returns when the process group is resumed again (with the shell's `fg' command). .SH 4. Examples .LP Here is a very small sample program: .DS <:main() { int lines, columns, flags; if (trmstart(&lines, &columns, &flags) != 0) exit(1); trmputdata(0, lines-1, 0, "Hello, \\327orld!"); trmsync(1, 0); trmend(); exit(0); }:> .DE It prints the text <:Hello, \fBW\fRorld!:> at the top of the screen, cleans the rest of the screen, and moves the cursor the the beginning of the second line. The `W' is displayed in stand-out mode. .TL Appendix \- <:\fBtrmstart:> error codes and flags .sp 2 .LP The file "trm.h" can be included to get definitions for the flags and error codes returned by <:trmstart:>. It contains the following: .sp 1 .nf <: .ta 8n 16n 24n 32n 40n 48n 56n 64n 72n /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1986. */ /* * Terminal capabilities. These correspond to bits set by trmstart in its * parameter flags parameter. */ #define HAS_STANDOUT 1 /* Terminal has inverse video or underline */ #define CAN_SCROLL 2 /* Terminal can insert/delete lines */ #define CAN_OPTIMISE 4 /* Terminal can insert/delete characters */ #define CAN_SENSE 8 /* Terminal can send cursor position */ /* * Error codes returned by trmstart. */ #define TE_OK 0 /* No errors */ #define TE_TWICE 1 /* Trmstart called again */ #define TE_NOTERM 2 /* $TERM not set or empty */ #define TE_BADTERM 3 /* $TERM not found in termcap database */ #define TE_DUMB 4 /* Terminal too dumb */ #define TE_NOTTY 5 /* Stdout not a tty device */ #define TE_NOMEM 6 /* Can't get enough memory */ #define TE_OTHER 7 /* This and higher are reserved errors */ :> .fi attachment and detachment. The call .CW "wmenuattach(win, mp)" attaches the menu .I mp to the window .I win . The call .CW "wmenudetach(win, mp)" reverses this effect. A menu may be attached to multiple windows; multiple menus may be attached to a window. After calling .CW "wmenusetdeflocal(FALSE)" , future menus will smtalk43/stdwin/Gen/0407550003270021170000000000005477556076010731 5 0 1 0 smtalk43/stdwin/Gen/waskfile.c1006440003270021170000000233105465303017013465 037777777777 1 0 /* STDWIN -- UNIVERSAL WASKFILE. */ #include "tools.h" #include "filedefs.h" #include "stdwin.h" /* Ask for a file name; default is initial contents of buf. Checks are made that the name typed is sensible: if 'new' is TRUE, it should be writable or creatable, and if it already exists confirmation is asked; if 'new' is FALSE, it should exist. */ bool waskfile(prompt, buf, len, new) char *prompt; char *buf; int len; bool new; { for (;;) { if (!waskstr(prompt, buf, len) || buf[0] == EOS) return FALSE; if (new) { if (access(buf, NOMODE) >= 0) { /* Existing file */ if (access(buf, WMODE) >= 0) { switch (waskync("Overwrite? [ny]", 0)) { case -1: return FALSE; case 1: return TRUE; } wmessage("Try again."); } else wmessage("No write permission."); } else { char *p= strrchr(buf, SEP); if (p == NULL) { if (access(CURDIR, WMODE) >= 0) return TRUE; } else { *p= EOS; if (access(buf, WMODE) >= 0) { *p= SEP; return TRUE; } } wmessage("Can't create file."); } } else { if (access(buf, RMODE) >= 0) return TRUE; wmessage("File not found."); } wfleep(); break; } return FALSE; } ait for a response: .sp .LP .CW "wmessage(string)" .IP Displays a message and waits until the user acknowledges it. The precise form of acknowledgement required is implementation-dependent; it could be pressing the Return key or clicking an `OK button' with the mouse. .LP .CW "waskstr(question,smtalk43/stdwin/Gen/waskync.c1006440003270021170000000132605465303017013342 037777777777 1 0 /* STDWIN -- ASK YES/NO QUESTIONS. */ #include "tools.h" #include "stdwin.h" /* Ask a yes/no question. Return value: yes ==> 1, no ==> 0, cancel (^C) ==> -1. Only the first non-blank character of the string typed is checked. The 'deflt' parameter is returned when an empty string is typed. */ int waskync(question, def) char *question; int def; { char buf[100]; char *p= ""; switch (def) { case 1: p= "Yes"; break; case 0: p= "No"; break; } strcpy(buf, p); for (;;) { if (!waskstr(question, buf, sizeof buf)) return -1; p= buf; while (isspace(*p)) ++p; if (*p == EOS) return def; switch (*p) { case 'y': case 'Y': return 1; case 'n': case 'N': return 0; } wfleep(); } } te standard file-selection dialogues (which is highly appreciated by the end users) was a strong motivation to include this function in STDWIN. .LP .CW "wperror(string)" .IP Displays an error message similar to that printed by the standard C function .I perror (3), and waits for an acknowledgementsmtalk43/stdwin/Gen/wdrawpar.c1006440003270021170000000305005465303017013506 037777777777 1 0 /* STDWIN -- PARAGRAPH DRAWING OPERATIONS. N.B. This is portable to other implementations of stdwin. */ #include "stdwin.h" #include "tools.h" /* Draw a paragraph of text. An EOL forces a new line, otherwise lines are broken at spaces (if at all possible). Parameters are the top left corner, the width, the text and its length. Return value is the v coordinate of the bottom line. (Note that an empty string is drawn as one blank line.) */ int wdrawpar(left, top, text, width) int left, top; char *text; int width; { return _wdrawpar(left, top, text, width, TRUE); } /* Measure the height of a paragraph of text, when drawn with wdrawpar. */ int wparheight(text, width) char *text; int width; { return _wdrawpar(0, 0, text, width, FALSE); } /* Routine to do the dirty work for the above two. */ static int _wdrawpar(left, top, text, width, draw) int left, top; char *text; int width; bool draw; { int len= strlen(text); int len1= 0; /* Len1 counts characters until next EOL */ while (len1 < len && text[len1] != EOL) ++len1; for (;;) { int n= wtextbreak(text, len1, width); if (n < len1) { char *cp= text+n; while (cp > text && *cp != ' ') --cp; if (cp > text) n= cp-text; } if (draw) (void) wdrawtext(left, top, text, n); top += wlineheight(); text += n; len -= n; len1 -= n; while (len1 > 0 && *text == ' ') { ++text; --len; --len1; } if (len1 == 0) { if (len == 0) break; ++text; --len; while (len1 < len && text[len1] != EOL) ++len1; } } return top; } ill be inserted. The focus can be set by the application with the call .CW "tesetfocus(tp, first, last)" , telling that the characters in the range [first..last-1] are selected, or, if first equals last, that the text insertion point is at that position (characters are counted starting at 0). If the focus is an insert position, the window's caret is set at that position in the document. Text can be inserted at the focus (replacing its previous contents) by calling .CWsmtalk43/stdwin/Gen/wperror.c1006440003270021170000000034505465303017013363 037777777777 1 0 /* STDWIN -- UNIVERSAL WPERROR. */ #include "tools.h" #include "stdwin.h" /* STDWIN equivalent of perror(). */ void wperror(name) char *name; { char buf[256]; sprintf(buf, "%s: Error %d.", name, errno); wmessage(buf); } lication is free to decide whether to offer an event to a text-editing block at all; e.g., it might have a different interpretation for the Return key (for which the text-editing package inserts a new-line character in the text string). .PP There are more text-editing calls, e.g. tosmtalk43/stdwin/Gen/wsetclip.c1006440003270021170000000037105465303017013514 037777777777 1 0 /* Simplified Cut Buffer Interface */ #include "stdwin.h" #include "tools.h" void wsetclip(data, len) char *data; int len; { wrotatecutbuffers(1); wsetcutbuffer(0, data, len); } char * wgetclip() { int len; return wgetcutbuffer(0, &len); } ed here to give a feel for the use of some of the routines described above. The program displays a window in which a text-edit block is placed; all events recognized by the text-edit package are handled correctly, and so are several ways of quitting. Other eventssmtalk43/stdwin/Gen/wsetcutbuffer.c1006440003270021170000000114705465303020014546 037777777777 1 0 /* Default Cut Buffer Interface */ #include "stdwin.h" #include "tools.h" static char *cb0data = NULL; static int cb0len = 0; void wsetcutbuffer(ibuffer, data, len) int ibuffer; char *data; int len; { if (ibuffer != 0) return; if (cb0data != NULL) free(cb0data); cb0len = 0; cb0data = malloc(len+1); if (cb0data != NULL) { memcpy(cb0data, data, len); cb0data[len]= EOS; cb0len = len; } } char * wgetcutbuffer(ibuffer, len_return) int ibuffer; int *len_return; { if (ibuffer != 0) return NULL; *len_return = cb0len; return cb0data; } /*ARGSUSED*/ void wrotatecutbuffers(n) int n; { } se(w); wdone(); exit(0); } .R .DE .if t .sp -.5v .NH Experiences .LP Five distinct STDWIN implementations have been created so far: for the Apple Macintosh, for the Whitechapel MG-1, for X version 11, for the Atari ST, and a subset for alphanumeric displays (which runs both under Unix and MS-DOS). .PP Once a STDWIN version for a target system is available, application portability is high. Most portsmtalk43/stdwin/Gen/wsetselection.c1006440003270021170000000054205465303020014544 037777777777 1 0 /* Dummy Selection Interface (always fails) */ #include "stdwin.h" #include "tools.h" /*ARGSUSED*/ int wsetselection(win, sel, data, len) WINDOW *win; int sel; char *data; int len; { return 0; } /*ARGSUSED*/ char * wgetselection(sel, len_return) int sel; int *len_return; { return NULL; } /*ARGSUSED*/ void wresetselection(sel) int sel; { } e with different target systems to be able to create an intermediate layer containing code which remains more or less constant between target systems. .NH Futsmtalk43/stdwin/Gen/wstyle.c1006440003270021170000000114105465303020013177 037777777777 1 0 /* STDWIN -- TEXT ATTRIBUTES. */ #include "tools.h" #include "stdwin.h" #include "style.h" TEXTATTR wattr; /* Setting text drawing parameters. */ void wsetplain() { wattr.style= PLAIN; } void wsethilite() { wattr.style |= HILITE; } void wsetinverse() { wattr.style |= INVERSE; } void wsetitalic() { wattr.style |= ITALIC; } void wsetbold() { wattr.style |= BOLD; } void wsetbolditalic() { wattr.style |= BOLD|ITALIC; } void wsetunderline() { wattr.style |= UNDERLINE; } void wgettextattr(attr) TEXTATTR *attr; { *attr= wattr; } void wsettextattr(attr) TEXTATTR *attr; { wattr= *attr; } t direction, independent of the addition of graphical primitives, may be the addition of more toolboxes built on top of the exiting facilities, like the text editing package. Tools are needed to manipulate higher-order graphical objects, to implement specific interaction techniques, to provide `canned applications' like text-editing windows, etc. .PP A third, potentially very useful, extension would be the additsmtalk43/stdwin/Gen/wtextbreak.c1006440003270021170000000323005465303020014031 037777777777 1 0 /* STDWIN -- TEXT BREAK ROUTINE. */ #include "stdwin.h" /* Portable version of wtextbreak(); use on systems where such an operation is not an available primitive and wtextwidth has a high overhead per call. This function makes an educated guess and then uses linear interpolation to find the exact answer. It assumes that the textwidth function is additive (if not, but almost, a final adjustment pass could be added). */ int wtextbreak(str, len, width) char *str; int len; int width; { int en= wcharwidth('n'); /* Estimated average char width */ /* NB: adapted below in the loop! */ int max; /* Maximum answer */ int min= 0; /* Minimum answer */ int wmin= 0; /* Corresponding string width */ if (len < 0) len= strlen(str); max= len; /* Invariants: 'min' characters fit, 'max+1' characters don't. Ergo: we can stop when min == max. */ while (min < max) { /* Guess a number of chars beyond min. */ int guess= (width - wmin)/en; int wguess; if (guess <= 0) guess= 1; else if (min+guess > max) guess= max-min; wguess= wtextwidth(str+min, guess); /* Width increment */ if (wguess > 0) en= (wguess + guess - 1) / guess; guess += min; wguess += wmin; if (wguess > width) { max= guess-1; } else /* wguess <= width */ { min= guess; wmin= wguess; } } #ifdef TEXT_NOT_ADDITIVE /* Initially, min==max. See if min should be smaller. */ while (min > 0 && wtextwidth(str, min) > width) { --min; } if (min == max) { /* Previous loop didn't decrease min. See if we can increase it... */ while (max < len && wtextwidth(str, ++max) <= width) { ++min; } } #endif return min; } t by pressing the middle mouse button. .PP Conventions for use of the .I "secondary selection" are less well-known. It is used as the second argument of operations with two arguments, such as swap or replace operations. There is no default support for it in the toolkit, but it is possible to customize toolkit clients to use it. .PP The .I clipboard is intendsmtalk43/stdwin/Gen/makefile.vms1006440003270021170000000021405470575501014023 037777777777 1 0 .c.obj: cc/include=[-.h] $* CORE=waskfile waskync wdrawpar wperror wsetclip wsetcutbuffer wsetselection wstyle wtextbreak all: $(CORE).obj When a client wants to become owner of a particular selection, it tells the server so, and the server will send the previous owner an event to tell it that it no longer owns the selection. .PP The protocol to transfer the contents of a selection between clients is fairly involved. Somewhat simplified, it works as follows: .IP \(bu A client requests the contents of a selsmtalk43/stdwin/H/0407550003270021170000000000005477556101010374 5 0 1 0 smtalk43/stdwin/H/_ARGS.h1006440003270021170000000216205434024327012240 037777777777 1 0 /* Define _ARGS(x) as either x or () depending on an educated guess on the presence of support for prototypes in the compiler. The idea is that you declare function with prototypes as follows: extern char *malloc _ARGS((unsigned int)); Watch the double parentheses (you'll quickly get used to them). Use _ARGS((void)) to declare a function with no arguments. Use things like _ARGS((char *, ...)) to declare printf-like functions. As a free extra, the macro HAVE_PROTOTYPES is defined if and only if prototypes are supported, and the macro 'const' is defined as empty if prototypes are not supported (and also if THINK_C is defined). */ #ifndef _ARGS #ifdef __STDC__ #define HAVE_PROTOTYPES #endif #ifdef THINK_C #undef HAVE_PROTOTYPES #define HAVE_PROTOTYPES #endif #ifdef sgi #ifdef mips #define HAVE_PROTOTYPES #endif #endif #ifdef HAVE_PROTOTYPES #define _ARGS(x) x #else #define _ARGS(x) () #endif #ifndef HAVE_PROTOTYPES #define const /*empty*/ #else /* HAVE_PROTOTYPES */ #ifdef THINK_C #undef const #define const /*empty*/ #endif /* THINK_C */ #endif /* HAVE_PROTOTYPES */ #endif /* _ARGS */ of selection contents to other clients is done automatically by .cW wgetevent() and .cW wpollevent() . Detailed descriptions of the new functions follow: .NH 2 Function \* .LP .sC L bool wsetselection(win, sel, data, len) WINDOW *win; int sel; char *data; int len; .eC .LP Parameters: .IP \* 6n Specifies a window that will be associated with the selection. This has no osmtalk43/stdwin/H/editwin.h1006440003270021170000000206505434024327013012 037777777777 1 0 /* Text Edit Window Package */ typedef struct editwin { /* Fields can be read by the caller but shouldn't be changed */ WINDOW *win; TEXTEDIT *tp; char *filename; char /*tbool*/ saved; } EDITWIN; EDITWIN *ewfind _ARGS((WINDOW *)); int ewcount _ARGS((void)); EDITWIN *ewcreate _ARGS((char *)); EDITWIN *ewnew _ARGS((void)); EDITWIN *ewopen _ARGS((void)); /*bool*/int ewclose _ARGS((EDITWIN *)); /*bool*/int ewsave _ARGS((EDITWIN *)); /*bool*/int ewsaveas _ARGS((EDITWIN *)); /*bool*/int ewsavecopy _ARGS((EDITWIN *)); /*bool*/int ewsaveprompt _ARGS((EDITWIN *, char *, /*bool*/int)); /*bool*/int ewrevert _ARGS((EDITWIN *)); /*bool*/int ewreadfile _ARGS((EDITWIN *, char *)); void ewsetdimensions _ARGS((EDITWIN *)); /*bool*/int ewwritefile _ARGS((EDITWIN *, char *)); /*bool*/int ewevent _ARGS((EDITWIN *, EVENT *, /*bool*/int *)); /*bool*/int ewsaveall _ARGS((void)); /*bool*/int ewcloseall _ARGS((void)); void ewreplace _ARGS((EDITWIN *, char *)); void ewundo _ARGS((EDITWIN *)); /* Not implemented */ void ewcopy _ARGS((EDITWIN *)); void ewpaste _ARGS((EDITWIN *)); xcluding the terminating null byte. .LP This function retrieves the contents of the specified selection. If it succeeds, a pointer to its data is returned. The data is terminated by a null byte but may contain null bytes, so the length is returned separately. The data pointer points to space internal to the STDWIN library. It remains valid until the next call involving selections. If the selection could not be retrieved somehow, a NULL pointer is returnedsmtalk43/stdwin/H/endian.h1006440003270021170000000021305434024327012576 037777777777 1 0 /* Definitions for byte order. */ #define LIL_ENDIAN 1234 /* VAX style */ #define BIG_ENDIAN 4321 /* 68000 style */ extern int endian; WIN Interface to Cut Buffers .LP For compatibility with old STDWIN or X11 clients and Andrew clients, an interface to the cut buffer interface is also provided. This is a ring of 8 buffers maintained at the server. The following functions are available: .NH 2 Function \* .LP .sC L void wsetcutbuffer(ibuffer, data, len) int ibuffer; char *data; int len;smtalk43/stdwin/H/filedefs.h1006440003270021170000000034305477543426013142 037777777777 1 0 /* File name parsing details: */ #define SEP '/' /* Separator in path names */ #define CURDIR "." /* Current directory */ /* Flags for access(2) system call: */ #define RMODE 4 #define WMODE 2 #define XMODE 1 #define NOMODE 0 cut buffer, terminated by a null byte. If the cut buffer is not accessible, it returns .cW NULL . .NH 2 Function \* .LP .sC L void wrotatecutbuffers(n) int n; .eC .LP Parameters: .IP \* 4n Specifies the amount of rotation. This may be negative. .LP The cutsmtalk43/stdwin/H/lists.h1006440003270021170000000577105434024330012506 037777777777 1 0 /* Package to manipulate dynamic arrays represented like argc/argv (but not necessarily containing character pointers). Operations provided are macros that expand to groups of statements; their arguments should be side-effect-free. The arguments argc and argv should be single identifiers, since they are assigned to. (L_DECLARE expands to a series of declarations.) This code was written because I found myself writing code very similar to it times and times over, or, worse, using fixed-length arrays out of laziness. It's slow for large arrays (although this could be improved easily by rounding up the sizes passed to malloc/realloc), but this shouldn't be a problem for the applications I am currently using it for. It sure helped me write some array processing code faster. Operations: L_DECLARE(argc, argv, type) declare a list with element type 'type' L_INIT(argc, argv) initialize a list L_DEALLOC(argc, argv) deallocate a list L_SETSIZE(argc, argv, type, size) set list to size 'size' L_EXTEND(argc, argv, type, count) append 'count' unitinialized elements L_APPEND(argc, argv, type, elem) append a given element L_REMOVE(argc, argv, type, index) remove element number 'index' L_INSERT(argc, argv, type, index, elem) insert 'elem' at 'index' L_SORT(argc, argv, type, compare) sort the list ('compare' is a function) (There should also be operations to insert in the middle and to remove elements.) NB: the 'type' argument could be discarded (except for L_DECLARE) if we could live with warnings about assignments from malloc/realloc to other pointer types. */ /* This file only works when included by "stdwtools.h" !!! */ /* You could define GOOD_REALLOC if your realloc() calls malloc() when passed a NULL pointer */ #ifdef GOOD_REALLOC #define _REALLOC(p, size) realloc(p, size) #else #define _REALLOC(p, size) ((p) ? realloc(p, size) : malloc(size)) #endif #define L_DECLARE(argc, argv, type) int argc = 0; type *argv = 0 #define L_INIT(argc, argv) argc = 0; argv = 0 #define L_DEALLOC(argc, argv) argc = 0; FREE(argv) #define L_SETSIZE(argc, argv, type, size) \ argv = (type *) _REALLOC((UNIVPTR) argv, \ (unsigned) (size) * sizeof(type)); \ argc = (argv == 0) ? 0 : size #define L_EXTEND(argc, argv, type, count) \ L_SETSIZE(argc, argv, type, argc+count) #define L_APPEND(argc, argv, type, elem) \ argv = (type *) _REALLOC((UNIVPTR) argv, \ (unsigned) (argc+1) * sizeof(type)); \ if (argv == 0) \ argc = 0; \ else \ argv[argc++] = elem #define L_REMOVE(argc, argv, type, index) \ { \ int k_; \ for (k_ = index+1; k_ < argc; ++k_) \ argv[k_-1] = argv[k_]; \ L_SETSIZE(argc, argv, type, argc-1); \ } #define L_INSERT(argc, argv, type, index, item) \ { \ int k_; \ L_SETSIZE(argc, argv, type, argc+1); \ for (k_ = argc-1; k_ > index; --k_) \ argv[k_] = argv[k_-1]; \ argv[index] = item; \ } #define L_SORT(argc, argv, type, compare) \ qsort((UNIVPTR)argv, argc, sizeof(type), compare) smtalk43/stdwin/H/patchlevel.h1006440003270021170000000002505434024330013462 037777777777 1 0 #define PATCHLEVEL 5 nificantly ease terminal-independent input and output for a screen-oriented program like a text editor, written in C. There are about a dozen routines, with few and simple parameters, that allow optimized output to almost any ASCII terminal designed in the Western hemisphere, and input of single characters without echoing. Features include adaptation to any screen size, scrolling, and inverse video or a similar `stand-out' mode of displaying selected characters. Screen refreshes use asmtalk43/stdwin/H/sigtype.h1006440003270021170000000073705434024330013031 037777777777 1 0 /* The type of signal handlers is somewhat problematic. This file encapsulates my knowledge about it: - on the Mac (THINK C), it's int - on other systems, it's usually void, except it's int on vax Ultrix. Pass -DSIGTYPE=... to cc if you know better. */ #ifndef SIGTYPE #ifdef THINK_C #define SIGTYPE int #else /* !THINK_C */ #if defined(vax) && !defined(AMOEBA) #define SIGTYPE int #else #define SIGTYPE void #endif #endif /* !THINK_C */ #endif /* !SIGTYPE */ model for a terminal screen: thesmtalk43/stdwin/H/stdwconf.h1006440003270021170000000140705434024330013167 037777777777 1 0 /* "configure.h" -- mess with predefined symbols. This file is supposed to be portable between all OSes. It is also reentrant. */ /* MPW defines "macintosh"; THINK C defines "THINK_C". Some portable code tests for "macintosh" to detect any Mac implementation; the distinction between MPW and THINK C is made by checking for "MPW" or "THINK_C". */ /* If "macintosh" defined but not "THINK_C", it must be MPW */ /* XXX (I hope I remember this right -- I haven't used MPW for years) */ #ifdef macintosh #ifndef THINK_C #define MPW #endif #endif /* Under THINK C, turn on "macintosh" if not already on */ #ifdef THINK_C #ifndef macintosh #define macintosh #endif #endif #ifdef THINK_C /* #define THINK_C_3_0 /*** TURN THIS ON FOR THINK C 3.0 ****/ #endif intable characters. Each character can be displayed in one of two modes: normal or `stand-out', which is usually inverse video or underlined (this is a choice made by the VTRM package). `Empty' parts of the screen contain spaces in normal mode. **smtalk43/stdwin/H/stdwin.h1006440003270021170000002031605470545675012674 037777777777 1 0 /* STDWIN INTERFACE */ #ifndef __STDWIN_H__ /* Guard against multiple inclusion */ #define __STDWIN_H__ #include "_ARGS.h" /* Definition of _ARGS() macro */ /***********************************/ /* Section 1. Types and constants */ /***********************************/ /* These structs are implementation-dependent, the user only sees pointers to them */ #define WINDOW struct _window #define MENU struct _menu #define CURSOR struct _cursor /* Fake window type used by the wgettag() and wsettag() macros */ struct _fakewindow { short tag; }; #define _FAKEWINDOW struct _fakewindow /* EVENT struct */ struct _event { int type; WINDOW *window; union { /* case WE_CHAR: */ int character; /* case WE_COMMAND: */ int command; /* case WE_MENU: */ struct { int id; int item; } m; /* case WE_DRAW: */ struct { int left, top, right, bottom; } area; /* case WE_MOUSE_DOWN, WE_MOUSE_MOVE, WE_MOUSE_UP: */ struct { int h; int v; int clicks; int button; int mask; } where; /* case WE_LOST_SEL: */ int sel; } u; }; #define EVENT struct _event /* Event types */ /* XXX Should be reordered */ #define WE_NULL 0 /* (Used internally) */ #define WE_ACTIVATE 1 /* Window became active */ #define WE_CHAR 2 /* Character typed at keyboard */ #define WE_COMMAND 3 /* Special command, function key etc. */ #define WE_MOUSE_DOWN 4 /* Mouse button pressed */ #define WE_MOUSE_MOVE 5 /* Mouse moved with button down */ #define WE_MOUSE_UP 6 /* Mouse button released */ #define WE_MENU 7 /* Menu item selected */ #define WE_SIZE 8 /* Window size changed */ #define WE_MOVE 9 /* Window moved (reserved) */ #define WE_DRAW 10 /* Request to redraw part of window */ #define WE_TIMER 11 /* Window's timer went off */ #define WE_DEACTIVATE 12 /* Window became inactive */ #define WE_EXTERN 13 /* Externally generated event (Amoeba) */ #define WE_KEY 14 /* Low-level key event (reserved) */ #define WE_LOST_SEL 15 /* Lost selection */ #define WE_CLOSE 16 /* User wants to close window */ /* Special keys reported by WE_COMMAND */ /* XXX Should become key events */ #define WC_CLOSE 1 /* Now a separate event! */ /* The following four are arrow keys */ #define WC_LEFT 2 #define WC_RIGHT 3 #define WC_UP 4 #define WC_DOWN 5 /* ASCII keys */ #define WC_CANCEL 6 #define WC_BACKSPACE 7 #define WC_TAB 8 #define WC_RETURN 9 /* IBM-PC keys -- not in all implementations */ /* XXX Should be done differently */ #define WC_HOME 10 #define WC_END 11 #define WC_CLEAR 12 #define WC_INS 13 #define WC_DEL 14 #define WC_PAGE_UP 15 #define WC_PAGE_DOWN 16 #define WC_META_LEFT 17 #define WC_META_RIGHT 18 #define WC_META_HOME 19 #define WC_META_END 20 #define WC_META_PAGE_UP 21 #define WC_META_PAGE_DOWN 22 /* XXX Should have entries for Alt-letter and F1-F10 etc. ? */ /* Codes for selections (e.u.sel for WE_LOST_SEL) */ #define WS_CLIPBOARD 0 #define WS_PRIMARY 1 #define WS_SECONDARY 2 /* TEXTATTR struct */ /* The contents of a text attributes struct are disclosed here because the interface allows the programmer to declare objects of this type. (I'm not so sure anymore that this is the right thing to do!) */ struct _textattr { short font; unsigned char size; unsigned char style; }; #define TEXTATTR struct _textattr /*************************************/ /* Section 2. Function declarations */ /*************************************/ void wargs _ARGS((int *pargc, char ***pargv)); void winit _ARGS((void)); void winitargs _ARGS((int *pargc, char ***pargv)); void wdone _ARGS((void)); void wgetscrsize _ARGS((int *pwidth, int *pheight)); void wgetscrmm _ARGS((int *pmmwidth, int *pmmheight)); void wsetmaxwinsize _ARGS((int width, int height)); void wsetdefwinsize _ARGS((int width, int height)); void wsetdefwinpos _ARGS((int h, int v)); void wgetdefwinsize _ARGS((int *pwidth, int *pheight)); void wgetdefwinpos _ARGS((int *ph, int *pv)); WINDOW *wopen _ARGS((char *title, void (*drawproc)(/*WINDOW *win, int left, int top, int right, int bottom*/))); void wclose _ARGS((WINDOW *win)); #define wgettag(win) (((_FAKEWINDOW *)(win)) -> tag) #define wsettag(win, newtag) (((_FAKEWINDOW *)(win)) -> tag = (newtag)) void wsetactive _ARGS((WINDOW *win)); WINDOW *wgetactive _ARGS((void)); void wgetwinsize _ARGS((WINDOW *win, int *width, int *height)); void wsetdocsize _ARGS((WINDOW *win, int width, int height)); void wgetdocsize _ARGS((WINDOW *win, int *width, int *height)); void wsettitle _ARGS((WINDOW *win, char *title)); char *wgettitle _ARGS((WINDOW *win)); /* Returns pointer to static data */ void wsetorigin _ARGS((WINDOW *win, int h, int v)); void wgetorigin _ARGS((WINDOW *win, int *h, int *v)); void wshow _ARGS((WINDOW *win, int left, int top, int right, int bottom)); void wchange _ARGS((WINDOW *win, int left, int top, int right, int bottom)); void wscroll _ARGS((WINDOW *win, int left, int top, int right, int bottom, int dh, int dv)); void wfleep _ARGS((void)); void wmessage _ARGS((char *str)); void wperror _ARGS((char *name)); /*bool*/int waskstr _ARGS((char *prompt, char *buf, int buflen)); int waskync _ARGS((char *question, int dflt)); /*bool*/int waskfile _ARGS((char *prompt, char *buf, int buflen, /*bool*/int newfile)); void wsetcaret _ARGS((WINDOW *win, int h, int v)); void wnocaret _ARGS((WINDOW *win)); void wsettimer _ARGS((WINDOW *win, int deciseconds)); MENU *wmenucreate _ARGS((int id, char *title)); void wmenudelete _ARGS((MENU *mp)); int wmenuadditem _ARGS((MENU *mp, char *text, int shortcut)); void wmenusetitem _ARGS((MENU *mp, int i, char *text)); void wmenusetdeflocal _ARGS((/*bool*/int local)); void wmenuattach _ARGS((WINDOW *win, MENU *mp)); void wmenudetach _ARGS((WINDOW *win, MENU *mp)); void wmenuenable _ARGS((MENU *mp, int item, int flag)); void wmenucheck _ARGS((MENU *mp, int item, int flag)); /* The following is only available in termcap stdwin: */ void wsetshortcut _ARGS((int id, int item, char *keys)); void wgetevent _ARGS((EVENT *ep)); /*bool*/int wpollevent _ARGS((EVENT *ep)); void wungetevent _ARGS((EVENT *ep)); void wupdate _ARGS((WINDOW *win)); void wbegindrawing _ARGS((WINDOW *win)); void wenddrawing _ARGS((WINDOW *win)); void wflush _ARGS((void)); void wdrawline _ARGS((int h1, int v1, int h2, int v2)); void wxorline _ARGS((int h1, int v1, int h2, int v2)); void wdrawcircle _ARGS((int h, int v, int radius)); void wdrawelarc _ARGS((int h, int v, int hrad, int vrad, int ang1, int ang2)); void wdrawbox _ARGS((int left, int top, int right, int bottom)); #ifdef VMS void wblank _ARGS((int left, int top, int right, int bottom)); #else void werase _ARGS((int left, int top, int right, int bottom)); #endif void wpaint _ARGS((int left, int top, int right, int bottom)); void winvert _ARGS((int left, int top, int right, int bottom)); void wshade _ARGS((int left, int top, int right, int bottom, int percent)); void wcliprect _ARGS((int left, int top, int right, int bottom)); void wnoclip _ARGS((void)); void wdrawtext _ARGS((int h, int v, char *str, int len)); void wdrawchar _ARGS((int h, int v, int c)); int wlineheight _ARGS((void)); int wbaseline _ARGS((void)); int wtextwidth _ARGS((char *str, int len)); int wcharwidth _ARGS((int c)); int wtextbreak _ARGS((char *str, int len, int width)); void wgettextattr _ARGS((TEXTATTR *attr)); void wsettextattr _ARGS((TEXTATTR *attr)); void wgetwintextattr _ARGS((WINDOW *win, TEXTATTR *attr)); void wsetwintextattr _ARGS((WINDOW *win, TEXTATTR *attr)); void wsetplain _ARGS((void)); void wsethilite _ARGS((void)); void wsetinverse _ARGS((void)); void wsetitalic _ARGS((void)); void wsetbold _ARGS((void)); void wsetbolditalic _ARGS((void)); void wsetunderline _ARGS((void)); void wsetfont _ARGS((char *fontname)); void wsetsize _ARGS((int pointsize)); /* Setting the mouse cursor for a window */ CURSOR *wfetchcursor _ARGS((char *name)); void wsetwincursor _ARGS((WINDOW *win, CURSOR *cursor)); /* X11 Selection interface */ /*bool*/int wsetselection _ARGS((WINDOW *, int, char *, int)); void wresetselection _ARGS((int)); char *wgetselection _ARGS((int, int *)); /* Cut buffer interface */ void wsetcutbuffer _ARGS((int, char *, int)); char *wgetcutbuffer _ARGS((int, int *)); void wrotatecutbuffers _ARGS((int)); void wsetclip _ARGS((char *, int)); char *wgetclip _ARGS((void)); /* Pull in definitions for TEXTEDIT package */ #include "stdwtext.h" #endif /* __STDWIN_H__ */ n() { int lines, columns, flags; if (trmstart(&lines, &columns, &flags) != 0) exit(1); trmputdata(0, lines-1, 0, "Hello, \\327orld!"); trmsync(1, 0); trmend(); exit(0); }:> .DE It prints the text <:Hello, \fBW\fRorld!:> at the top of the screen, cleans the rest of the screen, and moves the cursor thsmtalk43/stdwin/H/stdwtext.h1006440003270021170000000341305434024331013226 037777777777 1 0 /* STDWIN TEXTEDIT PACKAGE INTERFACE */ /* This file is only ever included by "stdwin.h" */ #define TEXTEDIT struct _textedit TEXTEDIT *tealloc _ARGS((WINDOW *win, int left, int top, int width)); TEXTEDIT *tecreate _ARGS((WINDOW *win, int left, int top, int right, int bottom)); void tefree _ARGS((TEXTEDIT *tp)); void tedestroy _ARGS((TEXTEDIT *tp)); void tesetactive _ARGS((TEXTEDIT *tp, /*bool*/int active)); void tedraw _ARGS((TEXTEDIT *tp)); void tedrawnew _ARGS((TEXTEDIT *tp, int left, int top, int right, int bottom)); void temove _ARGS((TEXTEDIT *tp, int left, int top, int width)); void temovenew _ARGS((TEXTEDIT *tp, int left, int top, int right, int bottom)); void tesetfocus _ARGS((TEXTEDIT *tp, int foc1, int foc2)); void tereplace _ARGS((TEXTEDIT *tp, char *str)); void tesetbuf _ARGS((TEXTEDIT *tp, char *buf, int buflen)); void tearrow _ARGS((TEXTEDIT *tp, int code)); void tebackspace _ARGS((TEXTEDIT *tp)); /*bool*/int teclicknew _ARGS((TEXTEDIT *tp, int h, int v, /*bool*/int extend, /*bool*/int dclick)); /*bool*/int tedoubleclick _ARGS((TEXTEDIT *tp, int h, int v)); /*bool*/int teevent _ARGS((TEXTEDIT *tp, EVENT *ep)); #define teclick(tp, h, v) teclicknew(tp, h, v, FALSE) #define teclickextend(tp, h, v) teclicknew(tp, h, v, TRUE) char *tegettext _ARGS((TEXTEDIT *tp)); int tegetlen _ARGS((TEXTEDIT *tp)); int tegetnlines _ARGS((TEXTEDIT *tp)); int tegetfoc1 _ARGS((TEXTEDIT *tp)); int tegetfoc2 _ARGS((TEXTEDIT *tp)); int tegetleft _ARGS((TEXTEDIT *tp)); int tegettop _ARGS((TEXTEDIT *tp)); int tegetright _ARGS((TEXTEDIT *tp)); int tegetbottom _ARGS((TEXTEDIT *tp)); /* Text paragraph drawing functions: */ int wdrawpar _ARGS((int h, int v, char *text, int width)); /* Returns new v coord. */ int wparheight _ARGS((char *text, int width)); /* Returns height */ 7 1 0 smtalk43/stdwin/H/style.h1006440003270021170000000027005434024331012476 037777777777 1 0 /* STDWIN -- TEXT ATTRIBUTES. */ #define PLAIN 0x00 #define HILITE 0x01 #define INVERSE 0x02 #define ITALIC 0x04 #define BOLD 0x08 #define UNDERLINE 0x10 extern TEXTATTR wattr; rn FALSE; case 1: return TRUE; } wmessage("Try again."); } else wmessage("No write permission."); } else { char *p= strrchr(buf, SEP); if (p == NULL) { if (access(CURDIR, WMODE) >= 0) return TRUE; } else { *p= EOS; if (access(buf, WMODE) >= 0) { *p= smtalk43/stdwin/H/tilist.h1006440003270021170000000105305434024331012646 037777777777 1 0 /* Text Item Lists */ struct _textitem { TEXTEDIT *tp; int left, top, right, bottom; int active; struct _textitem *next; struct _textitemlist *back; }; struct _textitemlist { WINDOW *win; struct _textitem *list; struct _textitem *focus; }; #define TEXTITEM struct _textitem #define TILIST struct _textitemlist TILIST *tilcreate(); void tildestroy(); void tildraw(); int tilevent(); void tilnextfocus(); TEXTITEM *tiladd(); TEXTITEM *tilinsert(); void tilremove(); void tilsetactive(); void tilfocus(); void tilsettext(); char *tilgettext(); lude "tools.h" #include "stdwin.h" /* Ask a yes/no question. Return value: yes ==> 1, no ==> 0, cancel (^C) ==> -1. Only the first non-blank character of the string typed is checked. The 'deflt' parameter is returned when an empty string is typed. */ int waskync(question, def) char *question; int def; { char buf[100]; char *p= ""; switch (def) { case 1: p= "Yes"; break; case 0: p= "No"; break; } strcpy(buf, p); for (;;) { if (!waskstr(questsmtalk43/stdwin/H/tools.h1006440003270021170000000641105476773612012524 037777777777 1 0 /* Useful includes, definitions etc. */ #include "stdwconf.h" /* Figure out on which system we are */ #include "_ARGS.h" /* Define _ARGS() macro appropriately */ /****************************/ /* Auto-configuration tests */ /****************************/ #ifdef __STDC__ #define VOID_PTR #define HAVE_STDLIB #endif #ifdef THINK_C #ifdef THINK_C_3_0 #define NO_STRING_H #else #define HAVE_STDLIB #endif #endif #ifdef THINK_C #define VOID_PTR #endif #ifdef SYSV #define VOID_PTR #endif /*********************/ /* Universal pointer */ /*********************/ #ifdef VOID_PTR #define UNIVPTR void * #else #define UNIVPTR char * #endif /*************/ /* C library */ /*************/ #include #include #include #ifdef NO_STRING_H /* Systems that don't have should at least have */ #include #else #include #endif #ifdef NO_STRCHR /* Systems that don't have str(r)chr should at least have (r)index */ #define strchr index #define strrchr rindex #endif #ifdef NO_MEMCPY /* Systems that don't have memcpy/memcmp should at least have bcopy/bcmp */ #define memcpy(dest, src, n) bcopy(src, dest, n) #define memcmp(a, b, cnt) bcmp(a, b, cnt) #endif #ifdef THINK_C #ifdef THINK_C_3_0 #include #endif #endif #ifdef HAVE_STDLIB #include #else UNIVPTR malloc _ARGS((size_t)); UNIVPTR calloc _ARGS((size_t, size_t)); UNIVPTR realloc _ARGS((UNIVPTR, size_t)); #ifndef NO_VOID_FREE void free _ARGS((UNIVPTR)); #endif #ifndef NO_VOID_EXIT void exit _ARGS((int)); #endif char *getenv _ARGS((char *)); #endif /* !HAVE_STDLIB */ /* According to the C Standard, errno may be a macro on systems with multiple threads. But on older systems, it may not be declared at all in . So we declare it here, except if it is a macro. */ #ifndef errno extern int errno; #endif /*************************************/ /* Miscellaneous useful declarations */ /*************************************/ /* Interface to getopt(): */ extern int optind; extern char *optarg; int getopt _ARGS((int, char **, char *)); /* Boolean data type: */ #define bool int /* For single variable, argument or return value */ #define tbool char /* Tiny bool, used in structs or arrays */ #define FALSE 0 #define TRUE 1 /* Character shorthands: */ #define EOS '\0' #define EOL '\n' /* Copy string to malloc'ed memory: */ #ifdef _SEQUENT_ char *strdup _ARGS((char *)); #else char *strdup _ARGS((const char *)); #endif /* Other useful macros: */ #define CNTRL(x) ((x) & 0x1f) /* Usage: CNTRL('X') */ #define ABS(x) ((x) < 0 ? -(x) : (x)) #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif #ifndef MAX #define MAX(a, b) ((a) > (b) ? (a) : (b)) #endif #define CLIPMIN(var, min) if ((var) >= (min)) ; else (var)= (min) #define CLIPMAX(var, max) if ((var) <= (max)) ; else (var)= (max) /* Memory allocation macros: */ #define ALLOC(type) ((type*) malloc(sizeof(type))) #define FREE(p) if ((p) != 0) { free((UNIVPTR)p); p = 0; } else /*empty*/ /* Array (re)allocation macros. RESIZE yields nonzero if the realloc succeeded. */ #define NALLOC(type, n) ((type*) malloc((unsigned)(n) * sizeof(type))) #define RESIZE(var, type, n) \ (var= (type *) realloc((UNIVPTR)var, (n) * sizeof(type))) /* Dynamic array macros: */ #include "lists.h" o offer an event to a text-editing block at all; e.g., it might have a different interpretation for the Return key (for which the text-editing package inserts a new-line character in the text string). .PP There are more text-editing calls, e.g. tosmtalk43/stdwin/H/vt.h1006440003270021170000001163305434024331011774 037777777777 1 0 /* Interface for VT (Virtual Terminal windows) package */ /* WARNING: the cursor coordinate system is (row, col) here, like in the ANSI escape sequences. However, the origin is 0, and ranges are given in C style: first, last+1. ANSI escapes (which have origin 1) are translated as soon as they are parsed. */ #define VTNARGS 10 /* Max # args in ansi escape sequence */ /* Structure describing a VT window */ typedef struct _vt { WINDOW *win; /* Window used for display */ char **data; /* Character data array [row][col] */ unsigned char **flags; /* Corresponding flags per character */ short *llen; /* Line length array */ short rows, cols; /* Size of data matrix */ short cwidth, cheight; /* Character cell size */ short cur_row, cur_col; /* Cursor position */ short save_row, save_col; /* Saved cursor position */ short scr_top, scr_bot; /* Scrolling region */ short topterm; /* Top line of emulated terminal */ short toscroll; /* Delayed screen scrolling */ unsigned char gflags; /* Global flags for inserted characters */ /* XXX The following Booleans are stored in characters. This is probably the most efficient way to store them. Since we normally have only one VT window per application, space considerations are not important and we could even use ints if they were faster. */ char insert; /* Insert mode */ char keypadmode; /* Send ESC O A for arrows, not ESC [ A */ char nlcr; /* \n implies \r */ char lazy; /* Delay output operations */ char mitmouse; /* Send ESC [ M on clicks */ char visualbell; /* Blink instead of beep (for ctrl-G) */ char flagschanged; /* Set when certain state flags changed */ char drawing; /* Used by VT{BEGIN,END}DRAWING() macros */ /* State for the ANSI escape sequence interpreter */ char modarg; /* \0: ansi vt100; '?': DEC private mode etc */ char *(*action)(); /* Function to call for next input */ short *nextarg; /* Points to current arg */ short args[VTNARGS]; /* Argument list */ /* State for the selected region */ short sel_row1, sel_col1; /* Start of selected region, <0 if nothing */ short sel_row2, sel_col2; /* End of selected region */ /* XXX There ought to be an array of tab stops somewhere... */ } VT; /* Flags in gflags and flags array. These correspond to the ANSI codes used in ESC [ ... m. Not all are implemented! */ #define VT_BOLD (1 << 1) #define VT_DIM (1 << 2) #define VT_UNDERLINE (1 << 4) #define VT_BLINK (1 << 5) #define VT_INVERSE (1 << 7) #define VT_SELECTED (1 << 3) /* <- This one does NOT correspond */ /* Access macros */ #define vtcheight(vt) ((vt)->cheight) #define vtcwidth(vt) ((vt)->cwidth) #define vtwindow(vt) ((vt)->win) #define vtsetnlcr(vt, new_nlcr) ((vt)->nlcr = (new_nlcr)) #define vtsetlazy(vt, new_lazy) ((vt)->lazy= (new_lazy)) #define vtsetflags(vt, new_flags) ((vt)->gflags= (new_flags)) #define vtsetinsert(vt, new_insert) ((vt)->insert= (new_insert)) /* Basic functions (vt.c) */ VT *vtopen _ARGS((char *title, int rows, int cols, int save)); void vtclose _ARGS((VT *vt)); void vtputstring _ARGS((VT *vt, char *text, int len)); void vtsetcursor _ARGS((VT *vt, int row, int col)); void vtreset _ARGS((VT *vt)); VT *vtfind _ARGS((WINDOW *win)); /* Optional functions (vtansi.c, vtputs.c, vtresize.c) */ void vtansiputs _ARGS((VT *vt, char *text, int len)); void vtputs _ARGS((VT *vt, char *text)); /*bool*/int vtresize _ARGS((VT *vt, int rows, int cols, int save)); /*bool*/int vtautosize _ARGS((VT *vt)); /* Functions used by the ANSI interface (vtfunc.c) */ void vtresetattr _ARGS((VT *vt)); void vtsetattr _ARGS((VT *vt, int bit)); void vtsavecursor _ARGS((VT *vt)); void vtrestorecursor _ARGS((VT *vt)); void vtarrow _ARGS((VT *vt, int code, int repeat)); void vteolclear _ARGS((VT *vt, int row, int col)); void vteosclear _ARGS((VT *vt, int row, int col)); void vtlinefeed _ARGS((VT *vt, int repeat)); void vtrevlinefeed _ARGS((VT *vt, int repeat)); void vtinslines _ARGS((VT *vt, int n)); void vtdellines _ARGS((VT *vt, int n)); void vtscrollup _ARGS((VT *vt, int r1, int r2, int n)); void vtscrolldown _ARGS((VT *vt, int r1, int r2, int n)); void vtinschars _ARGS((VT *vt, int n)); void vtdelchars _ARGS((VT *vt, int n)); void vtsetscroll _ARGS((VT *vt, int top, int bot)); void vtsendid _ARGS((VT *vt)); void vtsendpos _ARGS((VT *vt)); /* Selection interface (vtselect.c) */ /* XXX This will change */ int vtselect _ARGS((VT *vt, EVENT *ep)); int vtextendselection _ARGS((VT *vt, EVENT *ep)); /* Macros to avoid too many wbegindrawing calls */ #define VTBEGINDRAWING(vt) \ if (!(vt)->drawing) { wbegindrawing((vt)->win); (vt)->drawing= 1; } #define VTENDDRAWING(vt) \ if ((vt)->drawing) { wenddrawing((vt)->win); (vt)->drawing = 0; } /* Note -- the main application *MUST* call VTENDDRAWING(vt) before it calls wgetevent(). */ #ifndef NDEBUG /* Panic function. The caller may provide one. The library has a default. */ void vtpanic _ARGS((char *)); #endif /* NDEBUG */ smtalk43/stdwin/H/vtrm.h1006440003270021170000000145105434024332012331 037777777777 1 0 /* * Terminal capabilities. These correspond to bits set by trmstart in its * parameter flags parameter. */ #define HAS_STANDOUT 1 /* Terminal has inverse video or underline */ #define CAN_SCROLL 2 /* Terminal can insert/delete lines */ #define CAN_OPTIMISE 4 /* Terminal can insert/delete characters */ #define CAN_SENSE 8 /* Terminal can send cursor position */ /* * Error codes returned by trmstart. */ #define TE_OK 0 /* No errors */ #define TE_TWICE 1 /* Trmstart called again */ #define TE_NOTERM 2 /* $TERM not set or empty */ #define TE_BADTERM 3 /* $TERM not found in termcap database */ #define TE_DUMB 4 /* Terminal too dumb */ #define TE_NOTTY 5 /* Stdout not a tty device */ #define TE_NOMEM 6 /* Can't get enough memory */ #define TE_OTHER 7 /* This and higher are reserved errors */ wmin= wguess; } } #ifdef TEXT_NOT_ADDITIVE /* Initially, min==max. See if min should be smaller. */ while (min > 0 && wtextwidth(str, min) > width) { --min; } if (min == max) { /* Previous loop didnsmtalk43/stdwin/H/vtserial.h1006440003270021170000000102405434024332013166 037777777777 1 0 /* Definitions for serial interface */ /* Public interface to the serial line drivers (which have a machine-dependent implementation but a common interface) */ bool openserial _ARGS((void)); bool closeserial _ARGS((void)); bool sendserial _ARGS((char *buf, int len)); /* Blocking write */ int receiveserial _ARGS((char *buf, int len)); /* Non-blocking read */ bool breakserial _ARGS((void)); bool speedserial _ARGS((int baudrate)); /* Pseudo event reported when input from serial line available */ #define WE_SERIAL_AVAIL 42 [-.h] $* CORE=waskfile waskync wdrawpar wperror wsetclip wsetcutbuffer wsetselection wstyle wtextbreak all: $(CORE).obj When a client wants to become owner of a particular selection, it tells the server so, and the server will send the previous owner an event to tell it that it no longer owns the selection. .PP The protocol to transfer the contents of a selection between clients is fairly involved. Somewhat simplified, it works as follows: .IP \(bu A client requests the contents of a selsmtalk43/stdwin/H/winreq.h1006440003270021170000000575405434024332012660 037777777777 1 0 /* STDWIN Server -- Window (Manager) Requests. */ /* Command codes in transaction header. */ #define WIN_FIRST 1100 #define WIN_HELLO (WIN_FIRST+1) /* Say hello to server */ #define WIN_DROPDEAD (WIN_FIRST+2) /* Die, if idle */ #define WIN_OPEN (WIN_FIRST+3) /* Open new window */ #define WIN_CLOSE (WIN_FIRST+4) /* Close window */ #define WIN_DRAW (WIN_FIRST+5) /* Drawing commands; see subcodes */ #define WIN_GETEVENT (WIN_FIRST+6) /* Get event */ #define WIN_FLEEP (WIN_FIRST+7) /* Flash or beep */ #define WIN_ACTIVATE (WIN_FIRST+8) /* Make window active */ #define WIN_SETDOCSIZE (WIN_FIRST+9) /* Set document size */ #define WIN_SETTITLE (WIN_FIRST+10) /* Set window title */ #define WIN_SHOW (WIN_FIRST+11) /* Show part of document */ #define WIN_SETORIGIN (WIN_FIRST+12) /* Set window origin in document */ #define WIN_CHANGE (WIN_FIRST+13) /* Change part of document */ #define WIN_SCROLL (WIN_FIRST+14) /* Scroll part of document */ #define WIN_MESSAGE (WIN_FIRST+15) /* Output message */ #define WIN_ASKSTR (WIN_FIRST+16) /* Ask string */ #define WIN_ASKYNC (WIN_FIRST+17) /* Ask yes/no/cancel question */ #define WIN_SETCARET (WIN_FIRST+18) /* Set caret position */ #define WIN_STATUS (WIN_FIRST+19) /* Get window status */ #define WIN_GETFONTTAB (WIN_FIRST+20) /* Get font width table */ #define WIN_SETTIMER (WIN_FIRST+21) /* Set window timer */ #define WIN_SETCLIP (WIN_FIRST+22) /* Set clipboard string */ #define WIN_GETCLIP (WIN_FIRST+23) /* Get clipboard string */ #define WIN_POLLEVENT (WIN_FIRST+24) /* Poll for event */ #define MENU_FIRST (WIN_FIRST+50) #define MENU_CREATE (MENU_FIRST+1) #define MENU_DELETE (MENU_FIRST+2) #define MENU_ADDITEM (MENU_FIRST+3) #define MENU_SETITEM (MENU_FIRST+4) #define MENU_ATTACH (MENU_FIRST+5) #define MENU_DETACH (MENU_FIRST+6) #define MENU_ENABLE (MENU_FIRST+7) #define MENU_CHECK (MENU_FIRST+8) /* Subcodes in data buffer for WIN_DRAW. */ #define DRW_LINE 1 #define DRW_BOX 2 #define DRW_CIRCLE 3 #define DRW_ERASE 4 #define DRW_PAINT 5 #define DRW_SHADE 6 #define DRW_INVERT 7 #define DRW_TEXT 8 #define DRW_FONT 9 #define DRW_STYLE 10 #define DRW_ELARC 11 #define DRW_XORLINE 12 /* Error codes for h_status. */ #define WER_OK 0 /* ok */ #define WER_FAIL -101 /* don't know why it failed */ #define WER_COMBAD -102 /* bad command */ #define WER_CAPBAD -103 /* bad capability */ #define WER_NOSPACE -104 /* no space left */ #define WER_ABORT -105 /* call aborted */ #define WER_NODATA -106 /* No or insufficient data provided */ /* Event packing parameters. (This is a kludge! Should be variable-length and have a length byte in the data!) */ #define EVSHORTS 7 #define EVPACKSIZE (EVSHORTS * sizeof(short)) /* Server's buffer size. */ #define SVRBUFSIZE 4096 /* I suppose this should really be negotiated between server and client, e.g., WIN_HELLO should return the server's buffer size. */ /* Font width table length. */ #define FONTTABLEN 256 /* Number of chars in a font */ /* Pseudo-event sent when SIGAMOEBA received */ #define WE_ALERT 22 ewsavecopy _ARGS((Esmtalk43/stdwin/Packs/0407550003270021170000000000005477556104011251 5 0 1 0 smtalk43/stdwin/Packs/textedit/0407550003270021170000000000005477556103013102 5 0 1 0 smtalk43/stdwin/Packs/textedit/editwin.c1006440003270021170000001661205465303020015506 037777777777 1 0 /* Edit Windows */ /* The data structure exported by this module is intended to be accessible to the caller; the routines provided here don't duplicate operations that can be done by calling text-edit or window routines directly. Exception: ewreplace is like tereplace, but also clears the 'saved' flag and sets the document size */ #include "stdwin.h" #include "tools.h" #include "editwin.h" extern long ftell _ARGS((FILE *)); #define MAXFN 256 /* File name length */ static int ewnum; static EDITWIN **ewlist; EDITWIN * ewfind(win) WINDOW *win; { int i; if (win == NULL) return NULL; i= wgettag(win); if (i >= 0 && i < ewnum && ewlist[i] != NULL && ewlist[i]->win == win) return ewlist[i]; else return NULL; } int ewcount() { int count= 0; int i; for (i= 0; i < ewnum; ++i) { if (ewlist[i] != NULL) ++count; } return count; } static void ewdrawproc(win, left, top, right, bottom) WINDOW *win; { EDITWIN *ew= ewfind(win); if (ew != NULL) tedrawnew(ew->tp, left, top, right, bottom); } EDITWIN * ewcreate(filename) char *filename; { EDITWIN *ew= ALLOC(EDITWIN); int width, height; int i; if (ew == NULL) return NULL; ew->win= wopen(filename==NULL ? "Untitled" : filename, ewdrawproc); if (ew->win == NULL) { FREE(ew); return NULL; } wsetwincursor(ew->win, wfetchcursor("ibeam")); wgetwinsize(ew->win, &width, &height); ew->tp= tecreate(ew->win, 0, 0, width, height); if (ew->tp == NULL) { wclose(ew->win); FREE(ew); return NULL; } if (filename != NULL) { if (!ewreadfile(ew, filename)) { tefree(ew->tp); wclose(ew->win); FREE(ew); return NULL; } } ew->filename= strdup(filename); ew->saved= TRUE; for (i= 0; i < ewnum; ++i) { if (ewlist[i] == NULL) break; } wsettag(ew->win, i); if (i >= ewnum) { L_APPEND(ewnum, ewlist, EDITWIN*, NULL); } ewlist[i]= ew; return ew; } EDITWIN * ewnew() { return ewcreate((char*)NULL); } EDITWIN * ewopen() { char filename[MAXFN]; filename[0]= EOS; if (waskfile("Open file:", filename, sizeof filename, FALSE)) return ewcreate(filename); else return NULL; } bool ewclose(ew) EDITWIN *ew; { int i; if (!ew->saved) { char buf[MAXFN+25]; sprintf(buf, "Save changes to \"%s\" before closing?", ew->filename==NULL ? "Untitled" : ew->filename); switch (waskync(buf, 1)) { case -1: return FALSE; case 0: break; case 1: if (!ewsave(ew)) return FALSE; break; } } i= wgettag(ew->win); if (i >= 0 && i < ewnum && ewlist[i] == ew) ewlist[i]= NULL; tefree(ew->tp); wclose(ew->win); FREE(ew->filename); FREE(ew); return TRUE; } bool ewsave(ew) EDITWIN *ew; { if (ew->saved) return TRUE; if (!ew->filename) return ewsaveas(ew); return ew->saved= ewwritefile(ew, ew->filename); } bool ewsaveas(ew) EDITWIN *ew; { return ewsaveprompt(ew, "Save as:", TRUE); } bool ewsavecopy(ew) EDITWIN *ew; { return ewsaveprompt(ew, "Save a copy as:", FALSE); } bool ewsaveprompt(ew, prompt, changefile) EDITWIN *ew; char *prompt; bool changefile; { char filename[MAXFN]; filename[0]= EOS; if (ew->filename != NULL) { strncpy(filename, ew->filename, MAXFN); filename[MAXFN-1]= EOS; } if (!waskfile(prompt, filename, sizeof filename, TRUE)) return FALSE; if (!ewwritefile(ew, filename)) return FALSE; if (changefile) { FREE(ew->filename); ew->filename= strdup(filename); wsettitle(ew->win, filename); ew->saved= TRUE; } return TRUE; } bool ewrevert(ew) EDITWIN *ew; { char buf[MAXFN+50]; if (ew->saved) return TRUE; if (ew->filename == NULL) { wmessage("Not saved yet"); return FALSE; } sprintf(buf, "Discard changes since last save to \"%s\" ?", ew->filename); if (waskync(buf, 1) < 1) return FALSE; return ewreadfile(ew, ew->filename); } bool ewreadfile(ew, filename) EDITWIN *ew; char *filename; { FILE *fp= fopen(filename, "r"); long size; char *buf; if (fp == NULL) { wperror(filename); return FALSE; } if (fseek(fp, 0L, 2) == -1) { wperror (filename); fclose (fp); return FALSE; } size= ftell(fp); if (size >= 1L<<15) { char mbuf[MAXFN + 50]; sprintf(mbuf, "File \"%s\" is big (%d K). Still edit?", filename, (int) ((size+1023)/1024)); if (waskync(mbuf, 1) < 1) { fclose(fp); return FALSE; } } buf= malloc((unsigned)size); if (buf == NULL) { wmessage("Can't get memory for buffer"); fclose(fp); return FALSE; } if (fseek(fp, 0L, 0) == -1) { wperror (filename); fclose (fp); return FALSE; } if ((size = fread(buf, 1, (int) size, fp)) == -1) { wmessage("Read error"); fclose(fp); return FALSE; } fclose(fp); tesetbuf(ew->tp, buf, (int) size); /* Gives the buffer away! */ ew->saved= TRUE; ewsetdimensions(ew); return TRUE; } void ewsetdimensions(ew) EDITWIN *ew; { wsetdocsize(ew->win, 0, tegetbottom(ew->tp)); } bool ewwritefile(ew, filename) EDITWIN *ew; char *filename; { FILE *fp= fopen(filename, "w"); char *buf; int len, nwritten; if (fp == NULL) { wperror(filename); return FALSE; } buf= tegettext(ew->tp); len= strlen(buf); nwritten= fwrite(buf, 1, len, fp); fclose(fp); if (nwritten != len) { wmessage("Write error"); return FALSE; } /* Can't set saved to TRUE, because of 'save a copy' */ return TRUE; } bool ewevent(ew, e, closed_return) EDITWIN *ew; EVENT *e; bool *closed_return; { bool closed= FALSE; bool change= FALSE; if (ew == NULL) { ew= ewfind(e->window); if (ew == NULL) return FALSE; } else if (e->window != ew->win) return FALSE; switch (e->type) { case WE_ACTIVATE: break; case WE_SIZE: { int width, height; wgetwinsize(ew->win, &width, &height); temovenew(ew->tp, 0, 0, width, height); ewsetdimensions(ew); } break; case WE_COMMAND: if (e->u.command == WC_CLOSE) { closed= ewclose(ew); break; } /* Else, fall through */ if (e->u.command == WC_RETURN || e->u.command == WC_TAB || e->u.command == WC_BACKSPACE) change= TRUE; goto def; case WE_MOUSE_DOWN: /* Edit the coordinates slightly so teevent always believes it is in the rect */ { int left= tegetleft(ew->tp); int right= tegetright(ew->tp); int top= tegettop(ew->tp); int bottom= tegetbottom(ew->tp); CLIPMIN(e->u.where.h, left); CLIPMAX(e->u.where.h, right); CLIPMIN(e->u.where.v, top); if (e->u.where.v >= bottom) { e->u.where.v= bottom; e->u.where.h= right; } } /* Fall through */ default: def: if (!teevent(ew->tp, e)) return FALSE; if (e->type == WE_CHAR) change= TRUE; if (change) { ew->saved= FALSE; ewsetdimensions(ew); } break; } if (closed_return != NULL) *closed_return= closed; return TRUE; } bool ewsaveall() { int i; for (i= 0; i < ewnum; ++i) { if (ewlist[i] != NULL && !ewsave(ewlist[i])) return FALSE; } return TRUE; } bool ewcloseall() { int i; for (i= 0; i < ewnum; ++i) { if (ewlist[i] != NULL && !ewclose(ewlist[i])) return FALSE; } return TRUE; } void ewreplace(ew, str) EDITWIN *ew; char *str; { if (*str == EOS && tegetfoc1(ew->tp) == tegetfoc2(ew->tp)) return; tereplace(ew->tp, str); ew->saved= FALSE; ewsetdimensions(ew); } /*ARGSUSED*/ void ewundo(ew) EDITWIN *ew; { wfleep(); } void ewcopy(ew) EDITWIN *ew; { int f1= tegetfoc1(ew->tp); int f2= tegetfoc2(ew->tp); char *text; if (f1 == f2) wfleep(); else { text= tegettext(ew->tp); wsetclip(text+f1, f2-f1); } } void ewpaste(ew) EDITWIN *ew; { char *text= wgetclip(); if (text == NULL) wfleep(); else ewreplace(ew, text); } smtalk43/stdwin/Packs/textedit/text.h1006440003270021170000001005205434024333015027 037777777777 1 0 /* Text Edit, definitions */ /* Include header files */ #include "stdwin.h" /* Window interface */ #include "tools.h" /* Lots of useful goodies */ #ifndef LSC #define NDEBUG /* Turn off all debugging code */ #endif #define RESERVE 256 /* Increment for gap growth */ #define STARTINCR 20 /* Increment for start array growth; must be >= 1 */ /* Typedefs (for documentation only) */ typedef int focpos; /* Logical offset (not affected by gap) */ typedef int bufpos; /* Buffer offset (taking gap into account) */ typedef int lineno; /* Index into start array */ typedef int coord; /* Used to declare pairs of coordinates */ typedef coord hcoord; /* Hor. coordinate */ typedef coord vcoord; /* Ver. coordinate */ struct _textedit { /* Drawing environment */ WINDOW *win; coord left, top, right, bottom; hcoord width; /* == right-left */ TEXTATTR attr; /* Text attributes */ vcoord vspace; /* Vertical spacing (line height) */ hcoord tabsize; /* Spacing of horizontal tabs */ /* Text and focus representation */ char *buf; /* Text buffer */ bufpos buflen; /* Size of buffer */ bufpos gap; /* Start of gap */ int gaplen; /* Gap length */ focpos foc; /* Text selection focus start */ int foclen; /* Focus length */ bufpos *start; /* Array of screen line starts */ lineno nlines; /* Number of lines */ lineno nstart; /* Number of elements of start (must be > nlines) */ hcoord aim; /* Where vertical arrows should (try to) go */ focpos anchor; /* Anchor position of focus drag */ focpos anchor2; /* Other end of anchor */ tbool focprev; /* Set if foc between lines belongs to prev line */ tbool hilite; /* Set if focus area shown inverted */ tbool mdown; /* Set if mouse down */ tbool dclick; /* Set if mouse down in double click */ tbool drawing; /* FALSE if no window operations */ tbool active; /* FALSE to inhibit highlighting and caret */ /* To optimize single char inserts */ tbool opt_valid; /* Set if following data is valid */ tbool opt_in_first_word;/* Focus is in first word of line */ lineno opt_i; /* Line where focus is */ coord opt_h, opt_v; /* Caret position in window */ hcoord opt_avail; /* White pixels at end of line */ hcoord opt_end; /* End of line or next tab stop */ /* NB: aim, opt_h, opt_v are in window coordinates, i.e., tp->left or tp->top has already been added */ }; /* Constants */ #define UNDEF (-1) /* Undefined value, e.g., for aim */ /* NB: All macros below use a variable 'tp' pointing to the textedit struct */ /* Shorthands */ #define zfocend (tp->foc+tp->foclen) #define zgapend (tp->gap+tp->gaplen) /* Transformations between focpos and bufpos values */ #define zaddgap(f) ((f) < tp->gap ? (f) : (f)+tp->gaplen) #define zsubgap(pos) ((pos) <= tp->gap ? (pos) : \ (pos) <= zgapend ? tp->gap : (pos)-tp->gaplen) /* ++ and -- operators for bufpos variables */ #define zincr(p) (++*(p) == tp->gap ? (*(p) += tp->gaplen) : *(p)) #define zdecr(p) (*(p) == zgapend ? (*(p) = tp->gap - 1) : --*(p)) /* +1 and -1 operators for same */ #define znext(p) ((p) == tp->gap-1 ? zgapend : (p)+1) #define zprev(p) ((p) == zgapend ? (tp->gap-1) : (p)-1) /* Access characters at/before positions */ #define zcharat(p) (tp->buf[p]) #define zcharbefore(p) (tp->buf[zprev(p)]) /* Tab stop calculation */ #define znexttab(w) ((((w)+tp->tabsize) / tp->tabsize) * tp->tabsize) /* Functions that don't return int */ TEXTEDIT *tesetup(); char *zmalloc(); char *zrealloc(); /* Debugging help */ #ifndef NDEBUG #ifndef __LINE__ #define __LINE__ 0 #endif /* General assertion (NB: type command-period to dprintf to halt) */ #define zassert(n) ((n) || dprintf("line %d: zassert(n) failed", __LINE__)) /* Check the validity of a buffer offset */ #define zcheckpos(p) \ ((p)>=0 && (p)<=tp->buflen && ((p)gap || (p)>=zgapend) || \ dprintf("line %d: zcheckpos(p=%d) buf[%d] gap=%d+%d", \ __LINE__, p, tp->buflen, tp->gap, tp->gaplen)) /* Sanity checking routine for entire state */ #define zcheck() techeck(tp, __LINE__) #else /* NDEBUG */ #define zassert(n) /*empty*/ #define zcheckpos(pos) /*empty*/ #define zcheck() /*empty*/ #endif /* NDEBUG */ re anymore that this is the right thing to do!) */ struct _textattr { short font; unsigned char size; unsigned char style; }; #define TEXTATTR struct _textattr /*************************************/ /* Section 2. Function declarations */ /*************************************/ void wargs _ARGS((int *pargc, char ***pargv)); void winit _ARGS((void)); void winitargs _ARGS((int *pargc, char ***pargv)); void wdone _ARGS((void)); void wgetscrsize _ARGS((int *psmtalk43/stdwin/Packs/textedit/textdbg.c1006440003270021170000000425205465303020015501 037777777777 1 0 /* Text Edit, debugging code */ #include "text.h" #ifndef macintosh /*VARARGS1*/ dprintf(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) char *fmt; { printf("\r\n"); printf(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); printf("\r\n"); } #endif #ifndef NDEBUG /* Check the world's consistency */ techeck(tp, line) TEXTEDIT *tp; int line; { lineno i; #define zck(n) ((n) || dprintf("zck(n) line %d", line)) zck(tp->nlines >= 1); zck(tp->start[0] == zaddgap(0)); zck(tp->start[tp->nlines] == tp->buflen); zck(0 <= tp->gap); zck(0 <= tp->gaplen); zck(zgapend <= tp->buflen); zck(0 <= tp->foc); zck(0 <= tp->foclen); zck(zfocend <= tp->buflen-tp->gaplen); for (i= 0; i < tp->nlines; ++i) { if (i < tp->nlines-1) { zck(tp->start[i] < tp->start[i+1]); } else { zck(tp->start[i] <= tp->start[tp->nlines]); } zck(tp->start[i] < tp->gap || zgapend <= tp->start[i]); } #undef zck } #if 0 /* Dump the world's state to the screen (call from drawproc) */ zdebug(left, top, right, bottom) { int h, v; int i, j; h= 0, v= 15*wlh; if (v >= bottom) return; zprintf(h, v, "buflen=%d nlines=%d foc=%d foclen=%d gap=%d gaplen=%d.", buflen, nlines, foc, foclen, gap, gaplen); h= 0, v += wlh; if (v >= bottom) return; for (i= 0; i <= nlines; ++i) { h= zprintf(h, v, "%d:%d ", i, start[i]); } h= 0, v += wlh; if (v >= bottom) return; for (i= 0; i <= buflen; ++i) { h= zprintf(h, v, "%c", i == zaddgap(foc) ? (foclen == 0 ? '|' : '[') : (i == zaddgap(focend) ? ']' : ' ')); if (i >= buflen) break; if (i >= gap && i < gapend) h= zprintf(h, v, "**"); else h= zprintf(h, v, "%02x", buf[i] & 0xff); } h= 0, v += wlh; if (v >= bottom) return; for (i= 0; i <= buflen; ++i) { for (j= 0; j <= nlines; ++j) if (i == start[j]) break; if (j <= nlines) h= zprintf(h, v, "%-3d", j); else h= zprintf(h, v, " "); } } /* Printf into the window (could be of general use). NB: doesn't recognize \n */ static zprintf(h, v, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) int h, v; char *fmt; { char buf[256]; sprintf(buf, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); return wdrawtext(h, v, buf, -1); } #endif #endif /* !NDEBUG */ nt v2)); void wdrawcircle _ARGS((int h, int v, int radius)); void wdrawelarc _ARGS((int h, int v, int hrad, int vrad, int ang1, int ang2)); void wdrawbox _ARGS((int left, int top, int right, int bottom)); #ifdef VMS void wblank _ARGS((int left, int top, int right, int bottom)); #else void werase _ARGS((int left, int top, int right, int bottsmtalk43/stdwin/Packs/textedit/textedit.c1006440003270021170000003504305465303020015674 037777777777 1 0 /* Text Edit, high level routines */ #include "text.h" void tereplace(tp, str) TEXTEDIT *tp; char *str; { int len= strlen(str); if (len == 1 && teoptinschar(tp, (int) str[0])) return; teinsert(tp, str, len); } static teinschar(tp, c) TEXTEDIT *tp; int c; { char cbuf[2]; if (teoptinschar(tp, c)) return; cbuf[0]= c; cbuf[1]= EOS; teinsert(tp, cbuf, 1); } /* Optimization for the common case insert char. Assumes text measurement is additive. */ static tesetoptdata(tp) TEXTEDIT *tp; { lineno i; bufpos k, pos, end; zcheck(); zassert(tp->foclen == 0); pos= zaddgap(tp->foc); tp->opt_i= i= tewhichline(tp, pos, FALSE); tp->opt_h= tp->left + tetextwidth(tp, tp->start[i], pos); tp->opt_v= tp->top + i*tp->vspace; end= tp->start[i+1]; if (end > pos && zcharbefore(end) == EOL) zdecr(&end); while (end > pos && zcharbefore(end) == ' ') zdecr(&end); for (k= pos; k < end; zincr(&k)) { if (zcharat(k) == '\t') break; } if (k < end) { tp->opt_end= tp->left + tetextwidth(tp, tp->start[i], znext(k)); tp->opt_avail= tp->opt_end - (tp->left + tetextwidth(tp, tp->start[i], k)); } else { tp->opt_end= tp->right; tp->opt_avail= tp->width - tetextwidth(tp, tp->start[i], end); } if (tp->start[i] > 0 && zcharbefore(tp->start[i]) != EOL) { tp->opt_in_first_word= TRUE; for (k= tp->start[i]; k < pos; zincr(&k)) { if (isspace(zcharat(k))) { tp->opt_in_first_word= FALSE; break; } } } else tp->opt_in_first_word= FALSE; tp->opt_valid= TRUE; } static bool teoptinschar(tp, c) TEXTEDIT *tp; int c; { int w; if (tp->foclen != 0 || c == EOL || c == '\t' || tp->focprev) return FALSE; if (!tp->opt_valid) tesetoptdata(tp); if (c == ' ' && tp->opt_in_first_word) return FALSE; w= wcharwidth(c); if (w >= tp->opt_avail) return FALSE; temovegapto(tp, tp->foc); if (tp->gaplen < 1) tegrowgapby(tp, 1+RESERVE); if (tp->start[tp->opt_i] == zgapend) tp->start[tp->opt_i]= tp->gap; ++tp->gap; --tp->gaplen; tp->buf[tp->foc]= c; ++tp->foc; tp->opt_avail -= w; if (tp->active) wnocaret(tp->win); wscroll(tp->win, tp->opt_h, tp->opt_v, tp->opt_end, tp->opt_v + tp->vspace, w, 0); wbegindrawing(tp->win); wdrawchar(tp->opt_h, tp->opt_v, c); wenddrawing(tp->win); tp->opt_h += w; if (tp->active) { wsetcaret(tp->win, tp->opt_h, tp->opt_v); wshow(tp->win, tp->opt_h, tp->opt_v, tp->opt_h, tp->opt_v + tp->vspace); } tp->aim= tp->opt_h; return TRUE; } static teinsert(tp, str, len) TEXTEDIT *tp; char *str; int len; { focpos oldfoc= tp->foc; tehidefocus(tp); temovegapto(tp, zfocend); tp->gap= tp->foc; tp->gaplen += tp->foclen; teemptygap(tp); tp->foclen= 0; if (tp->gaplen < len) tegrowgapby(tp, len-tp->gaplen+RESERVE); strncpy(tp->buf+tp->gap, str, len); tp->gap += len; tp->gaplen -= len; tp->foc += len; /* Added to prevent displaying caret during line adds and scrolls */ /* Tom McCune*/ wnocaret(tp->win); terecompute(tp, zaddgap(oldfoc), zaddgap(tp->foc)); if(str[0] == '\n' && len == 1){ return; } else { wbegindrawing(tp->win); wdrawtext(tp->left,(tp->nlines-1)*tp->vspace,str,len); wenddrawing(tp->win); return; } } static int lasteol; /* Optimization trick for teendofline */ static terecompute(tp, first, last) TEXTEDIT *tp; int first, last; { lineno i; lineno chfirst, chlast; /* Area to pass to wchange */ lineno shift= 0; /* Lines to shift down (negative: up) */ vcoord newbottom; tp->start[0]= zaddgap(0); i= 2; while (i <= tp->nlines && tp->start[i] < first) ++i; i -= 2; chfirst= tp->nlines; chlast= i; lasteol= -1; /* TO DO: scroll up/down if inserting/deleting lines */ for (;; ++i) { bufpos end= teendofline(tp, tp->start[i]); bool unchanged= (i < tp->nlines && end == tp->start[i+1]); if (!unchanged) shift += tesetstart(tp, i+1, end, last); if (!(unchanged && end < first)) { if (i < chfirst) chfirst= i; chlast= i+1; } if (end >= tp->buflen) { if (end > tp->start[i] && zcharbefore(end) == EOL) continue; else break; } if (unchanged && end > last) { i= tp->nlines-1; break; } } zassert(tp->nlines > i); wsetdocsize(tp->win,tp->right-tp->left,tp->nlines*tp->vspace); if (tp->drawing) { if (shift != 0) { lineno k= chlast; if (shift > 0) k -= shift; wscroll(tp->win, tp->left, tp->top + k*tp->vspace, tp->right, tp->top + tp->nlines*tp->vspace, 0, shift*tp->vspace); } wchange(tp->win, tp->left, tp->top + chfirst*tp->vspace, tp->right, tp->top + chlast*tp->vspace); } tp->nlines= i+1; newbottom= tp->top + tp->vspace*tp->nlines; if (newbottom < tp->bottom) wchange(tp->win, tp->left, newbottom, tp->right, tp->bottom); tp->bottom= newbottom; tp->aim= UNDEF; tp->focprev= FALSE; if (tp->drawing) tesetcaret(tp); zcheck(); } static int tesetstart(tp, i, pos, last) register TEXTEDIT *tp; register lineno i; bufpos pos, last; { if (i > tp->nlines) { tp->nlines= i; if (tp->nlines >= tp->nstart) { tp->nstart= tp->nlines + STARTINCR; tp->start= (bufpos*)zrealloc((char*)tp->start, tp->nstart*sizeof(int)); } tp->start[i]= pos; return 0; } else { lineno shift= 0; lineno k; for (k= i; k < tp->nlines; ++k) { if (tp->start[k] > pos) break; } shift= k-1 - i; /* start[k] should really be start[i+1] */ if (shift < 0 && tp->start[k] >= last) { /* Insert one */ ++tp->nlines; if (tp->nlines >= tp->nstart) { tp->nstart= tp->nlines + STARTINCR; tp->start= (int*)zrealloc((char*)tp->start, tp->nstart*sizeof(int)); } for (k= tp->nlines; k > i; --k) tp->start[k]= tp->start[k-1]; } else if (shift > 0 && pos >= last) { /* Delete some */ for (; k <= tp->nlines; ++k) tp->start[k-shift]= tp->start[k]; tp->nlines -= shift; if (tp->nlines < tp->nstart - STARTINCR) { tp->nstart= tp->nlines+1; tp->start= (int*)zrealloc((char*)tp->start, tp->nstart*sizeof(int)); } } else shift= 0; /* Don't shift (yet) */ tp->start[i]= pos; return -shift; } } static int teendofline(tp, pos) TEXTEDIT *tp; bufpos pos; { bufpos end= tp->buflen; bufpos k; /* Find first EOL if any */ if (lasteol >= pos) k= lasteol; else { for (k= pos; k < end && zcharat(k) != EOL; zincr(&k)) ; lasteol= k; } end= tetextbreak(tp, pos, k, tp->width); /* Extend with any spaces immediately following end */ for (; end < tp->buflen && zcharat(end) == ' '; zincr(&end)) ; if (end < tp->buflen) { /* Extend with immediately following EOL */ if (zcharat(end) == EOL) zincr(&end); else { /* Search back for space before last word */ for (k= end; zdecr(&k) >= pos && !isspace(zcharat(k)); ) ; if (k >= pos) end= znext(k); } } /* Each line must be at least one character long, otherwise a very narrow text-edit box would cause the size calculation to last forever */ if (end == pos && end < tp->buflen) zincr(&end); return end; } bool teevent(tp, e) TEXTEDIT *tp; EVENT *e; { if (e->window != tp->win) return FALSE; switch (e->type) { case WE_CHAR: teinschar(tp, e->u.character); break; case WE_COMMAND: switch (e->u.command) { case WC_BACKSPACE: tebackspace(tp); break; case WC_RETURN: teinschar(tp, EOL); break; case WC_TAB: teinschar(tp, '\t'); break; case WC_LEFT: case WC_RIGHT: case WC_UP: case WC_DOWN: tearrow(tp, e->u.command); break; default: return FALSE; } break; case WE_MOUSE_DOWN: { int h= e->u.where.h, v= e->u.where.v; if (h >= tp->left && h <= tp->right && v >= tp->top && v <= tp->bottom) teclicknew(tp, h, v, e->u.where.button == 2, e->u.where.clicks > 1); else return FALSE; } break; case WE_MOUSE_MOVE: case WE_MOUSE_UP: if (!tp->mdown) return FALSE; teclicknew(tp, e->u.where.h, e->u.where.v, TRUE, tp->dclick); if (e->type == WE_MOUSE_UP) tp->mdown= FALSE; break; case WE_DRAW: wbegindrawing(tp->win); tedrawnew(tp, e->u.area.left, e->u.area.top, e->u.area.right, e->u.area.bottom); wenddrawing(tp->win); break; default: return FALSE; } /* If broke out of switch: */ return TRUE; } void tearrow(tp, code) TEXTEDIT *tp; int code; { lineno i; bufpos pos; tehidefocus(tp); switch (code) { case WC_LEFT: if (tp->foclen != 0) tp->foclen= 0; else { if (tp->foc > 0) --tp->foc; else wfleep(); } tp->aim= UNDEF; tp->focprev= FALSE; break; case WC_RIGHT: if (tp->foclen != 0) { tp->foc += tp->foclen; tp->foclen= 0; } else { if (tp->foc < tp->buflen-tp->gaplen) ++tp->foc; else wfleep(); } tp->aim= UNDEF; tp->focprev= FALSE; break; /* TO DO: merge the following two cases */ case WC_UP: if (tp->foclen > 0) tp->foclen= 0; else { pos= zaddgap(tp->foc); i= tewhichline(tp, pos, (bool) tp->focprev); if (i <= 0) wfleep(); else { if (tp->aim == UNDEF) tp->aim= tp->left + tetextwidth(tp, tp->start[i], pos); --i; pos= tetextround(tp, i, tp->aim); tp->foc= zsubgap(pos); tp->focprev= (pos == tp->start[i+1]); } } break; case WC_DOWN: if (tp->foclen > 0) { tp->foc += tp->foclen; tp->foclen= 0; } else { pos= zaddgap(tp->foc); i= tewhichline(tp, pos, (bool) tp->focprev); if (i+1 >= tp->nlines) wfleep(); else { if (tp->aim == UNDEF) tp->aim= tp->left + tetextwidth(tp, tp->start[i], pos); ++i; pos= tetextround(tp, i, tp->aim); tp->foc= zsubgap(pos); tp->focprev= (pos == tp->start[i+1]); } } break; default: dprintf("tearrow: bad code %d", code); break; } tesetcaret(tp); } void tebackspace(tp) TEXTEDIT *tp; { if (tp->foclen == 0) { if (tp->foc == 0) { wfleep(); return; } --tp->foc; tp->foclen= 1; } teinsert(tp, "", 0); } bool teclicknew(tp, h, v, extend, dclick) TEXTEDIT *tp; coord h, v; bool extend, dclick; { lineno i; bufpos pos; focpos f; tp->dclick= dclick; pos= tewhereis(tp, h, v, &i); f= zsubgap(pos); if (extend) { if (!tp->mdown) { tp->mdown= TRUE; if (f - tp->foc < tp->foc + tp->foclen - f) tp->anchor= tp->foc + tp->foclen; else tp->anchor= tp->foc; tp->anchor2= tp->anchor; } if (f >= tp->anchor) { if (dclick) f= tewordend(tp, f); techangefocus(tp, tp->anchor, f); } else { if (dclick) f= tewordbegin(tp, f); techangefocus(tp, f, tp->anchor2); } } else { tp->mdown= TRUE; tp->anchor= tp->anchor2= f; if (dclick) { tp->anchor= tewordbegin(tp, tp->anchor); tp->anchor2= tewordend(tp, f); } techangefocus(tp, tp->anchor, tp->anchor2); } tp->aim= UNDEF; tp->focprev= (tp->foclen == 0 && pos == tp->start[i+1]); tesetcaret(tp); return TRUE; } /* Return f, 'rounded down' to a word begin */ static int tewordbegin(tp, f) TEXTEDIT *tp; int f; { f= zaddgap(f); for (;;) { if (f == 0 || isspace(zcharbefore(f))) break; zdecr(&f); } return zsubgap(f); } /* Ditto to word end */ static int tewordend(tp, f) TEXTEDIT *tp; int f; { f= zaddgap(f); for (;;) { if (f >= tp->buflen || isspace(zcharat(f))) break; zincr(&f); } return zsubgap(f); } int tegetleft(tp) TEXTEDIT *tp; { return tp->left; } int tegettop(tp) TEXTEDIT *tp; { return tp->top; } int tegetright(tp) TEXTEDIT *tp; { return tp->right; } int tegetbottom(tp) TEXTEDIT *tp; { return tp->bottom; } void temove(tp, left, top, width) TEXTEDIT *tp; coord left, top, width; { temovenew(tp, left, top, left+width, top + tp->nlines*tp->vspace); } /*ARGSUSED*/ void temovenew(tp, left, top, right, bottom) TEXTEDIT *tp; int left, top, right, bottom; { int oldheight= tp->bottom - tp->top; tp->left= left; tp->top= top; tp->right= right; tp->bottom= tp->top + oldheight; if (right - left != tp->width) { tp->width= right - left; tp->nlines= 0; /* Experimental! */ terecompute(tp, 0, tp->buflen); } } void tesetfocus(tp, foc1, foc2) TEXTEDIT *tp; focpos foc1, foc2; { if (foc1 > tp->buflen - tp->gaplen) foc1= tp->buflen - tp->gaplen; if (foc2 > tp->buflen - tp->gaplen) foc2= tp->buflen - tp->gaplen; if (foc1 < 0) foc1= 0; if (foc2 < foc1) foc2= foc1; techangefocus(tp, foc1, foc2); tp->aim= UNDEF; tp->focprev= FALSE; tesetcaret(tp); } int tegetfoc1(tp) TEXTEDIT *tp; { return tp->foc; } int tegetfoc2(tp) TEXTEDIT *tp; { return tp->foc + tp->foclen; } int tegetnlines(tp) TEXTEDIT *tp; { return tp->nlines; } char * tegettext(tp) TEXTEDIT *tp; { temovegapto(tp, tp->buflen - tp->gaplen); if (tp->gaplen < 1) tegrowgapby(tp, 1+RESERVE); tp->buf[tp->gap]= EOS; return tp->buf; } int tegetlen(tp) TEXTEDIT *tp; { return tp->buflen - tp->gaplen; } void tesetbuf(tp, buf, buflen) TEXTEDIT *tp; char *buf; int buflen; { bool drawing= tp->drawing; if (buf == NULL || buflen < 0) return; if (drawing) wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom); free(tp->buf); tp->buf= buf; tp->buflen= buflen; tp->foc= tp->foclen= tp->gap= tp->gaplen= 0; tp->drawing= FALSE; terecompute(tp, 0, tp->buflen); if (drawing) { tp->drawing= TRUE; wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom); } } /* The following paragraph-drawing routines are experimental. They cannibalize on the existing text-edit code, which makes it trivial to ensure the lay-out is the same, but causes overhead to initialize a text-edit struct. The flag 'drawing' has been added to the textedit struct, which suppresses calls to tesetcaret, wchange and wscroll from tesetup and terecompute. It doesn't suppress actual drawing, which only occurs when tedraw is called. Note -- this could be optimized, but it is infrequently, so I don't care until I get complaints. */ /* Draw a paragraph of text, exactly like tedraw would draw it. Parameters are the top left corner, the width, the text and its length. Return value is the v coordinate of the bottom line. An empty string is drawn as one blank line. */ int wdrawpar(left, top, text, width) int left, top; char *text; int width; { return _wdrawpar(left, top, text, width, TRUE); } /* Measure the height of a paragraph of text, when drawn with wdrawpar. */ int wparheight(text, width) char *text; int width; { return _wdrawpar(0, 0, text, width, FALSE); } /* Routine to do the dirty work for the above two. Size calculations are implemented by going through the normal routine but suppressing the actual drawing. */ static int _wdrawpar(left, top, text, width, draw) int left, top; char *text; int width; bool draw; { TEXTEDIT *tp= tesetup((WINDOW*)NULL, left, top, left+width, top, FALSE); int v; tesetbuf(tp, text, strlen(text)); if (draw) tedraw(tp); v= tegetbottom(tp); tp->buf= NULL; tefree(tp); return v; } oid vtsetattr _ARGS((VT *vt, int bit)); void vtsavecursor _ARGS((VT *vt)); void vtrestorecursor _ARGS((VT *vt)); void vtarrow _ARGS((VT *vt, int code, int repeat)); void vteolclear _ARGS((VT *vt, int row, int col)); void vteosclear _ARGS((VT *vt, int row, int col)); void vtlinefeed _ARGS((VT *vt, int repeat)); void vtrevlinefeed _ARGS((VT *vt, int repeat)); void vtinslines _ARGS((VT *vt, int n)); void vtdellines _ARGS((VT *vt, int n)); void vtscrollup _ARGS((VT *vt, int r1smtalk43/stdwin/Packs/textedit/textlow.c1006440003270021170000003041605465303020015547 037777777777 1 0 /* Text Edit, low-level routines */ /* CONVENTION: routines beginning with te... have a first parameter 'tp'; routines beginning with z... don't, or are macros that implicitly use a variable or parameter 'tp' */ #include "text.h" /* Variants on wtextwidth, wtextbreak, wdrawtext taking the gap in account. These have two buffer offsets as parameters instead of a text pointer and a length; tetextbreak also returns a buffer offset */ /* These routines now also take tabs into account. They should now only be called with a line start for 'pos' ! */ int tetextwidth(tp, pos, end) register TEXTEDIT *tp; bufpos pos, end; { char *p= tp->buf + pos; register char *e= tp->buf + (tp->gap >= pos && tp->gap < end ? tp->gap : end); int w= 0; register char *k; zcheckpos(pos); zcheckpos(end); zassert(pos <= end); /* This do loop is executed once or twice only! */ do { for (k= p; k < e; ++k) { if (*k == '\t') { if (k > p) w += wtextwidth(p, (int)(k-p)); w= znexttab(w); p= k+1; } } if (k > p) w += wtextwidth(p, (int)(k-p)); if (tp->gap >= pos) { p= tp->buf + zgapend; e= tp->buf + end; } } while (k < e); return w; } bufpos tetextbreak(tp, pos, end, width) register TEXTEDIT *tp; bufpos pos, end; int width; { char *p= tp->buf + pos; register char *e= tp->buf + (tp->gap >= pos && tp->gap < end ? tp->gap : end); int w= 0; register char *k; zcheckpos(pos); zcheckpos(end); zassert(pos <= end); /* This do loop is executed once or twice only! */ do { for (k= p; k < e; ++k) { if (*k == '\t') { if (k > p) { int n= wtextbreak(p, (int)(k-p), width-w); if (n < k-p) return p - tp->buf + n; w += wtextwidth(p, (int)(k-p)); } w= znexttab(w); if (w > width) return k - tp->buf; p= k+1; } } if (k > p) { int n= wtextbreak(p, (int)(k-p), width-w); if (n < k-p) return p - tp->buf + n; w += wtextwidth(p, (int)(k-p)); } if (tp->gap >= pos) { p= tp->buf + zgapend; e= tp->buf + end; } } while (k < e); return end; } hcoord tedrawtext(tp, h, v, pos, end) register TEXTEDIT *tp; int h, v; bufpos pos, end; { char *p= tp->buf + pos; register char *e= tp->buf + (tp->gap >= pos && tp->gap < end ? tp->gap : end); int w= 0; register char *k; zcheckpos(pos); zcheckpos(end); zassert(pos <= end); /* This do loop is executed once or twice only! */ do { for (k= p; k < e; ++k) { if (*k == '\t') { if (k > p) wdrawtext(h+w, v, p, (int)(k-p)); w += wtextwidth(p, (int)(k-p)); w= znexttab(w); p= k+1; } } if (k > p) { wdrawtext(h+w, v, p, (int)(k-p)); w += wtextwidth(p, (int)(k-p)); } if (tp->gap >= pos) { p= tp->buf + zgapend; e= tp->buf + end; } } while (k < e); return h+w; } /* Safe memory allocation - these abort instead of returning NULL */ char * zmalloc(n) int n; { char *p= malloc((unsigned)n); if (p == NULL) { dprintf("zmalloc(%d): out of mem", n); exit(1); } return p; } char * zrealloc(p, n) char *p; int n; { char *q= realloc(p, (unsigned)n); if (q == NULL) { dprintf("zrealloc(0x%lx, %d): out of mem", (long)p, n); exit(1); } return q; } /* Create/destroy a text-edit record */ TEXTEDIT * tealloc(win, left, top, width) WINDOW *win; { return tesetup(win, left, top, left+width, top, TRUE); } TEXTEDIT * tecreate(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { return tesetup(win, left, top, right, bottom, TRUE); } /*ARGSUSED*/ TEXTEDIT * tesetup(win, left, top, right, bottom, drawing) WINDOW *win; int left, top, right, bottom; bool drawing; { TEXTEDIT *tp= (TEXTEDIT*) zmalloc(sizeof(TEXTEDIT)); TEXTATTR saveattr; tp->win= win; tp->left= left; tp->top= top; tp->right= right; tp->width= right-left; wgettextattr(&saveattr); if (win != NULL) { wgetwintextattr(win, &tp->attr); wsettextattr(&tp->attr); } else tp->attr = saveattr; tp->vspace= wlineheight(); tp->tabsize= 8*wcharwidth(' '); if (win != NULL) wsettextattr(&saveattr); tp->bottom= tp->top + tp->vspace; tp->foc= tp->foclen= 0; tp->buflen= 1; tp->buf= zmalloc(tp->buflen); tp->gap= 0; tp->gaplen= tp->buflen; tp->nlines= 1; tp->nstart= STARTINCR; tp->start= (bufpos*) zmalloc(tp->nstart*sizeof(bufpos)); tp->start[0]= tp->start[1]= tp->buflen; tp->aim= UNDEF; tp->focprev= FALSE; tp->hilite= FALSE; tp->mdown= FALSE; tp->drawing= tp->active= drawing; tp->opt_valid= FALSE; if (tp->active) tesetcaret(tp); zcheck(); return tp; } void tedestroy(tp) register TEXTEDIT *tp; { wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom); tefree(tp); } void tefree(tp) register TEXTEDIT *tp; { if (tp->active) { wnocaret(tp->win); tehidefocus(tp); } if (tp->buf != NULL) free(tp->buf); if (tp->start != NULL) free((char*)tp->start); free((char*)tp); } void tesetactive(tp, active) register TEXTEDIT *tp; bool active; { if (!tp->drawing || tp->active == active) return; tp->active = active; if (active) { tesetcaret(tp); } else { wnocaret(tp->win); tehidefocus(tp); } } /* Show/hide the focus highlighting. The boolean hilite is set when highlighting is visible. teshowfocus ensures the highlighting is visible (if applicable); tehidefocus ensures it is invisible. teinvertfocus does the hard work (it is also called from zdraw) */ teshowfocus(tp) register TEXTEDIT *tp; { if (tp->active && !tp->hilite && tp->foclen > 0) { wbegindrawing(tp->win); teinvertfocus(tp); wenddrawing(tp->win); tp->hilite= TRUE; } } tehidefocus(tp) register TEXTEDIT *tp; { if (tp->hilite) { wbegindrawing(tp->win); teinvertfocus(tp); wenddrawing(tp->win); tp->hilite= FALSE; } } static teinvertfocus(tp) register TEXTEDIT *tp; { teinvert(tp, tp->foc, zfocend); } /* Change to a new focus. Sometimes this may keep the focus visible, sometimes not. */ techangefocus(tp, f1, f2) register TEXTEDIT *tp; int f1, f2; { if (tp->hilite) { wbegindrawing(tp->win); if (f1 == tp->foc) teinvert(tp, zfocend, f2); else if (f2 == zfocend) teinvert(tp, f1, tp->foc); else { teinvert(tp, tp->foc, zfocend); tp->hilite= FALSE; } wenddrawing(tp->win); } tp->foc= f1; tp->foclen= f2-f1; } /* Low-level interface: invert the area between f1 and f2 */ static teinvert(tp, f1, f2) register TEXTEDIT *tp; int f1, f2; { coord h, v, hlast, vlast; if (f1 == f2) return; if (f2 < f1) { int temp= f1; f1= f2; f2= temp; } tewhichpoint(tp, f1, &h, &v); tewhichpoint(tp, f2, &hlast, &vlast); if (v == vlast) winvert(h, v, hlast, v + tp->vspace); else { winvert(h, v, tp->right, v + tp->vspace); winvert(tp->left, v + tp->vspace, tp->right, vlast); winvert(tp->left, vlast, hlast, vlast + tp->vspace); } } /* Draw procedure */ void tedraw(tp) register TEXTEDIT *tp; { tedrawnew(tp, tp->left, tp->top, tp->right, tp->bottom); } /*ARGSUSED*/ void tedrawnew(tp, left, top, right, bottom) register TEXTEDIT *tp; coord left, top, right, bottom; { lineno ifirst, ilast, i; /* Compute first, last line to be drawn */ ifirst= (top - tp->top)/tp->vspace; if (ifirst < 0) ifirst= 0; ilast= (bottom - tp->top + tp->vspace - 1)/tp->vspace; if (ilast > tp->nlines) ilast= tp->nlines; /* Draw lines ifirst...ilast-1 */ for (i= ifirst; i < ilast; ++i) { bufpos pos= tp->start[i]; bufpos end= tp->start[i+1]; if (end > pos && zcharbefore(end) == EOL) zdecr(&end); while (end > pos && zcharbefore(end) == ' ') zdecr(&end); (void) tedrawtext(tp, tp->left, tp->top + i*tp->vspace, pos, end); } if (tp->hilite) teinvertfocus(tp); } /* Move the gap to a new position */ temovegapto(tp, newgap) register TEXTEDIT *tp; bufpos newgap; { zcheck(); zassert(0<=newgap && newgap+tp->gaplen<=tp->buflen); if (newgap < tp->gap) teshift(tp, tp->gaplen, newgap, tp->gap); else if (newgap > tp->gap) teshift(tp, -tp->gaplen, zgapend, newgap+tp->gaplen); tp->gap= newgap; zcheck(); } /* Extend the gap */ tegrowgapby(tp, add) register TEXTEDIT *tp; int add; { zcheck(); zassert(add>=0); tp->buf= zrealloc(tp->buf, tp->buflen + add); teshift(tp, add, zgapend, tp->buflen); tp->gaplen += add; if (tp->start[tp->nlines-1] == tp->buflen) tp->start[tp->nlines-1]= tp->buflen+add; tp->start[tp->nlines]= (tp->buflen += add); zcheck(); } /* Shift buf[first..last-1] n bytes (positive right, negative left) */ static teshift(tp, n, first, last) register TEXTEDIT *tp; int n; bufpos first, last; { teoffset(tp, n, first, last); if (n < 0) temovedown(tp, last-first, tp->buf+first, tp->buf+first+n); else if (n > 0) temoveup(tp, last-first, tp->buf+first, tp->buf+first+n); } static teoffset(tp, n, first, last) register TEXTEDIT *tp; int n; int first, last; { int i; zassert(0<=first&&first<=last&&last<=tp->buflen); i= 0; while (tp->start[i] < first) ++i; while (tp->start[i] < last) { tp->start[i] += n; ++i; } } /*ARGSUSED*/ static temoveup(tp, n, from, to) TEXTEDIT *tp; int n; char *from, *to; { zassert(from <= to); from += n, to += n; while (--n >= 0) *--to = *--from; } /*ARGSUSED*/ static temovedown(tp, n, from, to) TEXTEDIT *tp; int n; char *from, *to; { zassert(from >= to); while (--n >= 0) *to++ = *from++; } /* Make all start entries pointing into the gap point to beyond it TO DO: replace by a routine to delete the focus??? */ teemptygap(tp) register TEXTEDIT *tp; { lineno i; for (i= 0; tp->start[i] < tp->gap; ++i) ; for (; tp->start[i] < zgapend; ++i) tp->start[i]= zgapend; } /* Set the caret at the new focus position, or display the focus highlighting, if applicable. Also call wshow() of the focus. As a side effect, the optimization data is invalidated */ tesetcaret(tp) register TEXTEDIT *tp; { coord h, v, hlast, vlast; tp->opt_valid = FALSE; if (!tp->active) return; tewhichpoint(tp, tp->foc, &h, &v); if (tp->foclen == 0) { wsetcaret(tp->win, h, v); hlast= h; vlast= v; } else { tewhichpoint(tp, zfocend, &hlast, &vlast); wnocaret(tp->win); teshowfocus(tp); } wshow(tp->win, h, v, hlast, vlast + tp->vspace); } /* Coordinate transformations. The following coordinate systems exist; a position in the text can be expressed in any of these: A) offset in buffer with gap removed (used for focus) B) offset in buffer (used for start[] array) C) (line number, offset in line taking gap into account) D) (h, v) on screen Conversions exist between successive pairs: A -> B: pos= zaddgap(foc) B -> A: foc= zsubgap(pos) B -> C: line= zwhichline(pos, prev); offset= pos-start[line] C -> B: pos= offset + start[line] C -> D: v= i*vspace; h= ztextwidth(start[i], start[i]+offset) D -> C: i= v/wlh; offset= ztextround(i, h) - start[i] */ /* Find (h, v) corresponding to focus position */ tewhichpoint(tp, f, h_ret, v_ret) TEXTEDIT *tp; focpos f; coord *h_ret, *v_ret; { bufpos pos= zaddgap(f); lineno i= tewhichline(tp, pos, f == tp->foc && tp->focprev); hcoord h= tetextwidth(tp, tp->start[i], pos); *h_ret= h + tp->left; *v_ret= i*tp->vspace + tp->top; } /* To which line does the given buffer position belong? */ lineno tewhichline(tp, pos, prev) register TEXTEDIT *tp; bufpos pos; bool prev; /* Cf. focprev */ { lineno i; for (i= 0; pos > tp->start[i+1]; ++i) ; if (pos == tp->start[i+1] && i+1 < tp->nlines) { ++i; if (prev && zcharbefore(tp->start[i]) != EOL) --i; } return i; } /* Convert point in window to buffer position, possibly taking double-clicking into account. If required, the line number is also returned. */ bufpos tewhereis(tp, h, v, line_return) register TEXTEDIT *tp; coord h, v; int *line_return; { bufpos pos; lineno i; i= (v - tp->top)/tp->vspace; if (i >= tp->nlines) { i= tp->nlines; pos= tp->buflen; } else if (i < 0) { i= 0; pos= 0; } else pos= tetextround(tp, i, h); if (line_return != NULL) *line_return= i; return pos; } /* Find the buffer position nearest to the given h coordinate, in the given line */ bufpos tetextround(tp, i, h) register TEXTEDIT *tp; lineno i; hcoord h; { bufpos pos; bufpos end= tp->start[i+1]; h -= tp->left; if (end > tp->start[i] && zcharbefore(end) == EOL) zdecr(&end); pos= tetextbreak(tp, tp->start[i], end, h); if (pos < end) { if (h - tetextwidth(tp, tp->start[i], pos) >= tetextwidth(tp, tp->start[i], znext(pos)) - h) zincr(&pos); } return pos; } LE *fp= fopen(filename, "r"); long size; char *buf; if (fp == NULL) { wperror(filename); return FALSE; } if (fseek(fp, 0L, 2) == -1) { wperror (filename); fclose (fp); return FALSE; } size= ftell(fp); if (size >= 1L<<15) {smtalk43/stdwin/Packs/textedit/wprintf.c1006440003270021170000000202005465303020015520 037777777777 1 0 #include "stdwin.h" /* "Printf to a window", with (h, v) and return value like wdrawtext. Use only in a draw procedure or between wbegindrawing/wenddrawing. */ void wprintf(h, v, fmt, rest_of_arguments) int h, v; char *fmt; { char buf[1000]; int len; int width; vsprintf(buf, fmt, &rest_of_arguments); len = strlen(buf); width = wtextwidth(buf, len); wdrawtext(h, v, buf, len); } /* "Centered printf to a window": like wprintf but allows centered text. The first parameter, align, is a percentage: a value of 0 prints at the right of h, a value of 50 centers around h, a value of 100 aligns the end of the text at h. The v coordinate always indicates the top of the text. Return value is the h coordinate at the right end of the text. */ void wcprintf(align, h, v, fmt, rest_of_arguments) int align; int h, v; char *fmt; { char buf[1000]; int len; int width; vsprintf(buf, fmt, &rest_of_arguments); len = strlen(buf); width = wtextwidth(buf, len); wdrawtext(h - align*width/100, v, buf, len); } idth, &height); temovenew(ew->tp, 0, 0, width, height); ewsetdimensions(ew); } break; case WE_COMMAND: if (e->u.command == WC_CLOSE) { closed= ewclose(ew); break; } /* Else, fall through */ if (e->u.command == WC_RETURN || e->u.command == WC_TAB || e->u.command == WC_BACKSPACE) change= TRUE; goto def; case WE_MOUSE_DOWN: /* Edit the coordinates slightly so teevent always believes it is in the rect */ { int left= tegetleft(ew->tp); intsmtalk43/stdwin/Packs/textedit/makefile.vms1006440003270021170000000013605470575606016216 037777777777 1 0 .c.obj: cc/include=[-.-.h] $* CORE=editwin textedit textdbg wprintf textlow all: $(CORE).obj wnum; ++i) { if (ewlist[i] != NULL && !ewsave(ewlist[i])) return FALSE; } return TRUE; } bool ewcloseall() { int i; for (i= 0; i < ewnum; ++i) { if (ewlist[i] != NULL && !ewclose(ewlist[i])) return FALSE; } return TRUE; } void ewreplace(ew, str) EDITWIN *ew; char *str; { if (*str == EOS && tegetfoc1(ew->tp) == tegetfoc2(ew->tp)) return; tereplace(ew->tp, str); ew->saved= FALSE; ewsetdimesmtalk43/stdwin/Packs/vt/0407550003270021170000000000005477556107011705 5 0 1 0 smtalk43/stdwin/Packs/vt/To.do1006440003270021170000000020205434024335013375 037777777777 1 0 Selection should remain visible Handle selections involving EOL more like xterm Need to remove aterm dependencies: extra_downs useful goodies */ #ifndef LSC #define NDEBUG /* Turn off all debugging code */ #endif #define RESERVE 256 /* Increment for gap growth */ #define STARTINCR 20 /* Increment for start array growth; must be >= 1 */ /* Typedefs (for documentation only) */ typedef int focpos; /* Logical offset (not affected by gap) */ typedef int bufpos; /* Buffer offset (taking gap into account) *smtalk43/stdwin/Packs/vt/vt.c1006440003270021170000004724605465303020013302 037777777777 1 0 /* Virtual Terminal -- basic output routines */ #include "vtimpl.h" #ifdef macintosh /* Bold mode uses the "Bold" font, found in VersaTerm; this matches Monaco and is available only in 9 pt. */ #define DO_BOLD #define SETBOLD() wsetfont("Bold") #define SETNORMAL() wsetfont("Monaco") #endif /* Forward */ STATIC void vtdrawproc _ARGS((WINDOW *win, int left, int top, int right, int bottom)); STATIC void vtdraw _ARGS((VT *vt, int r1, int c1, int r2, int c2)); STATIC void vtchrange _ARGS((VT *vt, int r1, int c1, int r2, int c2)); /* Administration for vtfind */ static VT **vtlist; /* Registered VT structs */ static int nvt; /* Number of registered VT structs */ /* Open a VT window of given size */ VT * vtopen(title, rows, cols, save) char *title; int rows, cols; int save; /* Number of rows scroll-back capacity */ { int row; VT *vt = ALLOC(VT); if (vt == NULL) return NULL; rows += save; /* Documentsize: cols * (rows + scrollback) */ vt->rows = rows; vt->cols = cols; vt->topterm = save; vt->cwidth = wcharwidth('0'); vt->cheight = wlineheight(); vt->llen = NALLOC(short, rows); vt->data = NALLOC(char *, rows); vt->flags = NALLOC(unsigned char *, rows); for (row = 0; row < rows; ++row) { if (vt->data != NULL) vt->data[row] = NALLOC(char, cols); if (vt->flags != NULL) vt->flags[row] = NALLOC(unsigned char, cols); } /* Assume that if one NALLOC fails, all following ones for the same size also fail... */ if (vt->llen == NULL || vt->data == NULL || vt->data[rows-1] == NULL || vt->flags == NULL || vt->flags[rows-1] == NULL) { vt->win = NULL; vtclose(vt); return NULL; } vt->win = wopen(title, vtdrawproc); if (vt->win == NULL) { vtclose(vt); return NULL; } wsetdocsize(vt->win, cols * vt->cwidth, rows * vt->cheight); wsetwincursor(vt->win, wfetchcursor("ibeam")); vt->nlcr = FALSE; vt->drawing = FALSE; vtreset(vt); /* Clear additional fields */ L_APPEND(nvt, vtlist, VT *, vt); return vt; } /* Close a VT window. Also used to clean-up when vtopen failed half-way */ void vtclose(vt) VT *vt; { int i, row; for (i = 0; i < nvt; ++i) { if (vt == vtlist[i]) { L_REMOVE(nvt, vtlist, VT *, i); break; } } if (vt->win != NULL) wclose(vt->win); for (row = 0; row < vt->rows; ++row) { if (vt->data != NULL) FREE(vt->data[row]); if (vt->flags != NULL) FREE(vt->flags[row]); } FREE(vt->data); FREE(vt->flags); FREE(vt); } /* Output a string to a VT window. This does not do escape sequence parsing or control character interpretation, but honors the 'modes' the VT can be in (insert, inverse/underline etc.) and the scrolling region. It updates the cursor position and scrolls if necessary. Note that after one or more calls to vtputstring it is necessary to call vtsync(vt)! */ void vtputstring(vt, text, len) VT *vt; char *text; int len; { int row = vt->cur_row; int col = vt->cur_col; short *llen = vt->llen; int scr_top = (vt->scr_top == vt->topterm) ? 0 : vt->scr_top; int scr_bot = (vt->cur_row >= vt->scr_bot) ? vt->rows : vt->scr_bot; int wrap = 0; /* Number of times wrapped around */ int last_drawn_col; #ifndef NDEBUG if (scr_top < 0 || scr_top > vt->rows) { fprintf(stderr, "vtputstring: scr_top = %d\n", scr_top); vtpanic("vtputstring bad scr_top"); } if (scr_bot < 0 || scr_bot > vt->rows) { fprintf(stderr, "vtputstring: scr_bot = %d\n", scr_bot); vtpanic("vtputstring bad scr_bot"); } #endif /* Compute text length if necessary */ if (len < 0) len = strlen(text); /* This is a 'do' loop so that a call with an empty string will still normalize the cursor position */ /* XXX This loop is 100 lines long! Sorry. */ do { int llen_row, n, oldcol; /* Normalize the cursor position. When we get past the bottom edge we must scroll, but the actual scrolling is delayed until later: here we just wrap around and remember how many times we've wrapped. Thus, scrolling multiple lines is effected as a 'jump' scroll up -- not so nice-looking, but essential with current performance limitations of bitblit hardware. When faster machines become available we may need an option to turn this optimization off in favour of smooth scrolling. */ if (col >= vt->cols) { col = 0; ++row; if (wrap > 0 && row < scr_bot) llen[row] = 0; /* Clear line */ } if (row >= scr_bot) { /* Should be able to turn this off? */ if (wrap == 0) last_drawn_col = col; ++wrap; row = scr_top; llen[row] = 0; } oldcol = col; /* For vtdraw call below */ /* If the cursor is beyond the current line length, eg because of cursor positioning, pad with space. Set llen_row to the new line length. */ llen_row = llen[row]; if (llen_row < col) { do { vt->data[row][llen_row] = ' '; vt->flags[row][llen_row] = 0; } while (++llen_row < col); } /* Set n to the number of characters that can be inserted in the current line */ n = vt->cols - col; CLIPMAX(n, len); /* When inserting, shift the rest of the line right. The last characters may fall of the edge. */ if (vt->insert && llen_row > col && col+n < vt->cols) { int k; llen_row += n; CLIPMAX(llen_row, vt->cols); vtscroll(vt, row, col, row+1, llen_row, 0, n); for (k = llen_row - n; --k >= col; ) { vt->data[row][k+n] = vt->data[row][k]; vt->flags[row][k+n] = vt->flags[row][k]; } } /* Copy the characters into the line data */ #ifndef NDEBUG if (col + n > vt->cols || row >= vt->rows) { fprintf(stderr, "col=%d, n=%d, row=%d\n", col,n,row); vtpanic("Bad index in vtputstring"); } #endif strncpy(vt->data[row] + col, text, n); /* Update loop administration, maintaining the invariant: 'len' characters starting at 'text' still to do */ len -= n; text += n; /* Set the corresponding flag bits. The current column is set as a side effect. */ while (--n >= 0) vt->flags[row][col++] = vt->gflags; /* Update line length */ CLIPMIN(llen_row, col); llen[row] = llen_row; /* Maybe draw the characters now */ if (vt->lazy) { D( printf("vtputstring: ") ); vtchrange(vt, row, oldcol, row, col); } else if (wrap == 0) { VTBEGINDRAWING(vt); werase(oldcol*vt->cwidth, row*vt->cheight, col*vt->cwidth, (row+1)*vt->cheight); D( printf("vtputstring: ") ); last_drawn_col = col; vtdraw(vt, row, oldcol, row + 1, col); } /* Loop while more work to do */ } while (len > 0); #if 0 /* XXX Why not? */ vtsetcursor(vt, row, col); #endif /* Process delayed scrolling. */ if (wrap > 0) { /* Yes, we need to scroll. When wrap > 1, we have scrolled more than a screenful; then the vtscroll call is skipped, but we must still circulate the lines internally. */ /* Picture: scr_top ___________________ (first line affected) . ___________________ . ______ row ________ . ___________________ (last line affected) scr_bot Data move: circulate down so that the data at row moves to scr_bot - 1. Screen bits move: the line below row must become scr_top. We must also invalidate the characters changed before we started scrolling, but we must do this after the vtscroll call, because some STDWIN versions don't properly scroll invalidated bits. */ if (row + 1 != scr_bot) vtcirculate(vt, scr_top, scr_bot, scr_bot - (row + 1)); if (wrap == 1) { int n = (row + 1) - scr_top; D( printf("Wrapped once; n=%d\n", n) ); vtscroll(vt, scr_top, 0, scr_bot, vt->cols, -n, 0); if (!vt->lazy) vtdraw(vt, scr_bot - n, last_drawn_col, scr_bot, vt->cols); } else { /* Scrolled more than the scrolling region */ D( printf("Whole scrolling region: ") ); if (!vt->lazy) vtdraw(vt, scr_top, 0, scr_bot, vt->cols); } row = scr_bot - 1; } /* Set the new cursor position */ vtsetcursor(vt, row, col); } /* Subroutine to invalidate the text range from (r1, c1) to (r2, c2). This is not the same as vtchange; this function deals with text ranges, while vtchange deals with rectangles. */ STATIC void vtchrange(vt, r1, c1, r2, c2) VT *vt; { D( printf("vtchrange [%d,%d]~[%d,%d]\n", c1, r1, c2, r2) ); if (c1 >= vt->cols) { MON_EVENT("vtchrange: c1 >= vt->cols"); ++r1; c1 = 0; } if (r1 >= r2) { vtchange(vt, r1, c1, r2+1, c2); } else { vtchange(vt, r1, c1, r1+1, vt->cols); vtchange(vt, r1+1, 0, r2, vt->cols); vtchange(vt, r2, 0, r2+1, c2); } } /* Set cursor position. This sets the STDWIN text caret and calls wshow for the character at the cursor. The cursor position is clipped to the screen dimensions, but it may sit on the right edge just beyond the last character. */ void vtsetcursor(vt, row, col) VT *vt; int row, col; { CLIPMAX(row, vt->rows - 1); CLIPMIN(row, 0); CLIPMAX(col, vt->cols); CLIPMIN(col, 0); vt->cur_row = row; vt->cur_col = col; CLIPMAX(col, vt->cols - 1); if (!vt->lazy) { VTENDDRAWING(vt); wsetcaret(vt->win, col * vt->cwidth, row * vt->cheight); vtshow(vt, row, col, row + 1, col); } } /* Set scrolling region. Lines in [top...bot) can scroll. If the parameters are valid, set the region and move to (0, 0); if there is an error, reset the region and don't move. (NB: the move is to (0, 0), not to the top of the region!) */ void vtsetscroll(vt, top, bot) VT *vt; int top, bot; { vtsync(vt); if (top >= vt->topterm && top < bot && bot <= vt->rows) { vt->scr_top = top; vt->scr_bot = bot; vtsetcursor(vt, vt->topterm, 0); /* vtshow(vt, vt->topterm, 0, vt->rows, vt->cols); */ } else { vt->scr_top = vt->topterm; vt->scr_bot = vt->rows; } vtshow(vt, vt->scr_top, 0, vt->scr_bot, vt->cols); } /* Major reset */ void vtreset(vt) VT *vt; { int row; vtchange(vt, 0, 0, vt->rows, vt->cols); vtshow(vt, vt->topterm, 0, vt->rows, vt->cols); for (row = 0; row < vt->rows; ++row) vt->llen[row] = 0; vt->toscroll = 0; vtsetflags(vt, 0); vtsetinsert(vt, FALSE); vtsetscroll(vt, 0, 0); vtsetcursor(vt, vt->topterm, 0); vt->sel_col1 = vt->sel_row1 = 0; vt->sel_col2 = vt->sel_row2 = 0; vt->save_row = vt->save_col = 0; vt->keypadmode = FALSE; vt->lazy = FALSE; vt->mitmouse = FALSE; vt->visualbell = FALSE; vt->flagschanged = TRUE; vt->action = NULL; /* This invalidates all other parsing fields */ } /* Draw procedure - this one is called because stdwin discovered an expose */ STATIC void vtdrawproc(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { VT *vt = vtfind(win); #ifndef NDEBUG if (vt == NULL) vtpanic("vtdrawproc not for VT window"); if (vt->drawing) vtpanic("vtdrawproc while drawing"); #endif vt->drawing = 1; /* Stdwin did this implicitely */ { int cw = vt->cwidth; int ch = vt->cheight; int col1 = left / cw; int col2 = (right + cw - 1) / cw; int row1 = top / ch; int row2 = (bottom + ch - 1) / vt->cheight; D( printf("vtdrawproc: ") ); vtdraw(vt, row1, col1, row2, col2); } vt->drawing = 0; /* Stdwin will do this implicitely */ } STATIC void set_textstyle(vt, flags) VT *vt; int flags; { #if 0 /* This isn't right, for various reasons. And do we need it? */ static int previous_flags = -3; /* Or anything < 0 */ if (flags == previous_flags) return; D( printf("Set_textstyle: 0x%x => 0x%x\n", previous_flags, flags) ); previous_flags = flags; #endif wsetplain(); if (flags & VT_UNDERLINE) wsetunderline(); if (flags & VT_INVERSE) wsetinverse(); #ifdef DO_BOLD if (flags & VT_BOLD) SETBOLD(); else SETNORMAL(); #endif } /* Draw procedure - doesn't draw [row2, col2], or any other char at row2, takes care of underlining, inverse video etc */ STATIC void vtdraw(vt, row1, col1, row2, col2) VT *vt; int row1, col1, row2, col2; { int cw = vt->cwidth; int ch = vt->cheight; register unsigned char cur_flags; int row; VTBEGINDRAWING(vt); D( printf("vtdraw [%d,%d]~[%d,%d]\n", col1, row1, col2, row2) ); CLIPMIN(col1, 0); CLIPMAX(col2, vt->cols); CLIPMIN(row1, 0); CLIPMAX(row2, vt->rows); for (row = row1; row < row2; ++row) { register int col; char *data_row = vt->data[row] + col1; register unsigned char *flags_row = vt->flags[row] + col1; int h = col1*cw; int v = row*ch; int first = col1; register int last = vt->llen[row]; CLIPMAX(last, col2); /* Don't draw more than asked for */ /* Set flags */ cur_flags = flags_row[0]; set_textstyle(vt, cur_flags); /* Attempt to draw as much text as possible in one wdrawtext */ for (col = first; col < last; ++col) { if (*flags_row++ != cur_flags) { int n = col-first; /* n cannot be < 0; ==0 means this line has different flags */ if (n > 0) { wdrawtext(h, v, data_row, n); first = col; data_row += n; h += n*cw; } cur_flags = flags_row[-1]; /* Set new flags */ set_textstyle(vt, cur_flags); } } /* Draw leftover text on this line and perhaps some black spaces: */ if (col > first) wdrawtext(h, v, data_row, col-first); } } /* Find the VT corresponding to a WINDOW */ VT * vtfind(win) WINDOW *win; { int i; for (i = 0; i < nvt; ++i) { if (vtlist[i]->win == win) return vtlist[i]; } return NULL; } /* Subroutine to circulate lines. For i in r1 ... r2-1, move line i to position i+n (modulo r2-r1). For ABS(n)==1, we have a fast solution that always works. For larger n, we have a slower solution allocating a temporary buffer; if we can't, we repeat the fast solution ABS(n) times (really slow). We assume reasonable input: 0 <= r1 < r2 <= vt->rows, 0 < abs(n) < r2-r1. */ void vtcirculate(vt, r1, r2, n) register VT *vt; int r1, r2; int n; { if (n == -1) { /* Fast solution, move 1 up */ char *tdata = vt->data[r1]; unsigned char *tflags = vt->flags[r1]; short tllen = vt->llen[r1]; register int i; MON_EVENT("circulate -1"); for (i = r1+1; i < r2; ++i) { vt->data[i-1] = vt->data[i]; vt->flags[i-1] = vt->flags[i]; vt->llen[i-1] = vt->llen[i]; } vt->data[i-1] = tdata; vt->flags[i-1] = tflags; vt->llen[i-1] = tllen; } else if (n == 1) { /* Fast solution, move 1 down */ char *tdata = vt->data[r2-1]; unsigned char *tflags = vt->flags[r2-1]; short tllen = vt->llen[r2-1]; register int i; MON_EVENT("circulate 1"); for (i = r2-1; i > r1; --i) { vt->data[i] = vt->data[i-1]; vt->flags[i] = vt->flags[i-1]; vt->llen[i] = vt->llen[i-1]; } vt->data[i] = tdata; vt->flags[i] = tflags; vt->llen[i] = tllen; } else if (n != 0) { if (!slowcirculate(vt, r1, r2, n)) { /* Couldn't -- do ABS(n) times the fast case... */ int step; if (n < 0) { n = -n; step = -1; } else step = 1; while (--n >= 0) vtcirculate(vt, r1, r2, step); } } } /* Slow version of the above; move lines r1..r2-1 n lines up */ STATIC bool slowcirculate(vt, r1, r2, n) register VT *vt; int r1, r2; int n; /* May be negative */ { char **tdata; /* Data buffer */ unsigned char **tflags; /* Flags buffer */ short *tllen; /* Line length buffer */ bool ok; if (n < 0) n += (r2 - r1); tdata = NALLOC(char *, n); tflags = NALLOC(unsigned char *, n); tllen = NALLOC(short, n); MON_EVENT("slowcirculate"); /* Did all the malloc's work? */ ok = tdata != NULL && tflags != NULL && tllen != NULL; if (ok) { register int i; r2 -= n; /* Now r2 "points" beyond the last target line */ /* Save data, flags and lengths to be overwritten */ for (i = 0; i < n; ++i) { tdata[i] = vt->data[r2+i]; tflags[i] = vt->flags[r2+i]; tllen[i] = vt->llen[r2+i]; } /* Copy "lower" part of the lines to r1..r1+n-1 (=r2-1) */ for (i = r2; --i >= r1; ) { vt->data[i+n] = vt->data[i]; vt->flags[i+n] = vt->flags[i]; vt->llen[i+n] = vt->llen[i]; } /* Restore saved lines in r1..r1+n-1 */ for (i = 0; i < n; ++i) { vt->data[r1+i] = tdata[i]; vt->flags[r1+i] = tflags[i]; vt->llen[r1+i] = tllen[i]; } } FREE(tdata); FREE(tflags); FREE(tllen); return ok; } /* VT interface to wchange */ void vtchange(vt, r1, c1, r2, c2) VT *vt; int r1, c1, r2, c2; { VTENDDRAWING(vt); D( printf("vtchange [%d, %d]~[%d, %d]\n", c1, r1, c2, r2) ); wchange(vt->win, c1 * vt->cwidth, r1 * vt->cheight, c2 * vt->cwidth, r2 * vt->cheight); } /* VT interface to wshow */ void vtshow(vt, r1, c1, r2, c2) VT *vt; int r1, c1, r2, c2; { VTENDDRAWING(vt); wshow(vt->win, c1 * vt->cwidth, r1 * vt->cheight, c2 * vt->cwidth, r2 * vt->cheight); } /* VT interface to wscroll. In lazy mode, the actual scrolling may be postponed (by setting vt->toscroll). */ void vtscroll(vt, r1, c1, r2, c2, drow, dcol) VT *vt; int r1, c1, r2, c2; int drow, dcol; /* Translation vector */ { int scr_top = vt->scr_top; if (scr_top == vt->topterm) scr_top = 0; D( printf("vtscroll %d lines\n", drow) ); if (vt->lazy && dcol == 0 && r1 == scr_top && r2 == vt->scr_bot && c1 == 0 && c2 == vt->cols) { if (drow * vt->toscroll < 0) vtsync(vt); vt->toscroll += drow; } else { if (vt->toscroll != 0 && r1 < vt->scr_bot && r2 > scr_top) vtsync(vt); /* Execute leftover scrolling first */ /* Convert to STDWIN coordinates */ c1 *= vt->cwidth; c2 *= vt->cwidth; dcol *= vt->cwidth; r1 *= vt->cheight; r2 *= vt->cheight; drow *= vt->cheight; VTENDDRAWING(vt); wnocaret(vt->win); wscroll(vt->win, c1, r1, c2, r2, dcol, drow); /* Despite what the stdwin document says, wscroll doesn't generate wchanges anymore */ if (vt->lazy) { if (drow < 0) { /* Scrolled upwards */ wchange(vt->win, c1, r2+drow, c2, r2); D( printf("^: wchange(%d, %d, %d, %d)\n", c1, r2+drow, c2, r2) ); } else if (drow > 0) { /* Scrolled downwards */ wchange(vt->win, c1, r1, c2, r1+drow); D( printf("V: wchange(%d, %d, %d, %d)\n", c1, r1, c2, r1+drow) ); } if (dcol < 0) { /* Scrolled to the left */ wchange(vt->win, c2+dcol, r1, c2, r2); D( printf("<: wchange(%d, %d, %d, %d)\n", c2+dcol, r1, c2, r2) ); } else if (dcol > 0) { /* Scrolled to the right */ wchange(vt->win, c1, r1, c1+dcol, r2); D( printf(">: wchange(%d, %d, %d, %d)\n", c1, r1, c1+dcol, r2) ); } } } } /* Execute delayed scrolling. Don't call from within drawproc: wscroll while drawing is BAD. */ void vtsync(vt) VT *vt; { VTENDDRAWING(vt); if (vt->toscroll != 0) { int scr_top = vt->scr_top; #if 0 /* XXX Why not? */ if (vt->toscroll < 0) vtpanic("vtsync: toscroll < 0"); #endif if (scr_top == vt->topterm) scr_top = 0; D( printf("VtSync [,%d]~[,%d] %d: wscroll\n", scr_top, vt->scr_bot, vt->toscroll) ); wscroll(vt->win, 0, scr_top * vt->cheight, vt->cols * vt->cwidth, vt->scr_bot * vt->cheight, 0, vt->toscroll * vt->cheight); D( printf("vtsync: ") ); /* I could get speedup from remembering * min and max columns for the call here */ vtchange(vt, vt->scr_bot + vt->toscroll, 0, vt->scr_bot, vt->cols); vt->toscroll = 0; } /* vtsetcursor doesn't do this if vt->lazy: */ if (vt->lazy) { MON_EVENT("vtsync for lazy"); wsetcaret(vt->win, vt->cur_col * vt->cwidth, vt->cur_row * vt->cheight); vtshow(vt, vt->cur_row,vt->cur_col, vt->cur_row+1,vt->cur_col); } } /* Internal VT interface to winvert. Must be called between wbegindrawing and wenddrawing. */ void vtinvert(vt, row1, col1, row2, col2) VT *vt; int row1, col1, row2, col2; { /* XXX Here was some code */ if (row1 == row2) { /* Whole selection within one line */ winvert(col1 * vt->cwidth, row1 * vt->cheight, col2 * vt->cwidth, (row2 + 1) * vt->cheight); } else { /* Invert first line of the selection */ winvert(col1 * vt->cwidth, row1 * vt->cheight, vt->cols * vt->cwidth, (row1 + 1) * vt->cheight); /* Invert intermediate lines, if any */ if (row1 + 1 < row2) { winvert(0, (row1 + 1) * vt->cheight, vt->cols * vt->cwidth, row2 * vt->cheight); } /* Invert last line */ winvert(0, row2 * vt->cheight, col2 * vt->cwidth, (row2 + 1) * vt->cheight); } } , tp->left, tp->top, tp->right, tp->bottom); free(tp->buf); tp->buf= buf; tp->buflen= buflen; tp->foc= tp->foclen= tp->gap= tp->gaplen= 0; tp->drawing= FALSE; terecompute(tp, 0, tp->buflen); if (drawing) { tp->drawing= TRUE; wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom); } } /* The following paragraph-drawing routinessmtalk43/stdwin/Packs/vt/vtansi.c1006440003270021170000002660505465303020014151 037777777777 1 0 /* ANSI escape sequence interpreter */ /* There is some ugly code here, since I assume that code looking at the input a character at a time is very time-critical. Action functions are called with the start of the text to process, and return a pointer to where they left off. When an action function hits the end of the string, it returns NULL and sets the action pointer to the function to call next (often itself), or to NULL for the default. A non-NULL return implies that the default action function must be called next and the action pointer is irrelevant. Remember that the general form of most ANSI escape sequences is ESC [ ; ; ... where is the command code and , etc. are optional numerical parameters. */ #include "vtimpl.h" #ifdef DEBUG /* Let it be heard that a command was not recognized */ #define FAIL() wfleep() #else /* Silently ignore unrecognized commands */ #define FAIL() 0 #endif /* Function prototypes */ STATIC char *def_action _ARGS((VT *vt, char *text, char *end)); STATIC char *esc_action _ARGS((VT *vt, char *text, char *end)); STATIC char *ansi_params _ARGS((VT *vt, char *text, char *end)); STATIC char *ansi_execute _ARGS((VT *vt, char *text)); STATIC void vtsetoptions _ARGS((VT *vt, bool flag)); STATIC void vtsetattrlist _ARGS((VT *vt)); /* Output a string, interpreting ANSI escapes */ void vtansiputs(vt, text, len) VT *vt; char *text; int len; { char *end; #ifndef NDEBUG if (vt->scr_top < 0 || vt->scr_top > vt->rows) { fprintf(stderr, "vtansiputs: scr_top = %d\n", vt->scr_top); vtpanic("vtansiputs: bad scr_top"); } #endif if (len < 0) len = strlen(text); end = text + len; D( printf("vtansiputs %d chars\n", len) ); /* Pick up where the last call left us behind */ if (vt->action != NULL) text = (*vt->action)(vt, text, end); /* Start in default state until text exhausted */ while (text != NULL) text = def_action(vt, text, end); /* Execute delayed scrolling */ vtsync(vt); D( printf("vtansiputs returns\n") ); } /* Default action function */ STATIC char * def_action(vt, text, end) VT *vt; char *text, *end; { again: for (;;) { if (text >= end) { vt->action = NULL; return NULL; } if (PRINTABLE(*text)) break; switch (*text++) { case ESC: /* ESC */ return esc_action(vt, text, end); case BEL: /* Bell */ if (vt->visualbell) { VTBEGINDRAWING(vt); vtinvert(vt, 0, 0, vt->rows, vt->cols); VTENDDRAWING(vt); VTBEGINDRAWING(vt); vtinvert(vt, 0, 0, vt->rows, vt->cols); VTENDDRAWING(vt); } else { wfleep(); } break; case BS: /* Backspace -- move 1 left */ /* Rely on vtsetcursor's clipping */ vtsetcursor(vt, vt->cur_row, vt->cur_col - 1); /* Don't erase -- that's part of intelligent echoing */ break; case TAB: /* Tab -- move to next tab stop */ /* Rely on vtsetcursor's clipping */ /* TO DO: use programmable tab stops! */ vtsetcursor(vt, vt->cur_row, (vt->cur_col & ~7) + 8); /* Normalize cursor (may cause scroll!) */ vtputstring(vt, "", 0); break; case LF: /* Linefeed -- move down one line */ if (vt->nlcr) /* First a \r? */ vtsetcursor(vt, vt->cur_row, 0); vtlinefeed(vt, 1); break; case FF: /* Formfeed */ /* vtreset(vt); */ break; case CR: /* Return -- to col 0 on same line */ vtsetcursor(vt, vt->cur_row, 0); break; case ' ': /* In case isprint(c) fails for space */ vtputstring(vt, " ", 1); break; default: D( printf("Unrecognized unprintable character 0x%x\n", text[-1]) ); FAIL(); break; } } /* We fall through the previous loop when we get a printable character */ { char *p = text; while (PRINTABLE(*++p)) { /* At least one character guaranteed! */ if (p >= end) break; } vtputstring(vt, text, (int)(p-text)); text = p; goto again; } } /* Action function called after ESC seen */ STATIC char * esc_action(vt, text, end) VT *vt; char *text, *end; { if (text >= end) { vt->action = esc_action; return NULL; } switch (*text++) { /* case '(': case ')': case '*': case '+': return cset_action(vt, text, end); */ case '=': vt->keypadmode = TRUE; break; case '>': vt->keypadmode = FALSE; break; case '7': vtsavecursor(vt); break; case '8': vtrestorecursor(vt); break; case 'D': vtlinefeed(vt, 1); break; case 'E': /* Next Line */ break; case 'H': /* Tab set */ break; case 'M': vtrevlinefeed(vt, 1); break; case '[': vt->nextarg = vt->args; *vt->nextarg = -1; vt->modarg = '\0'; return ansi_params(vt, text, end); case 'c': vtreset(vt); break; default: D( printf("Urecognized: esc-%c (0x%x)\n", text[-1], text[-1]) ); FAIL(); break; } return text; } /* Action function called after ESC-[ plus possible parameters seen */ STATIC char * ansi_params(vt, text, end) VT *vt; char *text, *end; { again: if (text >= end) { vt->action = ansi_params; return NULL; } if (isdigit(*text)) { long a = *vt->nextarg; if (a < 0) /* Still unused? */ a = 0; do { a = a*10 + (*text - '0'); CLIPMAX(a, 0x7fff); /* Avoid overflow */ } while (++text < end && isdigit(*text)); *vt->nextarg = a; /* Remember arg under construction */ if (text >= end) goto again; } switch (*text) { case ';': /* Arg no longer under construction */ ++text; if (vt->nextarg < &vt->args[VTNARGS-1]) ++vt->nextarg; /* Else: overflow; who cares? */ *vt->nextarg = -1; /* Mark unused */ goto again; case '?': ++text; if (vt->nextarg == vt->args && /* No arguments yet */ *vt->nextarg < 0 && vt->modarg == '\0') { vt->modarg = '?'; goto again; } else { /* Illegal here */ D( printf("Wrong argcount in DEC private mode\n") ); FAIL(); return text; } default: return ansi_execute(vt, text); } } /* Called after complete ESC [ ? h is parsed. This is called DEC private mode set. Most stuff is not implemented. The vt is guarantueed to contain the one and only argument allowed here. */ STATIC void vtprivset(vt) VT *vt; { switch (vt->args[0]) { case 1: /* Application cursor keys */ if (!vt->keypadmode) { vt->keypadmode = 1; vt->flagschanged = 1; } break; #if 0 case 3: /* 132 column mode */ case 4: /* Smooth (slow) scroll */ #endif case 5: /* Reverse video */ wfleep(); break; #if 0 case 6: /* Origin mode */ case 7: /* Wraparound mode */ case 8: /* Autorepeat keys */ #endif case 9: /* Send MIT mouse row & column on Button Press */ if (!vt->mitmouse) { /* If not already so */ vt->mitmouse = 1; vt->flagschanged = 1; } break; #if 0 case 38: /* Enter Tektronix Mode */ case 40: /* Allow 80 <-> 132 mode */ case 41: /* Curses(5) fix */ case 44: /* Turn on margin bell */ case 45: /* Reverse wraparound mode */ case 46: /* Start logging */ case 47: /* Use alternate screen buffer */ case 1000: /* Send vt200 mouse row & column on Button Press */ case 1003: /* Send vt200 Hilite mouse row & column on Button Press */ #endif default: D( printf("Unsupported DEC private mode set:") ); D( printf("esc [ ? %d h\n", vt->args[0]) ); wfleep(); } } /* Called after complete ESC [ ? l is parsed. This is called DEC private mode reset. The vt is guarantueed to contain the one and only argument allowed here. */ STATIC void vtprivreset(vt) VT *vt; { switch (vt->args[0]) { case 1: /* Normal cursor keys */ if (vt->keypadmode) { vt->keypadmode = 0; vt->flagschanged = 1; } break; #if 0 /* These are not supprted: */ case 3: /* 80 column mode */ case 4: /* Jumpscroll */ #endif case 5: /* Normal video (i.e. not reverse) */ /* XXX Why this beep? */ wfleep(); break; #if 0 case 6: /* Normal cursor mode */ case 7: /* No wraparound */ case 8: /* No autorepeat */ break; #endif case 9: /* Don't send mouse row & column on button press */ case 1000: /* Same */ case 1003: /* Same */ if (vt->mitmouse) { /* If not already so */ vt->mitmouse = 0; vt->flagschanged = 1; } break; #if 0 case 40: /* Disallow 80 <-> 132 mode */ case 41: /* No curses(5) fix */ case 44: /* Turn off Margin bell */ case 45: /* No reverse wraparound */ case 46: /* Stop logging */ case 47: /* Use normal screen buffer (opposed to alternate buffer) */ break; #endif default: D( printf("Unsupported DEC private mode reset:") ); D( printf("esc [ ? %d l\n", vt->args[0]) ); wfleep(); break; } } /* Action function called at last char of ANSI sequence. (This is only called when the char is actually seen, so there is no need for an 'end' parameter). */ STATIC char * ansi_execute(vt, text) VT *vt; char *text; { int a1 = vt->args[0]; int a2 = (vt->nextarg > vt->args) ? vt->args[1] : -1; if (vt->modarg == '?') { /* These escape sequences have exactly one numeric parameter */ if (a1 < 0 || a2 > 0) { wfleep(); return text+1; } switch (*text++) { case 'h': /* DEC Private mode Set */ vtprivset(vt); break; case 'l': /* DEC Private mode Reset */ vtprivreset(vt); break; /* To do: add private mode memory to vt-descriptor? */ case 'r': /* DEC Private mode Restore */ case 's': /* DEC Private mode Save */ default: /* Not supported or simply wrong */ wfleep(); } return text; } CLIPMIN(a1, 1); CLIPMIN(a2, 1); switch (*text++) { case '@': vtinschars(vt, a1); break; case 'A': vtarrow(vt, WC_UP, a1); break; case 'B': vtarrow(vt, WC_DOWN, a1); break; case 'C': vtarrow(vt, WC_RIGHT, a1); break; case 'D': vtarrow(vt, WC_LEFT, a1); break; case 'H': case 'f': if (vt->nextarg > &vt->args[0]) vtsetcursor(vt, vt->topterm + a1 - 1, a2 - 1); else vtsetcursor(vt, vt->topterm, 0); break; case 'J': switch (vt->args[0]) { case -1: case 0: vteosclear(vt, vt->topterm, 0); break; case 1: /* clear above cursor */ break; case 2: vteosclear(vt, vt->cur_row, vt->cur_col); break; default: FAIL(); break; } break; case 'K': switch (vt->args[0]) { case -1: case 0: vteolclear(vt, vt->cur_row, vt->cur_col); break; case 1: /* Clear left of cursor */ break; case 2: vteolclear(vt, vt->cur_row, 0); break; default: FAIL(); break; } break; case 'L': vtinslines(vt, a1); break; case 'M': vtdellines(vt, a1); break; case 'P': vtdelchars(vt, a1); break; case 'S': vtlinefeed(vt, a1); break; case 'T': vtrevlinefeed(vt, a1); break; case 'c': vtsendid(vt); break; case 'g': /* Tab clear */ break; /* 0: current col; 3: all */ case 'h': vtsetoptions(vt, TRUE); break; case 'l': vtsetoptions(vt, FALSE); break; case 'm': vtsetattrlist(vt); break; case 'n': if (a1 == 6) vtsendpos(vt); /* 5: echo 'ESC [ 0 n' */ break; case 'r': vtsetscroll(vt, vt->topterm+vt->args[0]-1, vt->topterm+a2); break; case 'x': /* Send terminal params */ break; default: FAIL(); break; } return text; } /* Set/reset numbered options given in args array */ STATIC void vtsetoptions(vt, flag) VT *vt; bool flag; /* Set/reset */ { short *a; for (a = vt->args; a <= vt->nextarg; ++a) { switch (*a) { case 4: vtsetinsert(vt, flag); break; case -1: /* Empty parameter, don't beep */ break; default: FAIL(); break; } } } /* Set/reset output mode attributes given in args array */ STATIC void vtsetattrlist(vt) VT *vt; { short *a; for (a = vt->args; a <= vt->nextarg; ++a) { switch (*a) { case -1: if (a == vt->args) vtresetattr(vt); break; case 0: vtresetattr(vt); break; default: vtsetattr(vt, *a); break; } } } d; ++i) tp->start[i]= zgapend; } /* Set the caret at the new focus position, or display the focus highlighting, if apsmtalk43/stdwin/Packs/vt/vtfunc.c1006440003270021170000001071605465303020014146 037777777777 1 0 /* Functions implementing ANSI operations */ #include "vtimpl.h" /* Linefeed */ void vtlinefeed(vt, n) VT *vt; int n; { while (--n >= 0) { if (vt->cur_row == vt->scr_bot - 1) { int scr_top = vt->scr_top; if (scr_top == vt->topterm) scr_top = 0; vtscrollup(vt, scr_top, vt->scr_bot, 1); } else vtsetcursor(vt, vt->cur_row + 1, vt->cur_col); } } /* Reverse linefeed */ void vtrevlinefeed(vt, n) VT *vt; int n; { while (--n >= 0) { if (vt->cur_row == vt->scr_top) vtscrolldown(vt, vt->scr_top, vt->scr_bot, 1); else vtsetcursor(vt, vt->cur_row - 1, vt->cur_col); } } /* Reset underline, inverse video attributes */ void vtresetattr(vt) VT *vt; { vtsetflags(vt, 0); } /* Set attribute flag (without clearing the others) */ void vtsetattr(vt, bit) VT *vt; int bit; { vtsetflags(vt, vt->gflags | (1 << bit)); } /* Save cursor position */ void vtsavecursor(vt) VT *vt; { vt->save_row = vt->cur_row; vt->save_col = vt->cur_col; } /* Restore cursor position */ void vtrestorecursor(vt) VT *vt; { vtsetcursor(vt, vt->save_row, vt->save_col); } /* Process an arrow key (possibly repeated) */ void vtarrow(vt, code, repeat) VT *vt; int code; int repeat; { int row = vt->cur_row; int col = vt->cur_col; int minrow = 0, maxrow = vt->rows; CLIPMAX(col, vt->cols-1); switch (code) { case WC_LEFT: col -= repeat; break; case WC_RIGHT: col += repeat; break; case WC_UP: row -= repeat; break; case WC_DOWN: row += repeat; break; } CLIPMAX(col, vt->cols-1); CLIPMIN(col, 0); if (vt->cur_row >= vt->scr_top) minrow = vt->scr_top; if (vt->cur_row < vt->scr_bot) maxrow = vt->scr_bot; CLIPMIN(row, minrow); CLIPMAX(row, maxrow-1); vtsetcursor(vt, row, col); } /* Clear to end of line */ void vteolclear(vt, row, col) VT *vt; int row, col; { if (row < vt->rows) { if (vt->llen[row] > col) { if (vt->lazy) vtchange(vt, row, col, row + 1, vt->llen[row]); else { VTBEGINDRAWING(vt); werase(col*vt->cwidth, row*vt->cheight, vt->llen[row]*vt->cwidth, (row+1)*vt->cheight); } vt->llen[row] = col; } } } /* Clear to end of screen */ void vteosclear(vt, row, col) VT *vt; int row, col; { vteolclear(vt, row, col); if (vt->lazy) vtchange(vt, row + 1, 0, vt->rows, vt->cols); else { VTBEGINDRAWING(vt); werase(0, (row + 1) * vt->cheight, vt->cols * vt->cwidth, vt->rows * vt->cheight); } for (row = row + 1; row < vt->rows; ++row) vt->llen[row] = 0; } /* Delete n lines */ void vtdellines(vt, n) VT *vt; int n; { vtscrollup(vt, vt->cur_row, vt->scr_bot, n); } /* Insert n lines */ void vtinslines(vt, n) VT *vt; int n; { vtscrolldown(vt, vt->cur_row, vt->scr_bot, n); } /* Scroll a range of lines n positions up */ void vtscrollup(vt, r1, r2, n) VT *vt; int r1, r2; int n; { if (n > 0 && r1 < r2) { int i; vtcirculate(vt, r1, r2, -n); /* Clear lines at bottom of scrolling screenpart */ for (i = r2 - n; i < r2; ++i) vt->llen[i] = 0; vtscroll(vt, r1, 0, r2, vt->cols, -n, 0); } } /* Scroll a range of lines n positions down */ void vtscrolldown(vt, r1, r2, n) VT *vt; int r1, r2; int n; { if (n > 0 && r1 < r2) { int i; vtcirculate(vt, r1, r2, n); for (i = r1 + n; --i >= r1; ) vt->llen[i] = 0; vtscroll(vt, r1, 0, r2, vt->cols, n, 0); } } /* Insert n characters */ void vtinschars(vt, n) VT *vt; int n; { int row; if (n > 0 && (row= vt->cur_row) < vt->rows) { int col = vt->cur_col; int len = vt->llen[row]; if (len > col) { if (col+n >= vt->cols) { vtchange(vt, row, col, row+1, len); vt->llen[row] = col; } else { register int i; char *data = vt->data[row]; unsigned char *flags = vt->flags[row]; len += n; if (len > vt->cols) len = vt->cols; for (i = len-n; --i >= col; ) data[i+n] = data[i]; vtscroll(vt, row, col, row+1, len, 0, n); vt->llen[row] = len; /* Clear the inserted stretch */ for (i = col+n; --i >= col; ) { data[i] = ' '; flags[i] = 0; } } } } } /* Delete n characters */ void vtdelchars(vt, n) VT *vt; int n; { int row; if (n > 0 && (row = vt->cur_row) < vt->rows) { int col = vt->cur_col; int len = vt->llen[row]; if (len > col) { if (len <= col+n) { vtchange(vt, row, col, row+1, len); vt->llen[row] = col; } else { register int i; char *data = vt->data[row]; for (i = col+n; i < len; ++i) data[i-n] = data[i]; vtscroll(vt, row, col, row+1, len, 0, -n); vt->llen[row] -= n; } } } } rect */ { int left= tegetleft(ew->tp); intsmtalk43/stdwin/Packs/vt/vtimpl.h1006440003270021170000000257305434024336014171 037777777777 1 0 /* Assorted things used by the VT implementation */ /* Include files */ #include "tools.h" #include "stdwin.h" #include "vt.h" /* Names for control characters */ #define ESC '\033' #define CR '\r' #define LF '\012' /* Can't use \n or EOL because of MPW on Macintosh */ #define BS '\b' #define BEL '\007' #define TAB '\t' #define FF '\014' /* Macro to check for non-control character */ #define PRINTABLE(c) isprint(c) /* Debugging facilities */ /* If you want static functions visible for adb, pass '-DSTATIC=static' to the cc compiler. */ #ifndef STATIC #define STATIC static #endif /* Macro D() to turn off code in NDEBUG mode or if debugging is off */ #ifdef NDEBUG #define D(stmt) 0 #else /* XXX Dependency on 'debugging' declared in calling application */ extern int debugging; #define D(stmt) if (!debugging) { } else stmt #endif /* In Amoeba, MON_EVENT() can be used to keep cheap performance statistics */ #ifndef MON_EVENT #define MON_EVENT(msg) do { } while (0) /* Funny syntax to work inside 'if' */ #endif /* Functions used internally */ /* XXX Ought to have names beginning with _vt */ void vtcirculate _ARGS((VT *vt, int r1, int r2, int n)); void vtchange _ARGS((VT *vt, int r1, int c1, int r2, int c2)); void vtshow _ARGS((VT *vt, int r1, int c1, int r2, int c2)); void vtscroll _ARGS((VT *vt, int r1, int c1, int r2, int c2, int dr, int dc)); void vtsync _ARGS((VT *vt)); smtalk43/stdwin/Packs/vt/vtpanic.c1006440003270021170000000035105465303020014277 037777777777 1 0 /* Panic function, not if NDEBUG. The application may provide a better one. */ #include "vtimpl.h" #ifndef NDEBUG void vtpanic(msg) char *msg; { fprintf(stderr, "vtpanic: %s\n", msg); wdone(); abort(); } #endif /* NDEBUG */ 37777777777 1 0 smtalk43/stdwin/Packs/vt/vtputs.c1006440003270021170000000240205465303020014177 037777777777 1 0 /* A simple output function, emulating a "dumb tty" */ #include "vtimpl.h" void vtputs(vt, text) register VT *vt; register char *text; { #ifndef NDEBUG if (text == NULL) vtpanic("vtputs with NULL text"); #endif while (*text != EOS) { if (PRINTABLE(*text)) { register char *end = text; do { text++; } while (PRINTABLE(*text)); vtputstring(vt, text, (int) (end-text)); text = end; } else switch (*text++) { case BEL: /* Make some noise */ wfleep(); break; case BS: /* Move 1 left */ /* Rely on vtsetcursor's clipping */ vtsetcursor(vt, vt->cur_row, vt->cur_col - 1); /* Don't erase -- that's part of intelligent echoing */ break; case TAB: /* Move to next tab stop */ /* Rely on vtsetcursor's clipping */ vtsetcursor(vt, vt->cur_row, (vt->cur_col & ~7) + 8); /* Normalize cursor (may cause scroll!) */ vtputstring(vt, "", 0); break; case LF: /* Move cursor down in same column */ vtsetcursor(vt, vt->cur_row + 1, vt->cur_col); /* Normalize cursor (may cause scroll!) */ vtputstring(vt, "", 0); break; case FF: /* Start over */ vtreset(vt); break; case CR: /* Back to col 0 on same line */ vtsetcursor(vt, vt->cur_row, 0); break; } } vtsync(vt); } t->cheight); wsetwincursor(vt->win, wfetchcursor("ibeam")); vt->nlcr = FALSE; vt->drawing = FALSE; vtreset(vt); /* Clear additional fields */ L_APPEND(nvt, vtlist, VT *, vt); return vt; } /* Close a VT window. Also used to clean-up when vtopesmtalk43/stdwin/Packs/vt/vtresize.c1006440003270021170000000571705465303020014521 037777777777 1 0 /* Resize function */ #include "vtimpl.h" /* Resize the screen. When growing, blanks are added to the right and/or at the top (!); when shrinking, characters are lost at those edges. It is really a disaster if we run out of memory halfway (much more so than in vtopen); in this case the caller should immediately call vtclose, and expect some memory leaks... */ bool vtresize(vt, rows, cols, save) VT *vt; int rows, cols; int save; { int rowdiff; int i; rows += save; rowdiff = rows - vt->rows; if (cols != vt->cols) { if (cols < vt->cols) { /* Clear the corresponding screen area */ vtchange(vt, 0, cols, vt->rows, vt->cols); vt->cols = cols; } i = vt->rows; if (rows < i) i = rows; while (--i >= 0) { if (!RESIZE(vt->data[i], char, cols)) return FALSE; if (!RESIZE(vt->flags[i], unsigned char, cols)) return FALSE; if (vt->llen[i] > cols) vt->llen[i] = cols; } if (cols > vt->cols) { /* Clear the corresponding screen area */ vtchange(vt, 0, vt->cols, rows, cols); vt->cols = cols; } } if (rowdiff != 0) { if (rowdiff < 0) { /* Get the last line into its new position */ vtscrollup(vt, 0, vt->rows, -rowdiff); /* Free the excess lines */ for (i = rows; i < vt->rows; ++i) { FREE(vt->data[i]); FREE(vt->flags[i]); } /* Clear the corresponding screen area */ vtchange(vt, rows, 0, vt->rows, cols); vt->rows = rows; } if (!RESIZE(vt->data, char *, rows)) return FALSE; if (!RESIZE(vt->flags, unsigned char *, rows)) return FALSE; if (!RESIZE(vt->llen, short, rows)) return FALSE; if (rowdiff > 0) { /* Add new lines */ for (i = vt->rows; i < rows; ++i) { if ((vt->data[i] = NALLOC(char, cols)) == NULL) return FALSE; if ((vt->flags[i] = NALLOC(unsigned char, cols)) == NULL) return FALSE; vt->llen[i] = 0; } /* Clear the corresponding screen area */ vtchange(vt, vt->rows, 0, rows, cols); vt->rows = rows; /* Get the last line into its new position */ vtscrolldown(vt, 0, rows, rowdiff); } } if (rowdiff != 0 || save != vt->topterm) { vt->topterm = save; vtsetscroll(vt, 0, 0); /* Reset scrolling region */ } wsetdocsize(vt->win, vt->cols * vt->cwidth, vt->rows * vt->cheight); i = vt->cur_row + rowdiff; CLIPMIN(i, save); vtsetcursor(vt, i, vt->cur_col); return TRUE; } /* Adapt the screen size to the new window dimensions. The 'save' parameter is computed so as to keep the total amount of rows the same (if possible). Return value as for vtresize (i.e., FALSE is a disaster). */ bool vtautosize(vt) VT *vt; { int width, height; int newrows, newcols, newsave; wgetwinsize(vt->win, &width, &height); newrows = height / vt->cheight; newcols = width / vt->cwidth; newsave = vt->rows - newrows; D( printf("vtautosize: size now %dx%d (char = %dx%d) => %dx%d\n", width,height, vt->cwidth,vt->cheight, newrows,newcols) ); CLIPMIN(newsave, 0); return vtresize(vt, newrows, newcols, newsave); } fprintf(stderr, "col=%d, n=%d, row=%d\n", col,smtalk43/stdwin/Packs/vt/vtselect.c1006440003270021170000002262405465303020014473 037777777777 1 0 /* Copy and paste operations for VT. The selections here are not rectangles, like in most other vt-stuff */ /* XXX This must be redesigned. In the new design, the event loop is in the caller and we remember the state somehow in the vt structure. This is necessary to make it independent of aterm (special semantics of WE_EXTERN events) and to support extending the selection with the third button. */ #include "vtimpl.h" int extra_downs=1; /* For aterm */ /* Data structure used by coord_sort */ struct coord { /* A coordinate */ int c, r; /* Column and row */ }; /* * Bubblesort an array of coordinates. */ static void coord_sort(coord, n) struct coord coord[]; int n; { int i, j, big; /* Bubble */ for (j = n; --j > 0; ) { /* Find biggest in 0..j */ for (big = i = 0; ++i <= j; ) { /* Compare big and i */ if (coord[big].r < coord[i].r || (coord[big].r == coord[i].r && coord[big].c < coord[i].c)) big = i; /* Found a bigger one */ } if (big != j) { struct coord swap; swap = coord[big]; coord[big] = coord[j]; coord[j] = swap; } } } /* * Delete double occurences in a sorted * array of coordinates (Both of them!) */ static int no_double(coord, n) struct coord coord[]; int n; { int i, j; for (i = j = 0; i < n; ) { if (i < n - 1 && coord[i].r == coord[i + 1].r && coord[i].c == coord[i + 1].c) { i += 2; /* Skip both */ } else { if (i != j) coord[j] = coord[i]; /* Copy */ ++i; ++j; } } return j; /* Return # array elements */ } /* * Set the selection of a vt, update state variables */ static void set_selection(vt, row1, col1, row2, col2) VT *vt; int row1, col1, row2, col2; { /* Screen coordinates of begins/ends of selection */ struct coord coord[4]; int n_coord, i; /* Above last remembered line; repair */ if (row1 < -vt->topterm) { row1 = -vt->topterm; col1 = 0; } /* Initialise array */ coord[0].r = vt->sel_row1; coord[0].c = vt->sel_col1; coord[1].r = vt->sel_row2; coord[1].c = vt->sel_col2; coord[2].r = row1; coord[2].c = col1; coord[3].r = row2; coord[3].c = col2; /* Sort, optimise */ coord_sort(coord, 4); n_coord = no_double(coord, 4); /* Blit */ if (n_coord > 0) { VTBEGINDRAWING(vt); for (i = 0; i < n_coord; i += 2) vtinvert(vt, coord[i].r, coord[i].c, coord[i+1].r, coord[i+1].c); VTENDDRAWING(vt); } /* Save state */ vt->sel_row1 = row1; vt->sel_col1 = col1; vt->sel_row2 = row2; vt->sel_col2 = col2; } /* set_selection */ /* Pass the selection to STDWIN. Always set cut buffer 0, also try primary selection. Return success/failure of the latter. */ static int pass_selection(vt, data, len) VT *vt; char *data; int len; { wsetcutbuffer(0, data, len); return wsetselection(vt->win, WS_PRIMARY, data, len); } /* Interface to STDWIN selection and cut buffer: save the copied text. Returns success/failure */ static int extract_selection(vt, row1, col1, row2, col2) VT *vt; { /* Swap if needed to make sure (row1, col1) <= (row2, col2) */ if (row1 > row2 || row1 == row2 && col1 > col2) { register int scratch; scratch = row1; row1 = row2; row2 = scratch; scratch = col1; col1 = col2; col2 = scratch; } /* Make sure (0, 0) <= (row1, col1) and (row2, col2) <= (vt->rows, 0) */ if (row1 < 0) { row1 = 0; col1 = 0; } if (row2 > vt->rows) { row2 = vt->rows; col2 = 0; } /* Now, if (row1, col1) >= (row2, col2), the selection is empty */ if (row1 > row2 || row1 == row2 && col1 >= col2) { wresetselection(WS_PRIMARY); /* Clear any previous selection */ return 1; } /* Check for simple case -- everything on one line */ if (row1 == row2 && col2 <= vt->llen[row2]) return pass_selection(vt, vt->data[row1] + col1, col2 - col1); /* Harder case: more lines, or one line + end-of-line */ { char *str, *p; int ok; /* Get (more than) enough memory, fail if can't get it */ p = str = malloc((row2 - row1 + 1) * (vt->cols + 1)); if (p == NULL) return 0; /* Fail */ /* Copy first line, add a newline */ if (col1 < vt->llen[row1]) { strncpy(p, vt->data[row1] + col1, vt->llen[row1] - col1); p += vt->llen[row1] - col1; } *p++ = '\n'; /* Copy intermediate lines, adding newlines */ while (++row1 < row2) { strncpy(p, vt->data[row1], vt->llen[row1]); p += vt->llen[row1]; *p++ = '\n'; } /* Copy last line -- if this is not the first as well, nor too far */ if (row1 == row2 && row2 < vt->rows) { if (col2 <= vt->llen[row2]) { strncpy(p, vt->data[row2], col2); p += col2; } else { /* Beyond last char, copy a \n as well */ strncpy(p, vt->data[row2], vt->llen[row2]); p += vt->llen[row2]; *p++ = '\n'; } } /* Pass the string to STDWIN, free it, and return success */ ok = pass_selection(vt, str, (int) (p - str)); free(str); return ok; } } /* Symbolic values for the modes we can be in while selecting: */ #define SEL_CHARS 0 /* Selecting chars */ #define SEL_WORDS 1 /* Selecting words */ #define SEL_LINES 2 /* Selecting lines */ #define SEL_KINDS 3 /* How many modes we know */ /* Macros to distinguish between various "brands" of characters. A "word" is a sequence of characters of the same brand */ #define BRAND_LETTER 0 #define BRAND_SPACE 1 #define BRAND_PUNCT 2 /* Determine the brand of a character */ static int brand(ch) int ch; { return (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || ('0' <= ch && ch <= '9') || (ch == '_') ? BRAND_LETTER : (ch == ' ' || ch == '\t') ? BRAND_SPACE : BRAND_PUNCT); } /* Called by the mainloop upon a mouse-down. Exits when the mouse is up again; any other intermediate events terminates the selection. Returns whether the selection succeeded */ int vtselect(vt, e) VT *vt; EVENT *e; { int first_row, first_col; /* Coords save at mouse-down */ int was_lazy; /* Zapped because vtsetcursor is lazy as well */ int csr_row, csr_col; /* Cursor saved at mouse-down */ int button_down = 1; /* That's the reason we're called after all */ int sel_mode = SEL_CHARS; /* This one is not yet handled */ int timer_pending = 0; int success = 1; /* We are optimists */ /* Save cursor position */ was_lazy = vt->lazy; vt->lazy = 0; csr_row = vt->cur_row; csr_col = vt->cur_col; /* Init */ first_row = e->u.where.v / vt->cheight; first_col = (e->u.where.h + vt->cwidth/2) / vt->cwidth; if (first_col > vt->llen[first_row]) { /* Clicked beyond eoln; use first char on next line instead */ ++first_row; first_col = 0; } vtsetcursor(vt, first_row, first_col); do { int row, col; /* Current mouse position */ wgetevent(e); switch (e->type) { case WE_MOUSE_UP: button_down = 0; wsettimer(vt->win, 2); timer_pending = 1; break; case WE_MOUSE_MOVE: break; case WE_MOUSE_DOWN: if (e->u.where.button != 1) { /* E.g. paste-button; stop selection */ timer_pending = button_down = 0; wungetevent(e); break; } button_down = 1; sel_mode = (sel_mode + 1) % SEL_KINDS; break; case WE_EXTERN: /* Got output from child - save */ ++extra_downs; continue; /* Get next event */ case WE_TIMER: timer_pending = 0; break; default: wungetevent(e); success = 0; goto reset; } /* * We only get here when we want * to draw the current selection; * Compute new coords */ row = e->u.where.v / vt->cheight; col = (e->u.where.h + vt->cwidth/2) / vt->cwidth; vtsetcursor(vt, row, col); #if 0 /* To do: Make sure everything in the neighbourhood can be seen: */ /* This does not work; it's far too fast */ if (vt->rows > 3 && vt->cols > 3) wshow(vt->win, e->u.where.h - vt->cwidth, e->u.where.v - vt->cheight, e->u.where.h + vt->cwidth, e->u.where.v + vt->cheight); #endif switch (sel_mode) { int rs, cs; case SEL_CHARS: case SEL_WORDS: /* Clip row and col */ if (row > vt->rows) row = vt->rows; else if (row < 0) row = 0; if (col > vt->cols) col = vt->cols; else if (col < 0) col = 0; rs = first_row; cs = first_col; if (sel_mode == SEL_CHARS) { /* Select including the eoln when beyond last char */ if (vt->llen[row] < col) col = vt->cols; } else { /* Sort coordinates */ if (rs > row || (rs == row && cs > col)) { register tmp; tmp = row; row = rs; rs = tmp; tmp = col; col = cs; cs = tmp; } /* Expand */ while (cs > 0 && brand(vt->data[rs][cs]) == brand(vt->data[rs][cs - 1])) --cs; if (col >= vt->llen[row]) col = vt->cols; else while (++col < vt->llen[row] && brand(vt->data[row][col - 1]) == brand(vt->data[row][col])) ; } /* Update screen */ set_selection(vt, rs, cs, row, col); break; case SEL_LINES: if (++row > vt->rows) row = vt->rows; set_selection(vt, first_row >= row ? first_row + 1 : first_row, 0, row, 0); break; } } while (button_down || timer_pending); /* Now pass the selection to STDWIN */ if (!extract_selection(vt, vt->sel_row1, vt->sel_col1, vt->sel_row2, vt->sel_col2)) wfleep(); /* Give the user some indication that it failed */ reset: /* Invert back to normal: */ set_selection(vt, 0, 0, 0, 0); vtsetcursor(vt, csr_row, csr_col); vt->lazy = was_lazy; return success; } /* Extend the selection */ int vtextendselection(vt, ep) VT *vt; EVENT *ep; { /* XXX not yet implemented */ wfleep(); return 0; } --i >= r1; ) { vt->data[i+n] = vt->data[i]; vt->flags[i+n] = vt->flags[i]; vt->llen[i+n] = vt->llensmtalk43/stdwin/Packs/vt/vtsend.c1006440003270021170000000021705465303020014137 037777777777 1 0 /* Default vtsend function */ #include "vtimpl.h" void vtsend(vt, text, len) VT *vt; char *text; int len; { vtansiputs(vt, text, len); } th, r1 * vt->cheight, c2 * vt->cwidth, r2 * vt->cheight); } /* VT interface to wscroll. In lazy mode, the actual scrolling may be postponed (by setting vt->toscroll). */ void vtscroll(vt, r1, c1, r2, c2, drow, dcol) VT *vt; int r1, c1, r2, c2; int drow, dcol; /* Translation vector */ { int scr_top = vt->scr_top; if (scr_top == vt->topterm) scr_top = smtalk43/stdwin/Packs/vt/vtusesend.c1006440003270021170000000053005465303020014652 037777777777 1 0 /* VT functions that send data back to the serial port. */ #include "vtimpl.h" void vtsendid(vt) VT *vt; { vtsend(vt, "\033[?0;0;0c", -1); } void vtsendpos(vt) VT *vt; { char buf[256]; int row = vt->cur_row - vt->topterm + 1; int col = vt->cur_col + 1; CLIPMIN(row, 1); sprintf(buf, "\033[%d;%dR", row, col); vtsend(vt, buf, -1); } 2+drow, c2, r2) ); } else if (drow > 0) { /* Scrolled downwards */ wchange(vt->win, c1, r1, c2, r1+drow); D( printf("V: wchange(%d, %d, %d, %d)\n", smtalk43/stdwin/Packs/vt/vtvtrm.c1006440003270021170000000510505465303020014177 037777777777 1 0 /* VTRM implementation using VT as lower layer. Unfortunately, this isn't too useful on the input part: you'll really want to use wgetevent directly to get access to mouse clicks, menu events etc. Another problem is that there is no portable way to direct normal output (e.g., from printf and putchar) to the VTRM window. One other thing: you'll have to call wdone() when you really exit. */ /* XXX This has never been tested... */ #include "vtimpl.h" #include "vtrm.h" static VT *vt; static bool active; int trmstart(rows_return, cols_return, flags_return) int *rows_return, *cols_return, *flags_return; { if (active) return TE_TWICE; /* Already started */ if (vt == NULL) { winit(); wsetdefwinsize(24*wcharwidth('0'), 80*wlineheight()); vt= vtopen("VTRM", 24, 80, 0); if (vt == NULL) return TE_NOMEM; /* Failure */ } *rows_return= 24; *cols_return= 80; *flags_return= HAS_STANDOUT | CAN_SCROLL | CAN_SENSE; return TE_OK; } trmend() { active= FALSE; } trmputdata(row, col, data) int row, col; char *data; { char *start= data; int mask= 0; vtsetcursor(vt, row, col); do { if ((*data & 0x80) != mask) { if (data > start) { if (mask) { char *p; for (p= start; p < data; ++p) *p &= 0x7f; vt->gflags= VT_INVERSE; } vtputstring(vt, start, data-start); if (mask) { char *p; for (p= start; p < data; ++p) *p |= 0x80; vt->gflags= 0; } start= data; } mask= *data & 0x80; } } while (*data++ != EOS); /* XXX This is likely to omit the final data? */ vteolclear(vt, vt->cur_row, vt->cur_col); } trmscrollup(r1, r2, n) int r1, r2; int n; { if (n > 0) vtscrollup(vt, r1, r2+1, n); else if (n < 0) vtscrolldown(vt, r1, r2+1, -n); } trmsync(row, col) int row, col; { vtsetcursor(vt, row, col); } static lasth, lastv; int trminput() { EVENT e; for (;;) { switch (e.type) { case WE_COMMAND: switch (e.type) { case WC_CANCEL: return '\003'; case WC_RETURN: return '\r'; case WC_TAB: return '\t'; case WC_BACKSPACE: return '\b'; case WC_LEFT: return '\034'; case WC_RIGHT: return '\035'; case WC_UP: return '\036'; case WC_DOWN: return '\037'; } break; case WE_CHAR: return e.u.character; break; case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: lasth= e.u.where.h; lastv= e.u.where.v; if (e.type == WE_MOUSE_UP) return '\007'; break; } } } int trmsense(row_return, col_return) int *row_return, *col_return; { *row_return= lastv / vtcheight(vt); *col_return= lasth / vtcwidth(vt); } re, since I assume that code looking at the input a character at a time is very time-critical. Action functions are called with the start of the text to process, and return a pointer to where they left off. When an action function hits the end of the string, it returns NULL and sets the action pointer to the function to call next (often itself), or to NULL for the default. A non-NULL return implies that the default actsmtalk43/stdwin/Ports/0407550003270021170000000000005477556124011321 5 0 1 0 smtalk43/stdwin/Ports/alfa/0407550003270021170000000000005477556113012222 5 0 1 0 smtalk43/stdwin/Ports/alfa/BUGS1006440003270021170000000040605434024340013474 037777777777 1 0 When there are multiple windows with global & local menus, opening the menus shows the local menus of the highest window instead of those of the active window. (Some menus of other windows may also be shown.) The menu bar is drawn correctly though. ("menu.c") * ESC */ return esc_action(vt, text, end); case BEL: /* Bell */ if (vt->visualbell) { VTBEGINDRAWING(vt); vtinvert(vt, 0, 0, vt->rows, vt->cols); VTENDDRAWING(vt); VTBEGINDRAWING(vt); vtinvert(vt, 0, 0, vt->rows, vt->cosmtalk43/stdwin/Ports/alfa/Make.proto1006440003270021170000000100705434024340014751 037777777777 1 0 # # Makefile prototype for X11 port # SRCS= \ $(ALFA)/bind.c \ $(ALFA)/draw.c \ $(ALFA)/event.c \ $(ALFA)/keymap.c \ $(ALFA)/measure.c \ $(ALFA)/menu.c \ $(ALFA)/scroll.c \ $(ALFA)/stdwin.c \ $(ALFA)/syswin.c \ $(ALFA)/timer.c \ $(TOOLS)/strdup.c \ $(GEN)/waskfile.c \ $(GEN)/waskync.c \ $(GEN)/wperror.c \ $(GEN)/wstyle.c \ $(GEN)/wsetclip.c \ $(GEN)/wsetcutbuffer.c \ $(GEN)/wsetselection.c \ $(VTRM_ALL) \ $(TEXTEDIT_PACK) all: lib.a _bootstrap: @putlibmf lib.a $(SRCS) x\n", text[-1]) ); FAIL(); break; } } /* We fall through the previous loop when we get a printable character */ { char *p = text; while (PRINTABLE(*++p)) { /* At least one character guaranteed! */ if (p >= end) break; } vtputstring(vt, text, (int)(p-text)); text = p; goto again; } } /* Action function called after ESC seen */ STATIC char * esc_action(vt, text, end) VT *vt; char *text, *end; { if (text >= end) { vt->action = esc_action; retusmtalk43/stdwin/Ports/alfa/To.do1006440003270021170000000266605434024340013731 037777777777 1 0 Complain about bad arguments (esp. window pointers) instead of ignoring them Don't scroll so much beyond end of window (in wshow?) Textedit highlights disappear when they are redrawn after a menu covered some text but *not* the highlight Fix wreshuffle to minimize redrawing Fix scrollupdate to minimize redrawing Maintain a stack of active windows so active window after a delete is less surprising Don't grow windows beyond their document size Let wmessage wait for CR to acknowledge? Dreams: Generalized key bindings read from a startup file ~ and $ expansion and file name completion in waskfile (or write a tiny directory browser?) Chages to stdwin by Euromath project? draw.c bogus! fix to scrollupdate; some comments added stdwin.c added wgetwinpos and wgetorigin; support for resize events; don't force showing the caret; don't reset the 'front' window when closing non-front; Lambert's attempts at imporving _wreshuffle??? Of the following changes I am not sure yet: menu.c changed standard menu title and contents; fixed minor bugs; and what else? (lots changed) scroll.c only change is to comment out a fallback on wchange in wscroll when there is horizontal scrolling or not the entire window width is affected. do we need this? syswin.c added wdialog which is like waskstr with an additional multiple-choice list of options (???) (why couldn't this be done as a normal stdwin window?); added RedrawAll and only argument allowed here. */ STATIC void vtprivset(vt) VT *vt;smtalk43/stdwin/Ports/alfa/alfa.h1006440003270021170000000707305434024340014074 037777777777 1 0 /* TERMCAP STDWIN -- INTERNAL HEADER FILE */ /* BEWARE: CONFUSED COORDINATE CONVENTIONS. The VTRM package, used here for terminal output, puts the y coordinate first. The stdwin package itself puts the x coordinate first (but instead of (x, y), it uses (h, v)). Also, when VTRM specifies a range of lines, the second number is the last line included. In stdwin, the second number is the first position NOT included. */ #include "tools.h" #include "stdwin.h" #include "menu.h" #include "vtrm.h" struct _window { short tag; /* Window tag, usable as document id */ short open; /* Set if this struct window is in use */ char *title; /* Title string */ void (*drawproc)(); /* Draw procedure */ short top; /* Top line on screen */ short bottom; /* Bottom line on screen + 1 */ int offset; /* Diff. between doc. and screen line no's */ int curh, curv; /* Text cursor position (doc. coord.) */ TEXTATTR attr; /* Text attributes */ struct menubar mbar; /* Collection of local menus */ long timer; /* Absolute timer value (see timer.c) */ short resized; /* Nonzero when resize event pending */ }; /* Note on the meaning of the 'offset' field: to convert from screen coordinates to document coordinates: add offset; from document coordinates to screen coordinates: subtract offset. */ /* Data structures describing windows. */ #define MAXWINDOWS 20 #define MAXLINES 120 extern WINDOW winlist[MAXWINDOWS]; extern char uptodate[MAXLINES]; extern WINDOW *wasfront, *front, *syswin; extern int lines, columns; extern TEXTATTR wattr; /* KEY MAPPING. */ /* The primary key map is a 256-entry array indexed by the first character received. Secondary key maps are lists terminated with a type field containing SENTINEL. The maps use the same data structure so they can be processed by the same routine. */ struct keymap { unsigned char key; /* Character for which this entry holds */ unsigned char type; /* Entry type */ unsigned char id; /* Id and item of menu shortcut */ unsigned char item; /* Also parameter for other types */ }; /* Entry types: */ #define ORDINARY 0 /* Report char as itself */ #define SECONDARY 1 /* Proceed to secondary keymap [id] */ #define SHORTCUT 2 /* Menu shortcut */ #define SENTINEL 127 /* End of secondary key map */ extern struct keymap _wprimap[256]; extern struct keymap **_wsecmap; #define SECMAPSIZE 128 /* The system menu (menu id 0) has a few entries for window manipulation, followed by entries corresponding to WE_COMMAND subcodes. WC_CLOSE happens to be the first of those, and corresponds with CLOSE_WIN. */ /* Item numbers in system menu: */ #define PREV_WIN 0 #define NEXT_WIN 1 #define CLOSE_WIN 2 /* Offsets between WE_COMMAND subcodes and item numbers in system menu: */ #define FIRST_CMD (CLOSE_WIN - WC_CLOSE) #define LAST_CMD 99 /* There are also some codes that have a shortcut and a special interpretation but no entry in the system menu: */ #define SUSPEND_PROC 100 #define REDRAW_SCREEN 101 #define MOUSE_DOWN 102 #define MOUSE_UP 104 #define LITERAL_NEXT 105 #define MENU_CALL 127 /* Start interactive menu selection */ void wsyscommand(); bool wsysevent(); void wmenuselect(); void wdrawtitle(); void wnewshortcuts(); void wgoto(); void _wselnext(); void _wselprev(); void _wredraw(); void _wsuspend(); void getbindings(); void initsyswin(); void drawmenubar(); void drawlocalmenubar(); void _wreshuffle(); void _wnewtitle(); void wsysdraw(); void killmenubar(); void initmenubar(); void gettckeydefs(); void getttykeydefs(); void wsetmetakey(); void menubarchanged(); void menuselect(); void _wlitnext(); ak; case 'L': vtinslines(vt, a1); break; case 'M': vtdellines(vt, a1); break; case 'P': vtdelchars(vt, a1); break; case 'S': vtlinefeed(vt, a1); break; case 'T': vtrevlinefeed(vt, a1); break; case 'c': vtsendid(vt); break; case 'g': /* Tab clear */ break; /* 0: current col; 3: all */ case 'h': vtsetoptions(vt, TRUE); break; case 'l': vtsetoptions(vt, FALSE); break; case 'm': vtsetattrlist(vt); break; case 'n': if (a1 == 6) vtsensmtalk43/stdwin/Ports/alfa/bind.c1006440003270021170000001601105465303020014067 037777777777 1 0 /* TERMCAP STDWIN -- KEY BINDING. */ /* Separated from the default tables; the application may override the tables but not the executable code. */ #ifdef SYSV #define TERMIO #endif #ifdef unix #ifndef TERMIO #define DO_SGTTY #endif #define DO_TERMCAP #endif #include "alfa.h" #ifdef DO_SGTTY #include #endif #ifdef TERMIO #include #endif #ifdef DO_TERMCAP /* Termcap functions: */ char *tgetstr(); int tgetnum(); bool tgetflag(); #endif /* DO_TERMCAP */ static void charbinding(), tcbinding(), setbinding(); /* Get key definitions from tty settings. */ void getttykeydefs(fd) int fd; { #ifdef unix #ifdef DO_SGTTY struct sgttyb gttybuf; struct tchars tcharbuf; #endif #ifdef TERMIO struct termio tio; #endif copydefaults(); #ifdef DO_SGTTY gtty(fd, >tybuf); charbinding(SHORTCUT, 0, FIRST_CMD+WC_BACKSPACE,(int)gttybuf.sg_erase); ioctl(fd, TIOCGETC, (char *) &tcharbuf); charbinding(SHORTCUT, 0, FIRST_CMD+WC_CANCEL, (int)tcharbuf.t_intrc); #endif #ifdef TERMIO ioctl(fd, TCGETA, &tio); charbinding(SHORTCUT, 0, FIRST_CMD+WC_BACKSPACE, (int)tio.c_cc[2]); charbinding(SHORTCUT, 0, FIRST_CMD+WC_CANCEL, (int)tio.c_cc[0]); #endif #ifdef TIOCGLTC { struct ltchars ltcharbuf; ioctl(fd, TIOCGLTC, (char *) <charbuf); charbinding(SHORTCUT, 0, SUSPEND_PROC, ltcharbuf.t_suspc); charbinding(SHORTCUT, 0, REDRAW_SCREEN, ltcharbuf.t_rprntc); charbinding(SHORTCUT, 0, LITERAL_NEXT, ltcharbuf.t_lnextc); } #endif /* TIOCGLTC */ #endif /* unix */ } #ifdef unix static void charbinding(type, id, item, key) int type; int id, item; int key; { if (key != 0 && (key&0xff) != 0xff) { char keys[2]; keys[0]= key; keys[1]= EOS; setbinding(&_wprimap[*keys & 0xff], type, id, item, keys); } } #endif /* unix */ /* Get key definitions from termcap. */ void gettckeydefs() { #ifdef DO_TERMCAP copydefaults(); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_BACKSPACE, "kb"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_LEFT, "kl"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_RIGHT, "kr"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_UP, "ku"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_DOWN, "kd"); /* tcbinding(SHORTCUT, 0, FIRST_CMD+WC_CLEAR, "kC"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_HOME, "kh"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_HOME_DOWN, "kH"); */ #endif /* DO_TERMCAP */ } #ifdef DO_TERMCAP static void tcbinding(type, id, item, capname) int type; int id, item; char capname[2]; /* Termcap capability name, e.g. "k1" */ { char buf[100]; char *p= buf; char *keys; keys= tgetstr(capname, &p); if (keys != NULL) setbinding(&_wprimap[*keys & 0xff], type, id, item, keys); } #endif /* DO_TERMCAP */ /* Bind a menu item to a meta-key. As there are no meta-keys on standard Unix, this is translated to ESC-key. */ void wsetmetakey(id, item, key) int id, item; int key; { char buf[3]; buf[0]= '\033'; /* ESC */ buf[1]= key; buf[2]= EOS; wsetshortcut(id, item, buf); } /* Bind a menu item to a key sequence. Note that this call is not part of the universal STDWIN interface, only of the Unix interface for ASCII terminals. */ void wsetshortcut(id, item, keys) int id, item; char *keys; { if (keys == NULL || *keys == EOS) return; /* Can't bind empty string */ copydefaults(); setbinding(&_wprimap[*keys & 0xff], SHORTCUT, id, item, keys); } static struct keymap *extendmap(); static int mapsize(map) struct keymap *map; { int size; if (map == NULL) return 0; for (size= 0; map[size].type != SENTINEL; ++size) ; return size+1; } static void setbinding(map, type, id, item, keys) struct keymap *map; int type; int id, item; char *keys; { if (keys[1] == EOS) { map->key= *keys; map->type= type; map->id= id; map->item= item; } else { struct keymap *nmap; if (map->type != SECONDARY) { map->type= SECONDARY; map->id= createmap(); } for (nmap= _wsecmap[map->id]; nmap->type != SENTINEL; ++nmap) { if (nmap->key == keys[1]) break; } if (nmap->type == SENTINEL) nmap= extendmap((int) map->id, (int) keys[1]); if (nmap != NULL) setbinding(nmap, type, id, item, keys+1); } } static struct keymap * extendmap(imap, c) int imap; int c; { L_DECLARE(size, map, struct keymap); if (imap == 0 || imap >= SECMAPSIZE || (map= _wsecmap[imap]) == NULL) return NULL; size= mapsize(map); L_EXTEND(size, map, struct keymap, 1); _wsecmap[imap]= map; if (map == NULL) return NULL; map += size - 2; map->type= ORDINARY; map->key= c; map[1].type= SENTINEL; return map; } static int createmap() { L_DECLARE(size, map, struct keymap); int i; L_EXTEND(size, map, struct keymap, 1); if (map == NULL) return 0; map->type= SENTINEL; for (i= 0; i < SECMAPSIZE && _wsecmap[i] != NULL; ++i) ; if (i >= SECMAPSIZE) { /* Overflow of _wsecmap array */ L_DEALLOC(size, map); return 0; } else { _wsecmap[i]= map; return i; } } /* Copy existing secondary key maps to dynamic memory. Note: don't copy map 0, which is a dummy to force a dead-end street. */ static copydefaults() { static bool been_here= FALSE; int i; struct keymap *map; if (been_here) return; been_here= TRUE; for (i= 1; i < SECMAPSIZE; ++i) { map= _wsecmap[i]; if (map != NULL) { int size= mapsize(map); struct keymap *nmap; int k; nmap= (struct keymap *) malloc( (unsigned) (size * sizeof(struct keymap))); if (nmap != NULL) { for (k= 0; k < size; ++k) nmap[k]= map[k]; } _wsecmap[i]= nmap; } } } /* Routines to get a nice description of a menu item's shortcuts. TO DO: protect against buffer overflow; cache output so it isn't called so often (i.e., twice for each drawitem call!). */ static char * charrepr(c) int c; { static char repr[10]; switch (c) { case 033: return "ESC"; case '\r': return "CR"; case '\b': return "BS"; case '\t': return "TAB"; case 0177: return "DEL"; default: if (c < ' ') { repr[0]= '^'; repr[1]= c|'@'; repr[2]= '\0'; } else if (c < 0177) { repr[0]= c; repr[1]= '\0'; } else { repr[0]= '\\'; repr[1]= '0' + (c>>6); repr[2]= '0' + ((c>>3) & 07); repr[3]= '0' + (c & 07); repr[4]= '\0'; } return repr; } } static char * addrepr(cp, c) char *cp; int c; { char *rp= charrepr(c); while (*rp != '\0') *cp++ = *rp++; return cp; } static char * followmap(cp, map, id, item, stack, level) char *cp; struct keymap *map; int id, item; unsigned char *stack; int level; { if (map->type == SHORTCUT) { if (map->id == id && map->item == item) { int i; for (i= 0; i < level; ++i) { cp= addrepr(cp, (int) stack[i]); *cp++ = '-'; } cp= addrepr(cp, (int) map->key); *cp++ = ','; *cp++ = ' '; } } else if (map->type == SECONDARY) { stack[level]= map->key; map= _wsecmap[map->id]; for (; map->type != SENTINEL; ++map) cp= followmap(cp, map, id, item, stack, level+1); } return cp; } void getbindings(buf, id, item) char *buf; int id; int item; { char *cp= buf; unsigned char stack[50]; struct keymap *map; for (map= _wprimap; map < &_wprimap[256]; ++map) cp= followmap(cp, map, id, item, stack, 0); if (cp > buf) cp -= 2; *cp= EOS; } * Functions used internally */ /* XXX Ought to have names beginning with _vt */ void vtcirculate _ARGS((VT *vt, int r1, int r2, int n)); void vtchange _ARGS((VT *vt, int r1, int c1, int r2, int c2)); void vtshow _ARGS((VT *vt, int r1, int c1, int r2, int c2)); void vtscroll _ARGS((VT *vt, int r1, int c1, int r2, int c2, int dr, int dc)); void vtsync _ARGS((VT *vt)); smtalk43/stdwin/Ports/alfa/draw.c1006440003270021170000002105405465303020014113 037777777777 1 0 /* ALFA STDWIN -- DRAWING. */ #include "alfa.h" static char *textline[MAXLINES]; static short textlen[MAXLINES]; static char texttouched[MAXLINES]; static TEXTATTR draw_saveattr; static WINDOW *draw_win; /* Cause a redraw of part of a window. */ /*ARGSUSED*/ void wchange(win, left, top, right, bottom) WINDOW *win; int left, top; int right, bottom; { int id= win - winlist; int i; if (id < 0 || id >= MAXWINDOWS || !win->open) return; top -= win->offset; bottom -= win->offset; if (top < win->top) top= win->top; if (bottom > win->bottom) bottom= win->bottom; for (i= top; i < bottom; ++i) uptodate[i]= FALSE; _wnewtitle(win); } /* (Try to) make sure a particular part of a window is visible, by scrolling in distant parts if necessary. */ void scrollupdate(); /*ARGSUSED*/ void wshow(win, left, top, right, bottom) WINDOW *win; int left, top; int right, bottom; { int id= win - winlist; int offset; int extra; int dv; if (id < 0 || id >= MAXWINDOWS || !win->open) return; extra= ( (win->bottom - win->top) - (bottom - top) ) / 2; if (extra < 0) extra= 0; offset= win->offset; if (bottom > win->bottom + offset) offset= bottom - win->bottom + extra; if (top < win->top + offset) offset= top - win->top - extra; if (win->top + offset < 0) offset= -win->top; dv= offset - win->offset; if (dv == 0) return; win->offset= offset; /* Now we'll use top, bottom to indicate the changed part. */ top= win->top; bottom= win->bottom; scrollupdate(top, bottom, dv); trmscrollup(top, bottom-1, dv); } /* Similar, but by giving an explicit new origin */ /*ARGSUSED*/ void wsetorigin(win, h, v) WINDOW *win; int h, v; { int id= win - winlist; int top, bottom; int dv; if (id < 0 || id >= MAXWINDOWS || !win->open) return; dv = (v - win->top) - win->offset; if (dv == 0) return; win->offset += dv; top = win->top; bottom = win->bottom; scrollupdate(top, bottom, dv); trmscrollup(top, bottom-1, dv); } /* Scroll the update bits */ /*ARGSUSED*/ void scrollupdate(top, bottom, dv) int top, bottom; int dv; { int i; #ifndef EUROGEMODDER for (i= top; i < bottom; ++i) uptodate[i] = FALSE; #else char *p; if(dv==0) return; if(dv > 0) { for (i= top; i < bottom; ++i) { if (uptodate[i+dv]) { p=textline[i]; textline[i]=textline[i+dv]; textlen[i]=textlen[i+dv]; uptodate[i]= TRUE; textline[i+dv]= p; /*needed? textlen[i+dv]= 0; */ uptodate[i+dv]= FALSE; } else { uptodate[i]= FALSE; } } } else { for (i= bottom-1; i >= top; --i) { if (uptodate[i+dv]) { p=textline[i]; textline[i]=textline[i+dv]; textlen[i]=textlen[i+dv]; uptodate[i]= TRUE; textline[i+dv]= p; /*needed? textlen[i+dv]= 0; */ uptodate[i+dv]= FALSE; } else { uptodate[i]= FALSE; } } } #endif } /* Set the caret (cursor) position. */ void wsetcaret(win, h, v) WINDOW *win; int h, v; { win->curh= h; win->curv= v; /* wshow(win, h, v, h+1, v+1); */ /* Shouldn't call wshow here -- it's not always desirable! */ } /* Remove the caret altogether. */ void wnocaret(win) WINDOW *win; { win->curh= win->curv= -1; } /* Cause a redraw of the window 's title bar. */ void _wnewtitle(win) WINDOW *win; { if (win->top > 0) uptodate[win->top-1]= FALSE; } /* Compute the smallest rectangle that needs an update. As a side effect, uptodate is set to TRUE for the affected lines, and the lines are cleared and set to touched (but no actual output is performed). Return FALSE if the rectangle is empty. */ bool wgetchange(win, pleft, ptop, pright, pbottom) WINDOW *win; int *pleft, *ptop, *pright, *pbottom; { int top= win->bottom; int bottom= win->top; int i; for (i= win->top; i < win->bottom; ++i) { if (!uptodate[i]) { texttouched[i]= TRUE; textlen[i]= 0; uptodate[i]= TRUE; if (top > i) top= i; bottom= i+1; } } if (top > bottom) { *pleft= *pright= *ptop= *pbottom= 0; return FALSE; } else { *pleft= 0; *pright= columns; *ptop= top + win->offset; *pbottom= bottom + win->offset; return TRUE; } } void wupdate(win) WINDOW *win; { int left, top, right, bottom; wgetchange(win, &left, &top, &right, &bottom); wbegindrawing(win); if (win->drawproc != NULL) (*win->drawproc)(win, 0, top, columns, bottom); wenddrawing(win); } void wbegindrawing(win) WINDOW *win; { int i; if (draw_win != NULL) wenddrawing(draw_win); /* Finish previous job */ /* Auto-initialization of the textline array. The other arrays needn't be initialized, since they are preset to zero. */ for (i= win->top; i < win->bottom; ++i) { if (textline[i] == NULL) textline[i]= malloc((unsigned) (columns+1)); /*uptodate[i]= FALSE;*/ } draw_saveattr= wattr; wattr= win->attr; draw_win= win; } void wenddrawing(win) WINDOW *win; { int i; if (draw_win != win) { return; /* Bad call */ } for (i= win->top; i < win->bottom; ++i) { if (texttouched[i]) { texttouched[i]= FALSE; textline[i][textlen[i]]= EOS; trmputdata(i, i, 0, textline[i]); } } wattr= draw_saveattr; draw_win= NULL; } void wdrawtitle(win) WINDOW *win; { int titline= win->top - 1; char buf[256]; char *title= win->title == NULL ? "" : win->title; int tlen= strlen(title); int space= columns-tlen; int mask= (win == front) ? 0200 : 0; int k; for (k= 0; k < space/2 - 1; ++k) buf[k]= '-'|mask; buf[k++]= ' '|mask; while (k < columns && *title != EOS) buf[k++]= *title++|mask; if (k < columns) buf[k++]= ' '|mask; while (k < columns) buf[k++]= '-'|mask; buf[k]= EOS; trmputdata(titline, titline, 0, buf); uptodate[titline]= TRUE; } void wdrawtext(h, v, str, len) int h, v; char *str; int len; { int k; int mask= (wattr.style == 0) ? 0 : 0200; char *text; WINDOW *win= draw_win; if (len < 0) len= strlen(str); v -= win->offset; if (v < win->top || v >= win->bottom || h >= columns || len == 0) return; text= textline[v]; k= textlen[v]; while (k < h) text[k++]= ' '; while (len > 0) { #define APPC(c) \ if (h >= 0) text[h]= (c) | mask; if (++h >= columns) break unsigned char c= *str++; --len; if (c < ' ') { APPC('^'); APPC(c | '@'); } else if (c < 0177) { APPC(c); } else if (c < 0200) { APPC('^'); APPC('?'); } else { APPC('\\'); APPC('0' | ((c>>6) & 07)); APPC('0' | ((c>>3) & 07)); APPC('0' | (c & 07)); } #undef APPC } if (h > textlen[v]) textlen[v]= h; texttouched[v]= TRUE; } void wdrawchar(h, v, c) int h, v; int c; { char cbuf[2]; cbuf[0]= c; cbuf[1]= EOS; wdrawtext(h, v, cbuf, 1); } void wgetwintextattr(win, attr) WINDOW *win; TEXTATTR *attr; { *attr= win->attr; } void wsetwintextattr(win, attr) WINDOW *win; TEXTATTR *attr; { win->attr= *attr; } /* Non-text drawing dummy functions: */ /*ARGSUSED*/ void wdrawline(h1, v1, h2, v2) int h1, v1, h2, v2; { } /*ARGSUSED*/ void wxorline(h1, v1, h2, v2) int h1, v1, h2, v2; { } /*ARGSUSED*/ void wdrawcircle(h, v, radius) int h, v; int radius; { } /*ARGSUSED*/ void wdrawelarc(h, v, radh, radv, ang1, ang2) int h, v; int radh, radv; int ang1, ang2; { } /*ARGSUSED*/ void wdrawbox(left, top, right, bottom) int left, top, right, bottom; { } /*ARGSUSED*/ void wpaint(left, top, right, bottom) int left, top, right, bottom; { } /*ARGSUSED*/ void wshade(left, top, right, bottom, percentage) int left, top, right, bottom; int percentage; { } /*ARGSUSED*/ void winvert(left, top, right, bottom) int left, top, right, bottom; { WINDOW *win= draw_win; int v; if (left < 0) left= 0; if (right >= columns) right= columns; if (left >= right) return; top -= win->offset; bottom -= win->offset; if (top < win->top) top= win->top; if (bottom > win->bottom) bottom= win->bottom; for (v= top; v < bottom; ++v) { int k= textlen[v]; char *text= textline[v]; if (k < right) { do { text[k++]= ' '; } while (k < right); textlen[v]= k; } for (k= left; k < right; ++k) text[k] ^= 0200; texttouched[v]= TRUE; } } /*ARGSUSED*/ void werase(left, top, right, bottom) int left, top, right, bottom; { WINDOW *win= draw_win; int v; if (left < 0) left= 0; if (right >= columns) right= columns; if (left >= right) return; top -= win->offset; bottom -= win->offset; if (top < win->top) top= win->top; if (bottom > win->bottom) bottom= win->bottom; for (v= top; v < bottom; ++v) { int k= textlen[v]; char *text= textline[v]; if (k > right) k= right; while (--k >= left) text[k]= ' '; texttouched[v]= TRUE; } } /*ARGSUSED*/ void wcliprect(left, top, right, bottom) int left, top, right, bottom; { /* XXX not implemented */ } /*ARGSUSED*/ void wnoclip() { /* XXX not implemented */ } vt->sel_col2; coord[2].r = row1; coord[2].c = col1; coord[3].r = row2; coord[3].c = col2; /* Sort, optimise */ coord_sort(coord, 4); n_coord = no_double(coord, 4); /* Blit */ if (n_coord > 0) { VTBEGINDRAWING(vt); for (i = 0; i < n_coord; i += 2) vtinvert(vt, coord[i].r, coord[i].c, coord[i+1].r, coord[i+1].c); VTENDDRAWING(vt); } /* Save state */ vt->sel_row1 = row1; vt->sel_col1 = col1; vt->sel_rsmtalk43/stdwin/Ports/alfa/event.c1006440003270021170000001405705465303020014304 037777777777 1 0 /* STDWIN -- EVENTS. */ #include "alfa.h" /* There are three levels of event processing. The lowest ('raw') level only inputs single characters. The middle ('sys') level translates sequences of keys to menu shortcuts and 'commands'. The highest ('appl') level executes certain commands and can call the interactive menu selection code. It also sets the window parameter. For each level there are variants to wait or poll. Additional routines to get from one level to another: wmapchar: inspect key map and possibly convert char event wsyscommand: execute/transform system menu /* Raw event -- read one character. If blocking is FALSE, don't read if trmavail() returns -1, meaning it can't tell whether there is input or not. In that case only synchronous input works. */ static bool wrawevent(ep, blocking) EVENT *ep; bool blocking; { if (!blocking && trmavail() <= 0) return FALSE; ep->u.character= trminput(); if (ep->u.character < 0) { ep->type= WE_NULL; return FALSE; } else { ep->type= WE_CHAR; return TRUE; } } static void wmapchar(); /* Forward */ /* System event -- read a character and translate using the key map. */ bool wsysevent(ep, blocking) EVENT *ep; bool blocking; { struct keymap mapentry; if (!wrawevent(ep, blocking)) return FALSE; /* Using a temporary to avoid a tahoe C compiler bug */ mapentry= _wprimap[ep->u.character & 0xff]; wmapchar(ep, mapentry); return ep->type != WE_NULL; } /* Key map translation from raw event. This may read more characters if the start of a multi-key sequence is found. */ static void wmapchar(ep, mapentry) EVENT *ep; struct keymap mapentry; { switch (mapentry.type) { case SHORTCUT: ep->type= WE_MENU; ep->u.m.id= mapentry.id; ep->u.m.item= mapentry.item; break; case SECONDARY: if (wrawevent(ep, TRUE)) { struct keymap *map; struct keymap *altmap= NULL; for (map= _wsecmap[mapentry.id]; map->type != SENTINEL; ++map) { if (map->key == ep->u.character) { wmapchar(ep, *map); return; } else if (islower(ep->u.character) && map->key == toupper(ep->u.character)) altmap= map; } if (altmap != NULL) { wmapchar(ep, *altmap); return; } } trmbell(); ep->type= WE_NULL; break; } } void wgoto(ep, type) EVENT *ep; int type; { int h, v; trmsense(&v, &h); if (v >= 0) { WINDOW *win; for (win= &winlist[1]; win < &winlist[MAXWINDOWS]; ++win) { if (win->open && v >= win->top && v < win->bottom) { if (win == front) { ep->type= type; ep->u.where.h= h; ep->u.where.v= v + win->offset; ep->u.where.clicks= 1; ep->u.where.button= 1; ep->u.where.mask= (type == WE_MOUSE_UP ? 0 : 1); return; } wsetactive(win); break; } } } ep->type= WE_NULL; } void wmouseup(ep) EVENT *ep; { int h, v; trmsense(&v, &h); if (v < 0) ep->type= WE_NULL; else { ep->type= WE_MOUSE_UP; ep->u.where.h= h; ep->u.where.v= v + front->offset; ep->u.where.clicks= 1; ep->u.where.button= 1; ep->u.where.mask= 0; } } static void wdoupdates(); /* Forward */ /* Application event. */ static EVENT ebuf; void wungetevent(ep) EVENT *ep; { ebuf= *ep; } bool wpollevent(ep) EVENT *ep; { return wevent(ep, FALSE); } void wgetevent(ep) EVENT *ep; { (void) wevent(ep, TRUE); } static bool wevent(ep, blocking) EVENT *ep; bool blocking; { static int lasttype= WE_NULL; if (ebuf.type != WE_NULL) { *ep= ebuf; ebuf.type= WE_NULL; return TRUE; } ep->type= WE_NULL; ep->window= NULL; if (lasttype == WE_MOUSE_DOWN) wmouseup(ep); while (ep->type == WE_NULL) { if (front != wasfront) { if (wasfront != NULL) { ep->type= WE_DEACTIVATE; ep->window= wasfront; wasfront= NULL; } else { menubarchanged(); ep->type= WE_ACTIVATE; wasfront= front; } } else { if (trmavail() <= 0) wdoupdates(ep); if (ep->type == WE_NULL) { /* Remove this call if no select() exists */ if (_w_checktimer(ep, blocking)) break; if (!wsysevent(ep, blocking)) { ep->type= WE_NULL; break; } if (ep->type == WE_MENU && ep->u.m.id == 0) wsyscommand(ep); } } } if (ep->window == NULL && front != syswin) ep->window= front; lasttype= ep->type; return ep->type != WE_NULL; } void wsyscommand(ep) EVENT *ep; { ep->type= WE_NULL; switch (ep->u.m.item) { default: if (ep->u.m.item <= LAST_CMD) { ep->type= WE_COMMAND; ep->u.command= ep->u.m.item - FIRST_CMD; } break; case NEXT_WIN: _wselnext(); break; case PREV_WIN: _wselprev(); break; case SUSPEND_PROC: _wsuspend(); break; case REDRAW_SCREEN: _wredraw(); break; case MOUSE_DOWN: case MOUSE_UP: wgoto(ep, ep->u.m.item - MOUSE_DOWN + WE_MOUSE_DOWN); break; case LITERAL_NEXT: _wlitnext(ep); break; case MENU_CALL: menuselect(ep); break; } } /* Flush output and place cursor. */ void wflush() { int y= front->curv - front->offset; int x= front->curh; if (front->curv < 0 || y < front->top || y >= front->bottom) { y= front->top; if (y > 0) --y; x= 0; } else if (x < 0) x= 0; else if (x >= columns) x= columns-1; trmsync(y, x); } /* Process pending window updates. If a window has no draw procedure, a WE_DRAW event is generated instead. */ static void wdoupdates(ep) EVENT *ep; { WINDOW *win; int left, top, right, bottom; for (win= winlist; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { if (win->top > 0 && !uptodate[win->top - 1]) wdrawtitle(win); if (wgetchange(win, &left, &top, &right, &bottom)) { if (win->drawproc == NULL) { ep->type= WE_DRAW; ep->window= win; ep->u.area.left= left; ep->u.area.top= top; ep->u.area.right= right; ep->u.area.bottom= bottom; return; } else { wbegindrawing(win); (*win->drawproc)(win, left, top, right, bottom); wenddrawing(win); } } if(win->resized) { win->resized = FALSE; ep->type = WE_SIZE; ep->window = win; return; } } } wflush(); } void _wlitnext(ep) EVENT *ep; { (void) wrawevent(ep, TRUE); } ep(); /* Give the user some indication that it failed */ reset: /* Invert back to normal: */ set_selection(vt, 0, 0, 0, 0); vtsetcursor(vt, csr_row, csr_col); vt->lazy = was_lazy; return success; } /* Extend the selection */ int vtextendselection(vt, ep) VT *vt; EVENT *ep; { /* XXX not yet implemented */ wfleep(); return 0; } --i >= r1; ) { vt->data[i+n] = vt->data[i]; vt->flags[i+n] = vt->flags[i]; vt->llen[i+n] = vt->llensmtalk43/stdwin/Ports/alfa/keymap.c1006440003270021170000000600405465303020014442 037777777777 1 0 /* STDWIN -- KEY MAPPING TABLES. */ #include "alfa.h" #define CTLX_MAP 1 #define ESC_MAP 2 #define PC_MAP 3 /* The key map is set up to provide shortcuts for the system menu. */ struct keymap _wprimap[256]= { #ifdef MSDOS /* ^@ */ { 0, SECONDARY, PC_MAP, 0}, /* ^@ map */ #else /* !MSDOS */ /* ^@ */ { 0, ORDINARY, 0, 0}, #endif /* ^A */ { 1, ORDINARY, 0, 0}, /* ^B */ { 2, SHORTCUT, 0, FIRST_CMD+WC_LEFT}, /* ^C */ { 3, SHORTCUT, 0, FIRST_CMD+WC_CANCEL}, /* ^D */ { 4, ORDINARY, 0, 0}, /* ^E */ { 5, ORDINARY, 0, 0}, /* ^F */ { 6, SHORTCUT, 0, FIRST_CMD+WC_RIGHT}, /* ^G */ { 7, SHORTCUT, 0, MOUSE_DOWN}, /* ^H */ { 8, SHORTCUT, 0, FIRST_CMD+WC_BACKSPACE}, /* ^I */ { 9, SHORTCUT, 0, FIRST_CMD+WC_TAB}, /* ^J */ {10, SHORTCUT, 0, FIRST_CMD+WC_RETURN}, /* ^K */ {11, ORDINARY, 0, 0}, /* ^L */ {12, SHORTCUT, 0, REDRAW_SCREEN}, /* ^M */ {13, SHORTCUT, 0, FIRST_CMD+WC_RETURN}, /* ^N */ {14, SHORTCUT, 0, FIRST_CMD+WC_DOWN}, /* ^O */ {15, ORDINARY, 0, 0}, /* ^P */ {16, SHORTCUT, 0, FIRST_CMD+WC_UP}, /* ^Q */ {17, ORDINARY, 0, 0}, /* ^R */ {18, SHORTCUT, 0, REDRAW_SCREEN}, /* ^S */ {19, ORDINARY, 0, 0}, /* ^T */ {20, ORDINARY, 0, 0}, /* ^U */ {21, ORDINARY, 0, 0}, /* ^V */ {22, SHORTCUT, 0, LITERAL_NEXT}, /* ^W */ {23, ORDINARY, 0, 0}, /* ^X */ {24, SECONDARY, CTLX_MAP, 0}, /* ^X map */ /* ^Y */ {25, ORDINARY, 0, 0}, /* ^Z */ {26, SHORTCUT, 0, SUSPEND_PROC}, /* ^[ */ {27, SECONDARY, ESC_MAP, 0}, /* ESC map */ /* ^\ */ {28, ORDINARY, 0, 0}, /* ^] */ {29, ORDINARY, 0, 0}, /* ^^ */ {30, ORDINARY, 0, 0}, /* ^_ */ {31, ORDINARY, 0, 0}, /* Followed by 224 entries with type == ORDINARY. */ /* NB: DEL (0177) should be mapped to BS_KEY. */ }; static struct keymap dummy_map[]= { {0, SENTINEL, 0, 0} }; static struct keymap ctlx_map[]= { {'N', SHORTCUT, 0, NEXT_WIN}, {'P', SHORTCUT, 0, PREV_WIN}, {'D', SHORTCUT, 0, CLOSE_WIN}, {'\003', SHORTCUT, 0, CLOSE_WIN}, /* ^X-^C */ {0, SENTINEL, 0, 0} }; static struct keymap esc_map[]= { {'\033', SHORTCUT, 0, MENU_CALL}, /* ESC-ESC */ {'\007', SHORTCUT, 0, MOUSE_UP}, /* ESC-^G */ {0, SENTINEL, 0, 0} }; #ifdef MSDOS static struct keymap pc_map[]= { /* {0003, ORDINARY, 0, 0}, */ /* ^@ should map to true ^@ */ {0107, SHORTCUT, 0, FIRST_CMD+WC_HOME}, {0110, SHORTCUT, 0, FIRST_CMD+WC_UP}, {0113, SHORTCUT, 0, FIRST_CMD+WC_LEFT}, {0115, SHORTCUT, 0, FIRST_CMD+WC_RIGHT}, {0120, SHORTCUT, 0, FIRST_CMD+WC_DOWN}, {0111, SHORTCUT, 0, FIRST_CMD+WC_PAGE_UP}, {0117, SHORTCUT, 0, FIRST_CMD+WC_END}, {0121, SHORTCUT, 0, FIRST_CMD+WC_PAGE_DOWN}, {0123, SHORTCUT, 0, FIRST_CMD+WC_CLEAR}, {0163, SHORTCUT, 0, FIRST_CMD+WC_META_LEFT}, {0164, SHORTCUT, 0, FIRST_CMD+WC_META_RIGHT}, {0165, SHORTCUT, 0, FIRST_CMD+WC_META_END}, {0166, SHORTCUT, 0, FIRST_CMD+WC_META_PAGE_DOWN}, {0167, SHORTCUT, 0, FIRST_CMD+WC_META_HOME}, {0204, SHORTCUT, 0, FIRST_CMD+WC_META_PAGE_UP}, {0, SENTINEL, 0, 0} }; #endif /* MSDOS */ static struct keymap *sec_map_list[SECMAPSIZE]= { dummy_map, ctlx_map, esc_map, #ifdef MSDOS pc_map, #endif }; struct keymap **_wsecmap= sec_map_list; int row, col; char *data; { char *start= data; int mask= 0; vtsetcursor(vt, row, col); do { if ((*data & 0x80) != mask) { if (data > start) { if (mask) { char *p; for (p= start; p < data; ++p) *p &= 0x7f; vt->gflags= VT_INVERSE; } vtputstring(vt, start, data-start); if (mask) { char *p; for (p= start; p < data; ++p) *p |= 0x80; vt->gflags= 0; } start= data; } mask= *data & 0x80; } } while (*data++ != EOS); /* XXX Thissmtalk43/stdwin/Ports/alfa/measure.c1006440003270021170000000134705465303020014622 037777777777 1 0 /* STANDARD WINDOWS -- TEXT MEASURING. */ #include "alfa.h" int wlineheight() { return 1; } int wbaseline() { return 1; } #define CHARWIDTH(c) ((c) < ' ' ? 2 : (c) < 0177 ? 1 : (c) < 0200 ? 2 : 4) int wtextwidth(str, len) char *str; int len; { int i; int w= 0; if (len < 0) len= strlen(str); for (i= 0; i < len; ++i) { unsigned char c= str[i]; w += CHARWIDTH(c); } return w; } int wcharwidth(c) int c; { c &= 0xff; return CHARWIDTH(c); } int wtextbreak(str, len, width) char *str; int len; int width; { int i; if (len < 0) len= strlen(str); for (i= 0; i < len && width > 0; ++i) { unsigned char c= str[i]; width -= CHARWIDTH(c); if (width < 0) break; /* Before incrementing i! */ } return i; } cess, and return a pointer to where they left off. When an action function hits the end of the string, it returns NULL and sets the action pointer to the function to call next (often itself), or to NULL for the default. A non-NULL return implies that the default actsmtalk43/stdwin/Ports/alfa/menu.c1006440003270021170000002417605465303020014132 037777777777 1 0 /* TERMCAP STDWIN -- MENUS. */ #include "alfa.h" static bool deflocal= FALSE; /* Default menu state */ static struct menubar gmenus; /* All global menus */ static struct menubar lmenus; /* All local menus */ static MENU *sysmenu; /* Window selection commands */ static MENU *curmenu; static void addtobar(mbp, mp) struct menubar *mbp; MENU *mp; { int i; for (i= 0; i < mbp->nmenus; ++i) { if (mp == mbp->menulist[i]) return; /* Already attached */ } L_APPEND(mbp->nmenus, mbp->menulist, MENU *, mp); } static void delfrombar(mbp, mp) struct menubar *mbp; MENU *mp; { int i; for (i= 0; i < mbp->nmenus; ++i) { if (mp == mbp->menulist[i]) { L_REMOVE(mbp->nmenus, mbp->menulist, MENU *, i); break; } } } _winitmenus() { sysmenu= wmenucreate(0, "Windows"); wmenuadditem(sysmenu, "Previous Window", -1); wmenuadditem(sysmenu, "Next Window", -1); #ifndef EM /* Somehow, Euromath doesn't like this?!? */ wmenuadditem(sysmenu, "Close Window", -1); wmenuadditem(sysmenu, "(left)", -1); wmenuadditem(sysmenu, "(right)", -1); wmenuadditem(sysmenu, "(up)", -1); wmenuadditem(sysmenu, "(down)", -1); wmenuadditem(sysmenu, "(cancel)", -1); wmenuadditem(sysmenu, "(backspace)", -1); wmenuadditem(sysmenu, "(tab)", -1); wmenuadditem(sysmenu, "(return)", -1); #endif /* Shortcuts are compiled in the key map! */ } MENU * wmenucreate(id, title) int id; char *title; { MENU *mp= ALLOC(MENU); if (mp == NULL) return NULL; mp->id= id; mp->title= strdup(title); mp->local= deflocal; mp->dirty= TRUE; mp->left= mp->right= 0; L_INIT(mp->nitems, mp->itemlist); addtobar(mp->local ? &lmenus : &gmenus, mp); if (!mp->local) menubarchanged(); return mp; } void wmenudelete(mp) MENU *mp; { int i; if (mp->local) { for (i= 0; i < MAXWINDOWS; ++i) { if (winlist[i].open) delfrombar(&winlist[i].mbar, mp); } } delfrombar(mp->local ? &lmenus : &gmenus, mp); for (i= 0; i < mp->nitems; ++i) { FREE(mp->itemlist[i].text); FREE(mp->itemlist[i].shortcut); } L_DEALLOC(mp->nitems, mp->itemlist); FREE(mp); menubarchanged(); } int wmenuadditem(mp, text, shortcut) MENU *mp; char *text; int shortcut; { struct item it; mp->dirty= TRUE; it.text= strdup(text); #ifdef EM /* need to add the shortcut now, otherwise it will be taken from the keymap whenever the menu is displayed, which might be after opening another window and overwriting the keymap entry. In the AddMenuEntry code I overwrite the shortcut anyway. */ /* I don't understand this --Guido */ if(shortcut >= 32) { it.shortcut=(char *)malloc(8); sprintf(it.shortcut,"ESC %c", shortcut); } else #endif it.shortcut= NULL; it.enabled= (text != NULL && *text != EOS); it.checked= FALSE; L_APPEND(mp->nitems, mp->itemlist, struct item, it); if (shortcut >= 0) wsetmetakey(mp->id, mp->nitems-1, shortcut); return mp->nitems-1; } void wmenusetitem(mp, item, text) MENU *mp; int item; char *text; { if (item < 0 || item >= mp->nitems) return; mp->dirty= TRUE; FREE(mp->itemlist[item].text); mp->itemlist[item].text= strdup(text); mp->itemlist[item].enabled= (text != NULL && *text != EOS); } void wmenuenable(mp, item, flag) MENU *mp; int item; int flag; { if (item < 0 || item >= mp->nitems) return; mp->itemlist[item].enabled= flag; } void wmenucheck(mp, item, flag) MENU *mp; int item; int flag; { if (item < 0 || item >= mp->nitems) return; mp->itemlist[item].checked= flag; } void wmenuattach(win, mp) WINDOW *win; MENU *mp; { if (!mp->local) return; addtobar(&win->mbar, mp); if (win == front) menubarchanged(); } void wmenudetach(win, mp) WINDOW *win; MENU *mp; { if (!mp->local) return; delfrombar(&win->mbar, mp); if (win == front) menubarchanged(); } void wmenusetdeflocal(local) bool local; { deflocal= local; } /* Interface routines for the rest of the library. */ void initmenubar(mb) struct menubar *mb; { L_INIT(mb->nmenus, mb->menulist); } void killmenubar(mb) struct menubar *mb; { L_DEALLOC(mb->nmenus, mb->menulist); } void drawmenubar() /* This is part of the syswin draw procedure! */ { WINDOW *win= front; char buf[256]; int k= 0; int i; buf[0]= EOS; for (i= 0; i < gmenus.nmenus; ++i) k= bufappend(buf, k, gmenus.menulist[i]); if (win != NULL) { for (i= 0; i < win->mbar.nmenus; ++i) k= bufappend(buf, k, win->mbar.menulist[i]); } wdrawtext(0, 0, buf, -1); } static int bufappend(buf, pos, mp) char *buf; int pos; MENU *mp; { if (pos > 0) { buf[pos++]= ' '; buf[pos++]= ' '; } mp->left= pos; strcpy(buf+pos, mp->title); pos += strlen(buf+pos); mp->right= pos; return pos; } /* TO DO: - highlight current menu title, current menu item - remember last menu and item - Allow GOTO to select menus or menu items (m-down on mbar opens the menu; m-up on item selects the item) */ static void menudraw(), menuitemdraw(), menucalcwidth(); static bool handleevt(), handlecmd(), handlemenu(); static int calcleft(); static leftblank; static bool curlocal; static struct menubar * curmbar; static int curimenu; static int curitem; static int lowest; static bool firstmenu() { curlocal= FALSE; curmbar= &gmenus; curimenu= 0; if (curmbar->nmenus == 0) { curmbar= &lmenus; curlocal= TRUE; if (curmbar->nmenus == 0) { wmessage("No menus defined"); return FALSE; } } curmenu= curmbar->menulist[curimenu]; curitem= 0; menudraw(); return TRUE; } static void nextmenu() { WINDOW *win=front; /* added mcv */ /* the menus are now taken from the window's menubar, instead of the menubar for *all* local menus */ ++curimenu; while (curimenu >= curmbar->nmenus) { curlocal= !curlocal; curmbar= curlocal ? &win->mbar /* changed mcv, was: &lmenus*/ : &gmenus; curimenu= 0; } curmenu= curmbar->menulist[curimenu]; curitem= 0; menudraw(); } static void prevmenu() { WINDOW *win=front; /* added mcv */ /* the menus are now taken from the window's menubar, instead of the menubar for *all* local menus */ --curimenu; while (curimenu < 0) { curlocal= !curlocal; curmbar= curlocal ? &win->mbar /* changed mcv, was: &lmenus*/ : &gmenus; curimenu= curmbar->nmenus - 1; } curmenu= curmbar->menulist[curimenu]; curitem= 0; menudraw(); } static void nextitem() { ++curitem; if (curitem >= curmenu->nitems) curitem= 0; trmsync(curitem+1, curmenu->left); } static void previtem() { --curitem; if (curitem < 0) curitem= curmenu->nitems - 1; trmsync(curitem+1, curmenu->left); } static void selectitem(ep) EVENT *ep; { ep->type= WE_NULL; if (curitem >= curmenu->nitems || !curmenu->itemlist[curitem].enabled) return; ep->type= WE_MENU; ep->u.m.id= curmenu->id; ep->u.m.item= curitem; } void menuselect(ep) EVENT *ep; { leftblank= columns; lowest= 0; wmessage((char *)NULL); if (!firstmenu()) return; for (;;) { wsysevent(ep, 1); if (handleevt(ep)) break; } } static bool handleevt(ep) EVENT *ep; { switch (ep->type) { case WE_MENU: return handlemenu(ep); case WE_COMMAND: return handlecmd(ep); default: trmbell(); return FALSE; } } static bool handlecmd(ep) EVENT *ep; { switch (ep->u.command) { default: trmbell(); return FALSE; case WC_RETURN: selectitem(ep); if (curmenu == sysmenu) wsyscommand(ep); return TRUE; case WC_LEFT: prevmenu(); break; case WC_RIGHT: nextmenu(); break; case WC_UP: previtem(); break; case WC_DOWN: nextitem(); break; case WC_CANCEL: ep->type= WE_NULL; return TRUE; } return FALSE; } static bool handlemenu(ep) EVENT *ep; { if (ep->u.m.id != 0) return TRUE; switch (ep->u.m.item) { case SUSPEND_PROC: _wsuspend(); menudraw(); break; case REDRAW_SCREEN: _wredraw(); menudraw(); break; case MENU_CALL: ep->type= WE_NULL; return TRUE; default: if (ep->u.m.item <= LAST_CMD) { wsyscommand(ep); if (ep->type == WE_COMMAND) return handlecmd(ep); else return TRUE; } else { trmbell(); return FALSE; } } return FALSE; } static void menudraw() { MENU *mp= curmenu; int left; int width; int i; wupdate(syswin); if (mp->dirty) menucalcwidth(mp); left= calcleft(mp); width= mp->maxwidth; if (left + width > columns) width= columns - left; for (i= 0; i < mp->nitems; ++i) menuitemdraw(i+1, left, &mp->itemlist[i], width); if (i+1 > lowest) { lowest= i+1; if (lowest < lines) uptodate[lowest]= FALSE; } trmputdata(i+1, lowest, 0, ""); leftblank= left; trmsync(curitem+1, mp->left); } static int calcleft(mp) MENU *mp; { int left= columns - mp->maxwidth; if (left > mp->left) left= mp->left; if (left < 0) left= 0; if (left-3 < leftblank) { leftblank= left-3; if (leftblank < 4) leftblank= 0; } return left; } static void menuitemdraw(line, left, ip, width) int line, left; struct item *ip; int width; { char buf[256]; int margin= left-leftblank; buf[0]= EOS; if (ip->text != NULL && *ip->text != EOS) { int space; char *p= buf; for (space= margin; space-- > 0; ) *p++ = ' '; if (ip->checked && margin >= 2) p[-2]= '*'; strcpy(p, ip->text); p += strlen(p); if (!ip->enabled && margin >= 1 && ip->text != NULL && ip->text[0] != EOS) { buf[margin-1]= '('; *p++= ')'; *p= '\0'; } if (ip->shortcut != NULL && *ip->shortcut != EOS) { space= width - (p - buf - margin) - strlen(ip->shortcut); if (space <= 0) space= 2; while (--space >= 0) *p++ = ' '; strcpy(p, ip->shortcut); } } /* This was added because brackets and stars from disabled/marked items on the first menu (after the sysmenu) weren't removed from the screen. I haven't tried to fix this in a more efficient manner. */ trmputdata(line, line, 0, ""); trmputdata(line, line, leftblank, buf); uptodate[line]= FALSE; } static void menucalcwidth(mp) MENU *mp; { int i; int width= 0; for (i= 0; i < mp->nitems; ++i) { struct item *ip= &mp->itemlist[i]; char *text= ip->text; if (text != NULL && *text != EOS) { int w= strlen(text); if (ip->shortcut == NULL) { char buf[256]; getbindings(buf, mp->id, i); ip->shortcut= strdup(buf); } if (ip->shortcut != NULL && *ip->shortcut != EOS) w += 2 + strlen(ip->shortcut); if (w > width) width= w; } } mp->maxwidth= width; mp->dirty= FALSE; } the executable code. */ #ifdef SYSV #define TERMIO #endif #ifdef unix #ifndef TERMIO #define DO_SGTTY #endif #define DO_TERMCAP #endif #include "alfa.h" #ifdef DO_SGTTY #include #endif #ifdef TERMIO #include #endif #ifdef DO_TERMCAP /* Termcap functions: */ char *tgetstr(); int tgetnum(); bool tgetflag(); #endif /* DO_TERMCAP */ static void charbinding(), smtalk43/stdwin/Ports/alfa/menu.h1006440003270021170000000127305434024342014133 037777777777 1 0 /* TERMCAP STDWIN -- MENU DEFINITIONS */ struct item { char *text; /* The item's text */ char *shortcut; /* Visible representation of the shortcuts */ tbool enabled; /* Can be selected */ tbool checked; /* Check mark left of menu text */ }; struct _menu { int id; /* Menu id, reported by wgetevent */ char *title; /* Menu title string */ bool local; /* Set if must explicitly attach to windows */ bool dirty; /* Set if items have changed */ int left, right; /* Left & right edge of title in menu bar */ int maxwidth; /* Max width of items */ int nitems; /* Number of items */ struct item *itemlist; /* List of items */ }; struct menubar { int nmenus; MENU **menulist; }; ], type, id, item, keys); } } #endif /* unix */ /* Get key definitions from termcap. */ void gettckeydefs() { #ifdef DO_TERMCAP copydefaults(); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_BACKSPACE, "kb"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_LEFT, "kl"); tcbinding(SHORTCUT, 0, FIRST_CMD+WC_RIGHT, "kr"); tcbinding(SHORTCUT, smtalk43/stdwin/Ports/alfa/scroll.c1006440003270021170000000225705465303020014460 037777777777 1 0 /* Scrolling. This is not meant to scroll the window with respect to the document (that's done with wshow), but to say that a change has occurred in the indicated rectangle for which a full update can be avoided by scrolling its content by (dh, dv). If we can't do such scrolls, we'll call wchange instead. */ #include "alfa.h" /*ARGSUSED*/ void wscroll(win, left, top, right, bottom, dh, dv) WINDOW *win; int left, top; int right, bottom; int dh, dv; { /* if (dh != 0 || left > 0 || right < columns) { wchange(win, left, top, right, bottom); return; }*/ /* Convert to screen coordinates: */ top -= win->offset; bottom -= win->offset; /* Clip to window: */ if (top < win->top) top= win->top; if (bottom > win->bottom) bottom= win->bottom; /* Do the scroll: */ if (top < bottom) { dv= -dv; trmscrollup(top, bottom-1, dv); /* Set the rectangle filled with 'empty' now: */ if (dv < 0) { if (top-dv < bottom) bottom= top-dv; } else { if (bottom-dv > top) top= bottom-dv; } /* wchange(win, left, top+win->offset, right, bottom+win->offset); */ wchange(win, left, win->top+win->offset, right, win->bottom+win->offset); } } p; if (map->type != SECONDARY) { map->type= SECONDARY; map->id= createmap(); } for (nmap= _wsecmap[map->id]; nmap->type != SENTINEL; ++nmap) { if (nmap->key == keys[1]) break; } if (nmap->type == SENTINEL) nmap= extendmap((int) map->id, (int) keys[1]); if (nmap != NULL) setbinding(nmap, type, id, item,smtalk43/stdwin/Ports/alfa/stdwin.c1006440003270021170000002340005465303020014463 037777777777 1 0 /* TERMCAP STDWIN -- BASIC ROUTINES. */ #include "alfa.h" #if defined(unix) || defined(AMOEBA) #define DO_SIGNAL #define DO_SYSTEM #endif #ifdef DO_SIGNAL #include #include #include "sigtype.h" static SIGTYPE handler(); /* Forward */ #endif int lines, columns; /* Initialization call. Should be called only once, before any others. Will exit when the initialization fails. */ void winit() { winitargs((int*)NULL, (char***)NULL); } /*ARGSUSED*/ void winitargs(pargc, pargv) int *pargc; char ***pargv; { int flags; int err; #ifdef DO_SIGNAL (void) signal(SIGINT, handler); #ifdef NDEBUG (void) signal(SIGQUIT, handler); #endif (void) signal(SIGILL, handler); (void) signal(SIGIOT, handler); (void) signal(SIGEMT, handler); (void) signal(SIGFPE, handler); (void) signal(SIGBUS, handler); (void) signal(SIGSEGV, handler); (void) signal(SIGSYS, handler); (void) signal(SIGTERM, handler); #endif /* DO_SIGNAL */ getttykeydefs(0); /* File descriptor 0 */ err= trmstart(&lines, &columns, &flags); if (err != 0) { fprintf(stderr, "STDWIN: trmstart error %d\n", err); exit(2); } gettckeydefs(); if (lines > MAXLINES) lines= MAXLINES; trmputdata(0, lines-1, 0, ""); initsyswin(); _winitmenus(); } /* Termination call. Should be called before the program exits (else the terminal will be left in almost raw mode). */ void wdone() { if (lines > 0) { /* Move cursor to last screen line. */ trmputdata(lines-1, lines-1, 0, ""); trmsync(lines-1, 0); } lines= 0; trmend(); } #ifdef DO_SIGNAL /* Signal handler. Print a message and exit. */ static SIGTYPE handler(sig) int sig; { wdone(); signal(sig, SIG_DFL); kill(0, sig); /* Kill all others in our process group */ kill(getpid(), sig); /* Commit suicide */ /* (On BSD, the signal is delivered to us only after we return.) */ } #endif /* DO_SIGNAL */ /* Essential data structures. */ WINDOW winlist[MAXWINDOWS] /* = {FALSE, ...}, ... */; WINDOW *wasfront; /* What the application thinks is active */ WINDOW *front; /* The window that is really active */ /* If these are not equal, an activate or deactivate event will be generated by wevent before anything else. */ char uptodate[MAXLINES] /* = FALSE, ... */; /* Open a window. */ WINDOW * wopen(title, drawproc) char *title; void (*drawproc)(); { int id; WINDOW *win; for (win= &winlist[0]; win < &winlist[MAXWINDOWS]; ++win) { if (!win->open) break; } id= win - &winlist[0]; if (id >= MAXWINDOWS) return NULL; /* Too many windows open */ win->open= TRUE; _wreshuffle(); win->resized = FALSE; /* Don't begin with a redraw event */ win->tag= 0; win->drawproc= drawproc; win->title= strdup(title); win->attr= wattr; win->offset= -win->top; win->curh= win->curv= -1; win->timer= 0; initmenubar(&win->mbar); front= win; return win; } /* Divide the available lines over the available windows. Line 0 is for window 0, the system window, and is different: it has no title, and is always one line high, except when it's the only window. */ void _wreshuffle() { int nwins= 0; int nlines= lines; int top= 0; WINDOW *win; /* Count open windows. */ for (win= winlist; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) ++nwins; } /* Assign each open window its share of the screen. */ for (win= winlist; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { int i= nlines/nwins; /* This window's share */ int id= win - winlist; #ifdef LM_S_PROB int oldtop= win->top, oldbot= win->bottom; int dv, scrbot; #endif /* Cause redraw event for old title position: */ if (win->top > 0) uptodate[win->top-1]= FALSE; if (id == 0) { /* System window */ win->top= top; if (nwins > 1) i=1; } else win->top= top+1; win->bottom= top + i; nlines -= i; --nwins; #ifndef LM_S_PROB /* This is overkill; we should try not cause a redraw of all lines! */ for (i= top; i < win->bottom; ++i) { uptodate[i]= FALSE; } #else /* LM's probeersel */ dv= oldtop-win->top; scrbot=win->bottom; if (oldbot-dv < scrbot) scrbot=oldbot-dv; scrollupdate(win->top, scrbot, dv); trmscrollup(win->top, scrbot-1, dv); for (i= top; i < win->bottom; ++i) if (!(win->top <= i && i < scrbot || win->top <= i+dv && i+dv < scrbot)) uptodate[i]= FALSE; #endif top= win->bottom; /* Cause redraw event for new title position: */ if (win->top > 0) uptodate[win->top-1]= FALSE; /* Cause resize event: */ win->resized= TRUE; /* Scroll back if negative line numbers visible: */ if (win->top + win->offset < 0) wshow(win, 0, 0, columns, win->bottom - win->top); #if 0 /* We don't really want to for showing the caret... */ /* Show caret: */ if (win->curv >= 0) wshow(win, win->curh, win->curv, win->curh, win->curv); #endif } } } /* Close a window. */ void wclose(win) WINDOW *win; { int id= win - winlist; if (id < 0 || id >= MAXWINDOWS || !win->open) return; killmenubar(&win->mbar); if (win == wasfront) wasfront= NULL; if (win == front) front= NULL; win->open= FALSE; if (win->title != NULL) { free(win->title); win->title= NULL; } _wreshuffle(); /* Select another window. */ if (front == NULL) { /* Search below the window we just closed. */ for (; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { front= win; break; /* First hit is OK */ } } if (front == NULL) { /* Try searching above it. */ for (win= winlist+1; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) front= win; /* NO break -- we need the last hit */ } } if (front == NULL) { /* Exasperation time. */ front= &winlist[0]; /* The system window */ } _wnewtitle(front); /* Make sure the title is redrawn */ } } /* Dummies for functions not supported by this version. */ /*ARGSUSED*/ void wsetdefwinpos(h, v) int h, v; { } /*ARGSUSED*/ void wsetdefwinsize(width, height) int width, height; { } /*ARGSUSED*/ void wsetmaxwinsize(width, height) int width, height; { } /* Make a window the active window. */ void wsetactive(win) WINDOW *win; { int id= win - winlist; if (id < 0 || id >= MAXWINDOWS || !win->open) return; _wnewtitle(front); front= win; _wnewtitle(front); } /* Select next, previous window. Note: these will never select the system window unless it is already selected (which can only occur if there are no other windows open). */ void _wselnext() { WINDOW *win; for (win= front+1; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { wsetactive(win); return; } } for (win= winlist+1; win < front; ++win) { if (win->open) { wsetactive(win); return; } } } void _wselprev() { WINDOW *win; for (win= front-1; win > winlist; --win) { if (win->open) { wsetactive(win); return; } } for (win= &winlist[MAXWINDOWS-1]; win > front; --win) { if (win->open) { wsetactive(win); return; } } } /* Force a redraw of the entire screen. (This routine only sets 'invalid' bits for all lines; the actual redraw is done later in wgetevent or wupdate.) */ void _wredraw() { int i; for (i= 0; i < lines; ++i) uptodate[i]= FALSE; _wreshuffle(); trmundefined(); trmputdata(0, lines-1, 0, ""); } /* Temporarily restore cooked tty mode. */ _wcooked() { trmputdata(lines-1, lines-1, 0, ""); trmsync(lines-1, 0); trmend(); } /* Back to window mode. If 'wait' flag is set, wait until a character is typed before continuing. clearing the screen. */ _wstdwin(wait) bool wait; { int flags; if (wait) { printf("\nCR to continue... "); fflush(stdout); } (void) trmstart(&lines, &columns, &flags); if (wait) (void) trminput(); _wredraw(); wmessage((char *)NULL); /* Reset menu bar */ } /* Suspend the process (BSD Unix only). */ void _wsuspend() { _wcooked(); trmsuspend(); _wstdwin(FALSE); } /* Execute a shell command, if possible and necessary outside the window manager. If the 'wait' parameter is set, the window manager pauses until a character is typed before continuing. */ int wsystem(cmd, wait) char *cmd; bool wait; { #ifdef DO_SYSTEM int status; _wcooked(); status= system(cmd); _wstdwin(wait); return status; #else return -1; #endif } /* Return active window. */ WINDOW * wgetactive() { return front; } /* Change a window's title. */ void wsettitle(win, title) WINDOW *win; char *title; { if (win->title != NULL) free(win->title); win->title= strdup(title); _wnewtitle(win); } /* Change the mouse cursor -- dummy */ /*ARGSUSED*/ void wsetwincursor(win, cursor) WINDOW *win; CURSOR *cursor; { } /* Fetch a mouse cursor -- always return NULL */ /*ARGSUSED*/ CURSOR * wfetchcursor(name) char *name; { return NULL; } /* Set a window's extent (document size). Not implemented here. */ /*ARGSUSED*/ void wsetdocsize(win, width, height) WINDOW *win; int width, height; { } /*ARGSUSED*/ void wgetdocsize(win, pwidth, pheight) WINDOW *win; int *pwidth, *pheight; { *pwidth = *pheight = 0; } /* Get a window's origin with respect to document. */ void wgetorigin(win, ph, pv) WINDOW *win; int *ph, *pv; { *ph= 0; *pv= win->top + win->offset; } /* Get a window's origin with respect to screen. */ void wgetwinpos(win, ph, pv) WINDOW *win; int *ph, *pv; { *ph= 0; *pv= win->top; } /* Get a window's window size. */ void wgetwinsize(win, pwidth, pheight) WINDOW *win; int *pwidth, *pheight; { *pwidth= columns; *pheight= win->bottom - win->top; } /* Get the screen size in pixels. */ void wgetscrsize(ph, pv) int *ph, *pv; { *ph= columns; *pv= lines; } /* Get the screen size in mm. Of course we don't know it; we pretend that the average character is 3 mm wide and 6 mm high, which is a reasonable approximation of reality on my terminal (an HP2621). */ void wgetscrmm(ph, pv) int *ph, *pv; { *ph= columns * 3; *pv= lines * 6; } void wfleep() { trmbell(); } c & 07)); } #undef APPC } if (h > textlen[v]) textlen[v]= h; texttouched[v]= TRUE; } void wdrawchar(h, v, c) int h, v; int c; { char cbuf[2]; cbuf[0]= c; cbuf[1]= EOS; wdrawtext(h, v, cbuf, 1); } void wgetwintextattr(win, attr) WINDOW *win;smtalk43/stdwin/Ports/alfa/syswin.c1006440003270021170000001507105465303020014514 037777777777 1 0 /* STDWIN -- SYSTEM WINDOW. */ #include "alfa.h" WINDOW *syswin; /* Window id 0, the system window */ /* Global because wgetevent needs to know about it, so it can suppress events belonging to this window. */ static void helpmessage() { char buf[256]; char shortcut[256]; getbindings(shortcut, 0, MENU_CALL); sprintf(buf, "[Use %s to get a menu of commands]", shortcut); wmessage(buf); } void initsyswin() { syswin= wopen("System", wsysdraw); helpmessage(); } char *sysmsg; /* Message to be drawn at (0, 0) */ TEXTEDIT *syste; /* Textedit record to be drawn, too */ #ifdef EM static char **Butt=NULL; #endif /*ARGSUSED*/ void wsysdraw(win, left, top, right, bottom) WINDOW *win; int left, top; int right, bottom; { if (sysmsg != NULL) { (void) wdrawtext(0, 0, sysmsg, -1); if (syste != NULL) tedraw(syste); #ifdef EM if(Butt) drawbuttons(); #endif } else drawmenubar(); } void menubarchanged() { uptodate[0]= FALSE; } /* Print a message in the system window. If the message is non-null, the screen is updated immediately. */ void wmessage(str) char *str; { if (sysmsg != NULL) free(sysmsg); sysmsg= strdup(str); if (syste != NULL) { tefree(syste); syste= NULL; } wchange(syswin, 0, 0, 9999, 9999); wnocaret(syswin); if (str != NULL) { wupdate(syswin); wflush(); } } /* Ask for an input string. */ bool waskstr(prompt, buf, len) char *prompt; char *buf; int len; { WINDOW *savewin= front; WINDOW *win= syswin; bool ok= FALSE; bool stop= FALSE; int teleft; wsetactive(win); wmessage((char *) NULL); sysmsg= prompt; teleft= wtextwidth(prompt, -1) + wtextwidth(" ", 1); if (teleft > columns * 3/4) teleft= columns * 3/4; syste= tealloc(syswin, teleft, 0, columns-teleft); tereplace(syste, buf); tesetfocus(syste, 0, 9999); do { EVENT e; if (!wsysevent(&e, FALSE)) { wupdate(syswin); wflush(); wsysevent(&e, TRUE); } e.window= syswin; /* Not filled in by wsys*event(); needed by teevent(). */ switch (e.type) { case WE_MENU: if (e.u.m.id != 0) { wfleep(); break; } switch (e.u.m.item) { case SUSPEND_PROC: _wsuspend(); break; case REDRAW_SCREEN: _wredraw(); break; default: if (e.u.m.item >= FIRST_CMD && e.u.m.item <= LAST_CMD) wsyscommand(&e); break; } if (e.type != WE_COMMAND) break; /* Fall through from previous case! */ case WE_COMMAND: switch (e.u.command) { case WC_RETURN: case WC_CANCEL: ok= e.u.command == WC_RETURN; stop= TRUE; break; default: if (!teevent(syste, &e)) wfleep(); break; } break; case WE_CHAR: case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: if (!teevent(syste, &e)) wfleep(); break; } } while (!stop); if (ok) { strncpy(buf, tegettext(syste), len); buf[len-1]= EOS; } sysmsg= NULL; wmessage((char *) NULL); wsetactive(savewin); return ok; } #ifdef EM /* EuroMath hacks -- I still hop I can get rid of this again... */ #define META(c) ((c)|128) #define UNMETA(c) ((c)&~128) #define min(a,b) (a)<(b)?(a):(b) char *hack; int Curr; wdialog(prompt, buf, len, butt, def) char *prompt, *buf, **butt; int len, def; { WINDOW *savewin= front; WINDOW *win= syswin; bool ok= FALSE; bool stop= FALSE; int teleft; int y=1, i; extern char* esc; extern char *expandCommand(); if(butt==NULL) return waskstr(prompt, buf, len); Butt=butt; Curr=0; /* highlight the default button */ for(i=0;butt[def-1][i];i++) butt[def-1][i]=META(butt[def-1][i]); wsetactive(win); wmessage((char *) NULL); sysmsg= prompt; teleft= wtextwidth(prompt, -1) + wtextwidth(" ", 1); if (teleft > columns * 3/4) teleft= columns * 3/4; syste= tealloc(syswin, teleft, 0, columns-teleft); tereplace(syste, strdup(buf)); tesetfocus(syste, 0, 9999); /* calculate the number of buttons */ while(butt[y-1]) { ++y; } --y; restart: do { EVENT e; if (!wsysevent(&e, FALSE)) { wupdate(syswin); wflush(); wsysevent(&e, TRUE); } e.window= syswin; /* Not filled in by wsys*event(); needed by teevent(). */ switch (e.type) { case WE_MENU: if (e.u.m.id != 0) { wfleep(); break; } switch (e.u.m.item) { case SUSPEND_PROC: _wsuspend(); break; case REDRAW_SCREEN: _wredraw(); break; default: if (e.u.m.item >= FIRST_CMD && e.u.m.item <= LAST_CMD) wsyscommand(&e); break; } if (e.type != WE_COMMAND) break; /* Fall through from previous case! */ case WE_COMMAND: switch (e.u.command) { /* the arrow-keys (up & down) are used to escape from the texedit buffer and select a button from the buttonlist */ case WC_UP: --Curr; if(Curr<0) Curr=0; break; case WC_DOWN: ++Curr; if(Curr>y) Curr=0; break; case WC_RETURN: case WC_CANCEL: ok= e.u.command == WC_RETURN; stop= TRUE; break; default: if (Curr > 0) wfleep(); else if (!teevent(syste, &e)) wfleep(); break; } break; case WE_CHAR: if(hack && e.u.character == *esc) { /* this is used by cmdbox(): pressing the `escape' character causes the typed in buffer to be expanded */ char *buf2; tesetfocus(syste,0,9999); strzcpy(buf,tegettext(syste),min(len,tegetlen(syste)+1)); buf2=expandCommand(hack, buf); tereplace(syste, buf2); tesetfocus(syste,0,9999); break; } case WE_MOUSE_DOWN: case WE_MOUSE_MOVE: case WE_MOUSE_UP: if(Curr > 0) wfleep(); else if (!teevent(syste, &e)) wfleep(); break; } } while (!stop); if(hack && Curr == 3) { /* button 3 is "EXPAND". Used by cmdbox() */ char *buf2; tesetfocus(syste,0,9999); strzcpy(buf,tegettext(syste),min(len,tegetlen(syste)+1)); buf2=expandCommand(hack, tegettext(syste)); tereplace(syste, buf2); tesetfocus(syste,0,9999); ok=stop=FALSE; Curr=0; goto restart; } if (ok) { strzcpy(buf, tegettext(syste), min(len, tegetlen(syste)+1)); } sysmsg= NULL; wmessage((char *) NULL); wsetactive(savewin); if(Curr==0) Curr=def; Butt=NULL; for(i=0;butt[def-1][i];i++) butt[def-1][i]=UNMETA(butt[def-1][i]); _wredraw(); return Curr; } /* this is inserted in the syswin drawproc whenever there are buttons active */ drawbuttons() { int y=1; char buf[256]; while(Butt[y-1]) { if(y==Curr) sprintf(buf, "%c %s", META('o'), Butt[y-1]); else sprintf(buf, "o %s", Butt[y-1]); trmputdata(y, y, 0, buf); ++y; } trmputdata(y,y,0,""); } /* additional EuroMath WM routine, called after returning from an Editor-session (OpenTTY) */ RedrawAll() { _wredraw(); } #endif (ep->type == WE_MENU && ep->u.m.id == 0) wsyscommand(ep); } } } if (ep->window == NULL && front != syswin) ep->window= front; lasttype= ep->type; return ep->type != WE_NULL; } void wsyscommand(ep) EVENT *ep; { ep->type= WE_NULL; switch (ep->u.m.item) { default: if (ep->u.m.item <= LAST_CMD) { ep->type= WE_COMMAND; ep->u.command= ep->u.m.item - FIRST_CMD; } break; case NEXT_WIN: _wselnext(); break; case Psmtalk43/stdwin/Ports/alfa/timer.c1006440003270021170000001054105465303020014275 037777777777 1 0 /* TERMCAP STDWIN -- Alarm timers (BSD-specific) */ #include "alfa.h" #include #include #ifdef AMOEBA #define select(a, b, c, d, e) (-1) /* XXX just to get it to link... */ #endif /* Alarm timer values must be stored as absolute times, but since they are in tenths of a second and stored in a long, there isn't enough space to store the true absolute time. Therefore, they are stored relative to the second when the first call to wsettimer was made, which is saved in torigin */ static long torigin; /* Seconds */ static long nexttimer; /* Deciseconds */ /* Return the window with the first timer to go off, if any, NULL otherwise */ static WINDOW * getnexttimer() { WINDOW *win; WINDOW *cand= NULL; for (win= &winlist[0]; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { long t= win->timer; if (t != 0) { if (cand == NULL || t < cand->timer) cand= win; } } } return cand; } /* Compute a new value for nexttimer. Return the relevant window as a convenience. */ static WINDOW * setnexttimer() { WINDOW *win= getnexttimer(); if (win == NULL) nexttimer= 0; else nexttimer= win->timer; return win; } /* Set the alarm timer for a given window */ void wsettimer(win, deciseconds) WINDOW *win; int deciseconds; { win->timer= 0; if (deciseconds > 0) { struct timeval tv; struct timezone tz; if (gettimeofday(&tv, &tz) >= 0) { if (torigin == 0) { torigin= tv.tv_sec; } win->timer= deciseconds + 10 * (tv.tv_sec - torigin) + tv.tv_usec/100000; } } (void) setnexttimer(); } /* Return a pointer suitable as timeout parameter for BSD select(2). If no alarms are currently set, return a NULL pointer. */ static struct timeval * timeout() { if (nexttimer == 0) { return NULL; } else { static struct timeval tv; struct timezone tz; if (gettimeofday(&tv, &tz) < 0) { return NULL; } else { long tout; tout= nexttimer - (tv.tv_sec - torigin) * 10 - tv.tv_usec / 100000; if (tout <= 0) tv.tv_sec= tv.tv_usec= 0; else { tv.tv_sec= tout / 10; tv.tv_usec= (tout % 10) * 100000; } return &tv; } } } /* Check if an alarm has gone off, and if so, generate an appropriate event. This can be called at any time, but for efficiency reasons it should only be called when an alarm has actually gone of (i.e., select has timed out). If an alarm has gone off, it will always be found by this function. */ static bool dotimer(ep) EVENT *ep; { WINDOW *win= setnexttimer(); struct timeval *tp; if (win == NULL) { /* no event found (spurious call) */ return FALSE; } tp= timeout(); if (tp == NULL) { /* unexpected NULL timeout() */ return FALSE; } if (tp->tv_sec == 0 && tp->tv_usec == 0) { /* report timer event */ ep->type= WE_TIMER; ep->window= win; win->timer= 0; (void) setnexttimer(); return TRUE; } else { /* it is not yet time */ return FALSE; } } /* Check for timer events. Call this after trmavail() returns 0, just before calling trminput() */ bool _w_checktimer(ep, mayblock) EVENT *ep; bool mayblock; { for (;;) { struct timeval *tp= timeout(); /* This is naive. BSD 4.3 really uses arrays of longs as arguments to select. Fortunately, stdin is fd 0. */ unsigned long rd, wd, xd; int fd, nfd; int nfound; if (!mayblock) { return tp != NULL && tp->tv_sec == 0 && tp->tv_usec == 0 && dotimer(ep); } fd= 0; /* stdin */ rd= 1 << fd; nfd= fd+1; wd= xd= 0; errno= 0; nfound= select(nfd, &rd, &wd, &xd, tp); /* Note: if select returns negative, we also break out of the loop -- better drop a timer event than loop forever on a select error. The only exception is EINTR, which may have been caused by an application's signal handler */ if (nfound < 0) { if (errno == EINTR) { continue; } } if (nfound != 0) break; if (dotimer(ep)) return TRUE; } return FALSE; } /* P.S.: It is not necessary to recompute nextalarm when windows are deleted. This can at most cause a spurious time-out, after which dotimeout() is called again which recomputes nextalarm as a side effect (twice, even). Applications incur a slight overhead if they delete a window with a timer set and no other windows have timers set; in this case a larger part of the timeout code is called until the alarm goes off (which is then ignored!). */ IRST_CMD+WC_DOWN}, {0111, SHORTCUT, 0, FIRST_CMD+WC_PAGE_UP}, {0117, SHORTCUT, 0, FIRST_CMD+WC_END}, {0121, SHORTCUT, 0, FIRST_CMD+WC_PAGE_DOWN}, {0123, SHsmtalk43/stdwin/Ports/mac/0407550003270021170000000000005477556120012055 5 0 1 0 smtalk43/stdwin/Ports/mac/README1006440003270021170000000240405434024343013531 037777777777 1 0 Using STDWIN on the Mac This assumes THINK C 4.0. I believe you can make it work for THINK C 3.0, check for the symbol THINK_C_3_0 (especially in H/stdwconf.h). It also works for MPW 2.0, see ../mac_mpw. Copy the files from the following directories to the Mac: H Tools Gen Ports/mac Packs/textedit Appls/miniedit (for testing) Make two projects, stdwin. and textedit. ( is the letter pi, Option-p). All of STDWIN together is too big for one segment, and the textedit module is not used by all applications. Project stdwin. receives all sources from Tools, Gen and Ports/mac; textedit. receives those from Packs/textedit. Turn off ; the sources know exactly which files to include. (To speed up compilation you can rename "macwin.h" and precompile it, placing the output in "macwin.h". This is completely optional.) Compile the sources in each project. Don't attempt to link. To test, make a project miniedit. and add all sources from Appls/miniedit. Add the ANSI and MacTraps libraries and the stdwin. and textedit. projects you just created. (Probably everything in its own segment.) You now have a simple editor with regular expression search facility. Study the source to learn more about using stdwin. Good luck! to where they left off. When an action function hits the end of the string, it returns NULL and sets the action pointer to the function to call next (often itself), or to NULL for the default. A non-NULL return implies that the default actsmtalk43/stdwin/Ports/mac/about.c1006440003270021170000000303305465303020014122 037777777777 1 0 /* MAC STDWIN -- "ABOUT STDWIN" MESSAGE. */ #include "macwin.h" #ifdef MPW #include #include #endif #ifdef THINK_C #include #include #endif /* Default About... message; applications may assign to this. You may also assign to about_item in "menu.c", *before* calling winit() or winitargs(). Also see your THINK C licence. */ char *about_message= "STDWIN version 0.9.5 (using THINK C 4.0)\r\r\ Copyright \251 1988, 1989, 1990 Stichting Mathematisch Centrum, \ Amsterdam\r\ Written by Guido van Rossum (guido@cwi.nl)\r\ CWI, dept. AA, P.O.B. 4079\r1009 AB Amsterdam, The Netherlands\r\r\ [Option-click in window scrolls as in MacPaint,\r\ Option-click in title sends behind]"; /* \251 is the (c) Copyright symbol. I don't want non-ASCII characters in my source. */ /* "About ..." procedure. This is self-contained -- if you have a better idea, change it. */ void do_about() { Rect r; WindowPtr w; EventRecord e; SetRect(&r, 0, 0, 340, 180); /* XXX Shouldn't be hardcoded */ OffsetRect(&r, (screen->portRect.right - r.right)/2, 40); w = NewWindow( (Ptr) NULL, /* No storage */ &r, /* Bounds rect */ "", /* No title */ true, /* Visible */ altDBoxProc, /* Plain box with shadow */ (WindowPtr) -1, /* In front position */ false, /* No go-away box */ 0L); /* RefCon */ SetPort(w); r = w->portRect; InsetRect(&r, 10, 10); TextBox(about_message, strlen(about_message), &r, teJustCenter); while (!GetNextEvent(mDownMask|keyDownMask, &e)) ; DisposeWindow(w); } ight= 0; L_INIT(mp->nitems, mp->itemlist); addtobar(mp->local ? &lmenus : &gmenus, mp); if (!mp->local) menubarchanged(); return mp; } void wmenudelete(mp) MENU *mp; { int i; if (mp->local) { for (i= 0; i < MAXWINDOWS; ++i) { if (winlist[i].open) delfrombar(&winlist[i].mbar, mp); } } delfrombar(mp->local ? &lmenus : &gmenus, mp); for (i= 0; i < mp->nitems; ++i) { FREE(mp->itemlist[i].text); FREE(mp->itemlist[i].shortcut); } L_DEALLOC(mp->nitems, mp-smtalk43/stdwin/Ports/mac/argcargv.c1006440003270021170000000223305465303020014605 037777777777 1 0 /* MAC STDWIN -- GET ARGC/ARGV. */ /* Copy the arguments passed from the finder into argc/argv. Neither MPW nor THINK C does this, making argc/argv pretty useless. By using winitargs(&argc, &argv) you get the arguments that you expect. When called to print, a "-p" flag is passed before the first argument. */ #include "macwin.h" #ifdef MPW #include #endif #ifdef THINK_C #include #endif void wargs(pargc, pargv) int *pargc; char ***pargv; { L_DECLARE(argc, argv, char *); char apname[256]; char buf[256]; short aprefnum; Handle apparam; short message; short count; short i; GetAppParms(apname, &aprefnum, &apparam); #ifndef CLEVERGLUE PtoCstr(apname); #endif L_APPEND(argc, argv, char *, strdup(apname)); CountAppFiles(&message, &count); if (message == appPrint) { /* Must have braces around L_*! */ L_APPEND(argc, argv, char *, "-p"); } for (i = 1; i <= count; ++i) { AppFile thefile; GetAppFiles(i, &thefile); fullpath(buf, thefile.vRefNum, p2cstr((char*)&thefile.fName)); L_APPEND(argc, argv, char *, strdup(buf)); } L_APPEND(argc, argv, char *, NULL); *pargc = argc - 1; *pargv = argv; } enubarchanged(); } void wmenusetdeflocal(local) bool local; { deflocal= local; } /* Interface routines for the rest of the library. */ void initmenubar(mb) struct menubar *mb; { L_INIT(mb->nmenus, mb->menulist); } void killmenubar(mb) struct menubar *mb; { L_DEALLOC(mb->nmenus, mb->menulist); } void drawmenubar() /* This is part of the syswin dsmtalk43/stdwin/Ports/mac/caret.c1006440003270021170000000541305465303020014112 037777777777 1 0 /* MAC STDWIN -- TEXT CARET HANDLING. */ /* The 'caret' is a blinking vertical bar indicating the text insertion point. Each window has its own caret position (hcaret, vcaret) telling where the insertion point is; if either is negative no caret is shown. Only the caret of the active window is actually visible. The blinking is done by repeatedly calling (in the event loop when idling) blinkcaret(), which flips the caret's state if it's been stable long enough. The file-static variable lastflip records when the caret has last changed state. A struct member caret_on indicates per window whether the caret is currently drawn or not. (A file-static variable would really suffice.) NB: all routines except w{set,no}caret assume win->w is the current GrafPort. */ #include "macwin.h" #ifdef MPW #include #endif /* Function prototypes */ STATIC void invertcaret _ARGS((WINDOW *win)); STATIC void flipcaret _ARGS((WINDOW *win)); static long lastflip = 0; /* Time when the caret last blinked */ /* Invert the caret's pixels. */ static void invertcaret(win) WINDOW *win; { Rect r; FontInfo finfo; if (win->hcaret < 0 || win->vcaret < 0) return; GetFontInfo(&finfo); makerect(win, &r, win->hcaret-1, win->vcaret, win->hcaret, win->vcaret + finfo.leading + finfo.ascent + finfo.descent); InvertRect(&r); } /* Flip the caret state, if the window has a caret. Also set lastflip, so blinkcaret() below knows when to flip it again. */ static void flipcaret(win) WINDOW *win; { if (win->hcaret < 0 || win->vcaret < 0) return; invertcaret(win); win->caret_on = !win->caret_on; lastflip= TickCount(); } /* Make sure the caret is invisible. This is necessary before operations like handling mouse clicks, bringing up dialog boxes, or when the window goes inactive. */ void rmcaret(win) WINDOW *win; { if (win->caret_on) flipcaret(win); } /* Blink the caret, if there is one. This should be called sufficiently often from the main event loop. We only blink if enough ticks have passed since the last flip, whether caused by us or by an explicit call to rmcaret(). */ void blinkcaret(win) WINDOW *win; { if (win->hcaret < 0 || win->vcaret < 0) return; if (TickCount() >= lastflip + GetCaretTime()) flipcaret(win); } /* User-callable routine to specify the caret position. The caret is not drawn now, but when the next blink is due. */ void wsetcaret(win, h, v) WINDOW *win; int h, v; { SetPort(win->w); rmcaret(win); win->hcaret = h; win->vcaret = v; } /* User-callable routine to specify that the window has no caret. This is indicated by setting (hcaret, vcaret) to (-1, -1). */ void wnocaret(win) WINDOW *win; { SetPort(win->w); rmcaret(win); /* See remark in wsetcaret() */ win->hcaret = win->vcaret= -1; } m(); break; case WC_DOWN: nextitem(); break; case WC_CANCEL: ep->type= WE_NULL; return TRUE; } return FALSE; } static bool handlemenu(ep) EVENT *ep; { if (ep->u.m.id != 0) return TRUE; switch (ep->u.m.item) { case SUsmtalk43/stdwin/Ports/mac/cursor.c1006440003270021170000000623705465303020014336 037777777777 1 0 /* MAC STDWIN -- MOUSE CURSORS. */ /* XXX Shouldn't named resources override the defaults? */ #include "macwin.h" #ifdef MPW #include #endif #ifdef THINK_C #include #endif extern CursPtr handcursorptr; /* Fetch a cursor by name. This really returns a resource handle, cast to the mythical type CURSOR *. If no resource by that name exists, some standard cursors may be returned. */ CURSOR * wfetchcursor(name) char *name; { CursHandle h = (CursHandle) GetNamedResource('CURS', name); if (h == NULL) { if (strcmp(name, "ibeam") == 0) h = GetCursor(iBeamCursor); else if (strcmp(name, "cross") == 0) h = GetCursor(crossCursor); else if (strcmp(name, "plus") == 0) h = GetCursor(plusCursor); else if (strcmp(name, "watch") == 0) h = GetCursor(watchCursor); else if (strcmp(name, "arrow") == 0) { /* The arrow is not a resource but a quickdraw global. Fake a handle with a static variable. */ static CursPtr arrowptr; arrowptr = &QD(arrow); h = &arrowptr; } else if (strcmp(name, "hand") == 0) { /* The hand is hardcoded below */ h = &handcursorptr; } } return (CURSOR *)h; } void wsetwincursor(win, cursor) WINDOW *win; CURSOR *cursor; { win->cursor = cursor; if (win == active) set_applcursor(); } /* Set the mouse cursor shape to the standard arrow. This shape is used when the program is ready for input without having the active window. */ void set_arrow() { /*XXX SetCursor(&QD(arrow)); */ InitCursor(); } /* Set the mouse cursor shape to the standard watch. This shape is used when a long task is being performed. In practice always between two calls to wgetevent() except when the mouse is down. Note: this call is ignored when the application has specified a cursor for the window; in this case it is up to the application to set an arrow when it goes away for a long time. */ void set_watch() { if (active == NULL || active->cursor == NULL) SetCursor(*GetCursor(watchCursor)); } /* Set the cursor to the standard cursor for the active window. If there is no active window, use an arrow. If a cursor is specified for the active window, use that, otherwise use a default. The default is normally a crosshair but can be changed by setting the global variable _w_cursor to a cursor ID. */ int _w_cursor= crossCursor; void set_applcursor() { if (active == NULL) set_arrow(); else if (active->cursor == NULL) SetCursor(*GetCursor(_w_cursor)); else { CursHandle h = (CursHandle) active->cursor; if (*h == NULL) LoadResource((Handle)h); SetCursor(*h); } } /* Set the mouse cursor shape to a little hand icon. This shape is used when scroll-dragging the document. */ static Cursor handcursor= { { /* Data: */ 0x0180, 0x1a70, 0x2648, 0x264a, 0x124d, 0x1249, 0x6809, 0x9801, 0x8802, 0x4002, 0x2002, 0x2004, 0x1004, 0x0808, 0x0408, 0x0408, }, { /* Mask: */ 0x0180, 0x1bf0, 0x3ff8, 0x3ffa, 0x1fff, 0x1fff, 0x7fff, 0xffff, 0xfffe, 0x7ffe, 0x3ffe, 0x3ffc, 0x1ffc, 0x0ff8, 0x07f8, 0x07f8, }, {8, 8} /* Hotspot */ }; static CursPtr handcursorptr = &handcursor; /* For wfetchcursor */ void set_hand() { SetCursor(&handcursor); } ool enabled; /* Can be selected */ tbool checked; /* Check mark left of menu text */ }; struct _menu { int id; /* Menu id, reported by wgetevent */ char *title; /* Menu title string */ bool local; /* Set if must explicitly attach to windows */ bool dirty; /* Set if items have changed */ int left, right; /* Left & right edge of title in msmtalk43/stdwin/Ports/mac/dialog.c1006440003270021170000001730705465303021014261 037777777777 1 0 /* MAC STDWIN -- DIALOGS. */ /* XXX These dialogs are distinctly ugly. Maybe we should fix their size based on the amount of text and the number of buttons. */ #include "macwin.h" #ifdef MPW #include #include #endif #ifdef THINK_C #include #include #endif /* Function prototypes */ STATIC struct itemlist **mkitemlist _ARGS((void)); STATIC struct item *finditem _ARGS((struct itemlist **h, int i)); STATIC void additem _ARGS((struct itemlist **h, long stuff, Rect *ppos, int type, int size, char *data)); STATIC struct itemlist **ynclist _ARGS((char *prompt)); STATIC struct itemlist **oklist _ARGS((char *prompt)); STATIC struct itemlist **editlist _ARGS((char *prompt)); STATIC int do_dialog _ARGS((struct itemlist **h, int emphasis, int lastbutton, char *buf)); /* Mac-specific interface for applications that need different file types */ extern OSType std_type; #ifdef THINK_C OSType std_type= 'TEXT'; #endif OSType *wasktypelist= &std_type; int waskntypes= 1; /* Standard File interface routine */ bool waskfile(prompt, buf, len, new) char *prompt; char *buf; int len; bool new; { static Point corner= {80, 60}; SFReply reply; if (active != NULL) rmcaret(active); if (new) { char *def= strrchr(buf, ':'); if (def != NULL) ++def; else def= buf; SFPutFile(PASSPOINT corner, PSTRING(prompt), #ifdef THINK_C /* XXX ??? */ CtoPstr(def), #else PSTRING(def), #endif (ProcPtr)NULL, &reply); } else { SFGetFile(PASSPOINT corner, (char*)NULL, (ProcPtr)NULL, waskntypes, wasktypelist, (ProcPtr)NULL, &reply); } set_watch(); if (!reply.good) return FALSE; fullpath(buf, reply.vRefNum, p2cstr((char*)&reply.fName)); return TRUE; } /* Data definitions for dialog item lists (from Inside Mac). */ struct item { long stuff; /* Handle or proc pointer */ Rect pos; /* Position (local coord.) */ char type; /* Item type */ char size; /* Length of data; must be even */ char data[256]; /* The data; variable length */ }; struct itemlist { short count; /* Number of items minus one */ struct item data; /* First item */ /* NB: items are variable length. */ }; #define ROUND_EVEN(x) (((x) + 1) & ~1) /* Round up to even */ #define FIXED_SIZE 14 /* Size of struct item w/o data */ /* Routines to manipulate Dialog item lists. */ /* Create an empty item list. */ static struct itemlist ** mkitemlist() { struct itemlist **h= (struct itemlist **) NewHandle(2); (*h)->count= -1; return h; } /* Find the i'th item, starting to count from 0. It may be asked for the non-existing item just beyond the last, but not beyond that. */ static struct item * finditem(h, i) struct itemlist **h; int i; { int count= (*h)->count; struct item *it= &(*h)->data; int k; if (i < 0 || i > count+1) { return NULL; } for (k= 0; k < i; ++k) { /* I don't trust two casts in one expression: */ char *p= (char *) it; int size= ROUND_EVEN(it->size); p += FIXED_SIZE + size; it= (struct item *) p; } return it; } /* Add an item to the list. */ static void additem(h, stuff, ppos, type, size, data) struct itemlist **h; long stuff; Rect *ppos; int type; int size; char *data; { struct item *it; long totalsize; if (size < 0) size= strlen(data); it= finditem(h, (*h)->count + 1); totalsize= (char *)it - (char *)(*h); SetHandleSize(h, totalsize + FIXED_SIZE + ROUND_EVEN(size)); it= finditem(h, (*h)->count + 1); it->stuff= stuff; it->pos= *ppos; it->type= type; it->size= size; BlockMove(data, it->data, size); ++(*h)->count; } /* Construct item list for question w/ Yes/No/Cancel response. Note: the statText item is first, so we can distinguish between a press on Return or Enter (when ModalDialog returns 1) and any of the three buttons. */ static struct itemlist ** ynclist(prompt) char *prompt; { struct itemlist **h= mkitemlist(); Rect pos; SetRect(&pos, 20, 20, 280, 70); additem(h, 0L, &pos, statText|itemDisable, -1, prompt); SetRect(&pos, 20, 80, 80, 100); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "Yes"); OffsetRect(&pos, 0, 30); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "No"); OffsetRect(&pos, 200, 0); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "Cancel"); return h; } /* Construct item list for message w/ OK button. */ static struct itemlist ** oklist(prompt) char *prompt; { struct itemlist **h= mkitemlist(); Rect pos; SetRect(&pos, 20, 20, 280, 100); additem(h, 0L, &pos, statText|itemDisable, -1, prompt); SetRect(&pos, 20, 110, 80, 130); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "OK"); return h; } /* Construct item list for dialog w/ edit-text, OK and Cancel button. */ static struct itemlist ** editlist(prompt) char *prompt; { struct itemlist **h= mkitemlist(); Rect pos; SetRect(&pos, 20, 20, 280, 70); additem(h, 0L, &pos, statText|itemDisable, -1, prompt); SetRect(&pos, 20, 110, 80, 130); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "OK"); OffsetRect(&pos, 200, 0); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "Cancel"); SetRect(&pos, 20, 80, 280, 96); additem(h, 0L, &pos, editText, 0, (char *) NULL); return h; } /* Perform an entire dialog. It stops when an item <= lastbutton is hit, and returns the item number. When buf is non-NULL, the next item is assumed to be an edit-text item and its contents are transferred to buf. */ static int do_dialog(h, emphasis, lastbutton, buf) struct itemlist **h; int emphasis; int lastbutton; char *buf; { Rect box; DialogPtr d; short hit; short type; Handle item; _wresetmouse(); /* Clean up mouse down status */ if (active != NULL) rmcaret(active); /* Create a box of convenient size, centered horizontally, somewhat below the top of the screen. */ SetRect(&box, 0, 0, 300, 140); OffsetRect(&box, (screen->portRect.right - box.right)/2, 60); d= NewDialog( (Ptr)NULL, &box, "", true, dBoxProc, (WindowPtr)(-1), false, 0L, h); if (emphasis > 0) { /* Emphasize default button */ GetDItem(d, emphasis, &type, &item, &box); SetPort(d); InsetRect(&box, -4, -4); PenSize(3, 3); FrameRoundRect(&box, 16, 16); } if (buf != NULL) { /* Set edit text and focus on entire text */ GetDItem(d, lastbutton+1, &type, &item, &box); SetIText(item, PSTRING(buf)); SelIText(d, lastbutton+1, 0, 32000); } set_arrow(); /* XXX Should support Cmd-period as shortcut for Cancel; perhaps other shortcuts as well? */ do { ModalDialog((ProcPtr)NULL, &hit); } while (hit > lastbutton); set_watch(); if (hit == 1 && emphasis > 0) { /* Pressed Return or Enter; flash default button. */ GetDItem(d, emphasis, &type, &item, &box); HiliteControl((ControlHandle)item, inButton); } if (buf != NULL) { GetDItem(d, lastbutton+1, &type, &item, &box); GetIText(item, buf); #ifndef CLEVERGLUE PtoCstr(buf); #endif } DisposDialog(d); return hit; } void wmessage(prompt) char *prompt; { do_dialog(oklist(prompt), 2, 2, (char *)NULL); } int waskync(prompt, def) char *prompt; { int emphasis; int hit; switch (def) { case 1: emphasis= 2; break; case 0: emphasis= 3; break; default: emphasis= 4; break; } hit= do_dialog(ynclist(prompt), emphasis, 4, (char *) NULL); switch (hit) { default: /* case 1: Return or Enter pressed */ return def; case 2: /* Yes button */ return 1; case 3: /* No button */ return 0; case 4: /* Cancel button */ return -1; } } bool waskstr(prompt, buf, len) char *prompt; char *buf; int len; { /* This code assumes 'buf' is at least 256 bytes long! */ return do_dialog(editlist(prompt), 2, 3, buf) <= 2; } void wperror(name) char *name; { char buf[256]; char *p= buf; if (name != NULL) { strcpy(p, name); strcat(p, ": "); p += strlen(p); } strcat(p, "I/O error"); p += strlen(p); sprintf(p, " %d", errno); wmessage(buf); } dow we just closed. */ for (; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) { front= win; break; /* First hit is OK */ } } if (front == NULL) { /* Try searching above it. */ for (win= winlist+1; win < &winlist[MAXWINDOWS]; ++win) { if (win->open) front= win; /smtalk43/stdwin/Ports/mac/dprintf.c1006440003270021170000000412105465303021014456 037777777777 1 0 /* A simple debugging routine, assuming you've got QuickDraw, windows and menus running. It can be called with up to 10 printf arguments. It beeps, draws a message over the menu bar, and waits for a key or mouse down event. If Command-Period is detected, it calls ExitToShell, to allow an emergency exit from a looping program. Warning: there are some side effects on the window manager's port, such as pen parameters and clipping. The printed string shouldn't exceed 255 chars. */ #include "macwin.h" #ifdef MPW #include #include #include #include #endif void dprintf(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) char *fmt; { char buf[256]; GrafPtr saveport; GrafPtr screen; Rect r; SysBeep(2); sprintf(buf, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); GetPort(&saveport); GetWMgrPort(&screen); SetPort(screen); r= screen->portRect; r.bottom= 19; /* Height of menu bar, less border line */ ClipRect(&r); PenNormal(); /* Reset more parameters, such as text font? */ EraseRect(&r); MoveTo(5, 15); /* Left margin and base line */ #ifndef CLEVERGLUE CtoPstr(buf); #endif DrawString(buf); /* Wait for mouse or key down event. Include auto key events so a flood of dprintf calls can be skipped quickly by holding a key. */ for (;;) { EventRecord e; if (GetNextEvent(keyDownMask|autoKeyMask|mDownMask, &e)) { if (e.what == keyDown && (e.message & charCodeMask) == '.' && (e.modifiers & cmdKey)) ExitToShell(); if ((e.what == keyDown || e.what == autoKey) && ((e.message & charCodeMask) == '\r' || (e.message & charCodeMask) == '\3') || e.what == mouseDown) break; } } /* Restore the situation, more or less. */ SetPort(saveport); DrawMenuBar(); } #ifdef UNUSED /* Print the extent of the stack. */ #define CurStackBase (* (long*)0x908) #define ApplZone (* (long*)0x2AA) #define ApplLimit (* (long*)0x130) prstack(where) char *where; { dprintf("ApplZone=%d, ApplLimit=%d, CurStackBase=%d, SP=%d", ApplZone, ApplLimit, CurStackBase, &where); } #endif /*UNUSED*/ tatus; #else return -1; #endif } /* Return active window. */ WINDOW * wgetactive() { return front; } /* Change a window's title. */ void wsettitle(win, title) WINDOW *win; char *title; { if (win->title != NULL) free(win->title); win->title= strdup(title); _wnewtitle(win); } /* Change the mouse cursor -- dummy */ /*ARGSUSED*/ void wsetwincursor(win, cursor) WINDOW *win; CURSOR *cursor; { } /* Fetch a mouse curssmtalk43/stdwin/Ports/mac/draw.c1006440003270021170000002535505465303021013761 037777777777 1 0 /* MAC STDWIN -- DOCUMENT DRAWING. */ /* Contents of this file: wchange, wscroll; wbegindrawing, wenddrawing, _wupdate, wupdate; text attribute manipulation (internal and external); text measuring; text drawing; coordinate conversion tools; ordinary drawing. XXX Should be split, only things used between w{begin,end}drawing belong here. BEWARE OF COORDINATE SYSTEMS! The window's origin is not always the same. When the aplication isn't drawing (i.e., outside w{begin,end}drawing), the origin is (0, 0); this is necessary because the control mgr doesn't like it otherwise. When the application is drawing, the origin is set to win->(orgh, orgv) so the drawing primitives don't need to do their own coordinate transformation. Routines called while not drawing must do their own transformations. XXX Routines that may be called any time are in trouble! (There shouldn't be any.) */ #include "macwin.h" #ifdef MPW #include #endif static WINDOW *drawing; static TEXTATTR drawsaveattr; static int baseline; static int lineheight; /* Function prototypes */ STATIC void getwattr _ARGS((GrafPtr port, TEXTATTR *attr)); STATIC void setwattr _ARGS((TEXTATTR *attr)); STATIC void getfinfo _ARGS((void)); void wchange(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { Rect r; SetPort(win->w); if (drawing) dprintf("warning: wchange called while drawing"); makerect(win, &r, left, top, right, bottom); InvalRect(&r); } void wscroll(win, left, top, right, bottom, dh, dv) WINDOW *win; int left, top, right, bottom; int dh, dv; { Rect r; if (drawing) dprintf("warning: wchange called while drawing"); makerect(win, &r, left, top, right, bottom); scrollby(win, &r, dh, dv); } /* Scroll a rectangle (given in window coordinates) by dh, dv. Also used from scroll.c. */ /* XXX need less visible name */ void scrollby(win, pr, dh, dv) WINDOW *win; Rect *pr; int dh, dv; { RgnHandle rgn= NewRgn(); SetPort(win->w); rmcaret(win); if (!EmptyRgn(( (WindowPeek)win->w )->updateRgn)) { RgnHandle ur= NewRgn(); int left, top; Rect r; /* Scroll the part of the update region that intersects the scrolling area. */ CopyRgn(( (WindowPeek)win->w )->updateRgn, ur); /* portBits.bounds is the screen in local coordinates! */ left= win->w->portBits.bounds.left; top= win->w->portBits.bounds.top; OffsetRgn(ur, left, top); /* Global to Local */ RectRgn(rgn, pr); SectRgn(rgn, ur, ur); if (!EmptyRgn(ur)) { ValidRgn(ur); OffsetRgn(ur, dh, dv); SectRgn(rgn, ur, ur); InvalRgn(ur); } DisposeRgn(ur); } ScrollRect(pr, dh, dv, rgn); InvalRgn(rgn); DisposeRgn(rgn); } /* Internal version of wupdate -- also used from event.c */ void _wupdate(win, pr) WINDOW *win; Rect *pr; { RgnHandle rgn= NewRgn(); SetPort(win->w); rmcaret(win); BeginUpdate(win->w); EraseRect(&win->w->portRect); DrawGrowIcon(win->w); DrawControls(win->w); getwinrect(win, pr); RectRgn(rgn, pr); SectRgn(rgn, win->w->visRgn, rgn); *pr= (*rgn)->rgnBBox; OffsetRect(pr, win->orgh, win->orgv); if (win->drawproc != NULL && !EmptyRect(pr)) { wbegindrawing(win); (*win->drawproc)(win, pr->left, pr->top, pr->right, pr->bottom); wenddrawing(win); } EndUpdate(win->w); DisposeRgn(rgn); } /* Process an update event -- call the window's draw procedure. */ /* XXX This function shouldn't be in the stdwin spec (why was it ever?) */ void wupdate(win) WINDOW *win; { if (win->drawproc != NULL) { Rect r; _wupdate(win, &r); } } void wbegindrawing(win) WINDOW *win; { Rect r; if (drawing != NULL) { dprintf("warning: recursive call to wbegindrawing"); /* Fix it */ wenddrawing(drawing); } if (win == NULL) { dprintf("warning: wbegindrawing(NULL) ignored"); return; } drawing= win; SetPort(win->w); SetOrigin(win->orgh, win->orgv); rmcaret(win); getwinrect(win, &r); ClipRect(&r); PenNormal(); wgettextattr(&drawsaveattr); wsettextattr(&win->attr); } void wenddrawing(win) WINDOW *win; { Rect r; if (drawing == NULL) { dprintf("warning: wenddrawing ignored while not drawing"); return; } if (drawing != win) { dprintf("warning: wenddrawing ignored for wrong window"); return; } SetOrigin(0, 0); SetRect(&r, -32000, -32000, 32000, 32000); ClipRect(&r); wsettextattr(&drawsaveattr); drawing= NULL; } /* Get the current text attributes of a GrafPort. */ static void getwattr(port, attr) GrafPtr port; TEXTATTR *attr; { SetPort(port); /* XXX Is this necessary to validate txFont etc.? */ attr->font= port->txFont; attr->style= port->txFace; attr->size= port->txSize; } /* Start using the given text attributes in the current grafport. */ static void setwattr(attr) TEXTATTR *attr; { TextFont(attr->font); TextFace(attr->style & ~TX_INVERSE); TextSize(attr->size); } /* Get font info and baseline from current GrafPort */ static void getfinfo() { FontInfo finfo; GetFontInfo(&finfo); baseline= finfo.ascent + finfo.leading; lineheight= baseline + finfo.descent; } /* Initialize 'wattr'. Uses the screen's grafport. */ int _w_font= applFont; int _w_size= 9; void initwattr() { TEXTATTR saveattr; SetPort(screen); getwattr(screen, &saveattr); TextFont(_w_font); TextSize(_w_size); getwattr(screen, &wattr); getfinfo(); setwattr(&saveattr); } /* TEXT ATTRIBUTES. */ void wgettextattr(attr) TEXTATTR *attr; { *attr= wattr; } void wsettextattr(attr) TEXTATTR *attr; { wattr= *attr; if (drawing != NULL) { setwattr(attr); getfinfo(); } } void wgetwintextattr(win, attr) WINDOW *win; TEXTATTR *attr; { *attr= win->attr; } void wsetwintextattr(win, attr) WINDOW *win; TEXTATTR *attr; { win->attr= *attr; if (drawing != NULL) dprintf("warning: wsetwintextattr called while drawing"); } void wsetfont(fontname) char *fontname; { if (fontname == NULL || *fontname == EOS) wattr.font= _w_font; else { short fnum= 0; GetFNum(PSTRING(fontname), &fnum); if (fnum == 0) dprintf("can't find font %s", fontname); wattr.font= fnum; } if (drawing != NULL) { TextFont(wattr.font); getfinfo(); } } void wsetsize(size) int size; { wattr.size= size; if (drawing != NULL) { TextSize(size); getfinfo(); } } void wsetstyle(face) Style face; { wattr.style= face; if (drawing != NULL) { TextFace(face & ~TX_INVERSE); getfinfo(); } } void wsetplain() { wsetstyle(0); } void wsetinverse() { wattr.style |= TX_INVERSE; } void wsetbold() { wsetstyle(bold); } void wsetitalic() { wsetstyle(italic); } void wsetbolditalic() { wsetstyle(bold|italic); } void wsetunderline() { wsetstyle(underline); } void wsethilite() { wsetstyle(TX_INVERSE); } /* TEXT MEASURING. */ int wlineheight() { if (drawing == NULL) { TEXTATTR saveattr; getwattr(screen, &saveattr); setwattr(&wattr); getfinfo(); setwattr(&saveattr); } return lineheight; } int wbaseline() { if (drawing == NULL) (void) wlineheight(); return baseline; } int wtextwidth(str, len) char *str; int len; { TEXTATTR saveattr; int width; if (drawing == NULL) { getwattr(screen, &saveattr); setwattr(&wattr); } if (len < 0) len= strlen(str); width= TextWidth(str, 0, len); if (drawing == NULL) setwattr(&saveattr); return width; } int wcharwidth(c) int c; { char cbuf[1]; cbuf[0]= c; return wtextwidth(cbuf, 1); } /* TEXT DRAWING. */ void wdrawtext(h, v, str, len) int h, v; char *str; int len; { Point pen; if (len < 0) len= strlen(str); MoveTo(h, v + baseline); DrawText(str, 0, len); GetPen(&pen); if (wattr.style & TX_INVERSE) { Rect r; SetRect(&r, h, v, pen.h, v + lineheight); InvertRect(&r); } } void wdrawchar(h, v, c) int h, v; int c; { if ((wattr.style & TX_INVERSE) == 0) { /* Attempt to optimize for appls. like dpv */ MoveTo(h, v + baseline); DrawChar(c); } else { char cbuf[1]; cbuf[0]= c; wdrawtext(h, v, cbuf, 1); } } /* COORDINATE CONVERSIONS ETC. */ /* Create a rect in current window coordinates (as for getwinrect) from a rectangle given in document coordinates. This works both while drawing and while not drawing. The resulting rectangle is clipped to the winrect. */ void makerect(win, pr, left, top, right, bottom) WINDOW *win; Rect *pr; int left, top, right, bottom; { Rect r; SetRect(pr, left, top, right, bottom); if (!drawing) OffsetRect(pr, - win->orgh, - win->orgv); getwinrect(win, &r); (void) SectRect(&r, pr, pr); } /* Retrieve the 'winrect', i.e., the contents area exclusive of the scroll bars and grow icon. Coordinates are in window coordinates, i.e., the origin is (0, 0) outside w{begin,end}drawing, but (win->orgh, win->orgv) between calls to these routines. */ void getwinrect(win, pr) WINDOW *win; Rect *pr; { *pr= win->w->portRect; pr->right -= BAR; pr->bottom -= BAR; } /* ACTUAL DRAW ROUTINES. */ void wdrawline(h1, v1, h2, v2) { MoveTo(h1, v1); Line(h2-h1, v2-v1); } void wxorline(h1, v1, h2, v2) { MoveTo(h1, v1); PenMode(patXor); Line(h2-h1, v2-v1); PenNormal(); } void wdrawbox(left, top, right, bottom) int left, top, right, bottom; { Rect r; SetRect(&r, left, top, right, bottom); FrameRect(&r); } void werase(left, top, right, bottom) int left, top, right, bottom; { Rect r; SetRect(&r, left, top, right, bottom); EraseRect(&r); } void winvert(left, top, right, bottom) int left, top, right, bottom; { Rect r; SetRect(&r, left, top, right, bottom); InvertRect(&r); } void wpaint(left, top, right, bottom) int left, top, right, bottom; { Rect r; SetRect(&r, left, top, right, bottom); FillRect(&r, QD(black)); } void wshade(left, top, right, bottom, perc) int left, top, right, bottom; int perc; { Rect r; unsigned char *p; /* really Pattern * or PatPtr */ perc= (perc + 12)/25; CLIPMIN(perc, 0); switch (perc) { case 0: p= &QD(white)[0]; break; case 1: p= &QD(ltGray)[0]; break; case 2: p= &QD(gray)[0]; break; case 3: p= &QD(dkGray)[0]; break; default: p= &QD(black)[0]; break; } SetRect(&r, left, top, right, bottom); FillRect(&r, p); } void wdrawcircle(h, v, radius) int h, v; int radius; { Rect r; /* XXX Isn't there an off-by-one error here? */ SetRect(&r, h-radius, v-radius, h+radius, v+radius); FrameOval(&r); } /* Draw counterclockwise elliptical arc. h, v are center; hrad, vrad are half axes; ang1 and ang2 are start and stop angles in degrees, with respect to 3 o'clock. */ void wdrawelarc(h, v, hrad, vrad, ang1, ang2) { Rect r; /* XXX Does this work? No off-by-one errors? */ SetRect(&r, h-hrad, v-vrad, h+hrad, v+vrad); FrameArc(&r, 90-ang1, ang1-ang2); /* ??? */ } /* CLIPPING */ void wcliprect(left, top, right, bottom) int left, top, right, bottom; { Rect r1, r2; SetRect(&r1, left, top, right, bottom); getwinrect(drawing, &r2); SectRect(&r1, &r2, /*dst:*/ &r2); ClipRect(&r2); } void wnoclip() { Rect r; getwinrect(drawing, &r); ClipRect(&r); } r == 0) { return NULL; } else { static struct timeval tv; struct timezone tz; if (gettimeofday(&tv, &tz) < 0) { return NULL; } else { long tout; tout= nexttimer - (tv.tv_sec - torigin) * 10 - tv.tv_usec / 100000; if (tout <= 0) tv.tv_smtalk43/stdwin/Ports/mac/event.c1006440003270021170000003130505465303021014135 037777777777 1 0 /* MAC STDWIN -- EVENT HANDLING. */ #include "macwin.h" #ifdef MPW #include #include #include #include #endif #ifdef THINK_C #include #endif void (*_w_idle_proc)(); /* Function to call in idle loop */ WINDOW *active= NULL; /* The active window */ /* XXX should be a less obvious name */ bool _wm_down; /* Set if mouse is down in content rect */ static EventRecord e; /* Global, so it's accessible to all subroutines */ /* XXX the name is too short */ /* Function prototypes */ STATIC void make_mouse_event _ARGS((EVENT *ep, Point *pwhere)); STATIC void do_idle _ARGS((EVENT *ep)); STATIC void do_update _ARGS((EVENT *ep)); STATIC void do_mouse_down _ARGS((EVENT *ep)); STATIC void do_mouse_up _ARGS((EVENT *ep)); STATIC void do_key _ARGS((EVENT *ep)); STATIC void do_activate _ARGS((EVENT *ep)); STATIC void do_disk _ARGS((EVENT *ep)); STATIC void activate _ARGS((WINDOW *win)); STATIC void deactivate _ARGS((void)); STATIC void do_click _ARGS((EVENT *ep, WindowPtr w)); STATIC void do_unclick _ARGS((EVENT *ep)); STATIC void do_drag _ARGS((WindowPtr w)); STATIC void do_grow _ARGS((EVENT *ep, WindowPtr w)); STATIC void do_goaway _ARGS((EVENT *ep, WindowPtr w)); STATIC void do_zoom _ARGS((EVENT *ep, WindowPtr w, int code)); STATIC void do_size _ARGS((EVENT *ep, WindowPtr w)); # ifndef NO_STDIO /* Some applications (e.g., Python) want events passed to the stdio console. They must call wsetstdio(1) before their first wgetevent() call. */ static int pass_to_stdio = 0; void wsetstdio(flag) int flag; { pass_to_stdio = flag; } #endif static EVENT pushback= {WE_NULL}; void wungetevent(ep) EVENT *ep; { pushback= *ep; } static void wwaitevent(ep, wait) EVENT *ep; bool wait; { _wfreeclip(); if (pushback.type != WE_NULL) { *ep= pushback; pushback.type= WE_NULL; return; } if (_wmenuhilite) { HiliteMenu(0); _wmenuhilite= FALSE; } if (active == NULL) set_arrow(); ep->type= WE_NULL; ep->window= NULL; do { if (!GetNextEvent(everyEvent, &e)) { if (e.what == nullEvent) { if (wait) do_idle(ep); else return; } } else { #ifndef NO_STDIO /* Give THINK C stdio a chance to handle the event. Unfortunately it also eats up clicks in title bars, so, to save our Option-click feature, we don't feed it those. */ if (pass_to_stdio && !(e.what == mouseDown && (e.modifiers & optionKey))) { if (StdEvent(&e)) continue; } #endif switch (e.what) { case mouseDown: do_mouse_down(ep); break; case mouseUp: do_mouse_up(ep); break; case keyDown: case autoKey: do_key(ep); break; case updateEvt: do_update(ep); break; case diskEvt: do_disk(ep); break; case activateEvt: do_activate(ep); break; } } } while (ep->type == WE_NULL); if (ep->window == NULL) ep->window= whichwin(FrontWindow()); if (!_wm_down) set_watch(); } int wpollevent(ep) EVENT *ep; { ep->type = WE_NULL; wwaitevent(ep, FALSE); return ep->type != WE_NULL; } void wgetevent(ep) EVENT *ep; { wwaitevent(ep, TRUE); } static void do_idle(ep) EVENT *ep; { if (checktimer(ep)) return; if (_w_idle_proc != NULL) (*_w_idle_proc)(); /* The user idle proc may have called wungetevent: */ if (pushback.type != WE_NULL) { *ep= pushback; pushback.type= WE_NULL; return; } SystemTask(); if (active != NULL) { Point where; Rect r; where= e.where; SetPort(active->w); GlobalToLocal(&where); if (_wm_down) { autoscroll(active, where.h, where.v); make_mouse_event(ep, &where); return; } getwinrect(active, &r); if (PtInRect(PASSPOINT where, &r)) { if (e.modifiers & optionKey) set_hand(); else set_applcursor(); } else set_arrow(); blinkcaret(active); } } static void do_update(ep) EVENT *ep; { WINDOW *win; Rect r; win= whichwin((WindowPtr) e.message); if (win == NULL) { /* dprintf("update evt for alien window"); */ return; } _wupdate(win, &r); if (win->drawproc == NULL && !EmptyRect(&r)) { ep->type= WE_DRAW; ep->window= win; ep->u.area.left= r.left; ep->u.area.top= r.top; ep->u.area.right= r.right; ep->u.area.bottom= r.bottom; } } static void do_mouse_down(ep) EVENT *ep; { WindowPtr w; int code= FindWindow(PASSPOINT e.where, &w); /* XXX This doesn't look incredibly necessary: if (active != NULL) { SetPort(active->win); rmcaret(active); } */ if (code != inContent && code != inSysWindow) set_arrow(); switch (code) { case inMenuBar: _wdo_menu(ep, MenuSelect(PASSPOINT e.where)); break; case inSysWindow: SystemClick(&e, w); break; case inContent: do_click(ep, w); break; case inDrag: do_drag(w); break; case inGrow: do_grow(ep, w); break; case inGoAway: do_goaway(ep, w); break; case inZoomIn: case inZoomOut: do_zoom(ep, w, code); break; } } static void do_mouse_up(ep) EVENT *ep; { do_unclick(ep); } static void do_key(ep) EVENT *ep; { char c= e.message & charCodeMask; /* XXX shouldn't mess at all with non-stdwin windows */ if (e.modifiers & cmdKey) { if (c == '.') { ep->type= WE_COMMAND; ep->u.command= WC_CANCEL; } else _wdo_menu(ep, MenuKey(c)); } else { ep->type= WE_COMMAND; switch (c) { default: ObscureCursor(); ep->type= WE_CHAR; ep->u.character= c; break; case LEFT_ARROW: case RIGHT_ARROW: case UP_ARROW: case DOWN_ARROW: ep->u.command= c-LEFT_ARROW + WC_LEFT; break; case '\b': ObscureCursor(); ep->u.command= WC_BACKSPACE; break; case '\t': ObscureCursor(); ep->u.command= WC_TAB; break; case '\r': case ENTER_KEY: ep->u.command= WC_RETURN; break; } } } static void do_disk(ep) EVENT *ep; { /* XXX Disk events not implemented -- who cares. */ } /* XXX Need to be easier for cases where we seem to have missed events */ static void do_activate(ep) EVENT *ep; { WINDOW *win= whichwin((WindowPtr)e.message); if (win == NULL) { /* dprintf("(de)activate evt for alien window"); */ return; } if (e.modifiers & activeFlag) { /* Activation */ if (active != NULL) { /* Perhaps reactivation after modal dialog */ #ifdef NO_STDIO /* But perhaps THINK C stdio is fooling us */ if (active == win) return; /* If we get here we've missed a deactivate event... */ dprintf("activate without deactivate"); #endif } activate(win); ep->type= WE_ACTIVATE; ep->window= active; } else { /* Deactivation */ if (win != active) { /* Spurious deactivation event. This always happens when we open two or more windows without intervening call to wgetevent(). Perhaps an conscious hack in the ROM to "help" programs that believe windows are created active? */ return; } ep->type= WE_DEACTIVATE; ep->window= active; deactivate(); } } static void deactivate() { SetPort(active->w); rmcaret(active); hidescrollbars(active); rmlocalmenus(active); DrawGrowIcon(active->w); active= NULL; set_arrow(); } static void activate(win) WINDOW *win; { if (active != NULL) deactivate(); if (win != NULL) { SetPort(win->w); active= win; showscrollbars(win); addlocalmenus(active); valid_border(win->w); /* Avoid flicker when window pops up */ } } static void do_click(ep, w) EVENT *ep; WindowPtr w; { WINDOW *win= whichwin(w); Point where; int pcode; ControlHandle bar; if (win == NULL) { /* dprintf("click in alien window"); */ return; } if (win != active) { set_arrow(); if (e.modifiers & optionKey) { /* Option-click sends a window behind. */ SendBehind(w, (WindowPtr) NULL); } else SelectWindow(win->w); return; /* Let activate events do the rest. */ } where= e.where; SetPort(win->w); GlobalToLocal(&where); pcode= FindControl(PASSPOINT where, w, &bar); if (pcode != 0) { set_arrow(); do_scroll(&where, win, bar, pcode); } else { Rect r; getwinrect(win, &r); if (PtInRect(PASSPOINT where, &r)) { if (e.modifiers & optionKey) { set_hand(); dragscroll(win, where.h, where.v, e.modifiers & shiftKey); } else { set_applcursor(); make_mouse_event(ep, &where); } } } } static void do_unclick(ep) EVENT *ep; { if (active != NULL) { Point where; where= e.where; SetPort(active->w); GlobalToLocal(&where); make_mouse_event(ep, &where); } } static void do_drag(w) WindowPtr w; { if (e.modifiers & optionKey) { /* Nonstandard: option-click sends a window behind. */ SendBehind(w, (WindowPtr) NULL); } else { Rect r; r= screen->portRect; r.top += MENUBARHEIGHT; InsetRect(&r, 4, 4); DragWindow(w, PASSPOINT e.where, &r); } } static void do_grow(ep, w) EVENT *ep; WindowPtr w; { Rect r; long reply; /* XXX shouldn't mess at all with non-stdwin windows */ /* Set minimal window size */ r.left= LSLOP + MIN_WIDTH + RSLOP + BAR; r.top= MIN_HEIGHT + BAR; /* The max size is derived from the document size. If there is no document size, it is unlimited. (There is nothing wrong with windows larger than the screen, really.) */ r.right = r.bottom = 0x7fff; { /* Max size restriction based on doc size, if specified */ WINDOW *win = whichwin(w); int docwidth = win->docwidth; int docheight = win->docheight; if (win->docwidth > 0) { CLIPMIN(docwidth, MIN_WIDTH); r.right = LSLOP + docwidth + RSLOP + BAR + 1; } if (win->docheight > 0) { CLIPMIN(docheight, MIN_HEIGHT); r.bottom = docheight + BAR + 1; } /* For some reason 1 has to be added. Sigh. */ } reply= GrowWindow(w, PASSPOINT e.where, &r); if (reply != 0) { SetPort(w); inval_border(w); SizeWindow(w, LoWord(reply), HiWord(reply), TRUE); do_size(ep, w); } } static void do_goaway(ep, w) EVENT *ep; WindowPtr w; { /* XXX shouldn't mess at all with non-stdwin windows */ if (TrackGoAway(w, PASSPOINT e.where)) { ep->type= WE_COMMAND; ep->window= whichwin(w); ep->u.command= WC_CLOSE; } } static void do_zoom(ep, w, code) EVENT *ep; WindowPtr w; int code; { /* XXX shouldn't mess at all with non-stdwin windows */ /* This code will never be reached on a machine with old (64K) ROMs, because FindWindow will never return inZoomIn or inZoomOut. Therefore, no check for new ROMs is necessary. A warning in Inside Macintosh IV says that it is necessary to make the zoomed window the current GrafPort before calling ZoomWindow. True enough, it fails spectacularly otherwise, but still this looks like a bug to me - there are no similar requirements for SizeWindow or DragWindow. */ SetPort(w); if (TrackBox(w, PASSPOINT e.where, code)) { inval_border(w); ZoomWindow(w, code, TRUE); do_size(ep, w); } } /* do_size assumes w is already the current grafport */ static void do_size(ep, w) EVENT *ep; WindowPtr w; { WINDOW *win= whichwin(w); if (win == NULL) { /* dprintf("alien window resized"); */ return; } inval_border(w); movescrollbars(win); ep->type= WE_SIZE; ep->window= win; _wfixorigin(win); } void inval_border(w) WindowPtr w; { Rect r; r= w->portRect; r.left= r.right - BAR; InvalRect(&r); r= w->portRect; r.top= r.bottom - BAR; InvalRect(&r); } void valid_border(w) WindowPtr w; { Rect r; r= w->portRect; r.left= r.right - BAR; ValidRect(&r); r= w->portRect; r.top= r.bottom - BAR; ValidRect(&r); } /* Variables needed in click and move detection. */ static int m_h, m_v; /* Doc. coord. of last mouse evt. */ static long m_when; /* TickCount of last mouse evt. */ static int m_clicks; /* N-fold click stage */ static int m_button; /* Which 'button'; 1=normal, 2=shift, 3=command. */ static void make_mouse_event(ep, pwhere) EVENT *ep; Point *pwhere; /* Mouse pos. in local coord. */ { WINDOW *win= active; int h= pwhere->h + win->orgh; int v= pwhere->v + win->orgv; int dh= h - m_h; int dv= v - m_v; if (dh*dh + dv*dv > CLICK_DIST*CLICK_DIST) m_clicks= 0; /* Moved too much for a click */ if (e.what == mouseDown) { if (e.when > m_when + GetDblTime()) m_clicks= 1; else ++m_clicks; ep->type= WE_MOUSE_DOWN; _wm_down= TRUE; /* XXX Should swap buttons 2 & 3 (also in textedit) since X11 (e.g., xterm) uses button 3 for extend */ m_button= (e.modifiers & cmdKey) ? 3 : (e.modifiers & shiftKey) ? 2 : 1; } else if (e.what == mouseUp) { if (!_wm_down) return; ep->type= WE_MOUSE_UP; _wm_down= FALSE; } else { if (!_wm_down || m_clicks > 0 || (dh == 0 && dv == 0)) return; ep->type= WE_MOUSE_MOVE; } ep->u.where.h= m_h= h; ep->u.where.v= m_v= v; ep->u.where.clicks= m_clicks; ep->u.where.button= m_button; ep->u.where.mask= (ep->type == WE_MOUSE_UP) ? 0 : 1; ep->window= win; m_when= e.when; } /* Reset the mouse state. Called when a dialog is started. */ void _wresetmouse() { _wm_down= FALSE; } 37777777777 1 0 smtalk43/stdwin/Ports/mac/fullpath.c1006440003270021170000000246405465303021014637 037777777777 1 0 /* GET FULL PATHNAME OF A FILE. */ #include "macwin.h" #ifdef MPW #include #endif #ifdef THINK_C #include #endif /* Mac file system parameters */ #define MAXPATH 256 /* Max path name length+1 */ #define SEP ':' /* Separator in path names */ #define ROOTID 2 /* DirID of a volume's root directory */ /* Macro to find out whether we can do HFS-only calls: */ #define FSFCBLen (* (short *) 0x3f6) #define hfsrunning() (FSFCBLen > 0) char * getdirname(dir) int dir; /* WDRefNum */ { union { HFileInfo f; DirInfo d; WDPBRec w; VolumeParam v; } pb; static char cwd[2*MAXPATH]; unsigned char namebuf[MAXPATH]; short err; long dirid= 0; char *next= cwd + sizeof cwd - 1; int len; if (!hfsrunning()) return ""; for (;;) { pb.d.ioNamePtr= namebuf; pb.d.ioVRefNum= dir; pb.d.ioFDirIndex= -1; pb.d.ioDrDirID= dirid; err= PBGetCatInfo(&pb.d, FALSE); if (err != noErr) { dprintf("PBCatInfo err %d", err); return NULL; } *--next= SEP; len= namebuf[0]; /* XXX There is no overflow check on cwd here! */ strncpy(next -= len, (char *)namebuf+1, len); if (pb.d.ioDrDirID == ROOTID) break; dirid= pb.d.ioDrParID; } return next; } void fullpath(buf, wdrefnum, file) char *buf; int wdrefnum; char *file; { strcpy(buf, getdirname(wdrefnum)); strcat(buf, file); } p to the application to set an arrow when it goes away for a long time. */ void set_watch() { if (active == NULL || active->cursor == NULL) SetCursor(*GetCursor(watchCursor)); } /* Set the cursor smtalk43/stdwin/Ports/mac/macwin.h1006440003270021170000001436505434024346014314 037777777777 1 0 /* Source for the precompiled header file "macwin.h" in THINK C. This file includes other header files and defines symbols and types. It is included in the project for convenience; it generates no code. ********************************************************************** * When you edit this file, you must generate a new "macwin.h": * * Choose "Precompile..." from the Source menu and save as "macwin.h" * * (overwriting the old "macwin.h"). * ********************************************************************** For Think C version 3.0, define THINK_C_3_0 in "stdwconf.h". For MPW, move macwin.c to macwin.h and remove the include below. */ #include /*** REMOVE THIS FOR MPW ***/ #include "stdwconf.h" /* Will set MPW or THINK_C */ #ifdef MPW /* Without NO_STDIO, some THINK specific code gets compiled */ #define NO_STDIO /* MPW names for Mac include files */ #include #include #include #include /* Quickdraw globals aren't really global in MPW */ #define QD(var) qd.var /* MPW allows 'static' in forward declarations */ #define STATIC static /* MPW passes all Points by value */ #define PASSPOINT & /* MPW glue converts most string on the fly. (XXX I believe you can turn this off now?) */ #define CLEVERGLUE #endif #ifdef THINK_C /* You may also define NO_STDIO under THINK C, to avoid pulling in stdio */ /* ...and for 4.0, it doesn't work anymore (sigh) */ #ifndef THINK_C_3_0 #define NO_STDIO #endif /* THINK's omits two essential constants of the Mac+ ROM */ #define zoomDocProc 8 #define zoomNoGrow 12 /* Pascal-to-C and back string conversion routines have different names */ #include #define p2cstr PtoCstr #define c2pstr CtoPstr /* XXX actually, used nowhere */ /* Quickdraw globals are real globals in THINK C */ #define QD(var) (var) /* THINK C can't declare forward functions as static */ #define STATIC /**/ /* THINK C passes Points by value to some toolbox routines */ #define PASSPOINT /**/ #endif /* Private include files: */ #include "tools.h" #include "stdwin.h" #include "menu.h" #ifdef CLEVERGLUE /* MPW converts C to Pascal strings in the glue */ #define PSTRING(str) (str) #else /* THINK C needs a real function to do this (see "pstring.c"). This is different from CtoPstr since it does not do it inline */ extern char *PSTRING _ARGS((char *)); #endif /* Window struct. */ struct _window { short tag; /* Window tag, usable as document id */ void (*drawproc)(); /* Draw procedure */ WindowPtr w; /* Mac Window */ int hcaret, vcaret; /* Caret position, document coordinates */ bool caret_on; /* Set if caret currently visible */ TEXTATTR attr; /* Text attributes */ ControlHandle hbar, vbar; /* Scroll bars */ int docwidth, docheight; /* Document size */ int orgh, orgv; /* Window origin, document coordinates */ struct menubar mbar; /* List of attached local menus */ unsigned long timer; /* Tick count for timer event */ CURSOR *cursor; /* Cursor if not default */ }; extern TEXTATTR wattr; /* Current text attributes */ #define TX_INVERSE 0x80 /* Or-ed into style bits */ /* Peculiarities of the Macintosh: */ #define TICKSPERSECOND 60 /* Clock ticks at 60 Hz (everywhere) */ #define MENUBARHEIGHT 20 /* Height of menu bar */ #define TITLEBARHEIGHT 18 /* Height of window title bar */ #define BAR 15 /* Scroll bar width, minus one pixel */ /* ASCII codes generated by special keys: */ #define ENTER_KEY 0x03 #define LEFT_ARROW 0x1c #define RIGHT_ARROW 0x1d #define UP_ARROW 0x1e #define DOWN_ARROW 0x1f /* Miscellaneous definitions. */ #define CLICK_DIST 5 /* Max mouse move within a click */ /* Parameters for top left corner choice algorithm: */ #define LEFT 20 /* Initial left */ #define TOP 40 /* Initial top */ #define HINCR 20 /* Increment for left */ #define VINCR 16 /* Increment for top */ /* Minimal window size (determined by room for scroll bars only): */ #define MIN_WIDTH (2*BAR) #define MIN_HEIGHT (2*BAR) /* Text drawn in the very left or right margin doesn't look nice. Therefore, we have a little margin on each side. Its width is determined here: */ #define LSLOP 4 /* Pixels in left margin */ #define RSLOP 4 /* Pixels in right margin */ /* Global data: */ extern GrafPtr screen; /* Window Manager's GrafPort */ extern WINDOW *active; /* Active window, if any */ extern bool _wmenuhilite; /* Set if menu item highlighted */ extern bool _wm_down; /* Set if mouse down (in appl. area) */ /* Function prototypes: */ void dprintf _ARGS((char *fmt, ...)); void wsetstyle _ARGS((Style face)); WINDOW *whichwin _ARGS((WindowPtr w)); void makerect _ARGS((WINDOW *win, Rect *pr, int left, int top, int right, int bottom)); void getwinrect _ARGS((WINDOW *win, Rect *pr)); void set_arrow _ARGS((void)); void set_applcursor _ARGS((void)); void set_watch _ARGS((void)); void set_ibeam _ARGS((void)); void set_hand _ARGS((void)); void makescrollbars _ARGS((WINDOW *win)); void movescrollbars _ARGS((WINDOW *win)); void hidescrollbars _ARGS((WINDOW *win)); void showscrollbars _ARGS((WINDOW *win)); void scrollby _ARGS((WINDOW *win, Rect *pr, int dh, int dv)); void do_scroll _ARGS((Point *pwhere, WINDOW *win, ControlHandle bar, int pcode)); void dragscroll _ARGS((WINDOW *win, int h, int v, int constrained)); void initwattr _ARGS((void)); void inval_border _ARGS((WindowPtr w)); void valid_border _ARGS((WindowPtr w)); void rmlocalmenus _ARGS((WINDOW *win)); void addlocalmenus _ARGS((WINDOW *win)); void initmbar _ARGS((struct menubar *mp)); void killmbar _ARGS((struct menubar *mp)); void setup_menus _ARGS((void)); void do_about _ARGS((void)); void getargcargv _ARGS((int *pargc, char ***pargv)); void fullpath _ARGS((char *buf, int wdrefnum, char *file)); char *getdirname _ARGS((int wdrefnum)); void rmcaret _ARGS((WINDOW *win)); void showcaret _ARGS((WINDOW *win)); void blinkcaret _ARGS((WINDOW *win)); void _wresetmouse _ARGS((void)); void _wfreeclip _ARGS((void)); bool checktimer _ARGS((EVENT *ep)); void autoscroll _ARGS((WINDOW *active, int h, int v)); void _wdo_menu _ARGS((EVENT *ep, long menu_item)); /* SetRect is much faster this way... */ #define SetRect(pr, l, t, r, b) ((pr)->left = (l), (pr)->top = (t), \ (pr)->right = (r), (pr)->bottom = (b)) , &pos, statText|itemDisable, -1, prompt); SetRect(&pos, 20, 110, 80, 130); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "OK"); OffsetRect(&pos, 200, 0); additem(h, 0L, &pos, ctrlItem|btnCtrl, -1, "Cancel"); SetRect(&pos, 20, 80, 280, 96); additem(h, 0L, &pos, edsmtalk43/stdwin/Ports/mac/menu.c1006440003270021170000001020305465303021013752 037777777777 1 0 /* MAC STDWIN -- MENUS. */ /* XXX Ought to find a way to allow the THINK C console menus to work when the console is active */ #include "macwin.h" #ifdef MPW #include #include #include #endif #ifdef THINK_C #include #endif #define MENUID(mp) ((*((MenuHandle)(mp)))->menuID) bool _wmenuhilite; /* Set if HiliteMenu(0) needed */ static bool deflocal= FALSE; /* Default menu state */ static int firstlocal; /* First local menu in menu bar */ /* Function prototypes */ STATIC void addtobar _ARGS((struct menubar *mbp, MENU *mp)); STATIC void delfrombar _ARGS((struct menubar *mbp, MENU *mp)); static void addtobar(mbp, mp) struct menubar *mbp; MENU *mp; { int i; for (i= 0; i < mbp->nmenus; ++i) { if (mp == mbp->menulist[i]) return; /* Already attached */ } L_APPEND(mbp->nmenus, mbp->menulist, MENU *, mp); } static void delfrombar(mbp, mp) struct menubar *mbp; MENU *mp; { int i; for (i= 0; i < mbp->nmenus; ++i) { if (mp == mbp->menulist[i]) { L_REMOVE(mbp->nmenus, mbp->menulist, MENU *, i); break; } } } MENU * wmenucreate(id, title) int id; char *title; { MENU *mp= (MENU *)NewMenu(id, PSTRING(title)); if (!deflocal) { InsertMenu(mp, firstlocal); DrawMenuBar(); } return mp; } void wmenudelete(mp) MENU *mp; { WindowPtr w; for (w= FrontWindow(); w != NULL; w= (WindowPtr)((WindowPeek)w)->nextWindow) { WINDOW *win= whichwin(w); if (win != NULL) delfrombar(&win->mbar, mp); } DeleteMenu(MENUID(mp)); DrawMenuBar(); DisposeMenu(mp); } int wmenuadditem(mp, text, shortcut) MENU *mp; char *text; int shortcut; { char buf[256]; int item; if (text == NULL || *text == EOS) strcpy(buf, "(-"); else strcpy(buf, "x"); if (shortcut >= 0) { char *p= buf + strlen(buf); *p++= '/'; *p++= shortcut; *p= EOS; } AppendMenu(mp, PSTRING(buf)); item= CountMItems(mp); if (text != NULL && *text != EOS) SetItem(mp, item, PSTRING(text)); return item-1; } void wmenusetitem(mp, item, text) MENU *mp; int item; char *text; { ++item; if (text == NULL || *text == EOS) DisableItem(mp, item); else { EnableItem(mp, item); SetItem(mp, item, PSTRING(text)); } } void wmenuenable(mp, item, flag) MENU *mp; int item; int flag; { ++item; if (flag) EnableItem(mp, item); else DisableItem(mp, item); } void wmenucheck(mp, item, flag) MENU *mp; int item; int flag; { ++item; CheckItem(mp, item, flag); } void wmenuattach(win, mp) WINDOW *win; MENU *mp; { addtobar(&win->mbar, mp); if (win == active) { InsertMenu(mp, 0); DrawMenuBar(); } } void wmenudetach(win, mp) WINDOW *win; MENU *mp; { delfrombar(&win->mbar, mp); if (win == active) { DeleteMenu(MENUID(mp)); DrawMenuBar(); } } void wmenusetdeflocal(local) bool local; { deflocal= local; } /* Interface routines for the rest of the library. */ void initmbar(mb) struct menubar *mb; { L_INIT(mb->nmenus, mb->menulist); } void killmbar(mb) struct menubar *mb; { L_DEALLOC(mb->nmenus, mb->menulist); } void addlocalmenus(win) WINDOW *win; { int i; firstlocal= 0; for (i= 0; i < win->mbar.nmenus; ++i) { if (firstlocal == 0) firstlocal= MENUID(win->mbar.menulist[i]); InsertMenu(win->mbar.menulist[i], 0); } if (i > 0) DrawMenuBar(); } void rmlocalmenus(win) WINDOW *win; { int i; firstlocal= 0; for (i= 0; i < win->mbar.nmenus; ++i) DeleteMenu(MENUID(win->mbar.menulist[i])); if (i > 0) DrawMenuBar(); } void _wdo_menu(ep, menu_item) EVENT *ep; long menu_item; { int id= HiWord(menu_item); int item= LoWord(menu_item); if (id == 0) return; if (id == APPLE_MENU) { if (item == 1) do_about(); else { char name[256]; GetItem(GetMHandle(id), item, name); (void) OpenDeskAcc(name); } HiliteMenu(0); } else { ep->type= WE_MENU; ep->u.m.id= id; ep->u.m.item= item-1; _wmenuhilite= TRUE; } } /* Call this routine exactly once to initialize the Apple menu. */ char *about_item= "About STDWIN..."; void setup_menus() { static char applename[2]= {appleMark, EOS}; MenuHandle m; m= (MenuHandle)wmenucreate(APPLE_MENU, applename); AppendMenu(m, PSTRING(about_item)); AppendMenu(m, PSTRING("(-")); AddResMenu(m, 'DRVR'); } buf); #endif DrawString(buf); /* Wait for mouse or key down event. Include auto key events so a flood of dprintf calls can be skipped quickly by holding a key. */ for (;;) { EventRecord e; if (GetNextEvent(keyDownMask|autoKeyMask|mDownMask, &e)) { if (e.what == keyDown && (e.message & charCodeMask) == '.' && (e.modifiers & cmdKey)) ExitToShell(smtalk43/stdwin/Ports/mac/menu.h1006440003270021170000000054205434024346013772 037777777777 1 0 /* MAC STDWIN -- MENU DEFINITIONS. */ /* Note -- struct menu isn't defined here. MENU * is taken to be equivalent to MenuPtr, whenever appropriate. I know this is a hack -- I'll fix it later. */ struct menubar { int nmenus; /* Number of menus in the list */ MENU **menulist; /* Pointer to list of MENU pointers */ }; #define APPLE_MENU 32000 wtitle(win); } /* Change the mouse cursor -- dummy */ /*ARGSUSED*/ void wsetwincursor(win, cursor) WINDOW *win; CURSOR *cursor; { } /* Fetch a mouse curssmtalk43/stdwin/Ports/mac/pstring.c1006440003270021170000000076105465303021014504 037777777777 1 0 /* Function to convert a C string to a Pascal string. The conversion is not in-line, but returns a pointer to a static buffer. This is needed when calling some toolbox routines. MPW does the conversion in the glue. */ #include "macwin.h" #ifndef CLEVERGLUE char * PSTRING(src) register char *src; { static char buf[256]; register char *dst; dst = &buf[1]; while ((*dst++ = *src++) != '\0' && dst < &buf[256]) ; buf[0] = dst - &buf[1]; return buf; } #endif /* CLEVERGLUE */ i.e., outside wsmtalk43/stdwin/Ports/mac/scrap.c1006440003270021170000000424205465303021014124 037777777777 1 0 /* Macintosh Scrap (Clipboard) Interface */ #include "macwin.h" #ifdef MPW #include #include #endif #ifdef THINK_C #include #include #endif static Handle hclip; static long lenclip; /* _wfreeclip is called from wgetevent and from wsetclip. */ void _wfreeclip() { if (hclip != NULL) { HUnlock(hclip); DisposHandle(hclip); hclip= NULL; } } char * wgetclip() { long offset; /* NB if the use of hclip or lenclip changes, also change wgetcutbuffer() below !!! */ if (hclip == NULL) hclip= NewHandle(1L); else HUnlock(hclip); lenclip= GetScrap(hclip, 'TEXT', &offset); if (lenclip < 0) return NULL; SetHandleSize(hclip, lenclip+1); HLock(hclip); (*hclip)[lenclip]= EOS; #ifndef CLEVERGLUE { /* Convert imported \r into \n */ char *p= *hclip; while ((p= strchr(p, '\r')) != NULL) *p++ = '\n'; } #endif return *hclip; } void wsetclip(p, len) char *p; int len; { int err; #ifndef CLEVERGLUE /* Convert \n into \r before exporting. Must make a copy, shit! */ char *q= malloc(len+1); if (q != NULL) { strncpy(q, p, len); q[len]= EOS; p= q; while ((p= strchr(p, '\n')) != NULL) *p++ = '\r'; p= q; } /* If there's no memory, export with \n's left in... */ #endif _wfreeclip(); err= ZeroScrap(); if (err != 0) dprintf("wsetclip: ZeroScrap error %d", err); err= PutScrap((long)len, 'TEXT', p); if (err != 0) dprintf("wsetclip: PutScrap error %d", err); #ifndef CLEVERGLUE if (q != NULL) free(q); #endif } /* For "compatibility" with X11 STDWIN: */ int wsetselection(win, sel, data, len) WINDOW *win; int sel; char *data; int len; { return 0; } char * wgetselection(sel, plen) int sel; int *plen; { return NULL; } void wresetselection(sel) int sel; { } void wsetcutbuffer(ibuffer, data, len) int ibuffer; char *data; int len; { if (ibuffer == 0) wsetclip(data, len); } char * wgetcutbuffer(ibuffer, plen) int ibuffer; int *plen; { if (ibuffer != 0) return NULL; if (wgetclip() == NULL) return NULL; /* This knows about the implementation of wgetclip() */ *plen = lenclip; /* NB: long --> int, may truncate... */ return *hclip; } void wrotatecutbuffers(n) int n; { } >drawproc)(win, pr->left, pr->top, pr->right, pr->bottom); wenddrawing(win); } EndUpdate(win->w); DisposeRgn(rgn); } /* Process an update event -- call the window's draw procedure. */ /* XXX This function shouldn't be in the stdwin spec (why was it ever?) */ void wupdate(win) WINDOW *win; { if (win->drawproc != NULL) { Rect r; _wupdatesmtalk43/stdwin/Ports/mac/scroll.c1006440003270021170000003253305465303021014316 037777777777 1 0 /* MAC STDWIN -- SCROLLING. */ /* All non-public functions here assume the current grafport is set */ /* XXX The contents of this file should be organized more top-down */ #include "macwin.h" #ifdef MPW #include #endif /* I am using the fact here that the scroll bars of an inactive window are invisible: when a window's origin or its document size changes while it isn't the active window, its controls get their new values but aren't redrawn. */ /* Key repeat constants in low memory (set by the Control Panel), in ticks (used here to control the continuous scrolling speed). */ #define KeyThresh (* (short*)0x18e) /* Delay until repeat starts */ #define KeyRepThresh (* (short*)0x190) /* Repeat rate */ #define JURJENBARPROC 48 /* CDEF id for Jurjen's proportional scrollbar */ STATIC void setscrollbarvalues _ARGS((WINDOW *win)); STATIC void usescrollbarvalues _ARGS((WINDOW *win)); STATIC void sizescrollbars _ARGS((WINDOW *win)); STATIC void calcbar _ARGS((ControlHandle bar, int org, int size, int begin, int end)); STATIC void setbar _ARGS((ControlHandle bar, int winsize, int val, int max)); STATIC void deltabar _ARGS((ControlHandle bar, int delta)); STATIC void showbar _ARGS((ControlHandle bar)); STATIC void hidebar _ARGS((ControlHandle bar)); STATIC void movebar _ARGS((ControlHandle bar, int left, int top, int right, int bottom)); void wsetorigin(win, orgh, orgv) WINDOW *win; int orgh, orgv; { Rect r; /* XXX wsetorigin is currently the only routine that allows the application to show bits outside the document. Is even this desirable? */ CLIPMIN(orgh, 0); CLIPMIN(orgv, 0); getwinrect(win, &r); orgh -= LSLOP; if (orgh != win->orgh || orgv != win->orgv) { SetPort(win->w); scrollby(win, &r, win->orgh - orgh, win->orgv - orgv); win->orgh= orgh; win->orgv= orgv; setscrollbarvalues(win); } } void wgetorigin(win, ph, pv) WINDOW *win; int *ph, *pv; { *ph = win->orgh + LSLOP; *pv = win->orgv; } void wshow(win, left, top, right, bottom) WINDOW *win; int left, top, right, bottom; { int orgh, orgv; int winwidth, winheight; int docwidth, docheight; /* Calls to wshow while the mouse is down are ignored, because they tend to mess up auto-scrolling. I presume it's harmless (even the right thing to do), since wshow is usually called to make sure the object being selected is visible, which isn't a problem while the user is busy pointing at it. The check must be here, not in wsetorigin, because the latter is used internally by the auto-scroll code! */ if (_wm_down) return; /* The code below is generic for all versions of stdwin */ wgetorigin(win, &orgh, &orgv); wgetwinsize(win, &winwidth, &winheight); wgetdocsize(win, &docwidth, &docheight); orgh = calcneworigin(orgh, left, right, winwidth, docwidth); orgv = calcneworigin(orgv, top, bottom, winheight, docheight); wsetorigin(win, orgh, orgv); } /* Subroutine for wshow to calculate new origin in h or v direction */ static int calcneworigin(org, low, high, winsize, docsize) int org, low, high, winsize, docsize; { if (docsize <= 0) return org; /* Ignore requests to show bits outside doc */ /* XXX Is this necessary? */ CLIPMIN(low, 0); CLIPMAX(high, docsize); /* Ignore requests for empty range */ /* XXX Is this what we want? */ if (high <= low) return org; if (org <= low && high <= org + winsize) return org; if (high - low > winsize) { /* Range too big for window */ /* Don't scroll if at least 1/3 of the window is in range */ /* XXX 1/3 is an arbitrary number! */ if (low <= org + winsize*2/3 && high >= org + winsize/3) return org; /* Center the end of the range that's closest to the window */ if (low - org >= org + winsize - high) { org = low - winsize/2; CLIPMIN(org, 0); return org; } else { org = high - winsize/2; CLIPMAX(org, docsize); CLIPMIN(org, 0); return org; } } /* The whole range will fit */ /* See if it makes sense to scroll less than the window size */ if (low < org) { if (org - low < winsize) return low; } else if (high > org + winsize) { if (high - (org + winsize) < winsize) return high - winsize; } /* Would have to scroll at least winsize -- center the range */ org = (low + high - winsize) / 2; /* Make sure we stay within the document */ CLIPMIN(org, 0); CLIPMAX(org, docsize); return org; } void wsetdocsize(win, docwidth, docheight) WINDOW *win; int docwidth, docheight; { CLIPMIN(docwidth, 0); CLIPMIN(docheight, 0); if (docwidth == win->docwidth && docheight == win->docheight) return; win->docwidth= docwidth; win->docheight= docheight; SetPort(win->w); setscrollbarvalues(win); _wfixorigin(win); /* Make the zoomed window size the full document size, or the full screen size if the document is bigger. */ if (((WindowPeek)(win->w))->dataHandle != NULL) { WStateData *data = (WStateData *) *((WindowPeek)(win->w))->dataHandle; if (data != NULL) { if (docwidth > 0) { CLIPMIN(docwidth, MIN_WIDTH); data->stdState.right = data->stdState.left + LSLOP + docwidth + RSLOP + BAR; } else data->stdState.right = 0x7fff; CLIPMAX(data->stdState.right, screen->portRect.right-3); if (docheight > 0) { CLIPMIN(docheight, MIN_HEIGHT); data->stdState.bottom = data->stdState.top + docheight + BAR; } else data->stdState.bottom = 0x7fff; CLIPMAX(data->stdState.bottom, screen->portRect.bottom-3); } } } void wgetdocsize(win, pwidth, pheight) WINDOW *win; int *pwidth, *pheight; { *pwidth = win->docwidth; *pheight = win->docheight; } /* Fix the window's origin after a document or window resize. (Also used from do_size() in event.c) */ _wfixorigin(win) WINDOW *win; { int orgh, orgv; int winwidth, winheight; int docwidth, docheight; wgetorigin(win, &orgh, &orgv); wgetwinsize(win, &winwidth, &winheight); wgetdocsize(win, &docwidth, &docheight); /* XXX Do we really want this? This means that in a text edit window, if you are focused at the bottom, every line deletion causes a scroll. Oh well, I suppose that text edit windows could fix their document size to include some blank lines at the end... */ CLIPMAX(orgh, docwidth - winwidth); CLIPMIN(orgh, 0); CLIPMAX(orgv, docheight - winheight); CLIPMIN(orgv, 0); wsetorigin(win, orgh, orgv); } /* do_scroll is called from event.c when a click in a scroll bar is detected */ STATIC pascal trackbar(ControlHandle bar, short pcode); /* Forward */ static WINDOW *scrollwin; /* The window (needed by 'trackbar') */ static int scrollstep; /* By how much we scroll */ static long deadline; /* When the next step may happen */ void do_scroll(pwhere, win, bar, pcode) Point *pwhere; WINDOW *win; ControlHandle bar; int pcode; { int step, page; ProcPtr action; int width, height; wgetwinsize(win, &width, &height); if (bar == win->hbar) { step= width / 20; CLIPMIN(step, 1); page= width / 2; } else if (bar == win->vbar) { step= wlineheight(); /* Should use current win's */ page= height - step; } else return; page= (page/step) * step; /* Round down to multiple of step */ action= trackbar; scrollwin= win; switch (pcode) { case inUpButton: scrollstep= -step; break; case inDownButton: scrollstep= step; break; case inPageUp: scrollstep= -page; break; case inPageDown: scrollstep= page; break; default: action= NULL; break; } deadline= 0; if (TrackControl(bar, PASSPOINT *pwhere, action) == inThumb) usescrollbarvalues(win); } static pascal trackbar(bar, pcode) ControlHandle bar; short pcode; { long now= TickCount(); if (now >= deadline && pcode != 0) { deltabar(bar, scrollstep); usescrollbarvalues(scrollwin); wupdate(scrollwin); if (deadline == 0 && KeyThresh > KeyRepThresh) deadline= now + KeyThresh; /* Longer delay first time */ else deadline= now + KeyRepThresh; } } /* Automatic scrolling when the mouse is pressed and moved outside the application panel. */ void autoscroll(win, h, v) WINDOW *win; int h, v; /* Mouse location in local coordinates */ { Rect r; int dh= 0, dv= 0; getwinrect(win, &r); if (h < r.left) dh= h - r.left; else if (h > r.right) dh= h - r.right; if (v < r.top) dv= v - r.top; else if (v > r.bottom) dv= v - r.bottom; if (dh != 0 || dv != 0) { /* NOTE: assuming current grafport is win->w */ deltabar(win->hbar, dh); deltabar(win->vbar, dv); usescrollbarvalues(win); } } /* Alternative scrolling: Option-click produces a 'hand' cursor and allows scrolling like in MacPaint. Called from event.c. */ void dragscroll(win, h, v, constrained) WINDOW *win; int h, v; int constrained; { int do_h= !constrained, do_v= !constrained; while (StillDown()) { Point mouse; SetPort(win->w); GetMouse(&mouse); if (constrained) { int ah= ABS(h - mouse.h); int av= ABS(v - mouse.v); if (ABS(ah - av) < 2) continue; if (ah > av) do_h= TRUE; else do_v= TRUE; constrained= FALSE; } if (do_h) deltabar(win->hbar, h - mouse.h); if (do_v) deltabar(win->vbar, v - mouse.v); usescrollbarvalues(win); wupdate(win); h= mouse.h; v= mouse.v; } } void makescrollbars(win) WINDOW *win; { Rect r; int id= scrollBarProc; /* The scroll bars are initially created at a dummy location, and then moved to their proper location. They are not displayed here; that's done only when an activate event arrives. */ #ifdef JURJENBARPROC /* If Jurjen's proportional scroll bar exists, use it. (For the vertical bar only -- it doesn't understand about horizontal bars...) */ if (cdefexists(JURJENBARPROC)) id= JURJENBARPROC; #endif JURJENBARPROC SetRect(&r, 0, 0, 1, 1); /* Dummy rectangle */ win->hbar= NewControl(win->w, &r, "", false, 0, 0, 0, scrollBarProc, 0L); win->vbar= NewControl(win->w, &r, "", false, 0, 0, 0, id, 0L); sizescrollbars(win); } #ifdef JURJENBARPROC static int cdefexists(id) int id; { return GetResource('CDEF', id/16) != NULL; } #endif void showscrollbars(win) WINDOW *win; { DrawGrowIcon(win->w); showbar(win->hbar); showbar(win->vbar); } void hidescrollbars(win) WINDOW *win; { hidebar(win->hbar); hidebar(win->vbar); } void movescrollbars(win) WINDOW *win; { hidescrollbars(win); sizescrollbars(win); showscrollbars(win); } static void sizescrollbars(win) WINDOW *win; { Rect r; /* This should be done while the scroll bars are invisible. */ r= win->w->portRect; movebar(win->vbar, r.right - BAR, r.top - 1, r.right + 1, r.bottom - BAR + 1); movebar(win->hbar, r.left - 1, r.bottom - BAR, r.right - BAR + 1, r.bottom + 1); setscrollbarvalues(win); } static void setscrollbarvalues(win) WINDOW *win; { Rect r; getwinrect(win, &r); calcbar(win->hbar, win->orgh, win->docwidth, LSLOP, r.right - r.left - RSLOP); calcbar(win->vbar, win->orgv, win->docheight, 0, r.bottom - r.top); if (win == active) { /* XXX Should only draw those controls that have changed. */ DrawControls(win->w); valid_border(win->w); } } /* * Calculate (and set!) the new value of a scroll bar. * Parameters (all pertaining to either h or v): * org: origin of window (win->orgh or win->orgv) * size: extent of document (win->docwidth or win->docheight) * begin: position of document origin if bar is at its beginning * end: position of document end if bar is at its end * Situation sketch: * 0 begin end winwidth * +====+==============================+====+ * +--------------------------------------------------+ * +--------------------------------------------------+ * Window shown on top; min document position in the middle; * max document position below. Org is (begin of win) - (begin of doc). */ static void calcbar(bar, org, size, begin, end) ControlHandle bar; int org, size; int begin, end; { int range; /* For the caller it's easier to remember to pass win->org{h,v}; but for our calculations it's easier to have the sign reversed! */ org= -org; CLIPMIN(begin, org); CLIPMIN(size, 0); CLIPMAX(end, org + size); range = size - (end - begin); CLIPMIN(range, 0); setbar(bar, end - begin, begin - org, range); } static void usescrollbarvalues(win) WINDOW *win; { wsetorigin(win, GetCtlValue(win->hbar) - GetCtlMin(win->hbar), GetCtlValue(win->vbar) - GetCtlMin(win->vbar)); /* Implies setscrollbarvalues! */ } static void setbar(bar, winsize, val, max) ControlHandle bar; int winsize, val, max; { if (bar != NULL) { ControlPtr p= *bar; if (max < 0) max= 0; if (val > max) val= max; if (val < 0) val= 0; p->contrlMin= winsize; p->contrlValue= val + winsize; p->contrlMax= max + winsize; /* Must be drawn by DrawControls or ShowControl. */ } } static void deltabar(bar, delta) ControlHandle bar; int delta; { int min= GetCtlMin(bar); int val= GetCtlValue(bar); int max= GetCtlMax(bar); int newval= val + delta; if (newval > max) newval= max; if (newval < min) newval= min; if (newval != val) SetCtlValue(bar, newval); } static void showbar(bar) ControlHandle bar; { if (bar != NULL) ShowControl(bar); } static void hidebar(bar) ControlHandle bar; { if (bar != NULL) HideControl(bar); } static void movebar(bar, left, top, right, bottom) ControlHandle bar; int left, top, right, bottom; { if (bar != NULL) { /* This works best while the scroll bar is invisible. */ MoveControl(bar, left, top); SizeControl(bar, right-left, bottom-top); } } */ static void do_activate(ep) EVENT *ep; { WINDOW *win= whichwin((WindowPtr)e.message); if (win == NULL) { /* dprintf("(de)activate evt for alien window");smtalk43/stdwin/Ports/mac/stdwin.c1006440003270021170000001430505465303021014325 037777777777 1 0 /* MAC STDWIN -- BASIC ROUTINES. */ #include "macwin.h" #ifdef MPW #include #include #include #include #include #include #endif /* GLOBAL DATA. */ /* XXX choose less obvious names */ GrafPtr screen; /* The Mac Window Manager's GrafPort */ TEXTATTR wattr; /* Current or default text attributes */ static int def_left= LEFT; static int def_top= TOP; static int def_width, def_height; /* INITIALIZATION AND TERMINATION. */ /* Initialization */ int std_open_hook(); STATIC pascal resume _ARGS((void)); /* Initialize, using and updating argc/argv: */ void winitargs(pargc, pargv) int *pargc; char ***pargv; { wargs(pargc, pargv); winit(); } /* Initialize without touching argc/argv */ void winit() { #ifndef NO_STDIO /* Tell the THINK C stdio library we have initialized already */ Stdio_MacInit(TRUE); #endif #ifdef THINK_C #ifndef THINK_C_3_0 /* THINK C 4.0 may have done these initializations for us when the application has already used the console in any way. Doing them again is not a good idea. The THINK library avoids initializing the world if it appears that it has already been initialized, but in that case it will only allow output (all input requests return EOF). Thus, the application has two options: - call winit() or winitargs() first, then use the console only for (debugging) output; or - print at least one character to stdout first, then stdwin menu bar may not function properly. From inspection of the THINK library source it appears that when the console is initialized, stdin->std is cleared, so the test below suffices to skip initializations. */ if (stdin->std) #endif #endif { MaxApplZone(); InitGraf(&QD(thePort)); InitFonts(); InitWindows(); TEInit(); InitDialogs(resume); InitMenus(); InitCursor(); setup_menus(); } GetWMgrPort(&screen); initwattr(); #ifdef MPW set_open_hook(std_open_hook); #endif wsetdefwinsize(0, 0); set_watch(); } void wdone() { } void wgetscrsize(pwidth, pheight) int *pwidth, *pheight; { Rect r; r= screen->portRect; *pwidth= r.right - r.left; *pheight= r.bottom - r.top; } void wgetscrmm(pmmwidth, pmmheight) int *pmmwidth, *pmmheight; { Rect r; r= screen->portRect; /* XXX Three pixels/mm is an approximation of the truth at most */ *pmmwidth= (r.right - r.left) / 3; *pmmheight= (r.bottom - r.top) / 3; } /* Routine called by "Resume" button in bomb box (passed to InitDialogs). I have yet to see a program crash where an attempted exit to the Finder caused any harm, so I think it's safe. Anyway, it's tremendously useful during debugging. */ static pascal resume() { ExitToShell(); } /* WINDOWS. */ /* Find the WINDOW pointer corresponding to a WindowPtr. */ WINDOW * whichwin(w) WindowPtr w; { if (((WindowPeek)w)->windowKind < userKind) return NULL; /* Not an application-created window */ else { WINDOW *win; win= (WINDOW *) GetWRefCon(w); if (win != NULL && win->w == w) return win; else return NULL; } } WINDOW * wopen(title, drawproc) char *title; void (*drawproc)(); { WINDOW *win= ALLOC(WINDOW); Rect r; if (win == NULL) { dprintf("wopen: ALLOC failed"); /* XXX */ return NULL; } /* Find a nice position for the window. */ if (def_left + def_width + BAR + LSLOP + RSLOP > screen->portRect.right) { def_left= LEFT; CLIPMAX(def_left, screen->portRect.right - (def_width + BAR + LSLOP + RSLOP)); CLIPMIN(def_left, 0); } if (def_top + def_height + BAR > screen->portRect.bottom) { def_top= TOP; CLIPMAX(def_top, screen->portRect.bottom - (def_height + BAR)); CLIPMIN(def_top, MENUBARHEIGHT + TITLEBARHEIGHT); } SetRect(&r, def_left, def_top, def_left+def_width + BAR + LSLOP + RSLOP, def_top+def_height + BAR); def_left += HINCR; def_top += VINCR; win->w= NewWindow((Ptr)NULL, &r, PSTRING(title), TRUE, zoomDocProc, (WindowPtr)(-1), TRUE, 0L); SetWRefCon(win->w, (long)win); win->tag= 0; win->drawproc= drawproc; win->hcaret= win->vcaret= -1; win->caret_on= FALSE; win->attr= wattr; win->hbar= win->vbar= NULL; win->docwidth= 0; win->docheight= 0; win->orgh= -LSLOP; win->orgv= 0; win->timer= 0; win->cursor = NULL; initmbar(&win->mbar); makescrollbars(win); return win; } void wclose(win) WINDOW *win; { if (win == active) { rmlocalmenus(win); active= NULL; } killmbar(&win->mbar); DisposeWindow(win->w); FREE(win); } void wgetwinsize(win, pwidth, pheight) WINDOW *win; int *pwidth, *pheight; { Rect r; getwinrect(win, &r); *pwidth= r.right - r.left - LSLOP - RSLOP; *pheight= r.bottom - r.top; } void wsettitle(win, title) WINDOW *win; char *title; { SetWTitle(win->w, PSTRING(title)); } char * wgettitle(win) WINDOW *win; { static char title[256]; GetWTitle(win->w, title); #ifndef CLEVERGLUE PtoCstr(title); #endif return title; } void wfleep() { SysBeep(5); } void wsetmaxwinsize(width, height) int width, height; { /* Not supported yet (should be stored in the window struct and used by do_grow). */ /* XXX This procedure should disappear completely, it was only invented for the Whitechapel which allocates bitmap memory to the window when it is first created! */ /* XXX Well, maybe it has some use. In fact both min and max window size are sometimes useful... */ } void wsetdefwinpos(h, v) int h, v; { /* XXX Sanity checks? Change interaction with wopen()? */ if (h > 0) def_left = h; if (v > 0) def_top = v; } void wgetdefwinpos(ph, pv) int *ph, *pv; { *ph = def_left; *pv = def_top; } void wsetdefwinsize(width, height) int width, height; { /* XXX Shouldn't this be done by wopen() instead? */ if (width <= 0) { width= screen->portRect.right * 2/3; CLIPMAX(width, 512); } CLIPMAX(width, screen->portRect.right - BAR - LSLOP - RSLOP); CLIPMIN(width, MIN_WIDTH); if (height <= 0) { height= screen->portRect.bottom * 2/3; CLIPMAX(height, 342); } CLIPMAX(height, screen->portRect.bottom - MENUBARHEIGHT - TITLEBARHEIGHT - BAR); CLIPMIN(height, MIN_HEIGHT); def_width= width; def_height= height; } void wgetdefwinsize(pwidth, pheight) int *pwidth, *pheight; { *pwidth = def_width; *pheight = def_height; } void wsetactive(win) WINDOW *win; { SelectWindow(win->w); } 37777777777 1 0 smtalk43/stdwin/Ports/mac/timer.c1006440003270021170000000361505465303021014137 037777777777 1 0 /* MAC STDWIN -- TIMER. */ /* XXX The timer mechanism should be coupled less strongly with the stdwin implementation -- stdwin should support a single timer, while thin layers on top could implement various timer strategies. */ #include "macwin.h" #ifdef MPW #include #endif static unsigned long nexttimer; /* Set a window's timer. The second parameter is the number of deciseconds from now when the timer is to go off, or 0 to clear the timer. When the timer goes off (or sometime later), a WE_TIMER event will be delivered. As a service to 'checktimer' below, a NULL window parameter is ignored, but causes the 'nexttimer' value to be recalculated. (The inefficient simplicity of the code here is due to MINIX, with some inventions of my own.) */ void wsettimer(win, deciseconds) WINDOW *win; int deciseconds; { WindowPeek w; nexttimer= 0; if (win != NULL) { if (deciseconds == 0) win->timer= 0; else { nexttimer= win->timer= TickCount() + deciseconds*(TICKSPERSECOND/10); } } for (w= (WindowPeek)FrontWindow(); w != NULL; w= w->nextWindow) { win= whichwin((WindowPtr)w); if (win != NULL && win->timer != 0) { if (nexttimer == 0 || win->timer < nexttimer) nexttimer= win->timer; } } } /* Check if a timer went off. If so, return TRUE and set the event record correspondingly; otherwise, return FALSE. */ bool checktimer(ep) EVENT *ep; { WindowPtr w; WINDOW *win; unsigned long now; if (nexttimer == 0) { return FALSE; } now= TickCount(); if (now < nexttimer) { return FALSE; } ep->type= WE_NULL; ep->window= NULL; for (w= FrontWindow(); w != NULL; w= (WindowPtr)((WindowPeek)w)->nextWindow) { win= whichwin(w); if (win != NULL && win->timer != 0) { if (win->timer <= now) { ep->type= WE_TIMER; ep->window= win; now= win->timer; } } } wsettimer(ep->window, 0); return ep->type == WE_TIMER; } smtalk43/stdwin/Ports/mac_mpw/0407550003270021170000000000005477556120012740 5 0 1 0 smtalk43/stdwin/Ports/mac_mpw/Makefile1006440003270021170000000161505434024350015175 037777777777 1 0 # Makefile for stdwin, generated under Unix SOURCES= about.c argcargv.c caret.c cursor.c dialog.c dprintf.c draw.c event.c fullpath.c menu.c pstring.c scrap.c scroll.c stdwin.c strdup.c timer.c wtextbreak.c HEADERS= macwin.h menu.h OBJECTS= about.c.o argcargv.c.o caret.c.o cursor.c.o dialog.c.o dprintf.c.o draw.c.o event.c.o fullpath.c.o getopt.c.o menu.c.o pstring.c.o scrap.c.o scroll.c.o set_open_hook.c.o stdwin.c.o strdup.c.o timer.c.o wtextbreak.c.o COptions= -i : -i ::h: lib.o {OBJECTS} Lib -o lib.o -sn Main=STDWIN {OBJECTS} clean {OBJECTS} delete {OBJECTS} SysLibes= {CLibraries}CInterface.o {CLibraries}CRuntime.o {CLibraries}CSANELib.o {CLibraries}StdClib.o test2 test2.c.o lib.o Link -o test2 -t APPL -c xxxx -p test2.c.o lib.o {SysLibes} */ #define QD(var) (var) /* THINK C can't declare forward functions as static */ #define STATIC /**/ /* THINK C psmtalk43/stdwin/Ports/mac_mpw/README1006440003270021170000000061705434024350014416 037777777777 1 0 This directory contains extra files needed to build stdwin for the Mac under MPW 2.0.2. Take these files together with all the files from the mac subdirectory, plus strdup.c, getopt.c and wtextbreak.c from elsewhere in the stdwin tree. The Makefile will build the library. Disclaimer: this hasn't been tested fully yet -- it is just provided in case you are stuck with MPW. --Guido (8 Jan 1991) coordinates */ struct menubar mbar; /* List of attached local menus */ unsigned long timer; /* Tick count for tsmtalk43/stdwin/Ports/mac_mpw/intercept.h1006440003270021170000000234205434024350015701 037777777777 1 0 /* The structure of the 'device switch' used by the standard I/O library. It is possible to install your own versions of selected routines by storing function pointers into this table. The structure of the control block for the dev_write function is also given. Careful! this information was gathered by disassembling parts of the library. There are no guarantees that the same code will work in future versions of MPW. Part of it has been tested with versions 1.0B1 and 1.0B2. */ typedef int (*funcptr)(); /* Pointer to integer function */ struct device { long dev_name; /* 'FSYS', 'CONS' or 'SYST' */ funcptr dev_faccess; funcptr dev_close; funcptr dev_read; funcptr dev_write; funcptr dev_ioctl; }; extern struct device _StdDevs[]; #define DEV_FSYS 0 #define DEV_CONS 1 #define DEV_SYST 2 /* Control block for dev_write (arg 1 is a pointer to this). You might guess that dev_read is similar. */ struct controlblock { long io_filler1; /* Flags? */ long io_filler2; /* Some pointer */ long io_filler3; /* Zero */ long io_nbytes; /* Number of bytes to write */ /* (Reset this to zero after writing) */ char *io_data; /* Start of data buffer */ }; #define IO_OK 0 /* Return value from dev_write */ oid getwinrect _ARGS((WINDOW *win, Rect *pr)); void set_arrow _ARGS((void)); void set_applcursor _ARGS((void)); void set_watch _ARGS((void)); void set_ibeam _ARGS((void)); void set_hand _ARGS((void)); void makescrollbars _ARGS((WINDOW *win)); void movescrollbars _ARGS((WINDOW *win));smtalk43/stdwin/Ports/mac_mpw/set_open_hook.c1006440003270021170000000636405465303021016542 037777777777 1 0 /* A procedure to install a hook in the MPW C 'open' library function. This is useful because you may want to create files automatically with type 'TEXT' without having to change all the 'open' or 'fopen' calls in a large C program you are trying to port. A standard hook procedure for this purpose is also provided. Call: set_open_hook(proc); This installs the hook proc, or restores the default situation if proc is NULL. The hook procedure will be called immediately *after* a successful open call, with the following parameters: proc(filename, oflag, fd) char *filename; The file name int oflag; Mode passed to open int fd; Return value from open Note: this only works when the program is linked as an application (type APPL); for tools (type MPST) the device switch is located in the Shell's memory. Careful! this information was gathered by disassembling parts of the library. There are no guarantees that the same code will work in future versions of MPW. It has been tested with version 1.0B2. */ #include #include #include #include "intercept.h" #define ERRFLAG 0x40000000 static ProcPtr open_hook; /* The hook for faccess, installed in the device switch. This will be called with cmd == F_OPEN from 'open', but also from 'faccess', with other values for cmd. The open_hook is only called if cmd == F_OPEN. It is not necessary to check whether open_hook is NULL, since we are only installed after open_hook is set non-NULL. */ static long my_faccess(file, cmd, arg) char *file; int cmd; short *arg; { long res= _fsFAccess(file, cmd, arg); if (cmd == F_OPEN && !(res&ERRFLAG)) { (void) (*open_hook)(file, *arg, (int)res); } return res; } /* Standard open hook, to set type and creator of created files. It will not change existing non-zero type or creator fields. It returns an error code even though this is ignored by the calling routine; you might want to call it yourself in a more fancyful hook, and test the error code. This routine can be customized by changing 'std_type' or 'std_creator'. */ OSType std_type= 'TEXT'; OSType std_creator= 'MPS '; int std_open_hook(file, mode, fd) char *file; int mode; int fd; { FInfo info; int err= noErr; switch (mode & 03) { case O_RDWR: case O_WRONLY: err= GetFInfo(file, 0, &info); if (err != noErr) return err; if (info.fdType == 0) { info.fdType= std_type; ++err; /* Use 'err' as a flag to call SetFInfo */ } if (info.fdCreator == 0) { info.fdCreator= std_creator; ++err; } if (err != noErr) err= SetFInfo(file, 0, &info); } return err; } /* The procedure to install the hook. Note: this assumes nobody else is also installing hooks for faccess, otherwise we would have to save and restore the old function, instead of blindly assuming _fsFAccess. */ set_open_hook(hook) ProcPtr hook; { if (hook == NULL) _StdDevs[DEV_FSYS].dev_faccess= _fsFAccess; else { open_hook= hook; _StdDevs[DEV_FSYS].dev_faccess= my_faccess; } } /* A trivial test program will be included if you #define MAIN: */ #ifdef MAIN #include extern int std_open_hook(); main() { set_open_hook(std_open_hook); fclose(fopen("ABC", "a")); } #endif p= buf + strlen(buf); *p++= '/'; *p++= shortcut; *p= EOS; } AppendMenu(mp, PSTRING(buf)); item= CountMItems(mp); if (text != NULL && *text != EOS) SetItem(mp, item, PSTRING(text)); return item-1; } void wmenusetitem(mp, item, text) MENU *mp; int item; smtalk43/stdwin/Ports/msdos/0407550003270021170000000000005477556121012443 5 0 1 0 smtalk43/stdwin/Ports/msdos/README1006440003270021170000000041605434024351014116 037777777777 1 0 Sorry, there is no real STDWIN port for MS-DOS yet. What you can is to port the alfa version with the help of the file "ptrm.c" in this directory, which is a substitute (using the MS-DOS console driver) for the VTRM module used by the alfa version for all its tty I/O. stlocal= 0; for (i= 0; i < win->mbar.nmenus; ++i) DeleteMenu(MENUID(win->mbar.menulist[i])); if (i > 0) DrawMenuBar(); } void _wdo_menu(ep, menu_item) EVENT *ep; long menu_item; { int id= HiWord(menu_item); int item= LoWord(menu_itsmtalk43/stdwin/Ports/msdos/dir.c1006440003270021170000000624705465303021014166 037777777777 1 0 /* * MS-DOS version of UNIX directory access package. * (opendir, readdir, closedir). */ #include #include #include #include extern int errno; #define MAXPATH 64 #include "dir.h" static char *firstf(); static char *nextf(); typedef int bool; #define TRUE 1 #define FALSE 0 #define EOS '\0' #define NULL 0 static char dirpath[MAXPATH+1]= ""; static bool busy= FALSE; /* * Open a directory. * This MS-DOS version allows only one directory to be open at a time. * The path must exist and be a directory. * Then it only saves the file name and returns a pointer to it. */ char * opendir(path) char *path; { struct stat buffer; if (dirpath[0] != EOS) { errno= EMFILE; return NULL; /* Only one directory can be open at a time */ } if (stat(path, &buffer) == -1) return NULL; /* Directory doesn't exist */ if ((buffer.st_mode & S_IFMT) != S_IFDIR) { errno= ENOENT; return NULL; /* Not a directory */ } strcpy(dirpath, path); path= dirpath + strlen(dirpath); if (path > dirpath && path[-1] != ':' && path[-1] != '/' && path[-1] != '\\') *path++ = '\\'; strcpy(path, "*.*"); busy= FALSE; /* Tell readdir this is the first time */ return dirpath; } /* * Close a directory. * We must clear the first char of dirpath to signal opendir that * no directory is open. */ closedir(dirp) char *dirp; { dirp[0]= EOS; } /* * Read the next directory entry. */ struct direct * readdir(dp) char *dp; { static struct direct buffer; char *p; if (!busy) p= firstf(dp); else p= nextf(); busy= (p != NULL); if (!busy) return NULL; strcpy(buffer.d_name, p); buffer.d_namlen= strlen(p); return &buffer; } /* * Low-level implementation -- access to DOS system calls FIRST and NEXT. */ static char dta[64]; /* Device Transfer Area */ /* File attributes */ #define READONLY 0x01 #define HIDDEN 0x02 #define SYSTEM 0x04 #define VOLUMEID 0x08 #define DIRECTORY 0x10 #define ARCHIVE 0x20 #define MATCHATTR (HIDDEN|SYSTEM|DIRECTORY) static char * firstf(pat) char *pat; { int flags; union REGS regs; struct SREGS segregs; setdta(dta); segread(&segregs); regs.h.ah = 0x4e; regs.x.cx = MATCHATTR; #ifdef M_I86LM /* Large Model -- far pointers */ regs.x.dx = FP_OFF(pat); segregs.ds = FP_SEG(pat); #else regs.x.dx = (int) pat; #endif flags= intdosx(®s, ®s, &segregs); if (regs.x.cflag) return NULL; fixfile(); return dta + 30; } static char * nextf() { int flags; union REGS regs; setdta(dta); regs.h.ah = 0x4f; flags= intdos(®s, ®s); if (regs.x.cflag) return NULL; fixfile(); return dta + 30; } /* * Convert the file name in the Device Transfer Area to lower case. */ static fixfile() { char *cp; for (cp= dta+30; *cp != EOS; ++cp) *cp= tolower(*cp); } /* * Tell MS-DOS where the Device Transfer Area is. */ static setdta(dta) char *dta; { union REGS regs; struct SREGS segregs; segread(&segregs); regs.h.ah = 0x1a; #ifdef M_I86LM /* Large Model -- far pointers */ regs.x.dx = FP_OFF(dta); segregs.ds = FP_SEG(dta); #else regs.x.dx = (int) dta; #endif intdosx(®s, ®s, &segregs); } #endif static Handle hclip; static long lenclip; /* _wfreeclip is called from wgetevent and from wsetclip. */ void _wfreeclip() { if (hclip != NULL) { HUnlock(hclip); DisposHandle(hclip); hclip= NULL; } } char * wgetclip() { long offset; /* NB if the use of hclip or lenclip changes, also change wgetcutbuffer(smtalk43/stdwin/Ports/msdos/dir.h1006440003270021170000000033705434024351014167 037777777777 1 0 /* * Interface for MS-DOS version of UNIX directory access package. * (opendir, readdir, closedir). */ struct direct { char d_namlen; char d_name[13]; }; typedef char DIR; DIR *opendir(); struct direct *readdir(); left in... */ #endif _wfreeclip(); err= ZeroScrap(); if (err != 0) dprintf("wsetclip: ZeroScrap error %d", err); err= PutScrap((long)len, 'TEXT', p); if (err != 0) dprintf("wsetclip: PutScrap error %d", err); #ifndef CLEVERGLUE if (q != NULL) free(q); #endif } /* For "compatibilismtalk43/stdwin/Ports/msdos/lib.1006440003270021170000000116205434024351014004 037777777777 1 0 .c.obj: cl -c -AL -DSYSV $*.c TOOLS= strdup.obj getopt.obj monocase.obj strdup.obj: getopt.obj: monocase.obj: TEXTEDIT= textedit.obj textbrk.obj par.obj \ askfile.obj askync.obj style.obj textedit.obj: textbrk.obj: par.obj: askfile.obj: askync.obj: style.obj: PTRM= ptrm.obj ptrm.obj: ALFA= bind.obj draw.obj event.obj keymap.obj measure.obj \ menu.obj scroll.obj stdwin.obj syswin.obj bind.obj: alfa.h draw.obj: alfa.h event.obj: alfa.h keymap.obj: alfa.h measure.obj: alfa.h menu.obj: alfa.h scroll.obj: alfa.h stdwin.obj: alfa.h syswin.obj: alfa.h ALL= $(TOOLS) $(TEXTEDIT) $(PTRM) $(ALFA) 0021170000003253305465303021014316 037777777777 1 0 smtalk43/stdwin/Ports/msdos/ptrm.c1006440003270021170000005500705465303021014370 037777777777 1 0 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1986. */ /* * ibm Pc virtual TeRMinal package. * * (Under reconstruction by Guido!) * * An implementation of the VTRM interface for MS-DOS machines. * * This code supports two modes of accessing the screen. * The first one (BIOS) will be used, unless the user overwrites this * by setting the SCREEN environment variable. * This variable can also be used to convey a screen size that differs * from the default 25 lines and 80 columns. See below. * * The two modes are: * * 1) IBM BIOS interrupt 10 hex, video io. * (See IBM PC XT Technical Reference 6936833, May 1983, * Appendix A, pages A46-A47). * This is what you really want to use, since it's the only one that * can decently scroll. It cannot insert or delete characters, so * most optimisations from vtrm.c are useless and taken out. * Unfortunately, not every PC-compatible machine supports this BIOS * interrupt, so for these unlucky souls there is the following escape: * * 2) The ANSI.SYS driver. * (See IBM MS-DOS 6936839, Jan 1983, Version 2.00, Chapter 13.) * (Some compatibles don't have a separate ANSI.SYS driver but do the * same escape interpretation by default.) * This works reasonably, apart from scrolling downward, or part of * the screen, which is clumsy. * (The ANSI standard provides an escape sequence for scrolling * but ANSI.SYS does not support it, nor any other way of scrolling.) * * The rest of the interface is the same as described in vtrm.c, * with the following exceptions: * - to ease coding for ansi scrolls, the terminal is supposed to * contain blanks at positions that were not written yet; * the unknown rubbish that is initially on the screen can * only be cleared by the caller by scrolling the whole screen up * by one or more lines; * - the number of lines on the terminal is assumed to be 25; * the number of columns is (1) determined by a BIOS function, or * (2) assumed to be 80 for ANSI; * the user can overwrite this by setting the environment variable: * * SET SCREEN=BIOS y x * or * SET SCREEN=ANSI y x * * where x and y are the number of lines and columns respectively. * * The lines and columns of our virtual terminal are numbered * y = {0...lines-1} from top to bottom, and * x = {0...cols-1} from left to right, * respectively. * * The Visible Procedures in this package are as described in vtrm.c. * */ /* * Includes and data definitions. */ #include #include #include #include #include #include char *malloc(); #define STDIN_HANDLE 0 #include "vtrm.h" #ifdef lint #define VOID (void) #else #define VOID #endif #define Forward #define Visible #define Hidden static #define Procedure typedef short intlet; typedef char *string; typedef char bool; #define Yes '\1' #define No '\0' #define Undefined (-1) #define Min(a,b) ((a) <= (b) ? (a) : (b)) #define MESS(number, text) text #ifdef GFX #include "gfx.h" #endif /* terminal status */ Hidden int started = No; Hidden int scr_mode = 0; #define ANSI 'A' #define BIOS 'B' #define Nlines 25 #define Ncols 80 Hidden int lines = Nlines; Hidden int cols = Ncols; Hidden int flags = 0; /* current standout mode */ #define Off 0 #define On 0200 Hidden int so_mode = Off; /* masks for char's and intlet's */ #define NULCHAR '\000' #define CHAR 0177 #define SOBIT On #define SOCHAR 0377 /* current cursor position */ Hidden intlet cur_y = Undefined, cur_x = Undefined; /* "line[y][x]" holds the char on the terminal, with the SOBIT. * the SOBIT tells whether the character is standing out. * "lenline[y]" holds the length of the line. * (Partially) empty lines are distinghuished by "lenline[y] < cols". * Unknown chars will be ' ', so the scrolling routines for ANSI * can use "unwritten" chars (with indent > 0 in trmputdata). * To make the optimising compare in putline fail, lenline[y] is initially 0. * The latter implies that if a line is first addressed with trmputdata, * any rubbish that is on the screen beyond the data that gets put, will * remain there. */ Hidden char **line = 0; Hidden intlet *lenline = 0; /* Make the cursor invisible when trmsync() tries to move outside the screen */ Hidden bool no_cursor = No; /* * Starting, Ending and (fatal) Error. */ bool wasbreak; /* * Initialization call. * Determine terminal mode. * Start up terminal and internal administration. * Return Yes if succeeded, No if trouble (which doesn't apply here). */ Visible int trmstart(plines, pcols, pflags) int *plines; int *pcols; int *pflags; { static char setup = No; int err; #ifdef TRACE if (!setup) freopen("TRACE.DAT", "a", stderr); fprintf(stderr, "\ttrmstart(&li, &co, &fl);\n"); #endif if (started) return TE_TWICE; #ifdef GFX if (gfx_mode != TEXT_MODE) gfx_mode= SPLIT_MODE; #endif if (!setup) { err= set_screen_up(); if (err != TE_OK) return err; setup = Yes; } err= start_trm(); /* internal administration */ if (err != TE_OK) return err; *plines = lines; *pcols = cols; *pflags = flags; setmode(STDIN_HANDLE, O_BINARY); /* Don't translate CRLF to LF */ setraw(STDIN_HANDLE, Yes); wasbreak= getbreak(); /* Save BREAK status; restore when done */ setbreak(No); set_handler(); started = Yes; return TE_OK; } Hidden int set_screen_up() { int height; int width; int get_screen_env(); int get_cols(); height = width = 0; scr_mode = get_screen_env(&height, &width); switch (scr_mode) { case BIOS: case TE_OK: cols = get_cols(); flags = HAS_STANDOUT|CAN_SCROLL; break; case ANSI: flags = HAS_STANDOUT; break; default: return scr_mode; /* Error flag */ } /* allow x and y in environment variable SCREEN to override */ if (height > 0) lines = height; if (width > 0) cols = width; return TE_OK; } Hidden int get_screen_env(pheight, pwidth) int *pheight, *pwidth; { string s; int mode; char screrr; string getenv(); string strip(); string skip(); screrr = No; s = getenv("SCREEN"); if (s == NULL) return BIOS; s = strip(s); switch (*s) { case '\0': return BIOS; case 'a': mode = ANSI; s = skip(s, "ansi"); break; case 'A': mode = ANSI; s = skip(s, "ANSI"); break; case 'b': mode = BIOS; s = skip(s, "bios"); break; case 'B': mode = BIOS; s = skip(s, "BIOS"); break; default: mode = BIOS; screrr = Yes; } /* *pheight and *pwidth were set to 0 above */ s = strip(s); while (isdigit(*s)) { *pheight = *pheight * 10 + (*s++ - '0'); } s = strip(s); while (isdigit(*s)) { *pwidth = *pwidth * 10 + (*s++ -'0'); } s = strip(s); if (screrr || *s != '\0') return TE_BADTERM; return mode; } Hidden string strip(s) string s; { while (*s == ' ' || *s == '\t') ++s; return s; } Hidden string skip(s, pat) string s, pat; { while (*s == *pat) ++s, ++pat; return s; } Hidden int /* initialise internal administration */ start_trm() { register int y; if (line == 0) { if ((line = (char**) malloc(lines * sizeof(char*))) == NULL) return TE_NOMEM; for (y = 0; y < lines; y++) { if ((line[y] = malloc(cols * sizeof(char))) == NULL) return TE_NOMEM; } } if (lenline == 0) { if ((lenline = (intlet *) malloc(lines * sizeof(intlet))) == NULL) return TE_NOMEM; } trmundefined(); return TE_OK; } /* * Termination call. * Beware that it might be called by a catched interrupt even in the middle * of trmstart()! */ Visible Procedure trmend() { #ifdef TRACE fprintf(stderr, "\ttrmend();\n"); #endif if (started && so_mode != Off) standend(); if (scr_mode == ANSI) { VOID fflush(stdout); } /* Always turn off RAW mode -- it is unlikely that anybody would want to interface to COMMAND.COM in raw mode. This way, if you were accidentally left in RAW mode because of a crash, it will go away if you re-enter. */ setraw(STDIN_HANDLE, No); setbreak(wasbreak); started = No; } /* * Set all internal statuses to undefined, especially the contents of * the screen, so a hard redraw will not be optimised to heaven. */ Visible Procedure trmundefined() { register int y, x; #ifdef TRACE fprintf(stderr, "\ttrmundefined();\n"); #endif cur_y = cur_x = Undefined; so_mode = Undefined; for (y = 0; y < lines; y++) { for (x = 0; x < cols; x++) line[y][x] = ' '; /* they may get printed in scrolling */ lenline[y] = 0; } } #ifdef DEBUG Hidden Procedure check_started(m) char *m; { if (!started) { printf("Not started: %s\n", m); exit(TE_TWICE); } } #else #define check_started(m) /*empty*/ #endif /* * Sensing the cursor. * (NOT IMPLEMENTED, since there is no way to locally move the cursor.) */ /* * Sense the current (y, x) cursor position, after a possible manual * change by the user with local cursor motions. * If the terminal cannot be asked for the current cursor position, * or if the string returned by the terminal is garbled, * the position is made Undefined. */ Visible Procedure trmsense(py, px) int *py; int *px; { /* bool getpos(); */ #ifdef TRACE fprintf(stderr, "\ttrmsense(&yy, &xx);\n"); #endif check_started(MESS(7904, "trmsense called outside trmstart/trmend")); *py = *px = Undefined; /* * if (flags&CAN_SENSE && getpos(py, px)) { * if (*py < 0 || lines <= *py || *px < 0 || cols <= *px) * *py = *px = Undefined; * } */ cur_y = *py; cur_x = *px; } /* * Putting data on the screen. */ /* * Fill screen area with given data. * Characters with the SO-bit (0200) set are put in standout mode. * (Unfortunately this makes it impossible to display accented characters. * The interface should change.) */ Visible Procedure trmputdata(yfirst, ylast, indent, data) int yfirst; int ylast; register int indent; register string data; { register int y; int x, len, lendata, space; #ifdef TRACE fprintf(stderr, "\ttrmputdata(%d, %d, %d, \"%s\");\n", yfirst, ylast, indent, data); #endif check_started(MESS(7905, "trmputdata called outside trmstart/trmend")); if (yfirst < 0) yfirst = 0; if (ylast >= lines) ylast = lines-1; space = cols*(ylast-yfirst+1) - indent; if (space <= 0) return; yfirst += indent/cols; indent %= cols; y = yfirst; if (data) { x = indent; lendata = strlen(data); if (ylast == lines-1 && lendata >= space) lendata = space - 1; len = Min(lendata, cols-x); while (len > 0 && y <= ylast) { put_line(y, x, data, len); y++; lendata -= len; if (lendata > 0) { x = 0; data += len; len = Min(lendata, cols); } else break; } } if (y <= ylast) clear_lines(y, ylast); } /* * We will try to get the picture: * * op>>>>>>>>>>>op oq * ^ ^ ^ * <-----m1----><---------------od--------------------> * OLD: "You're in a maze of twisty little pieces of code, all alike" * NEW: "in a maze of little twisting pieces of code, all alike" * <-----m1----><----------------nd---------------------> * ^ ^ ^ * np>>>>>>>>>>>np nq * where * op, oq, np, nq are pointers to start and end of Old and New data, * and * xskip = length of indent to be skipped, * m1 = length of Matching part at start, * od = length of Differing end on screen, * nd = length of Differing end in data to be put. */ Hidden int put_line(y, xskip, data, len) int y, xskip; string data; int len; { register char *op, *oq, *np, *nq; int m1, od, nd, delta; /* calculate the magic parameters */ op = &line[y][xskip]; oq = &line[y][lenline[y]-1]; np = data; nq = data + len - 1; m1 = 0; while ((*op&SOCHAR) == (*np&SOCHAR) && op <= oq && np <= nq) op++, np++, m1++; od = oq - op + 1; nd = nq - np + 1; /* now we have the picture above */ if (od==0 && nd==0) return; delta = nd - od; move(y, xskip + m1); if (nd > 0) { put_str(np, nd); } if (delta < 0) { clr_to_eol(); return; } lenline[y] = xskip + len; if (cur_x == cols) { cur_y++; cur_x = 0; } } /* * Scrolling (part of) the screen up (or down, dy<0). */ Visible Procedure trmscrollup(yfirst, ylast, by) register int yfirst; register int ylast; register int by; { #ifdef TRACE fprintf(stderr, "\ttrmscrollup(%d, %d, %d);\n", yfirst, ylast, by); #endif check_started(MESS(7906, "trmscrollup called outside trmstart/trmend")); if (by == 0) return; if (yfirst < 0) yfirst = 0; if (ylast >= lines) ylast = lines-1; if (yfirst > ylast) return; if (so_mode != Off) standend(); if (by > 0 && yfirst + by > ylast || by < 0 && yfirst - by > ylast) { clear_lines(yfirst, ylast); return; } switch (scr_mode) { case BIOS: biosscrollup(yfirst, ylast, by); break; case ANSI: if (by > 0 && yfirst == 0) { lf_scroll(ylast, by); } else if (by > 0) { move_lines(yfirst+by, yfirst, ylast-yfirst+1-by, 1); clear_lines(ylast-by+1, ylast); } else { move_lines(ylast+by, ylast, ylast-yfirst+1+by, -1); clear_lines(yfirst, yfirst-by-1); } break; } } /* * Synchronization, move cursor to given position (or previous if < 0). */ Visible Procedure trmsync(y, x) int y; int x; { #ifdef TRACE fprintf(stderr, "\ttrmsync(%d, %d);\n", y, x); #endif check_started(MESS(7907, "trmsync called outside trmstart/trmend")); if (0 <= y && y < lines && 0 <= x && x < cols) { move(y, x); } VOID fflush(stdout); } /* * Send a bell, visible if possible. */ Visible Procedure trmbell() { #ifdef TRACE fprintf(stderr, "\ttrmbell();\n"); #endif check_started(MESS(7908, "trmbell called outside trmstart/trmend")); ring_bell(); } /* * Now for the real work: here are all low level routines that really * differ for BIOS or ANSI mode. */ /* * BIOS video io is called by generating an 8086 software interrupt, * using lattice's int86() function. * To ease coding, all routines fill in the apropriate parameters in regs, * and then call bios10(code), where code is to be placed in ah. */ Hidden union REGS regs, outregs; /* A macro for speed */ #define bios10(code) (regs.h.ah = (code), int86(0x10, ®s, ®s)) #define nbios10(code) (regs.h.ah = (code), int86(0x10, ®s, &outregs)) /* Video attributes: (see the BASIC manual) (used for standout mode) */ Hidden int video_attr; #ifndef GFX #define V_NORMAL 7 #else #define V_NORMAL (gfx_mode == TEXT_MODE ? 7 : 0) #endif #define V_STANDOUT (7<<4) /* Some BIOS only routines */ Hidden get_cols() { bios10(15); return regs.h.ah; } /* * ANSI escape sequences */ #define A_CUP "\033[%d;%dH" /* cursor position */ #define A_SGR0 "\033[0m" /* set graphics rendition to normal */ #define A_SGR7 "\033[7m" /* set graphics rendition to standout */ #define A_ED "\033[2J" /* erase display (and cursor home) */ #define A_EL "\033[K" /* erase (to end of) line */ /* * The following routine is the time bottleneck, I believe! */ Hidden Procedure put_str(data, n) char *data; int n; { register char c, so; so = so_mode; if (scr_mode == BIOS) { regs.x.cx = 1; /* repition count */ regs.h.bh = 0; /* page number */ regs.h.bl = video_attr; while (--n >= 0) { c = (*data++)&SOCHAR; if ((c&SOBIT) != so) { so = c&SOBIT; so ? standout() : standend(); regs.h.bl = video_attr; } regs.h.al = c&CHAR; nbios10(9); if (cur_x >= cols-1) { line[cur_y][cols-1] = c; continue; } regs.h.dh = cur_y; regs.h.dl = cur_x + 1; nbios10(2); line[cur_y][cur_x] = c; cur_x++; } } else { while (--n >= 0) { c = (*data++)&SOCHAR; if ((c&SOBIT) != so) { so = c&SOBIT; so ? standout() : standend(); } putch(c&CHAR); line[cur_y][cur_x] = c; cur_x++; } } } /* * Move to position y,x on the screen */ Hidden Procedure move(y, x) int y, x; { if (scr_mode != BIOS && cur_y == y && cur_x == x) return; switch (scr_mode) { case BIOS: regs.h.dh = y; regs.h.dl = x; regs.h.bh = 0; /* Page; must be 0 for graphics */ bios10(2); break; case ANSI: cprintf(A_CUP, y+1, x+1); break; } cur_y = y; cur_x = x; } Hidden Procedure standout() { so_mode = On; switch (scr_mode) { case BIOS: video_attr = V_STANDOUT; break; case ANSI: cputs(A_SGR7); break; } } Hidden Procedure standend() { so_mode = Off; switch (scr_mode) { case BIOS: video_attr = V_NORMAL; break; case ANSI: cputs(A_SGR0); break; } } #ifdef UNUSED Hidden Procedure put_c(c) int c; { int ch; ch = c&CHAR; #ifndef NDEBUG if (!isprint(ch)) { ch = '?'; c = (c&SOBIT)|'?'; } #endif switch (scr_mode) { case BIOS: regs.h.al = ch; regs.h.bl = video_attr; regs.x.cx = 1; /* repition count */ regs.h.bh = 0; /* page number */ bios10(9); if (cur_x >= cols-1) { line[cur_y][cols-1] = c; return; } regs.h.dh = cur_y; regs.h.dl = cur_x + 1; bios10(2); break; case ANSI: putch(ch); break; } line[cur_y][cur_x] = c; cur_x++; } #endif /* UNUSED */ Hidden Procedure clear_lines(yfirst, ylast) int yfirst, ylast ; { register int y; if (scr_mode == BIOS) { regs.h.al = 0; /* scroll with al = 0 means blank window */ regs.h.ch = yfirst; regs.h.cl = 0; regs.h.dh = ylast; regs.h.dl = cols-1; regs.h.bh = V_NORMAL; bios10(6); for (y = yfirst; y <= ylast; y++) lenline[y] = 0; return; } /* scr_mode == ANSI */ if (yfirst == 0 && ylast == lines-1) { if (so_mode == On) standend(); move(0, 0); /* since some ANSI'd don't move */ cputs(A_ED); cur_y = cur_x = 0; for (y = yfirst; y < ylast; y++) lenline[y] = 0; return; } for (y = yfirst; y <= ylast; y++) { if (lenline[y] > 0) { move(y, 0); clr_to_eol(); } } } Hidden Procedure clr_to_eol() { if (so_mode == On) standend(); switch (scr_mode) { case BIOS: regs.h.bh = 0; /* page */ regs.x.cx = lenline[cur_y] - cur_x; regs.h.al = ' '; regs.h.bl = V_NORMAL; bios10(9); break; case ANSI: cputs(A_EL); break; } lenline[cur_y] = cur_x; } Hidden Procedure /* scrolling for BIOS */ biosscrollup(yfirst, ylast, by) int yfirst; int ylast; int by; { regs.h.al = (by < 0 ? -by : by); regs.h.ch = yfirst; regs.h.cl = 0; regs.h.dh = ylast; regs.h.dl = cols-1; regs.h.bh= V_NORMAL; bios10(by < 0 ? 7 : 6); cur_y = cur_x = Undefined; if (by > 0) scr_lines(yfirst, ylast, by, 1); else scr_lines(ylast, yfirst, -by, -1); } Hidden Procedure /* Reset internal administration accordingly */ scr_lines(yfrom, yto, n, dy) int yfrom, yto, n, dy; { register int y, x; char *saveln; while (n-- > 0) { saveln = line[yfrom]; for (y = yfrom; y != yto; y += dy) { line[y] = line[y+dy]; lenline[y] = lenline[y+dy]; } line[yto] = saveln; for (x = 0; x < cols; x++ ) line[yto][x] = ' '; lenline[yto] = 0; } } Hidden Procedure lf_scroll(yto, by) int yto; int by; { register int n = by; move(lines-1, 0); while (n-- > 0) { putch('\n'); } scr_lines(0, lines-1, by, 1); move_lines(lines-1-by, lines-1, lines-1-yto, -1); clear_lines(yto-by+1, yto); } Hidden Procedure /* for dumb scrolling, uses and updates */ move_lines(yfrom, yto, n, dy) /* internal administration */ int yfrom; int yto; int n; int dy; { while (n-- > 0) { put_line(yto, 0, line[yfrom], lenline[yfrom]); yfrom += dy; yto += dy; } } Hidden Procedure ring_bell() { switch (scr_mode) { case BIOS: regs.h.al = '\007'; regs.h.bl = V_NORMAL; bios10(14); break; case ANSI: putch('\007'); break; } } /* * Show the current internal statuses of the screen on stderr. * For debugging only. */ #ifdef SHOW Visible Procedure trmshow(s) char *s; { int y, x; fprintf(stderr, "<<< %s >>>\n", s); for (y = 0; y < lines; y++) { for (x = 0; x <= lenline[y] /*** && x < cols ***/ ; x++) { fputc(line[y][x]&CHAR, stderr); } fputc('\n', stderr); for (x = 0; x <= lenline[y] && x < cols-1; x++) { if (line[y][x]&SOBIT) fputc('-', stderr); else fputc(' ', stderr); } fputc('\n', stderr); } fprintf(stderr, "CUR_Y = %d, CUR_X = %d.\n", cur_y, cur_x); VOID fflush(stderr); } #endif /* * Interrupt handling. * * (This has not properly been tested, nor is it clear that * this interface is what we want. Anyway, it's here for you * to experiment with. What does it do, you may ask? * Assume an interactive program which reads its characters * through trminput. Assume ^C is the interrupt character. * Normally, ^C is treated just like any other character: when * typed, it turns up in the input. The program may understand * input ^C as "quit from the current mode". * Occasionally, the program goes into a long period of computation. * Now it would be uninterruptible, except if it calls trminterrupt * at times in its computational loop. Trminterrupt magically looks * ahead in the input queue, and if it sees a ^C, discards all input * before that point and returns Yes. It also sets a flag, so that * the interupt "sticks around" until either trminput or trmavail * is called. It is undefined whether typing ^C several times in * a row is seen as one interrupt, or an interrupt followed by input * of ^C's. A program should be prepared for either.) */ static bool intrflag= No; static handler(sig) int sig; { signal(sig, handler); intrflag= Yes; } static set_handler() { signal(SIGINT, handler); } bool trminterrupt() { /* Force a check for ^C which will call handler. */ /* (This does a ^C check even if stdin is in RAW mode. */ (void) kbhit(); return intrflag; } /* Definitions for DOS function calls. */ #define IOCTL 0x44 #define IOCTL_GETDATA 0x4400 #define IOCTL_SETDATA 0x4401 #define DEVICEBIT 0x80 #define RAWBIT 0x20 #define BREAKCK 0x33 #define GET 0x00 #define SET 0x01 #define IOCTL_GETSTS 0x4406 #define STDIN_HANDLE 0 /* * Terminal input without echo. */ int trminput() { char c; intrflag= No; /* Assume stdin is in RAW mode; this turns echo and ^C checks off. */ if (read(STDIN_HANDLE, &c, 1) < 1) return -1; else return c; } /* * Check for character available. * */ trmavail() { intrflag= No; regs.x.ax= IOCTL_GETSTS; regs.x.bx= STDIN_HANDLE; intdos(®s, ®s); if (regs.x.cflag) return -1; /* Error */ return regs.h.al != 0; } trmsuspend() { /* Not implementable on MS-DOS */ } /* Issue an IOCTL to turn RAW for a device on or off. */ setraw(handle, raw) int handle; bool raw; { regs.x.ax= IOCTL_GETDATA; regs.x.bx= handle; intdos(®s, ®s); if (regs.x.cflag || !(regs.h.dl & DEVICEBIT)) return; /* Error or not a device -- ignore it */ regs.h.dh= 0; if (raw) regs.h.dl |= RAWBIT; else regs.h.dl &= ~RAWBIT; regs.x.ax= IOCTL_SETDATA; intdos(®s, ®s); /* Ignore errors */ } /* Get the raw bit of a device. */ int getraw(handle) int handle; { regs.x.ax= IOCTL_GETDATA; regs.x.bx= handle; intdos(®s, ®s); return !regs.x.cflag && (regs.h.dh & (DEVICEBIT|RAWBIT)) == (DEVICEBIT|RAWBIT); } /* Set the break status. */ setbreak(on) bool on; { bdos(BREAKCK, on, SET); } /* Get the break status. */ int getbreak() { regs.x.ax= (BREAKCK << 8) | GET; intdos(®s, ®s); return regs.h.dl; } 3/stdwin/Ports/mac_mpw/0407550003270021170000000000005477556120012740 5 0 1 0 smtalk43/stdwin/Ports/vtrm/0407550003270021170000000000005477556124012311 5 0 1 0 smtalk43/stdwin/Ports/vtrm/DIST/0407550003270021170000000000005477556122013052 5 0 1 0 smtalk43/stdwin/Ports/vtrm/DIST/README1006440003270021170000000314305434024352014525 037777777777 1 0 THIS IS VTRM ============ VTRM is a terminal control package, with two implementations: one for Unix (only well-tested on 4.2/4.3 BSD, but supposedly running under System 5 as well, as long as there is a termcap database), and one for MS-DOS, to be compiled with the Microsoft C compiler (tested only with version 3.0). This is a "curses replacement", which does not mean it is a curses reimplementation: the interface is totally different, only the purpose is more or less the same: to shield an application program from the nitty-gritty detail of cursor navigation, inverse video, scrolling, etc. There are also a few routines for CBREAK-mode input. UNPACKING NOTES The shars yield six files: README (this file) pag.c (a trivial application using the package) vtrmdoc.ms (an attempt at documentation) trm.h (common header file) ptrm.c (MS-DOS version) vtrm.c_1 vtrm.c_2 The latter two should be pasted together to get a file named vtrm.c: cat vtrm.c_[12] >vtrm.c AUTHORS This software was written by: Timo Krijnen and Guido van Rossum CWI, dept. AA Kruislaan 413 1089 SJ Amsterdam The Netherlands Electronic mail: timo@cwi.nl, guido@cwi.nl Phone: ... 20 - 592 4138. COPYRIGHT This software is copyright (c) 1986 by Stichting Mathematisch Centrum, Amsterdam, The Netherlands. Its use is allowed freely for non-commercial purposes only. Use at your own risk: SMC does not take responsibility for the proper functioning of the software or for damage caused by its use. Redistribution is allowed for non-commercial purposes only, and only unchanged, in its entirety, and including this copyright notice. all your own versions of selected routines by storing function pointers into this table. The structure of the control block for the dev_write function is also given. Careful! this information was gathered by disassembling parts of the library. There are no guarantees that the same code will work in future versions of MPW. Part of it has been tested with versions 1.0B1 and 1.0B2. */ typedesmtalk43/stdwin/Ports/vtrm/DIST/pag.c1006440003270021170000000502605465303021014557 037777777777 1 0 /* VTRM example -- a trivial pager. There are zillions of things this pager doesn't do, or would crash on, but it is a nice demonstration of the use of VTRM. */ #include char *index(); #define CTRL(c) ((c)&0x1F) #include "trm.h" int lines, columns, flags; FILE *fp; /* Main program -- scan arguments, open file, set-up VTRM, main loop. */ main(argc, argv) int argc; char **argv; { int n, c; if (argc != 2) { fprintf(stderr, "usage: %s file\n", argv[0]); exit(2); } if ((fp= fopen(argv[1], "r")) == NULL) { perror(argv[1]); exit(1); } if ((n= trmstart(&lines, &columns, &flags)) != 0) { fprintf(stderr, "trmstart error %d\n", n); exit(3); } page(); for (;;) { prompt(); c= trminput(); switch (c) { case ' ': /* Display one more page */ page(); break; case '\n': /* Display one more line */ case '\r': line(); break; case 'q': /* Quit */ case CTRL('C'): /* or Interrupt */ trmputdata(lines-1, lines-1, 0, ""); trmsync(lines-1, 0); trmend(); exit(2); case CTRL('Z'): /* Suspend */ trmputdata(lines-1, lines-1, 0, ""); trmsync(lines-1, 0); trmend(); trmsuspend(); if (trmstart(&lines, &columns, &flags)) exit(3); page(); break; default: /* Error */ trmbell(); break; } } } int left; /* Lines left on current page */ /* Output one page, using line() as a subroutine. BUG: if the last line takes up more space than available, it is displayed in its entirety, scrolling up more than a page in total. */ page() { left= lines-1; do { line(); } while (left > 0); } /* Output one line. The line is displayed at the bottom, assuming the botom line of the screen is free. Update count of lines left on display. Exit if EOF hit. */ line() { char linebuf[BUFSIZ]; char *p; int n; if (fgets(linebuf, sizeof linebuf, fp) == NULL) { trmend(); exit(0); } if (p= index(linebuf, '\n')) *p= '\0'; n= need(linebuf); trmscrollup(0, lines-1, n); trmputdata(lines-n-1, lines-2, 0, linebuf); left -= n; } /* Compute the number of screen lines required. Assumes only printing characters. */ need(buf) char *buf; { int len= strlen(buf); if (len == 0) return 1; else return (len+columns-1) / columns; } /* Issue a prompt on the bottom line. Assumes this line is already free. */ prompt() { static int beenhere= 0; static char pr[]= "--More--"; if (!beenhere++) { char *p; for (p= pr; *p; ++p) *p |= 0x80; } trmputdata(lines-1, lines-1, 0, pr); trmsync(lines-1, strlen(pr)); } L. */ static long my_faccess(file, cmd, arg) char *file; int cmd; short *arg; { long res= _fsFAccess(file, cmd, arg); if (cmd == F_OPEN && !(res&ERRFLAG)) { (void) (*open_hook)(file, *arg, (int)res); } return res; } /* Standard open hook, to set type and creator of created files. It will not change existing non-zero type or creator fields. It returns an error code even though this is ignored by the calling routine; you might want to call it yourself in a more fsmtalk43/stdwin/Ports/vtrm/uxtty.c1006440003270021170000001160505465303021014442 037777777777 1 0 /* VTRM -- unix-dependent tty twiddling. */ #ifdef SYSV #define TERMIO #endif #include #ifndef TERMIO #include #else #include #endif TERMIO #include #include #include "vtrm.h" #include "sigtype.h" /* Defines SIGTYPE as int or void */ typedef char *string; typedef int bool; #define Yes 1 #define No 0 extern short ospeed; /* Defined in vtrm.c, used by termcap's tgoto/tputs. */ /* tty modes */ #ifndef TERMIO /* v7/BSD tty control */ static struct sgttyb oldtty, newtty; #ifdef TIOCSETN /* Redefine stty to uses TIOCSETN, so type-ahead is not flushed */ #define stty(fd, bp) ioctl(fd, TIOCSETN, (char *) bp) #endif #ifdef TIOCSLTC /* BSD -- local special chars, must all be turned off */ static struct ltchars oldltchars; static struct ltchars newltchars= {-1, -1, -1, -1, -1, -1}; #endif TIOCSLTC #ifdef TIOCSETC /* V7 -- standard special chars, some must be turned off too */ static struct tchars oldtchars; static struct tchars newtchars; #endif TIOCSETC #else TERMIO /* AT&T tty control */ static struct termio oldtty, newtty; #define gtty(fd,bp) ioctl(fd, TCGETA, (char *) bp) #define stty(fd,bp) ioctl(fd, TCSETAW, (char *) bp) #endif TERMIO static bool know_ttys = No; int setttymode() { if (!know_ttys) { if (gtty(0, &oldtty) != 0 || gtty(0, &newtty) != 0) return TE_NOTTY; #ifndef TERMIO ospeed = oldtty.sg_ospeed; #ifdef PWB newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS) | RAW; #else PWB newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS) | CBREAK; #endif PWB #ifdef TIOCSLTC ioctl(0, TIOCGLTC, (char *) &oldltchars); #endif #ifdef TIOCSETC ioctl(0, TIOCGETC, (char *) &oldtchars); #endif #else TERMIO /* ospeed= oldtty.c_lflag & CBAUD; /* BOGUS */ newtty.c_iflag &= ~ICRNL; /* No CR->NL mapping on input */ newtty.c_oflag &= ~ONLCR; /* NL doesn't output CR */ newtty.c_lflag &= ~(ICANON|ECHO|ISIG); /* No line editing, no echo, no signals */ newtty.c_cc[VMIN]= 3; /* wait for 3 characters */ newtty.c_cc[VTIME]= 1; /* or 0.1 sec. */ #endif TERMIO know_ttys = Yes; } stty(0, &newtty); #ifndef TERMIO #ifdef TIOCSLTC ioctl(0, TIOCSLTC, (char *) &newltchars); #endif TIOCSLTC #ifdef TIOCSETC ioctl(0, TIOCGETC, (char *) &newtchars); newtchars.t_intrc= -1; #ifdef NDEBUG newtchars.t_quitc= -1; #endif newtchars.t_eofc= -1; newtchars.t_brkc= -1; ioctl(0, TIOCSETC, (char *) &newtchars); #endif TIOCSETC #endif TERMIO return TE_OK; } resetttymode() { if (know_ttys) { stty(0, &oldtty); #ifndef TERMIO #ifdef TIOCSLTC ioctl(0, TIOCSLTC, (char *) &oldltchars); #endif TIOCSLTC #ifdef TIOCSETC ioctl(0, TIOCSETC, (char *) &oldtchars); #endif TIOCSETC #endif TERMIO know_ttys= No; } } /* * Return the next input character, or -1 if read fails. * Only the low 7 bits are returned, so reading in RAW mode is permissible * (although CBREAK is preferred if implemented). * To avoid having to peek in the input buffer for trmavail, we use the * 'read' system call rather than getchar(). * (The interface allows 8-bit characters to be returned, to accomodate * larger character sets!) */ static int pushback= -1; int trminput() { char c; if (pushback >= 0) { c= pushback; pushback= -1; return c; } if (read(0, &c, 1) <= 0) return -1; return c & 0177; } trmpushback(c) int c; { pushback= c; } /* * See if there's input available from the keyboard. * The code to do this is dependent on the type of Unix you have * (BSD, System V, ...). * Return value: 0 -- no input; 1 -- input; -1 -- unimplementable. * Note that each implementation form should first check pushback. * * TO DO: * - Implement it for other than 4.x BSD! (notably System 5) */ #ifdef SELECT #include int trmavail() { int nfound, nfds, readfds; static struct timeval timeout= {0, 0}; if (pushback >= 0) return 1; readfds= 1 << 0; nfds= 0+1; nfound= select(nfds, &readfds, (int*) NIL, (int*) NIL, &timeout); return nfound > 0; } #define TRMAVAIL_DEFINED #endif SELECT #if !defined(TRMAVAIL_DEFINED) && defined(FIONREAD) int trmavail() { long n; if (pushback >= 0) return 1; if (ioctl(0, FIONREAD, (char *) &n) < 0) return -1; return n > 0; } #define TRMAVAIL_DEFINED #endif FIONREAD #ifndef TRMAVAIL_DEFINED int trmavail() { if (pushback >= 0) return 1; return -1; } #endif /* * Suspend the editor. * Should be called only after trmend and before trmstart! */ trmsuspend() { SIGTYPE (*oldsig)(); oldsig= signal(SIGTSTP, SIG_IGN); if (oldsig == SIG_IGN) return; /* Could spawn a subshell here... */ trmend(); /* Safety net */ (void) signal(SIGTSTP, oldsig); kill(0, SIGSTOP); } /* * Get the true window size. * May return 0 if unknown. */ gettruewinsize(plines, pcols) int *plines, *pcols; { #ifdef TIOCGWINSZ struct winsize win; if (ioctl(0, TIOCGWINSZ, (char *) &win) == 0) { *plines= win.ws_row; *pcols= win.ws_col; } else #endif *plines= *pcols= 0; } MEID 0x08 #define DIRECTORY 0x10 #define ARCHIVE 0x20 #define MATCHATTR (HIDDEN|SYSTEM|DIRECTORY) static char * firstf(psmtalk43/stdwin/Ports/vtrm/vtrm.c1006440003270021170000010361605465303021014241 037777777777 1 0 /* * Virtual TeRMinal package. * (For a description see at the end of this file.) * * TO DO: * - add interrupt handling (trminterrupt) * - adapt to changed window size when suspended or at SIGWINCH * (unfortunately, the calling module must be changed first -- * it is not prepared for the changed window size...) */ #include "tools.h" int tgetent(); int tgetnum(); int tgetflag(); char *tgetstr(); char *tgoto(); #include "vtrm.h" #ifdef TRACE #define Tprintf(args) fprintf args #else #define Tprintf(args) /*empty*/ #endif #ifdef lint #define VOID (void) #else #define VOID #endif #define Forward #define Visible #define Hidden static #define Procedure typedef char *string; #ifndef bool #define bool int #endif #define Yes 1 #define No 0 #define Min(a,b) ((a) <= (b) ? (a) : (b)) /* Variables needed by termcap's tgoto() or tputs(): */ char PC; char *BC; char *UP; short ospeed; Forward int outchar(); /* procedure for termcap's tputs */ #define Putstr(str) tputs((str), 1, outchar) /* termcap terminal capabilities */ Hidden int lines; Hidden int cols; /* * String-valued capabilities are saved in one big array. * Extend this only at the end (even though it disturbs the sorting) * because otherwise you have to change all macros... */ #define par_al_str strcaps[0] /* parametrized al (AL) */ #define cap_cm_str strcaps[1] /* screen-relative cursor motion (CM) */ #define par_dl_str strcaps[2] /* parametrized dl (DL) */ #define al_str strcaps[3] /* add new blank line */ #define cd_str strcaps[4] /* clear to end of display */ #define ce_str strcaps[5] /* clear to end of line */ #define cl_str strcaps[6] /* cursor home and clear screen */ #define cm_str strcaps[7] /* cursor motion */ #define cp_str strcaps[8] /* cursor position sense reply */ #define cr_str strcaps[9] /* carriage return */ #define cs_str strcaps[10] /* change scrolling region */ #define dc_str strcaps[11] /* delete character */ #define dl_str strcaps[12] /* delete line */ #define dm_str strcaps[13] /* enter delete mode */ #define do_str strcaps[14] /* cursor down one line */ #define ed_str strcaps[15] /* end delete mode */ #define ei_str strcaps[16] /* end insert mode */ #define ho_str strcaps[17] /* cursor home */ #define ic_str strcaps[18] /* insert character (if necessary; may pad) */ #define im_str strcaps[19] /* enter insert mode */ #define nd_str strcaps[20] /* cursor right (non-destructive space) */ #define nl_str strcaps[21] /* newline */ #define se_str strcaps[22] /* end standout mode */ #define sf_str strcaps[23] /* scroll text up (from bottom of region) */ #define so_str strcaps[24] /* begin standout mode */ #define sp_str strcaps[25] /* sense cursor position */ #define sr_str strcaps[26] /* scroll text down (from top of region) */ #define te_str strcaps[27] /* end termcap */ #define ti_str strcaps[28] /* start termcap */ #define vb_str strcaps[29] /* visible bell */ #define ve_str strcaps[30] /* make cursor visible again */ #define vi_str strcaps[31] /* make cursor invisible */ #define le_str strcaps[32] /* cursor left */ #define bc_str strcaps[33] /* backspace character */ #define up_str strcaps[34] /* cursor up */ #define pc_str strcaps[35] /* pad character */ #define ks_str strcaps[36] /* keypad mode start */ #define ke_str strcaps[37] /* keypad mode end */ /* Insert new entries here only! Don't forget to change the next line! */ #define NSTRCAPS 38 /* One more than the last entry's index */ Hidden char *strcaps[NSTRCAPS]; Hidden char strcapnames[] = "ALCMDLalcdceclcmcpcrcsdcdldmdoedeihoicimndnlsesfsospsrtetivbvevilebcuppckske"; /* Same for Boolean-valued capabilities */ #define has_am flagcaps[0] /* has automatic margins */ #define has_da flagcaps[1] /* display may be retained above screen */ #define has_db flagcaps[2] /* display may be retained below screen */ #define has_in flagcaps[3] /* not safe to have null chars on the screen */ #define has_mi flagcaps[4] /* move safely in insert (and delete?) mode */ #define has_ms flagcaps[5] /* move safely in standout mode */ #define has_xs flagcaps[6] /* standout not erased by overwriting */ #define has_bs flagcaps[7] /* terminal can backspace */ #define hardcopy flagcaps[8] /* hardcopy terminal */ #define has_xn flagcaps[9] /* Vt100 / Concept glitch */ #define NFLAGS 10 Hidden char flagcaps[NFLAGS]; Hidden char flagnames[]= "amdadbinmimsxsbshcxn"; Hidden Procedure getcaps(parea) register char **parea; { register char *capname; register char **capvar; register char *flagvar; for (capname= flagnames, flagvar= flagcaps; *capname != '\0'; capname += 2, ++flagvar) *flagvar= tgetflag(capname); for (capname= strcapnames, capvar= strcaps; *capname != '\0'; capname += 2, ++capvar) *capvar= tgetstr(capname, parea); } /* terminal status */ /* calling order of Visible Procs */ Hidden bool started = No; /* to exports the capabilities mentioned in vtrm.h: */ Hidden int flags = 0; /* cost for impossible operations */ #define Infinity 9999 /* Allow for adding Infinity+Infinity within range */ /* (Range is assumed at least 2**15 - 1) */ /* The following for all sorts of undefined things (except for UNKNOWN char) */ #define Undefined (-1) /* current mode of putting char's */ #define Normal 0 #define Insert 1 #define Delete 2 Hidden short mode = Normal; /* current standout mode */ #define Off 0 #define On 0200 Hidden short so_mode = Off; /* masks for char's and short's */ #define NULCHAR '\000' #define CHAR 0177 #define SOBIT On #define SOCHAR 0377 /* if (has_xs) record cookies placed on screen in extra bit */ /* type of cookie is determined by the SO bit */ #define XSBIT 0400 #define SOCOOK 0600 #define COOKBITS SOCOOK #define UNKNOWN 1 #define NOCOOK UNKNOWN /* current cursor position */ Hidden short cur_y = Undefined, cur_x = Undefined; /* "line[y][x]" holds the char on the terminal, with the SOBIT and XSBIT. * the SOBIT tells whether the character is standing out, the XSBIT whether * there is a cookie on the screen at this position. * In particular a standend-cookie may be recorded AFTER the line * (just in case some trmputdata will write after that position). * "lenline[y]" holds the length of the line. * Unknown chars will be 1, so the optimising compare in putline will fail. * (Partially) empty lines are distinghuished by "lenline[y] < cols". */ Hidden short **line = 0, *lenline = 0; /* Clear the screen initially iff only memory cursor addressing available */ Hidden bool mustclear = No; /* Make the cursor invisible when trmsync() tries to move outside the screen */ Hidden bool no_cursor = No; /* Optimise cursor motion */ Hidden int abs_cost; /* cost of absolute cursor motion */ Hidden int cr_cost; /* cost of carriage return */ Hidden int do_cost; /* cost of down */ Hidden int le_cost; /* cost of left */ Hidden int nd_cost; /* cost of right */ Hidden int up_cost; /* cost of up */ /* Optimise trailing match in put_line, iff the terminal can insert and delete * characters; the cost per n characters will be: * n * MultiplyFactor + OverHead */ Hidden int ins_mf, ins_oh, del_mf, del_oh; Hidden int ed_cost, ei_cost; /* used in move() */ /* The type of scrolling possible determines which routines get used; * these may be: * (1) with addline and deleteline (termcap: al_str & dl_str); * (2) with a settable scrolling region, like VT100 (cs_str, sr_str, sf_str); * (3) no scrolling available. (NOT YET IMPLEMENTED) */ Hidden Procedure (*scr_up)(); Hidden Procedure (*scr_down)(); Forward Procedure scr1up(); Forward Procedure scr1down(); Forward Procedure scr2up(); Forward Procedure scr2down(); /*Forward Procedure scr3up(); */ /*Forward Procedure scr3down(); */ /* * Starting, Ending and (fatal) Error. */ /* * Initialization call. * Determine terminal capabilities from termcap. * Set up tty modes. * Start up terminal and internal administration. * Return 0 if all well, error code if in trouble. */ Visible int trmstart(plines, pcols, pflags) int *plines; int *pcols; int *pflags; { register int err; Tprintf((stderr, "\ttrmstart(&li, &co, &fl);\n")); if (started) return TE_TWICE; err= gettermcaps(); if (err != TE_OK) return err; err= setttymode(); if (err != TE_OK) return err; err= start_trm(); if (err != TE_OK) { trmend(); return err; } *plines = lines; *pcols = cols; *pflags = flags; started = Yes; return TE_OK; } /* * Termination call. * Reset tty modes, etc. * Beware that it might be called by a caught interrupt even in the middle * of trmstart()! */ Visible Procedure trmend() { Tprintf((stderr, "\ttrmend();\n")); set_mode(Normal); if (so_mode != Off) standend(); Putstr(ke_str); Putstr(te_str); VOID fflush(stdout); resetttymode(); started = No; } /* * Set all internal statuses to undefined, especially the contents of * the screen, so a hard redraw will not be optimised to heaven. */ Visible Procedure trmundefined() { register int y, x; Tprintf((stderr, "\ttrmundefined();\n")); cur_y = cur_x = Undefined; mode = so_mode = Undefined; for (y = 0; y < lines; y++) { for (x = 0; x <= cols; x++) line[y][x] = 1; /* impossible char, no so bits */ lenline[y] = cols; } } #ifndef NDEBUG /*ARGSUSED*/ Hidden Procedure check_started(m) char *m; { if (!started) { trmend(); fprintf(stderr, "bad VTRM call\n"); abort(); } } #else #define check_started(m) /*empty*/ #endif Hidden int ccc; /*ARGSUSED*/ Hidden Procedure countchar(ch) char ch; { ccc++; } Hidden int strcost(str) char *str; { if (str == NULL) return Infinity; return str0cost(str); } Hidden int str0cost(str) char *str; { ccc = 0; tputs(str, 1, countchar); return ccc; } /* * Get terminal capabilities from termcap and compute related static * properties. Return TE_OK if all well, error code otherwise. */ Hidden int gettermcaps() { string trmname; static char tc_buf[1024]; /* Static so main program can get keydefs */ static char strbuf[1024]; /* Buffer where our caps are saved */ char *area = strbuf; int sg; static bool tc_initialized = No; if (tc_initialized) return TE_OK; trmname=getenv("TERM"); if (trmname == NULL || trmname[0] == '\0') return TE_NOTERM; if (tgetent(tc_buf, trmname) != 1) return TE_BADTERM; getcaps(&area); /* Read all flag and string type capabilities */ if (hardcopy) return TE_DUMB; BC = le_str; if (BC == NULL) { BC = bc_str; if (BC == NULL) { if (has_bs) BC = "\b"; else return TE_DUMB; } } UP = up_str; if (UP == NULL) return TE_DUMB; PC = (pc_str != NULL? pc_str[0] : NULCHAR); if (cm_str == NULL) { cm_str = cap_cm_str; if (cm_str == NULL) { if (ho_str == NULL || do_str == NULL || nd_str == NULL) return TE_DUMB; } else mustclear = Yes; } if (al_str && dl_str) { scr_up = scr1up; scr_down = scr1down; flags |= CAN_SCROLL; } else { if (sf_str == NULL) sf_str = "\n"; if (cs_str && sr_str) { scr_up = scr2up; scr_down = scr2down; flags |= CAN_SCROLL; } else return TE_DUMB; } lines = tgetnum("li"); cols = tgetnum("co"); if (lines <= 0) lines = 24; if (cols <= 0) cols = 80; if ((sg=tgetnum("sg")) == 0) has_xs = Yes; else if (sg > 0) return TE_DUMB; if (!ce_str) return TE_DUMB; if (cr_str == NULL) cr_str = "\r"; if (do_str == NULL) { do_str = nl_str; if (do_str == NULL) do_str = "\n"; } le_str = BC; up_str = UP; if (vb_str == NULL) /* then we will do with the audible bell */ vb_str = "\007"; /* cursor sensing (non standard) */ if (cp_str != NULL && sp_str != NULL) flags |= CAN_SENSE; if (so_str != NULL && se_str != NULL) flags |= HAS_STANDOUT; /* calculate costs of local and absolute cursor motions */ if (cm_str == NULL) abs_cost = Infinity; else abs_cost = strcost(tgoto(cm_str, 0, 0)); cr_cost = strcost(cr_str); do_cost = strcost(do_str); le_cost = strcost(le_str); nd_cost = strcost(nd_str); up_cost = strcost(up_str); /* cost of leaving insert or delete mode, used in move() */ ei_cost = str0cost(ei_str); ed_cost = str0cost(ed_str); /* calculate insert and delete cost multiply_factor and overhead */ if (((im_str && ei_str) || ic_str) && dc_str) { flags |= CAN_OPTIMISE; ins_mf = 1 + str0cost(ic_str); ins_oh = str0cost(im_str) + ei_cost; del_mf = str0cost(dc_str); del_oh = str0cost(dm_str) + ed_cost; } tc_initialized = Yes; return TE_OK; } Hidden int start_trm() { register int y; int newlines, newcols; gettruewinsize(&newlines, &newcols); if (newcols != 0 && newcols != cols || newlines != 0 && newlines != lines) { /* Window size has changed. Release previously allocated buffers. */ if (line != NULL) { for (y= 0; y < lines; ++y) free((char *) line[y]); free((char *) line); line= NULL; } if (lenline != NULL) { free((char *) lenline); lenline= NULL; } if (newcols != 0) cols = newcols; if (newlines != 0) lines = newlines; } if (line == NULL) { line = (short **) malloc((unsigned) (lines * sizeof(short*))); if (line == NULL) return TE_NOMEM; for (y = 0; y < lines; y++) { line[y] = (short *) malloc((unsigned) ((cols+1) * sizeof(short))); if (line == NULL) return TE_NOMEM; } } if (lenline == NULL) { lenline = (short *) malloc((unsigned) (lines * sizeof(short))); if (lenline == NULL) return TE_NOMEM; } trmundefined(); Putstr(ti_str); Putstr(ks_str); if (cs_str) Putstr(tgoto(cs_str, lines-1, 0)); if (mustclear) clear_lines(0, lines-1); return TE_OK; } /* * Sensing and moving the cursor. */ /* * Sense the current (y, x) cursor position, after a possible manual * change by the user with local cursor motions. * If the terminal cannot be asked for the current cursor position, * or if the string returned by the terminal is garbled, * the position is made Undefined. */ Visible Procedure trmsense(py, px) int *py; int *px; { bool getpos(); Tprintf((stderr, "\ttrmsense(&yy, &xx);\n")); check_started("trmsense"); *py = *px = Undefined; set_mode(Normal); if (so_mode != Off) standend(); if (flags&CAN_SENSE && getpos(py, px)) { if (*py < 0 || lines <= *py || *px < 0 || cols <= *px) *py = *px = Undefined; } cur_y = Undefined; cur_x = Undefined; } Hidden bool getpos(py, px) int *py, *px; { char *format = cp_str; int fc; /* current format character */ int ic; /* current input character */ int num; int on_y = 1; bool incr_orig = No; int i, ni; Putstr(sp_str); VOID fflush(stdout); while (fc = *format++) { if (fc != '%') { if (trminput() != fc) return No; } else { switch (fc = *format++) { case '%': if (trminput() != '%') return No; continue; case 'r': on_y = 1 - on_y; continue; case 'i': incr_orig = Yes; continue; case 'd': ic = trminput(); if (!isdigit(ic)) return No; num = ic - '0'; while (isdigit(ic=trminput())) num = 10*num + ic - '0'; trmpushback(ic); break; case '2': case '3': ni = fc - '0'; num = 0; for (i=0; i