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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log


/*
 * Draw a crude map of the world using mini-X graphics on MINIX.
 * Converted from an Amiga program by Mike Groshart and Bob Dufford.
 * Author: David I. Bell
 *
 * ported to 16 bit systems by Greg Haerr
 */
#include <stdio.h>
#include <string.h>
#define MWINCLUDECOLORS
#include "nano-X.h"
 
#if defined(MSDOS) || defined(__ECOS)
#include <fcntl.h>
#endif
 
#if LINUX | DOS_DJGPP
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#endif
 
#ifndef O_BINARY
#define O_BINARY        0
#endif
 
#if defined(DOS_DJGPP) || defined(__ECOS)
#define MAPFILE "world.map"
#else
#define MAPFILE "demos/nanox/world.map"         /* was /usr/lib*/
#endif
 
#define SELECTBUTTON    GR_BUTTON_L
#define COORDBUTTON     GR_BUTTON_R
 
 
/*
 * Definitions to use fixed point in place of true floating point.
 */
typedef long    FLOAT;
 
#define SCALE   100             /* fixed point scaling factor */
 
#define FFMUL(a,b)      (((FLOAT)(a) * (b) + (SCALE / 2)) / SCALE)
#define FFDIV(a,b)      (((FLOAT)(a) * SCALE) / (b))
#define FIMUL(a,b)      ((FLOAT)(a) * (b))
#define FIDIV(a,b)      ((FLOAT)(a) / (b))
#define ITOF(a)         ((FLOAT)(a) * SCALE)
#define FTOI(a)         (((FLOAT)(a) + (SCALE / 2)) / SCALE)
 
 
#define QSPAN   (90L*60*SCALE)  /* equator to pole (90 degrees) */
#define HSPAN   (QSPAN*2)       /* pole to pole (180 degrees) */
#define WSPAN   (QSPAN*4)       /* around equator (360 degrees) */
 
#define ABS(n)  (((n) < 0) ? -(n) : (n))
 
 
/*
 * Structure of a point in the database file.
 */
typedef struct {
        short   Code;           /* type of point (see code_colors below) */
        short   Lat;            /* latitude in minutes */
        short   Lon;            /* longitude in minutes */
} MWPACKED DBPOINT;
 
#if BIGENDIAN
#define SHORT_SWAP(p) (p = ((p & 0xff) << 8) | ((p >> 8) & 0xff))
#define DBPOINT_CONVERT(p) (SHORT_SWAP(p->Code),SHORT_SWAP(p->Lat),SHORT_SWAP(p->Lon))
#else
#define DBPOINT_CONVERT(p)      ((void)p)
#endif
 
#define POINTSize       sizeof(DBPOINT)
#define PCount          128             /* number of points to read at once */
 
 
/*
 * The following variables are the scaling factors to be used when drawing
 * points.  However, they are larger than the true value by a factor of 60.
 * This is done because without real floating point, their true values are
 * too small to be accurate enough.  I cannot just increase the fixed point
 * precision because that causes overflows.  What a pain!
 */
static  FLOAT           X_Scale;
static  FLOAT           Y_Scale;
 
/*
 * Other variables.
 */
static  FLOAT           Latitude, Longitude;    /* current center of view */
static  FLOAT           zoom;           /* current zoom scaling factor */
 
static  FLOAT           latradius;      /* half of view of latitide */
static  FLOAT           longradius;     /* half of view of longitude */
static  FLOAT           viewlong;       /* amount of longitide in view */
static  FLOAT           viewlat;        /* amount of latitude in view */
 
static  GR_SIZE         mapwidth;       /* width of map in pixels */
static  GR_SIZE         mapheight;      /* height of map in pixels */
static  GR_COORD        mapxorig;       /* one half of map width */
static  GR_COORD        mapyorig;       /* one half of map height */
static  GR_COORD        selectx;        /* x position of current selection */
static  GR_COORD        selecty;        /* y position of current selection */
static  GR_COORD        selectptrx;     /* x position of pointer in selection */
static  GR_COORD        selectptry;     /* y position of pointer in selection */
static  GR_SIZE         selectwidth;    /* width of current selection */
static  GR_SIZE         selectheight;   /* height of current selection */
static  int             selectmode;     /* selection mode */
static  GR_BOOL         selectvisible;  /* TRUE if selection is visible on screen */
static  GR_SIZE         selectxscale;   /* x scaling factor for selection rectangle */
static  GR_SIZE         selectyscale;   /* y scaling factor for selection rectangle */
static  GR_BOOL         coordvisible;   /* TRUE if coordinates are visible on screen */
static  GR_BOOL         coordenabled;   /* TRUE if coordinate display is enabled */
static  GR_COORD        coordx;         /* x position of coordinates */
static  GR_COORD        coordy;         /* y position of coordinates */
static  GR_COORD        ptrx;           /* latest x position of pointer */
static  GR_COORD        ptry;           /* latest y position of pointer */
static  char            coordstring[32];        /* coordinate string */
 
static  GR_WINDOW_ID    mainwid;        /* main window id */
static  GR_WINDOW_ID    mapwid;         /* window id for map */
static  GR_GC_ID        mapgc;          /* GC used for drawing map */
static  GR_GC_ID        xorgc;          /* GC used for rubber banding */
static  GR_SIZE         COLS, ROWS;
 
 
/*
 * Current selection mode
 */
#define SELECT_NONE     0
#define SELECT_SCALE    1
#define SELECT_MOVE     2
 
/*
 * Order of color table (indexed by type of point):
 *      unused
 *      continents
 *      countries
 *      unused
 *      USA states
 *      islands
 *      lakes
 *      rivers
 */
