URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [demos/] [nxscribble/] [nxscribble.c] - Blame information for rev 174

Details | Compare with Previous | View Log


/*
 * Copyright (c) 2000 Greg Haerr <greg@censoft.com>
 * Copyright (c) 2000 Century Software <embedded.centurysoftware.com>
 *
 * Scribble Handwriting Recognition for Nano-X!
 */
#include <stdio.h>
#include <stdlib.h>
#define MWINCLUDECOLORS
#include "nano-X.h"
#include "scrib.h"
 
#define TEXTWIN_WIDTH   200             /* text window width/height*/
#define TEXTWIN_HEIGHT  150
 
static ScribbleWidget   w;
 
static GR_BOOL          bTextwin = GR_FALSE;
static GR_WINDOW_ID     wt = 0;
static GR_GC_ID         gct = 0;
static GR_GC_ID         gctb = 0;
static GR_COORD         xpos = 0;
static GR_COORD         ypos = 0;
static GR_SIZE          width;          /* width of character */
static GR_SIZE          height;         /* height of character */
static GR_SIZE          base;           /* height of baseline */
static void char_out(GR_CHAR ch);
static void char_del(GR_COORD x, GR_COORD y);
 
void do_buttondown(GR_EVENT_BUTTON      *bp);
void do_buttonup(GR_EVENT_BUTTON        *bp);
void do_motion(GR_EVENT_MOUSE           *mp);
void do_focusin(GR_EVENT_GENERAL        *gp);
void do_keystroke(GR_EVENT_KEYSTROKE    *kp);
void do_exposure(GR_EVENT_EXPOSURE      *ep);
 
int
main(int argc, char **argv)
{
        int             t = 1;
        GR_EVENT        event;          /* current event */
 
        while (t < argc) {
                if (!strcmp("-t", argv[t])) {
                        bTextwin = GR_TRUE;
                        ++t;
                        continue;
                }
        }
 
        if (GrOpen() < 0) {
                fprintf(stderr, "cannot open graphics\n");
                exit(1);
        }
 
        if (bTextwin) {
                /* create text output window for debugging*/
                wt = GrNewWindow(GR_ROOT_WINDOW_ID, 50, 20,
                                TEXTWIN_WIDTH, TEXTWIN_HEIGHT, 5, BLACK, GREEN);
                GrSelectEvents(wt,
                        GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_KEY_DOWN
                        | GR_EVENT_MASK_EXPOSURE);
                GrMapWindow(wt);
                gct = GrNewGC();
                GrSetGCForeground(gct, GREEN);
                GrGetGCTextSize(gct, "A",1, GR_TFASCII, &width, &height, &base);
                GrSetGCFont(gct, GrCreateFont(GR_FONT_OEM_FIXED, 0, NULL));
                gctb = GrNewGC();
                GrSetGCForeground(gctb, BLACK);
        }
 
        /* create scribble input window*/
        w = create_scribble();
 
        while (1) {
                GrGetNextEvent(&event);
 
                switch (event.type) {
                        case GR_EVENT_TYPE_BUTTON_DOWN:
                                do_buttondown(&event.button);
                                break;
 
                        case GR_EVENT_TYPE_BUTTON_UP:
                                do_buttonup(&event.button);
                                break;
 
                        case GR_EVENT_TYPE_MOUSE_POSITION:
                        case GR_EVENT_TYPE_MOUSE_MOTION:
                                do_motion(&event.mouse);
                                break;
 
                        case GR_EVENT_TYPE_FOCUS_IN:
                                do_focusin(&event.general);
                                break;
 
                        case GR_EVENT_TYPE_KEY_DOWN:
                                do_keystroke(&event.keystroke);
                                break;
 
                        case GR_EVENT_TYPE_EXPOSURE:
                                do_exposure(&event.exposure);
                                break;
 
                        case GR_EVENT_TYPE_CLOSE_REQ:
                                GrClose();
                                exit(0);
                }
        }
}
 
 
/*
 * Here when a button is pressed.
 */
void
do_buttondown(GR_EVENT_BUTTON   *bp)
{
        ActionStart(w, bp->x, bp->y);
}
 
 
/*
 * Here when a button is released.
 */
void
do_buttonup(GR_EVENT_BUTTON     *bp)
{
        ActionEnd(w, bp->x, bp->y);
}
 
 
/*
 * Here when the mouse has a motion event.
 */
void
do_motion(GR_EVENT_MOUSE        *mp)
{
        ActionMove(w, mp->x, mp->y);
}
 
 
/*
 * Here when our window gets focus
 */
void
do_focusin(GR_EVENT_GENERAL     *gp)
{
#if 0
        /* if the window receiving focus is scribble, remember last window*/
        if (gp->wid == w->win && gp->wid != 1)
                w->lastfocusid = gp->otherid;
#endif
}
 
 
/*
 * Here when an exposure event occurs.
 */
