harvey/sys/src/libscribble/graffiti.c

/*
 * This file is part of the UCB release of Plan 9. It is subject to the license
 * terms in the LICENSE file found in the top-level directory of this
 * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
 * part of the UCB release of Plan 9, including this file, may be copied,
 * modified, propagated, or distributed except according to the terms contained
 * in the LICENSE file.
 */

/*
 * Graffiti.c is based on the file Scribble.c copyrighted
 * by Keith Packard:
 *
 * Copyright © 1999 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <u.h>
#include <libc.h>
#include <draw.h>
#include <scribble.h>

#include "scribbleimpl.h"
#include "graffiti.h"

int ScribbleDebug;

char *cl_name[3] = {
	DEFAULT_LETTERS_FILE,
	DEFAULT_DIGITS_FILE,
	DEFAULT_PUNC_FILE
};

Rune
recognize (Scribble *s)
{
	struct graffiti *graf = s->graf;
	Stroke	    *ps = &s->ps;
	Rune		    rune;
	int		    	c;
	int				nr;
	rec_alternative	*ret;

	if (ps->npts == 0)
		return '\0';

	c = recognizer_translate(
		graf->rec[s->puncShift ? CS_PUNCTUATION : s->curCharSet],
		1, ps, false, &nr, &ret);
	if (c != -1)
		delete_rec_alternative_array(nr, ret, false);

	rune = '\0';

	switch (c) {
	case '\0':
		if(ScribbleDebug)fprint(2, "(case '\\0')\n");
		break;
	case 'A':	/* space */
		rune = ' ';
		if(ScribbleDebug)fprint(2, "(case A) character = ' %C' (0x%x)\n", rune, rune);
		break;
	case 'B':	/* backspace */
		rune = '\b';
		if(ScribbleDebug)fprint(2, "(case B) character = \\b (0x%x)\n", rune);
		break;
	case 'N': /* numlock */
		if(ScribbleDebug)fprint(2, "(case N)\n");
		if (s->curCharSet == CS_DIGITS) {
			s->curCharSet = CS_LETTERS;
		} else {
			s->curCharSet = CS_DIGITS;
		}
		s->tmpShift = 0;
		s->puncShift = 0;
		s->ctrlShift = 0;
		break;
	case 'P': /* usually puncshift, but we'll make it CTRL */
		if(ScribbleDebug)fprint(2, "(case P)\n");
		s->ctrlShift = !s->ctrlShift;
		s->tmpShift = 0;
		s->puncShift = 0;
		break;
	case 'R':	/* newline */
		rune = '\n';
		if(ScribbleDebug)fprint(2, "(case R) character = \\n (0x%x)\n", rune);
		break;
	case 'S': /* shift */
		if(ScribbleDebug)fprint(2, "(case S)\n");
		s->puncShift = 0;
		s->ctrlShift = 0;
		if (s->capsLock) {
			s->capsLock = 0;
			s->tmpShift = 0;
			break;
		}
		if (s->tmpShift == 0) {
			s->tmpShift++;
			break;
		}
		/* fall through */
	case 'L': /* caps lock */
		if(ScribbleDebug)fprint(2, "(case L)\n");
		s->capsLock = !s->capsLock;
		break;
	case '.':	/* toggle punctuation mode */
		if (s->puncShift) {
			s->puncShift = 0;
		} else {
			s->puncShift = 1;
			s->ctrlShift = 0;
			s->tmpShift = 0;
			return rune;
		}
		rune = '.';
		if(0)fprint(2, "(case .) character = %c (0x%x)\n", rune, rune);
		break;
	default:
		if ('A' <= c && c <= 'Z') {
			if(ScribbleDebug)fprint(2, "(bad case?) character = %c (0x%x)\n", c, c);
			return rune;
		}
		rune = c;
		if (s->ctrlShift)
		{
			if (c < 'a' || 'z' < c)
			{
				if(ScribbleDebug)fprint(2, "(default) character = %c (0x%x)\n", rune, rune);
				return rune;
			}
			rune = rune & 0x1f;
		} else if ((s->capsLock && !s->tmpShift) ||
				 (!s->capsLock && s->tmpShift))
		{
			if (rune < 0xff)
				rune = toupper(rune);
		}
		s->tmpShift = 0;
		s->puncShift = 0;
		s->ctrlShift = 0;
		if(ScribbleDebug)fprint(2, "(default) character = %c (0x%x)\n", rune, rune);
	}
	return rune;
}