static  GR_COLOR        code_colors[] = {
        BLACK, GREEN, RED, BLACK, BROWN, GREEN, BLUE, BLUE
};
 
 
static  void    load();
static  void    setzoom();
static  void    checkevent();
static  void    doexposure();
static  void    dobuttondown();
static  void    dobuttonup();
static  void    doposition();
static  void    dokeydown();
static  void    showselection();
static  void    showcoords();
static  void    mintostr();
 
 
#ifdef __ECOS
int
world_main(int argc, char **argv)
#else
int
main(int argc, char **argv)
#endif
{
        GR_SCREEN_INFO  si;
        GR_WM_PROPERTIES props;
 
        if (GrOpen() < 0) {
                fprintf(stderr, "Cannot open graphics\n");
                exit(1);
        }
 
        GrReqShmCmds(65536); /* Test by Morten Rolland for shm support */
 
        GrGetScreenInfo(&si);
#ifdef __ECOS
/* 240x320 screen*/
COLS = si.cols - 10;
ROWS = si.rows - 40;
#else
COLS = si.cols - 40;
ROWS = si.rows - 80;
#endif
 
        mainwid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, COLS, ROWS,
                0, BLACK, BLACK);
 
        /* set title */
        props.flags = GR_WM_FLAGS_TITLE | GR_WM_FLAGS_PROPS;
        props.props = GR_WM_PROPS_BORDER | GR_WM_PROPS_CAPTION;
        props.title = "NanoX World Map";
        GrSetWMProperties(mainwid, &props);
 
        mapwidth = COLS - 2;
        mapheight = ROWS - 2;
        mapxorig = mapwidth / 2;
        mapyorig = mapheight / 2;
        selectxscale = 4;
        selectyscale = 3;
        coordx = 0;
        coordy = ROWS - 1;
        mapwid = GrNewWindow(mainwid, 1, 1, mapwidth, mapheight,
#if 0
                1, BLACK, WHITE);
#else
                1, LTGRAY, BLACK);
#endif
        GrSelectEvents(mainwid, GR_EVENT_MASK_CLOSE_REQ);
        GrSelectEvents(mapwid, GR_EVENT_MASK_EXPOSURE |
                GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_BUTTON_UP |
                GR_EVENT_MASK_MOUSE_POSITION | GR_EVENT_MASK_KEY_DOWN);
 
        GrMapWindow(mainwid);
        GrMapWindow(mapwid);
 
        mapgc = GrNewGC();
        xorgc = GrNewGC();
        GrSetGCMode(xorgc, GR_MODE_XOR);
 
        Longitude = ITOF(0);
        Latitude = ITOF(0);
        setzoom(ITOF(1));
 
        while (1)
                checkevent();
}
 
 
static void
checkevent()
{
        GR_EVENT        event;
 
        GrGetNextEvent(&event);
        switch (event.type) {
                case GR_EVENT_TYPE_EXPOSURE:
                        doexposure(&event.exposure);
                        break;
                case GR_EVENT_TYPE_BUTTON_DOWN:
                        dobuttondown(&event.button);
                        break;
                case GR_EVENT_TYPE_BUTTON_UP:
                        dobuttonup(&event.button);
                        break;
                case GR_EVENT_TYPE_MOUSE_POSITION:
                        doposition(&event.mouse);
                        break;
                case GR_EVENT_TYPE_KEY_DOWN:
                        dokeydown(&event.keystroke);
                        break;
                case GR_EVENT_TYPE_CLOSE_REQ:
                        GrClose();
                        exit(0);
        }
}
 
 
static void
doexposure(ep)
        GR_EVENT_EXPOSURE       *ep;
{
        if (ep->wid != mapwid)
                return;
 
        /* removed: helps with blink with nanowm*/
        /*GrClearWindow(mapwid, GR_FALSE);*/
        selectvisible = GR_FALSE;
        coordvisible = GR_FALSE;
        load(MAPFILE);
        showselection(GR_TRUE);
        showcoords(GR_TRUE);
}
 
 
static void
dobuttondown(bp)
        GR_EVENT_BUTTON *bp;
{
        if (bp->wid != mapwid)
                return;
 
        if (bp->changebuttons & SELECTBUTTON) {
                showselection(GR_FALSE);
                selectx = bp->x;
                selecty = bp->y;
                selectptrx = bp->x;
                selectptry = bp->y;
                selectwidth = 0;
                selectheight = 0;
                selectmode = SELECT_SCALE;
                showselection(GR_TRUE);
        }
 
        if (bp->changebuttons & COORDBUTTON) {
                showcoords(GR_FALSE);
                ptrx = bp->x;
                ptry = bp->y;
                coordenabled = GR_TRUE;
                showcoords(GR_TRUE);
        }
}
 
 
static void
dobuttonup(bp)
        GR_EVENT_BUTTON *bp;
{
        if (bp->wid != mapwid)
                return;
 
        if (bp->changebuttons & COORDBUTTON) {
                showcoords(GR_FALSE);
                coordenabled = GR_FALSE;
        }
 
        if (bp->changebuttons & SELECTBUTTON) {
                showselection(GR_FALSE);
                if (selectmode == SELECT_NONE)
                        return;
                selectmode = SELECT_NONE;
                if (selectwidth <= 0)
                        return;
                Longitude +=
                        FIDIV(FIMUL(viewlong, selectx - mapxorig), mapwidth);
                Latitude -=
                        FIDIV(FIMUL(viewlat, selecty - mapyorig), mapheight);
                setzoom(FIDIV(FIMUL(zoom, mapwidth), selectwidth));
                GrClearWindow(mapwid, GR_TRUE);
        }
}
 
 
static void
doposition(mp)
        GR_EVENT_MOUSE  *mp;
{
        GR_SIZE temp;
 
        if (mp->wid != mapwid)
                return;
 
        if (coordenabled) {
                showcoords(GR_FALSE);
                ptrx = mp->x;
                ptry = mp->y;
                showcoords(GR_TRUE);
        }
 
        showselection(GR_FALSE);
        switch (selectmode) {
                case SELECT_SCALE:
                        selectwidth = ABS(mp->x - selectx) * 2 + 1;
                        selectheight = ABS(mp->y - selecty) * 2 + 1;
                        temp = ((long) selectwidth) * selectyscale
                                / selectxscale;
                        if (selectheight < temp)
                                selectheight = temp;
                        temp = ((long) selectheight) * selectxscale
                                / selectyscale;
                        if (selectwidth < temp)
                                selectwidth = temp;
                        break;
 
                case SELECT_MOVE:
                        selectx += (mp->x - selectptrx);
                        selecty += (mp->y - selectptry);
                        break;
        }
 
        selectptrx = mp->x;
        selectptry = mp->y;
        showselection(GR_TRUE);
}
 
 
static void
dokeydown(kp)
        GR_EVENT_KEYSTROKE      *kp;
{
        if (kp->wid != mapwid)
                return;
 
        if (selectmode != SELECT_NONE) {
                switch (kp->ch) {
                        case 's':       /* scale selection */
                                selectmode = SELECT_SCALE;
                                break;
 
                        case 'm':       /* move selection */
                                selectmode = SELECT_MOVE;
                                break;
 
                        case '\033':    /* cancel selection */
                                showselection(GR_FALSE);
                                selectmode = SELECT_NONE;
                                break;
                }
                return;
        }
 
        switch (kp->ch) {
                case 'q':               /* quit */
                case 'Q':
                        GrClose();
                        exit(0);
 
                case 't':               /* redraw total map */
                        Longitude = ITOF(0);
                        Latitude = ITOF(0);
                        setzoom(ITOF(1));
                        GrClearWindow(mapwid, GR_TRUE);
        }
}
 
 
/*
 * Draw or erase the current selection if any is defined.
 * The selection is a rectangle centered on a specified point, and with a
 * specified width and height.  Drawing and erasing the selection are the
 * same drawing operation because of the XOR operation.
 */