void
do_exposure(GR_EVENT_EXPOSURE   *ep)
{
        if (ep->wid == w->win)
                Redisplay(w);
}
 
 
/*
 * Here when a keyboard press or injection occurs.
 */
void
do_keystroke(GR_EVENT_KEYSTROKE *kp)
{
        if (bTextwin)
                char_out(kp->ch);
}
 
static void
char_del(GR_COORD x, GR_COORD y)
{
        xpos -= width;
        GrFillRect(wt, gctb, x+1, y /*- height*/ /*+ base*/, width, height);
}
 
static void
char_out(GR_CHAR ch)
{
        switch(ch) {
        case '\r':
        case '\n':
                xpos = 0;
                ypos += height;
                if(ypos >= TEXTWIN_HEIGHT - height) {
                        ypos -= height;
 
                        /* FIXME: changing FALSE to TRUE crashes nano-X*/
                        /* clear screen, no scroll*/
                        ypos = 0;
                        GrClearWindow(wt, GR_FALSE);
                }
                return;
        case '\007':                    /* bel*/
                return;
        case '\t':
                xpos += width;
                while((xpos/width) & 7)
                        char_out(' ');
                return;
        case '\b':                      /* assumes fixed width font!!*/
                if (xpos <= 0)
                        return;
                char_del(xpos, ypos);
                char_out(' ');
                char_del(xpos, ypos);
                return;
        }
        GrText(wt, gct, xpos+1, ypos, &ch, 1, GR_TFTOP);
        xpos += width;
 
        if (xpos >= TEXTWIN_WIDTH-width)
                char_out('\n');
}

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [demos/] [nxscribble/] [nxscribble.c] - Blame information for rev 174