/* This procedure is called to initialize pg by loading the three
 * recognizers, loading the initial set of three classifiers, and
 * loading & verifying the recognizer extension functions.  If the
 * directory $HOME/.recognizers exists, the classifier files will be
 * loaded from that directory.  If not, or if there is an error, the
 * default files (directory specified in Makefile) will be loaded
 * instead.  Returns non-zero on success, 0 on failure.  (Adapted from
 * package tkgraf/src/GraffitiPkg.c.
 */

static int
graffiti_load_recognizers(struct graffiti *pg)
{
	bool usingDefault;
	char* homedir;
	int i;
	rec_fn *fns;

	/* First, load the recognizers... */
	/* call recognizer_unload if an error ? */
	for (i = 0; i < NUM_RECS; i++) {
		/* Load the recognizer itself... */
		pg->rec[i] = recognizer_load(DEFAULT_REC_DIR, "", nil);
		if (pg->rec[i] == nil) {
			fprint(2,"Error loading recognizer from %s.", DEFAULT_REC_DIR);
			return 0;
		}
		if ((* (int *)(pg->rec[i])) != 0xfeed) {
			fprint(2,"Error in recognizer_magic.");
			return 0;
		}
	}

	/* ...then figure out where the classifiers are... */
	if ( (homedir = (char*)getenv("home")) == nil ) {
		if(0)fprint(2, "no homedir, using = %s\n", REC_DEFAULT_USER_DIR);
		strecpy(pg->cldir, pg->cldir+sizeof pg->cldir, REC_DEFAULT_USER_DIR);
		usingDefault = true;
	} else {
		if(0)fprint(2, "homedir = %s\n", homedir);
		snprint(pg->cldir, sizeof pg->cldir, "%s/%s", homedir, CLASSIFIER_DIR);
		usingDefault = false;
	}

	/* ...then load the classifiers... */
	for (i = 0; i < NUM_RECS; i++) {
		int rec_return;
		char *s;

		rec_return = recognizer_load_state(pg->rec[i], pg->cldir, cl_name[i]);
		if ((rec_return == -1) && (usingDefault == false)) {
			if(0)fprint(2, "Unable to load custom classifier file %s/%s.\nTrying default classifier file instead.\nOriginal error: %s\n ",
				pg->cldir, cl_name[i],
				(s = recognizer_error(pg->rec[i])) ? s : "(none)");
			rec_return = recognizer_load_state(pg->rec[i],
						REC_DEFAULT_USER_DIR, cl_name[i]);
		}
		if (rec_return == -1) {
			fprint(2, "Unable to load default classifier file %s.\nOriginal error: %s\n",
				cl_name[i],
				(s = recognizer_error(pg->rec[i])) ? s : "(none)");
			return 0;
		}
	}

	/* We have recognizers and classifiers now.   */
	/* Get the vector of LIextension functions..     */
	fns = recognizer_get_extension_functions(pg->rec[CS_LETTERS]);
	if (fns == nil) {
		fprint(2, "LI Recognizer Training:No extension functions!");
		return 0;
	}

	/* ... and make sure the training & get-classes functions are okay. */
	if( (pg->rec_train = (li_recognizer_train)fns[LI_TRAIN]) == nil ) {
		fprint(2,
			"LI Recognizer Training:li_recognizer_train() not found!");
		if (fns != nil) {
			free(fns);
		}
		return 0;
	}

	if( (pg->rec_getClasses = (li_recognizer_getClasses)fns[LI_GET_CLASSES]) == nil ) {
		fprint(2,
			"LI Recognizer Training:li_recognizer_getClasses() not found!");
		if (fns != nil) {
			free(fns);
		}
		return 0;
	}
	free(fns);
	return 1;
}

Scribble *
scribblealloc(void)
{
	Scribble *s;

	s = mallocz(sizeof(Scribble), 1);
	if (s == nil)
		sysfatal("Initialize: %r");
	s->curCharSet = CS_LETTERS;

	s->graf = mallocz(sizeof(struct graffiti), 1);
	if (s->graf == nil)
		sysfatal("Initialize: %r");

	graffiti_load_recognizers(s->graf);

	return s;
}