static void
showselection(show)
        GR_BOOL show;           /* TRUE if show the selection */
{
        if ((show == 0) == (selectvisible == 0))
                return;
        if (selectmode == SELECT_NONE)
                return;
        GrRect(mapwid, xorgc, selectx - selectwidth / 2,
                selecty - selectheight / 2, selectwidth, selectheight);
        selectvisible = show;
}
 
 
/*
 * Draw or erase the coordinate string of the current pointer position.
 * Both of these are the same operation because of the XOR operation.
 */
static void
showcoords(show)
        GR_BOOL show;           /* TRUE if show the coordinates */
{
        long    curlong;
        long    curlat;
        FLOAT   ptrlat;
        FLOAT   ptrlong;
 
        if (((show == 0) == (coordvisible == 0)) || !coordenabled)
                return;
 
        if (show) {
                ptrlat = FIDIV(FIMUL(viewlat, ptry), mapheight - 1);
                ptrlong = FIDIV(FIMUL(viewlong, ptrx), mapwidth - 1);
 
                curlat = FTOI(Latitude + latradius - ptrlat);
                curlong = FTOI(Longitude - longradius + ptrlong);
 
                if (curlong > 180*60)
                        curlong -= 360*60;
                if (curlong < -180*60)
                        curlong += 360*60;
 
                mintostr(coordstring, curlong);
                strcat(coordstring, "  ");
                mintostr(coordstring + strlen(coordstring), curlat);
        }
 
        GrText(mapwid, xorgc, coordx, coordy, coordstring, -1, GR_TFBOTTOM);
        coordvisible = show;
}
 
 
/*
 * Convert minutes to a string of the form "ddd'mm" and store it
 * into the indicated buffer.
 */
static void
mintostr(buf, minutes)
        char    *buf;
        long    minutes;
{
        if (minutes < 0) {
                minutes = -minutes;
                *buf++ = '-';
        }
        sprintf(buf, "%ld'%02ld", (long)(minutes / 60), (long)(minutes % 60));
}
 
 
#if 0
/*
 * Convert "ddd'mm" to mins
 */
static long
degtomin(s)
        char    *s;
{
        int     deg, minutes;
        char    str[10],*strchr(),*cp;
 
        strcpy(str,s);
        if (cp = strchr(str,'\047')) {
                *cp = '\0';
                minutes = atoi(++cp);
        } else
                minutes = 0;
        if ((deg = atoi(str)) < 0)
                minutes = -minutes;
        return(deg * 60 + minutes);
}
#endif
 
 
/*
 * Set the scale factors for the given zoom factor.
 * The factors 3 and 4 are here to compensate for the screen aspect ratio.
 */
static void
setzoom(newzoom)
        FLOAT   newzoom;
{
        zoom = newzoom;
 
        Y_Scale = FIDIV(FIMUL(zoom, mapheight * 3), 180 * 4);
        X_Scale = FIDIV(FIMUL(zoom, mapwidth), 360);
 
        viewlong = FFDIV(WSPAN, zoom);
        viewlat = FFDIV(HSPAN * 4 / 3, zoom);
        longradius = FIDIV(viewlong, 2);
        latradius = FIDIV(viewlat, 2);
}
 
 
/*
 * Read the database file and draw the world.
 */