Line No.	Rev	Author	Line
1	27	unneback	`/*`
2			`* Copyright (c) 2000 Greg Haerr <greg@censoft.com>`
3			`* Copyright (c) 2000 Century Software <embedded.centurysoftware.com>`
4			`*`
5			`* Scribble Handwriting Recognition for Nano-X!`
6			`*/`
7			`#include <stdio.h>`
8			`#include <stdlib.h>`
9			`#define MWINCLUDECOLORS`
10			`#include "nano-X.h"`
11			`#include "scrib.h"`
12
13			`#define TEXTWIN_WIDTH 200 /* text window width/height*/`
14			`#define TEXTWIN_HEIGHT 150`
15
16			`static ScribbleWidget w;`
17
18			`static GR_BOOL bTextwin = GR_FALSE;`
19			`static GR_WINDOW_ID wt = 0;`
20			`static GR_GC_ID gct = 0;`
21			`static GR_GC_ID gctb = 0;`
22			`static GR_COORD xpos = 0;`
23			`static GR_COORD ypos = 0;`
24			`static GR_SIZE width; /* width of character */`
25			`static GR_SIZE height; /* height of character */`
26			`static GR_SIZE base; /* height of baseline */`
27			`static void char_out(GR_CHAR ch);`
28			`static void char_del(GR_COORD x, GR_COORD y);`
29
30			`void do_buttondown(GR_EVENT_BUTTON *bp);`
31			`void do_buttonup(GR_EVENT_BUTTON *bp);`
32			`void do_motion(GR_EVENT_MOUSE *mp);`
33			`void do_focusin(GR_EVENT_GENERAL *gp);`
34			`void do_keystroke(GR_EVENT_KEYSTROKE *kp);`
35			`void do_exposure(GR_EVENT_EXPOSURE *ep);`
36
37			`int`
38			`main(int argc, char **argv)`
39			`{`
40			`int t = 1;`
41			`GR_EVENT event; /* current event */`
42
43			`while (t < argc) {`
44			`if (!strcmp("-t", argv[t])) {`
45			`bTextwin = GR_TRUE;`
46			`++t;`
47			`continue;`
48			`}`
49			`}`
50
51			`if (GrOpen() < 0) {`
52			`fprintf(stderr, "cannot open graphics\n");`
53			`exit(1);`
54			`}`
55
56			`if (bTextwin) {`
57			`/* create text output window for debugging*/`
58			`wt = GrNewWindow(GR_ROOT_WINDOW_ID, 50, 20,`
59			`TEXTWIN_WIDTH, TEXTWIN_HEIGHT, 5, BLACK, GREEN);`
60			`GrSelectEvents(wt,`
61			`GR_EVENT_MASK_CLOSE_REQ \| GR_EVENT_MASK_KEY_DOWN`
62			`\| GR_EVENT_MASK_EXPOSURE);`
63			`GrMapWindow(wt);`
64			`gct = GrNewGC();`
65			`GrSetGCForeground(gct, GREEN);`
66			`GrGetGCTextSize(gct, "A",1, GR_TFASCII, &width, &height, &base);`
67			`GrSetGCFont(gct, GrCreateFont(GR_FONT_OEM_FIXED, 0, NULL));`
68			`gctb = GrNewGC();`
69			`GrSetGCForeground(gctb, BLACK);`
70			`}`
71
72			`/* create scribble input window*/`
73			`w = create_scribble();`
74
75			`while (1) {`
76			`GrGetNextEvent(&event);`
77
78			`switch (event.type) {`
79			`case GR_EVENT_TYPE_BUTTON_DOWN:`
80			`do_buttondown(&event.button);`
81			`break;`
82
83			`case GR_EVENT_TYPE_BUTTON_UP:`
84			`do_buttonup(&event.button);`
85			`break;`
86
87			`case GR_EVENT_TYPE_MOUSE_POSITION:`
88			`case GR_EVENT_TYPE_MOUSE_MOTION:`
89			`do_motion(&event.mouse);`
90			`break;`
91
92			`case GR_EVENT_TYPE_FOCUS_IN:`
93			`do_focusin(&event.general);`
94			`break;`
95
96			`case GR_EVENT_TYPE_KEY_DOWN:`
97			`do_keystroke(&event.keystroke);`
98			`break;`
99
100			`case GR_EVENT_TYPE_EXPOSURE:`
101			`do_exposure(&event.exposure);`
102			`break;`
103
104			`case GR_EVENT_TYPE_CLOSE_REQ:`
105			`GrClose();`
106			`exit(0);`
107			`}`
108			`}`
109			`}`
110
111
112			`/*`
113			`* Here when a button is pressed.`
114			`*/`
115			`void`
116			`do_buttondown(GR_EVENT_BUTTON *bp)`
117			`{`
118			`ActionStart(w, bp->x, bp->y);`
119			`}`
120
121
122			`/*`
123			`* Here when a button is released.`
124			`*/`
125			`void`
126			`do_buttonup(GR_EVENT_BUTTON *bp)`
127			`{`
128			`ActionEnd(w, bp->x, bp->y);`
129			`}`
130
131
132			`/*`
133			`* Here when the mouse has a motion event.`
134			`*/`
135			`void`
136			`do_motion(GR_EVENT_MOUSE *mp)`
137			`{`
138			`ActionMove(w, mp->x, mp->y);`
139			`}`
140
141
142			`/*`
143			`* Here when our window gets focus`
144			`*/`
145			`void`
146			`do_focusin(GR_EVENT_GENERAL *gp)`
147			`{`
148			`#if 0`
149			`/* if the window receiving focus is scribble, remember last window*/`
150			`if (gp->wid == w->win && gp->wid != 1)`
151			`w->lastfocusid = gp->otherid;`
152			`#endif`
153			`}`
154
155
156			`/*`
157			`* Here when an exposure event occurs.`
158			`*/`
159			`void`
160			`do_exposure(GR_EVENT_EXPOSURE *ep)`
161			`{`
162			`if (ep->wid == w->win)`
163			`Redisplay(w);`
164			`}`
165
166
167			`/*`
168			`* Here when a keyboard press or injection occurs.`
169			`*/`
170			`void`
171			`do_keystroke(GR_EVENT_KEYSTROKE *kp)`
172			`{`
173			`if (bTextwin)`
174			`char_out(kp->ch);`
175			`}`
176
177			`static void`
178			`char_del(GR_COORD x, GR_COORD y)`
179			`{`
180			`xpos -= width;`
181			`GrFillRect(wt, gctb, x+1, y /- height/ /+ base/, width, height);`
182			`}`
183
184			`static void`
185			`char_out(GR_CHAR ch)`
186			`{`
187			`switch(ch) {`
188			`case '\r':`
189			`case '\n':`
190			`xpos = 0;`
191			`ypos += height;`
192			`if(ypos >= TEXTWIN_HEIGHT - height) {`
193			`ypos -= height;`
194
195			`/* FIXME: changing FALSE to TRUE crashes nano-X*/`
196			`/* clear screen, no scroll*/`
197			`ypos = 0;`
198			`GrClearWindow(wt, GR_FALSE);`
199			`}`
200			`return;`
201			`case '\007': /* bel*/`
202			`return;`
203			`case '\t':`
204			`xpos += width;`
205			`while((xpos/width) & 7)`
206			`char_out(' ');`
207			`return;`
208			`case '\b': /* assumes fixed width font!!*/`
209			`if (xpos <= 0)`
210			`return;`
211			`char_del(xpos, ypos);`
212			`char_out(' ');`
213			`char_del(xpos, ypos);`
214			`return;`
215			`}`
216			`GrText(wt, gct, xpos+1, ypos, &ch, 1, GR_TFTOP);`
217			`xpos += width;`
218
219			`if (xpos >= TEXTWIN_WIDTH-width)`
220			`char_out('\n');`
221			`}`