Subversion Repositories planix.SVN

/*

 * 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;

}