static void
load(fn)
        char    *fn;
{
        register DBPOINT        *pp;
        DBPOINT         *pend;
        FLOAT           x, y, LonPrv, LatPrv;
        long            oldlong = 0L;
        GR_COORD        xnew, ynew;
        GR_COORD        xold = 0, yold = 0;
        GR_BOOL         is_out;
        GR_BOOL         was_out;
        GR_BOOL         newseg = GR_FALSE;
        GR_COLOR        oldcolor;
        GR_COLOR        newcolor;
        int             n;
        int             fh;
        DBPOINT         p[PCount];
 
        LonPrv = ITOF(0);
        LatPrv = ITOF(0);
        oldcolor = -1;
        is_out = GR_FALSE;
        was_out = GR_FALSE;
 
        fh = open(fn, O_BINARY | O_RDONLY);
        if (fh < 0) {
                GrClose();
                fprintf(stderr, "Cannot open %s\n", fn);
                exit(1);
        }
 
        while ((n = read(fh, p, PCount * POINTSize)) > 0) {
                for (pp = p,pend = p + n/POINTSize; pp < pend; pp++)
                {
                        DBPOINT_CONVERT(pp);
                        /* do displacement */
                        x = ITOF(pp->Lon) - Longitude;
                        y = ITOF(pp->Lat) - Latitude;
 
                        /* wrap around for East-West */
                        if (x < -HSPAN)
                                x += WSPAN;
                        if (x > HSPAN)
                                x -= WSPAN;
 
                        if (pp->Code > 5) {
                                newcolor = code_colors[pp->Code / 1000];
                                if (newcolor != oldcolor) {
                                        oldcolor = newcolor;
                                        GrSetGCForeground(mapgc, oldcolor);
                                }
                                newseg = GR_TRUE;
                        }
 
                        if (oldcolor == BLACK)
                                goto go_on;
 
                        /* ignore points outside magnified area */
                        if ((x < -longradius || x > longradius ||
                                y < -latradius || y > latradius))
                        {
                                is_out = 1;
                                if (was_out) {          /* out to out */
                                        LonPrv = x;
                                        LatPrv = y;
                                        goto go_on;
                                }
 
                                /* in to out */
                                xold = mapxorig + FTOI(FFMUL(LonPrv, X_Scale)) / 60;
                                yold = mapyorig - FTOI(FFMUL(LatPrv, Y_Scale)) / 60;
                        } else {                        /* out to in */
                                is_out = 0;
                                if (was_out) {
                                        xold = mapxorig +
                                                FTOI(FFMUL(LonPrv, X_Scale)) / 60;
                                        yold = mapyorig -
                                                FTOI(FFMUL(LatPrv, Y_Scale)) / 60;
                                }
                                /* in to in */
                        }
                        LonPrv = x;
                        LatPrv = y;
 
                        /* scale points w/in area to interlace screen */
                        xnew = mapxorig + FTOI(FFMUL(x, X_Scale)) / 60;
                        ynew = mapyorig - FTOI(FFMUL(y, Y_Scale)) / 60;
 
                        /* if new segment, move to place */
                        if (newseg || ABS(oldlong - pp->Lon) > 180*60) {
                                xold = xnew;
                                yold = ynew;
                        }
                        oldlong = pp->Lon;
 
                        GrLine(mapwid, mapgc, xold, yold, xnew, ynew);
                        xold = xnew;
                        yold = ynew;
go_on:
                        was_out = is_out;
                        newseg = GR_FALSE;
                }
        }
        close(fh);
}
 
/* END CODE */

Browse

Tools

Subversion Repositories openrisc

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

Line No.	Rev	Author	Line
1	27	unneback	`/*`
2			`* Draw a crude map of the world using mini-X graphics on MINIX.`
3			`* Converted from an Amiga program by Mike Groshart and Bob Dufford.`
4			`* Author: David I. Bell`
5			`*`
6			`* ported to 16 bit systems by Greg Haerr`
7			`*/`
8			`#include <stdio.h>`
9			`#include <string.h>`
10			`#define MWINCLUDECOLORS`
11			`#include "nano-X.h"`
12
13			`#if defined(MSDOS) \|\| defined(__ECOS)`
14			`#include <fcntl.h>`
15			`#endif`
16
17			`#if LINUX \| DOS_DJGPP`
18			`#include <sys/types.h>`
19			`#include <sys/stat.h>`
20			`#include <fcntl.h>`
21			`#include <unistd.h>`
22			`#endif`
23
24			`#ifndef O_BINARY`
25			`#define O_BINARY 0`
26			`#endif`
27
28			`#if defined(DOS_DJGPP) \|\| defined(__ECOS)`
29			`#define MAPFILE "world.map"`
30			`#else`
31			`#define MAPFILE "demos/nanox/world.map" /* was /usr/lib*/`
32			`#endif`
33
34			`#define SELECTBUTTON GR_BUTTON_L`
35			`#define COORDBUTTON GR_BUTTON_R`
36
37
38			`/*`
39			`* Definitions to use fixed point in place of true floating point.`
40			`*/`
41			`typedef long FLOAT;`
42
43			`#define SCALE 100 /* fixed point scaling factor */`
44
45			`#define FFMUL(a,b) (((FLOAT)(a) * (b) + (SCALE / 2)) / SCALE)`
46			`#define FFDIV(a,b) (((FLOAT)(a) * SCALE) / (b))`
47			`#define FIMUL(a,b) ((FLOAT)(a) * (b))`
48			`#define FIDIV(a,b) ((FLOAT)(a) / (b))`
49			`#define ITOF(a) ((FLOAT)(a) * SCALE)`
50			`#define FTOI(a) (((FLOAT)(a) + (SCALE / 2)) / SCALE)`
51
52
53			`#define QSPAN (90L60SCALE) /* equator to pole (90 degrees) */`
54			`#define HSPAN (QSPAN2) / pole to pole (180 degrees) */`
55			`#define WSPAN (QSPAN4) / around equator (360 degrees) */`
56
57			`#define ABS(n) (((n) < 0) ? -(n) : (n))`
58
59
60			`/*`
61			`* Structure of a point in the database file.`
62			`*/`
63			`typedef struct {`
64			`short Code; /* type of point (see code_colors below) */`
65			`short Lat; /* latitude in minutes */`
66			`short Lon; /* longitude in minutes */`
67			`} MWPACKED DBPOINT;`
68
69			`#if BIGENDIAN`
70			`#define SHORT_SWAP(p) (p = ((p & 0xff) << 8) \| ((p >> 8) & 0xff))`
71			`#define DBPOINT_CONVERT(p) (SHORT_SWAP(p->Code),SHORT_SWAP(p->Lat),SHORT_SWAP(p->Lon))`
72			`#else`
73			`#define DBPOINT_CONVERT(p) ((void)p)`
74			`#endif`
75
76			`#define POINTSize sizeof(DBPOINT)`
77			`#define PCount 128 /* number of points to read at once */`
78
79
80			`/*`
81			`* The following variables are the scaling factors to be used when drawing`
82			`* points. However, they are larger than the true value by a factor of 60.`
83			`* This is done because without real floating point, their true values are`
84			`* too small to be accurate enough. I cannot just increase the fixed point`
85			`* precision because that causes overflows. What a pain!`
86			`*/`
87			`static FLOAT X_Scale;`
88			`static FLOAT Y_Scale;`
89
90			`/*`
91			`* Other variables.`
92			`*/`
93			`static FLOAT Latitude, Longitude; /* current center of view */`
94			`static FLOAT zoom; /* current zoom scaling factor */`
95
96			`static FLOAT latradius; /* half of view of latitide */`
97			`static FLOAT longradius; /* half of view of longitude */`
98			`static FLOAT viewlong; /* amount of longitide in view */`
99			`static FLOAT viewlat; /* amount of latitude in view */`
100
101			`static GR_SIZE mapwidth; /* width of map in pixels */`
102			`static GR_SIZE mapheight; /* height of map in pixels */`
103			`static GR_COORD mapxorig; /* one half of map width */`
104			`static GR_COORD mapyorig; /* one half of map height */`
105			`static GR_COORD selectx; /* x position of current selection */`
106			`static GR_COORD selecty; /* y position of current selection */`
107			`static GR_COORD selectptrx; /* x position of pointer in selection */`
108			`static GR_COORD selectptry; /* y position of pointer in selection */`
109			`static GR_SIZE selectwidth; /* width of current selection */`
110			`static GR_SIZE selectheight; /* height of current selection */`
111			`static int selectmode; /* selection mode */`
112			`static GR_BOOL selectvisible; /* TRUE if selection is visible on screen */`
113			`static GR_SIZE selectxscale; /* x scaling factor for selection rectangle */`
114			`static GR_SIZE selectyscale; /* y scaling factor for selection rectangle */`
115			`static GR_BOOL coordvisible; /* TRUE if coordinates are visible on screen */`
116			`static GR_BOOL coordenabled; /* TRUE if coordinate display is enabled */`
117			`static GR_COORD coordx; /* x position of coordinates */`
118			`static GR_COORD coordy; /* y position of coordinates */`
119			`static GR_COORD ptrx; /* latest x position of pointer */`
120			`static GR_COORD ptry; /* latest y position of pointer */`
121			`static char coordstring[32]; /* coordinate string */`
122
123			`static GR_WINDOW_ID mainwid; /* main window id */`
124			`static GR_WINDOW_ID mapwid; /* window id for map */`
125			`static GR_GC_ID mapgc; /* GC used for drawing map */`
126			`static GR_GC_ID xorgc; /* GC used for rubber banding */`
127			`static GR_SIZE COLS, ROWS;`
128
129
130			`/*`
131			`* Current selection mode`
132			`*/`
133			`#define SELECT_NONE 0`
134			`#define SELECT_SCALE 1`
135			`#define SELECT_MOVE 2`
136
137			`/*`
138			`* Order of color table (indexed by type of point):`
139			`* unused`
140			`* continents`
141			`* countries`
142			`* unused`
143			`* USA states`
144			`* islands`
145			`* lakes`
146			`* rivers`
147			`*/`
148			`static GR_COLOR code_colors[] = {`
149			`BLACK, GREEN, RED, BLACK, BROWN, GREEN, BLUE, BLUE`
150			`};`
151
152
153			`static void load();`
154			`static void setzoom();`
155			`static void checkevent();`
156			`static void doexposure();`
157			`static void dobuttondown();`
158			`static void dobuttonup();`
159			`static void doposition();`
160			`static void dokeydown();`
161			`static void showselection();`
162			`static void showcoords();`
163			`static void mintostr();`
164
165
166			`#ifdef __ECOS`
167			`int`
168			`world_main(int argc, char **argv)`
169			`#else`
170			`int`
171			`main(int argc, char **argv)`
172			`#endif`
173			`{`
174			`GR_SCREEN_INFO si;`
175			`GR_WM_PROPERTIES props;`
176
177			`if (GrOpen() < 0) {`
178			`fprintf(stderr, "Cannot open graphics\n");`
179			`exit(1);`
180			`}`
181
182			`GrReqShmCmds(65536); /* Test by Morten Rolland for shm support */`
183
184			`GrGetScreenInfo(&si);`
185			`#ifdef __ECOS`
186			`/* 240x320 screen*/`
187			`COLS = si.cols - 10;`
188			`ROWS = si.rows - 40;`
189			`#else`
190			`COLS = si.cols - 40;`
191			`ROWS = si.rows - 80;`
192			`#endif`
193
194			`mainwid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, COLS, ROWS,`
195			`0, BLACK, BLACK);`
196
197			`/* set title */`
198			`props.flags = GR_WM_FLAGS_TITLE \| GR_WM_FLAGS_PROPS;`
199			`props.props = GR_WM_PROPS_BORDER \| GR_WM_PROPS_CAPTION;`
200			`props.title = "NanoX World Map";`
201			`GrSetWMProperties(mainwid, &props);`
202
203			`mapwidth = COLS - 2;`
204			`mapheight = ROWS - 2;`
205			`mapxorig = mapwidth / 2;`
206			`mapyorig = mapheight / 2;`
207			`selectxscale = 4;`
208			`selectyscale = 3;`
209			`coordx = 0;`
210			`coordy = ROWS - 1;`
211			`mapwid = GrNewWindow(mainwid, 1, 1, mapwidth, mapheight,`
212			`#if 0`
213			`1, BLACK, WHITE);`
214			`#else`
215			`1, LTGRAY, BLACK);`
216			`#endif`
217			`GrSelectEvents(mainwid, GR_EVENT_MASK_CLOSE_REQ);`
218			`GrSelectEvents(mapwid, GR_EVENT_MASK_EXPOSURE \|`
219			`GR_EVENT_MASK_BUTTON_DOWN \| GR_EVENT_MASK_BUTTON_UP \|`
220			`GR_EVENT_MASK_MOUSE_POSITION \| GR_EVENT_MASK_KEY_DOWN);`
221
222			`GrMapWindow(mainwid);`
223			`GrMapWindow(mapwid);`
224
225			`mapgc = GrNewGC();`
226			`xorgc = GrNewGC();`
227			`GrSetGCMode(xorgc, GR_MODE_XOR);`
228
229			`Longitude = ITOF(0);`
230			`Latitude = ITOF(0);`
231			`setzoom(ITOF(1));`
232
233			`while (1)`
234			`checkevent();`
235			`}`
236
237
238			`static void`
239			`checkevent()`
240			`{`
241			`GR_EVENT event;`
242
243			`GrGetNextEvent(&event);`
244			`switch (event.type) {`
245			`case GR_EVENT_TYPE_EXPOSURE:`
246			`doexposure(&event.exposure);`
247			`break;`
248			`case GR_EVENT_TYPE_BUTTON_DOWN:`
249			`dobuttondown(&event.button);`
250			`break;`
251			`case GR_EVENT_TYPE_BUTTON_UP:`
252			`dobuttonup(&event.button);`
253			`break;`
254			`case GR_EVENT_TYPE_MOUSE_POSITION:`
255			`doposition(&event.mouse);`
256			`break;`
257			`case GR_EVENT_TYPE_KEY_DOWN:`
258			`dokeydown(&event.keystroke);`
259			`break;`
260			`case GR_EVENT_TYPE_CLOSE_REQ:`
261			`GrClose();`
262			`exit(0);`
263			`}`
264			`}`
265
266
267			`static void`
268			`doexposure(ep)`
269			`GR_EVENT_EXPOSURE *ep;`
270			`{`
271			`if (ep->wid != mapwid)`
272			`return;`
273
274			`/* removed: helps with blink with nanowm*/`
275			`/GrClearWindow(mapwid, GR_FALSE);/`
276			`selectvisible = GR_FALSE;`
277			`coordvisible = GR_FALSE;`
278			`load(MAPFILE);`
279			`showselection(GR_TRUE);`
280			`showcoords(GR_TRUE);`
281			`}`
282
283
284			`static void`
285			`dobuttondown(bp)`
286			`GR_EVENT_BUTTON *bp;`
287			`{`
288			`if (bp->wid != mapwid)`
289			`return;`
290
291			`if (bp->changebuttons & SELECTBUTTON) {`
292			`showselection(GR_FALSE);`
293			`selectx = bp->x;`
294			`selecty = bp->y;`
295			`selectptrx = bp->x;`
296			`selectptry = bp->y;`
297			`selectwidth = 0;`
298			`selectheight = 0;`
299			`selectmode = SELECT_SCALE;`
300			`showselection(GR_TRUE);`
301			`}`
302
303			`if (bp->changebuttons & COORDBUTTON) {`
304			`showcoords(GR_FALSE);`
305			`ptrx = bp->x;`
306			`ptry = bp->y;`
307			`coordenabled = GR_TRUE;`
308			`showcoords(GR_TRUE);`
309			`}`
310			`}`
311
312
313			`static void`
314			`dobuttonup(bp)`
315			`GR_EVENT_BUTTON *bp;`
316			`{`
317			`if (bp->wid != mapwid)`
318			`return;`
319
320			`if (bp->changebuttons & COORDBUTTON) {`
321			`showcoords(GR_FALSE);`
322			`coordenabled = GR_FALSE;`
323			`}`
324
325			`if (bp->changebuttons & SELECTBUTTON) {`
326			`showselection(GR_FALSE);`
327			`if (selectmode == SELECT_NONE)`
328			`return;`
329			`selectmode = SELECT_NONE;`
330			`if (selectwidth <= 0)`
331			`return;`
332			`Longitude +=`
333			`FIDIV(FIMUL(viewlong, selectx - mapxorig), mapwidth);`
334			`Latitude -=`
335			`FIDIV(FIMUL(viewlat, selecty - mapyorig), mapheight);`
336			`setzoom(FIDIV(FIMUL(zoom, mapwidth), selectwidth));`
337			`GrClearWindow(mapwid, GR_TRUE);`
338			`}`
339			`}`
340
341
342			`static void`
343			`doposition(mp)`
344			`GR_EVENT_MOUSE *mp;`
345			`{`
346			`GR_SIZE temp;`
347
348			`if (mp->wid != mapwid)`
349			`return;`
350
351			`if (coordenabled) {`
352			`showcoords(GR_FALSE);`
353			`ptrx = mp->x;`
354			`ptry = mp->y;`
355			`showcoords(GR_TRUE);`
356			`}`
357
358			`showselection(GR_FALSE);`
359			`switch (selectmode) {`
360			`case SELECT_SCALE:`
361			`selectwidth = ABS(mp->x - selectx) * 2 + 1;`
362			`selectheight = ABS(mp->y - selecty) * 2 + 1;`
363			`temp = ((long) selectwidth) * selectyscale`
364			`/ selectxscale;`
365			`if (selectheight < temp)`
366			`selectheight = temp;`
367			`temp = ((long) selectheight) * selectxscale`
368			`/ selectyscale;`
369			`if (selectwidth < temp)`
370			`selectwidth = temp;`
371			`break;`
372
373			`case SELECT_MOVE:`
374			`selectx += (mp->x - selectptrx);`
375			`selecty += (mp->y - selectptry);`
376			`break;`
377			`}`
378
379			`selectptrx = mp->x;`
380			`selectptry = mp->y;`
381			`showselection(GR_TRUE);`
382			`}`
383
384
385			`static void`
386			`dokeydown(kp)`
387			`GR_EVENT_KEYSTROKE *kp;`
388			`{`
389			`if (kp->wid != mapwid)`
390			`return;`
391
392			`if (selectmode != SELECT_NONE) {`
393			`switch (kp->ch) {`
394			`case 's': /* scale selection */`
395			`selectmode = SELECT_SCALE;`
396			`break;`
397
398			`case 'm': /* move selection */`
399			`selectmode = SELECT_MOVE;`
400			`break;`
401
402			`case '\033': /* cancel selection */`
403			`showselection(GR_FALSE);`
404			`selectmode = SELECT_NONE;`
405			`break;`
406			`}`
407			`return;`
408			`}`
409
410			`switch (kp->ch) {`
411			`case 'q': /* quit */`
412			`case 'Q':`
413			`GrClose();`
414			`exit(0);`
415
416			`case 't': /* redraw total map */`
417			`Longitude = ITOF(0);`
418			`Latitude = ITOF(0);`
419			`setzoom(ITOF(1));`
420			`GrClearWindow(mapwid, GR_TRUE);`
421			`}`
422			`}`
423
424
425			`/*`
426			`* Draw or erase the current selection if any is defined.`
427			`* The selection is a rectangle centered on a specified point, and with a`
428			`* specified width and height. Drawing and erasing the selection are the`
429			`* same drawing operation because of the XOR operation.`
430			`*/`
431			`static void`
432			`showselection(show)`
433			`GR_BOOL show; /* TRUE if show the selection */`
434			`{`
435			`if ((show == 0) == (selectvisible == 0))`
436			`return;`
437			`if (selectmode == SELECT_NONE)`
438			`return;`
439			`GrRect(mapwid, xorgc, selectx - selectwidth / 2,`
440			`selecty - selectheight / 2, selectwidth, selectheight);`
441			`selectvisible = show;`
442			`}`
443
444
445			`/*`
446			`* Draw or erase the coordinate string of the current pointer position.`
447			`* Both of these are the same operation because of the XOR operation.`
448			`*/`
449			`static void`
450			`showcoords(show)`
451			`GR_BOOL show; /* TRUE if show the coordinates */`
452			`{`
453			`long curlong;`
454			`long curlat;`
455			`FLOAT ptrlat;`
456			`FLOAT ptrlong;`
457
458			`if (((show == 0) == (coordvisible == 0)) \|\| !coordenabled)`
459			`return;`
460
461			`if (show) {`
462			`ptrlat = FIDIV(FIMUL(viewlat, ptry), mapheight - 1);`
463			`ptrlong = FIDIV(FIMUL(viewlong, ptrx), mapwidth - 1);`
464
465			`curlat = FTOI(Latitude + latradius - ptrlat);`
466			`curlong = FTOI(Longitude - longradius + ptrlong);`
467
468			`if (curlong > 180*60)`
469			`curlong -= 360*60;`
470			`if (curlong < -180*60)`
471			`curlong += 360*60;`
472
473			`mintostr(coordstring, curlong);`
474			`strcat(coordstring, " ");`
475			`mintostr(coordstring + strlen(coordstring), curlat);`
476			`}`
477
478			`GrText(mapwid, xorgc, coordx, coordy, coordstring, -1, GR_TFBOTTOM);`
479			`coordvisible = show;`
480			`}`
481
482
483			`/*`
484			`* Convert minutes to a string of the form "ddd'mm" and store it`
485			`* into the indicated buffer.`
486			`*/`
487			`static void`
488			`mintostr(buf, minutes)`
489			`char *buf;`
490			`long minutes;`
491			`{`
492			`if (minutes < 0) {`
493			`minutes = -minutes;`
494			`*buf++ = '-';`
495			`}`
496			`sprintf(buf, "%ld'%02ld", (long)(minutes / 60), (long)(minutes % 60));`
497			`}`
498
499
500			`#if 0`
501			`/*`
502			`* Convert "ddd'mm" to mins`
503			`*/`
504			`static long`
505			`degtomin(s)`
506			`char *s;`
507			`{`
508			`int deg, minutes;`
509			`char str[10],strchr(),cp;`
510
511			`strcpy(str,s);`
512			`if (cp = strchr(str,'\047')) {`
513			`*cp = '\0';`
514			`minutes = atoi(++cp);`
515			`} else`
516			`minutes = 0;`
517			`if ((deg = atoi(str)) < 0)`
518			`minutes = -minutes;`
519			`return(deg * 60 + minutes);`
520			`}`
521			`#endif`
522
523
524			`/*`
525			`* Set the scale factors for the given zoom factor.`
526			`* The factors 3 and 4 are here to compensate for the screen aspect ratio.`
527			`*/`
528			`static void`
529			`setzoom(newzoom)`
530			`FLOAT newzoom;`
531			`{`
532			`zoom = newzoom;`
533
534			`Y_Scale = FIDIV(FIMUL(zoom, mapheight * 3), 180 * 4);`
535			`X_Scale = FIDIV(FIMUL(zoom, mapwidth), 360);`
536
537			`viewlong = FFDIV(WSPAN, zoom);`
538			`viewlat = FFDIV(HSPAN * 4 / 3, zoom);`
539			`longradius = FIDIV(viewlong, 2);`
540			`latradius = FIDIV(viewlat, 2);`
541			`}`
542
543
544			`/*`
545			`* Read the database file and draw the world.`
546			`*/`
547			`static void`
548			`load(fn)`
549			`char *fn;`
550			`{`
551			`register DBPOINT *pp;`
552			`DBPOINT *pend;`
553			`FLOAT x, y, LonPrv, LatPrv;`
554			`long oldlong = 0L;`
555			`GR_COORD xnew, ynew;`
556			`GR_COORD xold = 0, yold = 0;`
557			`GR_BOOL is_out;`
558			`GR_BOOL was_out;`
559			`GR_BOOL newseg = GR_FALSE;`
560			`GR_COLOR oldcolor;`
561			`GR_COLOR newcolor;`
562			`int n;`
563			`int fh;`
564			`DBPOINT p[PCount];`
565
566			`LonPrv = ITOF(0);`
567			`LatPrv = ITOF(0);`
568			`oldcolor = -1;`
569			`is_out = GR_FALSE;`
570			`was_out = GR_FALSE;`
571
572			`fh = open(fn, O_BINARY \| O_RDONLY);`
573			`if (fh < 0) {`
574			`GrClose();`
575			`fprintf(stderr, "Cannot open %s\n", fn);`
576			`exit(1);`
577			`}`
578
579			`while ((n = read(fh, p, PCount * POINTSize)) > 0) {`
580			`for (pp = p,pend = p + n/POINTSize; pp < pend; pp++)`
581			`{`
582			`DBPOINT_CONVERT(pp);`
583			`/* do displacement */`
584			`x = ITOF(pp->Lon) - Longitude;`
585			`y = ITOF(pp->Lat) - Latitude;`
586
587			`/* wrap around for East-West */`
588			`if (x < -HSPAN)`
589			`x += WSPAN;`
590			`if (x > HSPAN)`
591			`x -= WSPAN;`
592
593			`if (pp->Code > 5) {`
594			`newcolor = code_colors[pp->Code / 1000];`
595			`if (newcolor != oldcolor) {`
596			`oldcolor = newcolor;`
597			`GrSetGCForeground(mapgc, oldcolor);`
598			`}`
599			`newseg = GR_TRUE;`
600			`}`
601
602			`if (oldcolor == BLACK)`
603			`goto go_on;`
604
605			`/* ignore points outside magnified area */`
606			`if ((x < -longradius \|\| x > longradius \|\|`
607			`y < -latradius \|\| y > latradius))`
608			`{`
609			`is_out = 1;`
610			`if (was_out) { /* out to out */`
611			`LonPrv = x;`
612			`LatPrv = y;`
613			`goto go_on;`
614			`}`
615
616			`/* in to out */`
617			`xold = mapxorig + FTOI(FFMUL(LonPrv, X_Scale)) / 60;`
618			`yold = mapyorig - FTOI(FFMUL(LatPrv, Y_Scale)) / 60;`
619			`} else { /* out to in */`
620			`is_out = 0;`
621			`if (was_out) {`
622			`xold = mapxorig +`
623			`FTOI(FFMUL(LonPrv, X_Scale)) / 60;`
624			`yold = mapyorig -`
625			`FTOI(FFMUL(LatPrv, Y_Scale)) / 60;`
626			`}`
627			`/* in to in */`
628			`}`
629			`LonPrv = x;`
630			`LatPrv = y;`
631
632			`/* scale points w/in area to interlace screen */`
633			`xnew = mapxorig + FTOI(FFMUL(x, X_Scale)) / 60;`
634			`ynew = mapyorig - FTOI(FFMUL(y, Y_Scale)) / 60;`
635
636			`/* if new segment, move to place */`
637			`if (newseg \|\| ABS(oldlong - pp->Lon) > 180*60) {`
638			`xold = xnew;`
639			`yold = ynew;`
640			`}`
641			`oldlong = pp->Lon;`
642
643			`GrLine(mapwid, mapgc, xold, yold, xnew, ynew);`
644			`xold = xnew;`
645			`yold = ynew;`
646			`go_on:`
647			`was_out = is_out;`
648			`newseg = GR_FALSE;`
649			`}`
650			`}`
651			`close(fh);`
652			`}`
653
654			`/* END CODE */`