roadmap-commit Mailing List for RoadMap (Page 71)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/roadmap/roadmap_editor/j2me/c
In directory sc8-pr-cvs9.sourceforge.net:/tmp/cvs-serv15814/j2me/c

Added Files:
      Tag: BR-J2ME
	Makefile roadmap_canvas.c roadmap_file.c roadmap_main.c 
	roadmap_path.c roadmap_serial.c roadmap_time.c stubs.c 
Log Message:
OK, who wants to run RoadMap on his J2ME phone?

This is an import of the RoadMap j2ME branch.

--- NEW FILE: roadmap_time.c ---
/* roadmap_time.c - Manage time information & display.
 *
 * LICENSE:
 *
 *   Copyright 2002 Pascal F. Martin
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   See roadmap_time.h
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "roadmap.h"
#include "roadmap_time.h"

char *roadmap_time_get_hours_minutes (time_t gmt) {

    return "00:00";
#if 0
    static char image[16];

    struct tm *tm;

    tm = localtime (&gmt);
    snprintf (image, sizeof(image), "%2d:%02d", tm->tm_hour, tm->tm_min);

    return image;
#endif    
}

--- NEW FILE: roadmap_path.c ---
/* roadmap_path.c - a module to handle file path in an OS independent way.
 *
 * LICENSE:
 *
 *   Copyright 2002 Pascal F. Martin
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   See roadmap_path.h.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "roadmap.h"
#include "roadmap_file.h"
#include "roadmap_path.h"

typedef struct RoadMapPathRecord *RoadMapPathList;

struct RoadMapPathRecord {

   RoadMapPathList next;

   char  *name;
   int    count;
   char **items;
   char  *preferred;
};

static RoadMapPathList RoadMapPaths = NULL;

/* This list exist because the user context is a special case
 * that we want to handle in a standard way.
 */
static const char *RoadMapPathUser[] = {
   ".",
   "./roadmap",
   NULL
};
static const char *RoadMapPathUserPreferred = "./roadmap";

/* Skins directories */
static const char *RoadMapPathSkin[] = {
   ".",
   "./roadmap/skins/default/day",
   "./roadmap/skins/default",
   NULL
};
static const char *RoadMapPathSkinPreferred = "./roadmap/skins";

/* The hardcoded path for configuration files (the "config" path).
 * (Note that the user directory (~/.roadmap) does not appear here
 * as it is implicitely used by the callers--see above.)
 */ 
static const char *RoadMapPathConfig[] = {
   /* This is for standard Unix configurations. */
   ".",
   "./roadmap",
   NULL
};
static const char *RoadMapPathConfigPreferred =
                      "./roadmap";

/* The default path for the map files (the "maps" path): */
static const char *RoadMapPathMaps[] = {
   /* This is for standard Unix configurations. */
   ".",
   "./roadmap/maps",
   NULL
};
static const char *RoadMapPathMapsPreferred =
                      "./roadmap/maps";

static char *roadmap_path_expand (const char *item, size_t length);

static void roadmap_path_list_create(const char *name,
                                     const char *items[],
                                     const char *preferred) {

   size_t i;
   size_t count;
   RoadMapPathList new_path;

   for (count = 0; items[count] != NULL; ++count) ;

   new_path = malloc (sizeof(struct RoadMapPathRecord));
   roadmap_check_allocated(new_path);

   new_path->next  = RoadMapPaths;
   new_path->name  = strdup(name);
   new_path->count = (int)count;

   new_path->items = calloc (count, sizeof(char *));
   roadmap_check_allocated(new_path->items);

   for (i = 0; i < count; ++i) {
      new_path->items[i] = roadmap_path_expand (items[i], strlen(items[i]));
   }
   new_path->preferred  = roadmap_path_expand (preferred, strlen(preferred));

   RoadMapPaths = new_path;
}

static RoadMapPathList roadmap_path_find (const char *name) {

   RoadMapPathList cursor;

   if (RoadMapPaths == NULL) {

      /* Add the hardcoded configuration. */

      roadmap_path_list_create ("user",   RoadMapPathUser,
                                          RoadMapPathUserPreferred);

      roadmap_path_list_create ("config", RoadMapPathConfig,
                                          RoadMapPathConfigPreferred);

      roadmap_path_list_create ("skin",   RoadMapPathSkin,
                                          RoadMapPathSkinPreferred);

      roadmap_path_list_create ("maps",   RoadMapPathMaps,
                                          RoadMapPathMapsPreferred);
   }

   for (cursor = RoadMapPaths; cursor != NULL; cursor = cursor->next) {
      if (strcasecmp(cursor->name, name) == 0) break;
   }
   return cursor;
}

/* Directory path strings operations. -------------------------------------- */

static char *roadmap_path_cat (const char *s1, const char *s2) {

    char *result = malloc (strlen(s1) + strlen(s2) + 4);

    roadmap_check_allocated (result);

    strcpy (result, s1);
    strcat (result, "/");
    strcat (result, s2);

    return result;
}

char *roadmap_path_join (const char *path, const char *name) {

   if (path == NULL) {
      return strdup (name);
   }
   return roadmap_path_cat (path, name);
}

char *roadmap_path_parent (const char *path, const char *name) {

   char *separator;
   char *full_name = roadmap_path_join (path, name);

   separator = strrchr (full_name, '/');
   if (separator == NULL) {
      return ".";
   }

   *separator = 0;

   return full_name;
}

char *roadmap_path_skip_directories (const char *name) {

   char *result = strrchr (name, '/');

   if (result == NULL) return (char *)name;

   return result + 1;
}

char *roadmap_path_remove_extension (const char *name) {

   char *result;
   char *p;

   result = strdup(name);
   roadmap_check_allocated(result);

   p = roadmap_path_skip_directories (result);
   p = strrchr (p, '.');
   if (p != NULL) *p = 0;

   return result;
}

/* The standard directory paths: ------------------------------------------- */

static const char *roadmap_path_home (void) {

   return ".";
}

const char *roadmap_path_user (void) {

    static char *RoadMapUser = NULL;

    if (RoadMapUser == NULL) {
        RoadMapUser = roadmap_path_cat (roadmap_path_home(), "/roadmap");
    }
    return RoadMapUser;
}

const char *roadmap_path_trips (void) {

    static char  RoadMapDefaultTrips[] = ".roadmap/trips";
    static char *RoadMapTrips = NULL;

    if (RoadMapTrips == NULL) {

            RoadMapTrips =
               roadmap_path_cat (roadmap_path_home(), RoadMapDefaultTrips);
    }
    return RoadMapTrips;
}

static char *roadmap_path_expand (const char *item, size_t length) {

   const char *expansion;
   size_t expansion_length;
   char *expanded;

   switch (item[0]) {
      case '~': expansion = roadmap_path_home(); item++; length--; break;
      case '&': expansion = roadmap_path_user(); item++; length--; break;
      default:  expansion = "";
   }
   expansion_length = strlen(expansion);

   expanded = malloc (length + expansion_length + 1);
   roadmap_check_allocated(expanded);

   strcpy (expanded, expansion);
   strncat (expanded, item, length);

   expanded[length+expansion_length] = 0;

   return expanded;
}

/* Path lists operations. -------------------------------------------------- */

void roadmap_path_set (const char *name, const char *path) {

   int i;
   size_t count;
   const char *item;
   const char *next_item;

   RoadMapPathList path_list = roadmap_path_find (name);

   if (path_list == NULL) {
      roadmap_log(ROADMAP_FATAL, "unknown path set '%s'", name);
   }

   while (*path == ',') path += 1;
   if (*path == 0) return; /* Ignore empty path: current is better. */

   if (path_list->items != NULL) {

      /* This replaces a path that was already set. */

      for (i = path_list->count-1; i >= 0; --i) {
         free (path_list->items[i]);
      }
      free (path_list->items);
   }

   /* Count the number of items in this path string. */

   count = 0;
   for (item = path-1; item != NULL; item = strchr (item+1, ',')) {
      count += 1;
   }

   path_list->items = calloc (count, sizeof(char *));
   roadmap_check_allocated(path_list->items);

   /* Extract and expand each item of the path.
    * Ignore directories that do not exist yet.
    */
   for (i = 0, item = path-1; item != NULL; item = next_item) {

      item += 1;
      next_item = strchr (item, ',');

      if (next_item == NULL) {
         path_list->items[i] = roadmap_path_expand (item, strlen(item));
      } else {
         path_list->items[i] =
            roadmap_path_expand (item, (size_t)(next_item - item));
      }

      if (roadmap_file_exists(NULL, path_list->items[i])) {
         ++i;
      } else {
         free (path_list->items[i]);
         path_list->items[i] = NULL;
      }
   }
   path_list->count = i;
}

const char *roadmap_path_first (const char *name) {

   RoadMapPathList path_list = roadmap_path_find (name);

   if (path_list == NULL) {
      roadmap_log (ROADMAP_FATAL, "invalid path set '%s'", name);
   }

   if (path_list->count > 0) {
      return path_list->items[0];
   }

   return NULL;
}

const char *roadmap_path_next  (const char *name, const char *current) {

   int i;
   RoadMapPathList path_list = roadmap_path_find (name);

   for (i = 0; i < path_list->count-1; ++i) {

      if (path_list->items[i] == current) {
         return path_list->items[i+1];
      }
   }

   return NULL;
}

const char *roadmap_path_last (const char *name) {

   RoadMapPathList path_list = roadmap_path_find (name);

   if (path_list == NULL) {
      roadmap_log (ROADMAP_FATAL, "invalid path set '%s'", name);
   }

   if (path_list->count > 0) {
      return path_list->items[path_list->count-1];
   }
   return NULL;
}

const char *roadmap_path_previous (const char *name, const char *current) {

   int i;
   RoadMapPathList path_list = roadmap_path_find (name);

   for (i = path_list->count-1; i > 0; --i) {

      if (path_list->items[i] == current) {
         return path_list->items[i-1];
      }
   }
   return NULL;
}

/* This function always return a hardcoded default location,
 * which is the recommended location for these objects.
 */
const char *roadmap_path_preferred (const char *name) {

   RoadMapPathList path_list = roadmap_path_find (name);

   if (path_list == NULL) {
      roadmap_log (ROADMAP_FATAL, "invalid path set '%s'", name);
   }

   return path_list->preferred;
}

void roadmap_path_create (const char *path) {
}

static char *RoadMapPathEmptyList = NULL;

char **roadmap_path_list (const char *path, const char *extension) {

   return &RoadMapPathEmptyList;
}

void   roadmap_path_list_free (char **list) {

   char **cursor;

   if ((list == NULL) || (list == &RoadMapPathEmptyList)) return;

   for (cursor = list; *cursor != NULL; ++cursor) {
      free (*cursor);
   }
   free (list);
}

void roadmap_path_free (const char *path) {
   free ((char *) path);
}

const char *roadmap_path_search_icon (const char *name) {

   static char result[256];

   sprintf (result, "%s/pixmaps/rm_%s.png", roadmap_path_home(), name);
   if (roadmap_file_exists(NULL, result)) return result;

   sprintf (result, "/usr/local/share/pixmaps/rm_%s.png", name);
   if (roadmap_file_exists(NULL, result)) return result;

   sprintf (result, "/usr/share/pixmaps/rm_%s.png", name);
   if (roadmap_file_exists(NULL, result)) return result;

   return NULL; /* Not found. */
}

int roadmap_path_is_full_path (const char *name) {
   return name[0] == '/';
}

int roadmap_path_is_directory (const char *name) {

   return 0;
}

const char *roadmap_path_temporary (void) {

   return "/tmp";
}

--- NEW FILE: roadmap_serial.c ---
/* roadmap_serial.c - a module to open/read/close a serial IO device.
 *
 * LICENSE:
 *
 *   Copyright 2006 Ehud Shabtai
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * DESCRIPTION:
 *
 *   This module hides the OS specific API to access a serial device.
 *   NOT IMPLEMENTED YET.
 */

#include "roadmap.h"
#include "roadmap_serial.h"
#include <gps_manager.h>

static NOPH_GpsManager_t gps_mgr;
RoadMapSerial roadmap_serial_open  (const char *name,
                                    const char *mode,
                                    int speed) {
   if (!gps_mgr) {
      gps_mgr = NOPH_GpsManager_getInstance();
   }

   return NOPH_GpsManager_connect (gps_mgr, name);
}

int roadmap_serial_read  (RoadMapSerial serial, void *data, int size) {
   if (!gps_mgr) return -1;

   return NOPH_GpsManager_read (gps_mgr, data, size);
}

int roadmap_serial_write (RoadMapSerial serial, const void *data, int length) {
   return -1;
}

void  roadmap_serial_close (RoadMapSerial serial) {
   if (!gps_mgr) return;

   NOPH_GpsManager_disconnect (gps_mgr);
}

--- NEW FILE: Makefile ---
######################################################################
##
## Copyright (C) 2006,  Blekinge Institute of Technology
##
## Filename:      Makefile
## Author:        Simon Kagstrom <sk...@bt...>
## Description:   Generic Makefile
##
## $Id: Makefile,v 1.1.2.1 2007/02/09 17:29:09 eshabtai Exp $
##
######################################################################
SUBDIRS =
TARGET  = program

OBJS    = ../../src/roadmap_dbread.o \
	  ../../src/roadmap_line.o \
	  ../../src/roadmap_log.o \
	  ../../src/roadmap_line_route.o \
	  ../../src/roadmap_line_speed.o \
	  ../../src/roadmap_turns.o \
	  ../../src/roadmap_dictionary.o \
	  ../../src/roadmap_math.o \
	  ../../src/roadmap_point.o \
	  ../../src/roadmap_polygon.o \
	  ../../src/roadmap_shape.o \
	  ../../src/roadmap_square.o \
	  ../../src/roadmap_config.o \
	  ../../src/roadmap_state.o \
	  ../../src/roadmap_layer.o \
	  ../../src/roadmap_street.o \
	  ../../src/roadmap_county.o \
	  ../../src/roadmap_locator.o \
	  ../../src/roadmap_metadata.o \
	  ../../src/roadmap_skin.o \
	  ../../src/roadmap_plugin.o \
	  ../../src/roadmap_hash.o \
	  ../../src/roadmap_list.o \
	  ../../src/roadmap_option.o \
	  ../../src/roadmap_display.o \
	  ../../src/roadmap_message.o \
	  ../../src/roadmap_sprite.o \
	  ../../src/roadmap_label.o \
	  ../../src/roadmap_object.o \
	  ../../src/roadmap_string.o \
	  ../../src/roadmap_lang.o \
	  ../../src/roadmap_adjust.o \
	  ../../src/roadmap_trip.o \
	  ../../src/roadmap_screen.o \
	  ../../src/roadmap_factory.o \
	  ../../src/roadmap_navigate.o \
	  ../../src/roadmap_fuzzy.o \
	  ../../src/roadmap_start.o \
	  ../../src/roadmap_screen_obj.o \
	  ../../src/roadmap_gps.o \
	  ../../src/roadmap_nmea.o \
	  ../../src/roadmap_input.o \
	  ../../src/roadmap_io.o \
	  ./roadmap_path.o \
	  ./roadmap_file.o \
	  ./roadmap_canvas.o \
	  ./roadmap_time.o \
	  ./roadmap_serial.o \
	  ./roadmap_main.o \
	  ./stubs.o \
#	  ../../src/roadmap_screen.o \
	  ../../src/roadmap_trip.o \

LDLIBS  = -lc -lsoftfloat -lm
CFLAGS  = -I../../src -DJ2ME

CIBYL_MIPS2JAVA_OPTS ?=

include $(CIBYL_BASE)/build/Rules.mk

--- NEW FILE: stubs.c ---
/* roadmap_log.c - a module for managing uniform error & info messages.
 *
 * LICENSE:
 *
 *   Copyright 2002 Pascal F. Martin
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   #include "roadmap.h"
 *
 *   void roadmap_log (int level, char *format, ...);
 *
 * This module is used to control and manage the appearance of messages
 * printed by the roadmap program. The goals are (1) to produce a uniform
 * look, (2) have a central point of control for error management and
 * (3) have a centralized control for routing messages.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>

#include "roadmap.h"
#include "roadmap_path.h"
#include "roadmap_net.h"
#include "roadmap_serial.h"
#include "roadmap_spawn.h"
#include "roadmap_file.h"

int roadmap_net_receive (RoadMapSocket s, void *data, int size) { return -1; }
int roadmap_net_send    (RoadMapSocket s, const void *data, int length,
                         int wait) { return -1; }

void roadmap_net_close  (RoadMapSocket s) {}

int  roadmap_spawn_write_pipe (RoadMapPipe pipe, const void *data, int length) { return -1; }
int  roadmap_spawn_read_pipe  (RoadMapPipe pipe, void *data, int size) { return -1; }
void roadmap_spawn_close_pipe (RoadMapPipe pipe) {}

--- NEW FILE: roadmap_file.c ---
/* roadmap_file.c - a module to open/read/close a roadmap database file.
 *
 * LICENSE:
 *
 *   Copyright 2002 Pascal F. Martin
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   See roadmap_file.h.
 */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "roadmap.h"
#include "roadmap_path.h"
#include "roadmap_file.h"

struct RoadMapFileContextStructure {

   FILE  *fd;
   void *base;
   int   size;
};

FILE *roadmap_file_fopen (const char *path,
                          const char *name,
                          const char *mode) {

   int   silent;
   FILE *file;
   const char *full_name = roadmap_path_join (path, name);

   if (mode[0] == 's') {
      /* This special mode is a "lenient" read: do not complain
       * if the file does not exist.
       */
      silent = 1;
      ++mode;
   } else {
      silent = 0;
   }

   file = fopen (full_name, mode);
   roadmap_log (ROADMAP_DEBUG, "After fopen for: %s, file=%x", full_name, file);

   if ((file == NULL) && (! silent)) {
      roadmap_log (ROADMAP_ERROR, "cannot open file %s", full_name);
   }

   roadmap_path_free (full_name);
   return file;
}

void roadmap_file_remove (const char *path, const char *name) {

   assert("roadmap_file_remove");
   const char *full_name = roadmap_path_join (path, name);

   //remove(full_name);
   roadmap_path_free (full_name);
}

int roadmap_file_exists (const char *path, const char *name) {

   int   status;
   const char *full_name = roadmap_path_join (path, name);

   FILE *f = fopen (full_name, "r");

   status = (f != NULL);

   if (f) fclose(f);

   return status;
}

/*
int roadmap_file_length (const char *path, const char *name) {

   int   status;
   const char *full_name = roadmap_path_join (path, name);
   struct stat stat_buffer;

   status = stat (full_name, &stat_buffer);
   roadmap_path_free (full_name);

   if (status == 0) {
      return stat_buffer.st_size;
   }
   return -1;
}

void roadmap_file_save (const char *path, const char *name,
                        void *data, int length) {

   int   fd;
   const char *full_name = roadmap_path_join (path, name);

   fd = open (full_name, O_CREAT+O_WRONLY+O_TRUNC, 0666);
   roadmap_path_free (full_name);

   if (fd >= 0) {

      write (fd, data, length);
      close(fd);
   }
}

int roadmap_file_truncate (const char *path, const char *name,
                           int length) {

   int   res;
   const char *full_name = roadmap_path_join (path, name);

   res = truncate (full_name, length);
   roadmap_path_free (full_name);

   return res;
}

void roadmap_file_append (const char *path, const char *name,
                          void *data, int length) {

   int   fd;
   const char *full_name = roadmap_path_join (path, name);

   fd = open (full_name, O_CREAT+O_WRONLY+O_APPEND, 0666);
   roadmap_path_free (full_name);

   if (fd >= 0) {

      write (fd, data, length);
      close(fd);
   }
}

const char *roadmap_file_unique (const char *base) {

    static int   UniqueNameCounter = 0;
    static char *UniqueNameBuffer = NULL;
    static int   UniqueNameBufferLength = 0;

    int length;

    length = strlen(base + 16);

    if (length > UniqueNameBufferLength) {

        if (UniqueNameBuffer != NULL) {
            free(UniqueNameBuffer);
        }
        UniqueNameBuffer = malloc (length);

        roadmap_check_allocated(UniqueNameBuffer);

        UniqueNameBufferLength = length;
    }

    sprintf (UniqueNameBuffer,
             "%s%d_%d", base, getpid(), UniqueNameCounter);

    UniqueNameCounter += 1;

    return UniqueNameBuffer;
}

*/

const char *roadmap_file_map (const char *set,
                              const char *name,
                              const char *sequence,
                              const char *mode,
                              RoadMapFileContext *file) {

   RoadMapFileContext context;

   context = malloc (sizeof(*context));
   roadmap_check_allocated(context);

   context->fd = NULL;
   context->base = NULL;
   context->size = 0;

   if (strcmp(mode, "r")) {
      roadmap_log (ROADMAP_ERROR,
                   "%s: invalid file access mode %s", name, mode);
      free (context);
      return NULL;
   }

   if (name[0] == '/') {

      context->fd = fopen (name, mode);
      sequence = ""; /* Whatever, but NULL. */

   } else {

      char *full_name;

      int full_name_size;
      int name_size = strlen(name);
      int size;

      if (sequence == NULL) {
         sequence = roadmap_path_first(set);
      } else {
         sequence = roadmap_path_next(set, sequence);
      }
      if (sequence == NULL) {
         free (context);
         return NULL;
      }

      full_name_size = 512;
      full_name = malloc (full_name_size);
      roadmap_check_allocated(full_name);

      do {
         size = strlen(sequence) + name_size + 2;

         if (size >= full_name_size) {
            full_name = realloc (full_name, size);
            roadmap_check_allocated(full_name);
            full_name_size = size;
         }

         strcpy (full_name, sequence);
         strcat (full_name, "/");
         strcat (full_name, name);

         context->fd = fopen (full_name, mode);

         if (context->fd > 0) break;

         sequence = roadmap_path_next(set, sequence);

      } while (sequence != NULL);

      free (full_name);
   }

   if (context->fd <= 0) {
      if (sequence == 0) {
         roadmap_log (ROADMAP_INFO, "cannot open file %s", name);
      }
      roadmap_file_unmap (&context);
      return NULL;
   }

   if ((context->size = favail(context->fd)) <= 0) {
      roadmap_file_unmap (&context);
      return NULL;
   }

   context->base = malloc(context->size);

   if ((context->base == NULL) ||
       (fread(context->base, context->size, 1, context->fd) != context->size)) {
      roadmap_log (ROADMAP_ERROR, "cannot map file %s", name);
      roadmap_file_unmap (&context);
      return NULL;
   }

   *file = context;

   return sequence; /* Indicate the next directory in the path. */
}

void *roadmap_file_base (RoadMapFileContext file){

   if (file == NULL) {
      return NULL;
   }
   return file->base;
}

int roadmap_file_size (RoadMapFileContext file){

   if (file == NULL) {
      return 0;
   }
   return file->size;
}

int roadmap_file_sync (RoadMapFileContext file) {

   return 0;
}

void roadmap_file_unmap (RoadMapFileContext *file) {

   RoadMapFileContext context = *file;

   if (context->base != NULL) {
      free(context->base);
      context->base = NULL;
   }

   if (context->fd > 0) {
      fclose (context->fd);
   }
   free(context);
   *file = NULL;
}

RoadMapFile roadmap_file_open  (const char *name, const char *mode) {

   return -1;
}

int roadmap_file_read  (RoadMapFile file, void *data, int size) {
   return -1;
}

int roadmap_file_write (RoadMapFile file, const void *data, int length) {
   return -1;
}

void  roadmap_file_close (RoadMapFile file) {
}

int roadmap_file_free_space (const char *path) {
   return -1;
}

--- NEW FILE: roadmap_canvas.c ---
/* roadmap_canvas.c - manage the canvas that is used to draw the map with j2me
 *
 * LICENSE:
 *
 *   Copyright 2007 Ehud Shabtai
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   See roadmap_canvas.h.
 */

#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include <javax/microedition/lcdui.h>
#include <javax/microedition/lcdui/game.h>
#include <jmicropolygon.h>

#include "roadmap.h"
#include "roadmap_types.h"
#include "roadmap_gui.h"
#include "roadmap_screen.h"
#include "roadmap_canvas.h"
#include "roadmap_messagebox.h"
#include "roadmap_math.h"
#include "roadmap_config.h"
#include "roadmap_path.h"

struct roadmap_canvas_pen {   
   struct roadmap_canvas_pen *next;
   char  *name;
   unsigned char color[3];
   int thickness;
};

static struct roadmap_canvas_pen *RoadMapPenList = NULL;
static RoadMapPen CurrentPen = 0;
static NOPH_GameCanvas_t canvas = 0;
static NOPH_Graphics_t graphics = 0;
static NOPH_Graphics_t graphicsBuffer = 0;

/* The canvas callbacks: all callbacks are initialized to do-nothing
 * functions, so that we don't care checking if one has been setup.
 */
static void roadmap_canvas_ignore_mouse (RoadMapGuiPoint *point) {}

RoadMapCanvasMouseHandler RoadMapCanvasMouseButtonPressed =
                                     roadmap_canvas_ignore_mouse;

RoadMapCanvasMouseHandler RoadMapCanvasMouseButtonReleased =
                                     roadmap_canvas_ignore_mouse;

RoadMapCanvasMouseHandler RoadMapCanvasMouseMoved =
                                     roadmap_canvas_ignore_mouse;

static void roadmap_canvas_ignore_configure (void) {}

RoadMapCanvasConfigureHandler RoadMapCanvasConfigure =
                                     roadmap_canvas_ignore_configure;

void roadmap_canvas_get_text_extents 
        (const char *text, int size, int *width,
            int *ascent, int *descent, int *can_tilt) {

   *width = 0;
   *ascent = 0;
   *descent = 0;
   *can_tilt = 0;
   return;

#if 0   
   *ascent = 0;
   *descent = 0;
   if (can_tilt) *can_tilt = 1;

   wchar_t wstr[255];
   int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);

   if (length <=0) {
      *width = 0;
      return;
   }

   double x  = 0;
   double y  = 0;
   const wchar_t* p = wstr;

   font_manager_type *fman;

   if (size == -1) {
      /* Use the regular font */
      *descent = abs((int)m_feng.descender()) + 1;
      *ascent = (int)m_feng.ascender() + 1;
      fman = &m_fman;
   } else {

      m_image_feng.height(size);
      m_image_feng.width(size);
      *descent = abs((int)m_image_feng.descender()) + 1;
      *ascent = (int)m_image_feng.ascender() + 1;
      fman = &m_image_fman;
   }

   while(*p) {
      const agg::glyph_cache* glyph = fman->glyph(*p);

      if(glyph) {
         x += glyph->advance_x;
         y += glyph->advance_y;
         //if (-glyph->bounds.y1 > *descent) *descent=-glyph->bounds.y1 - 1;
      }
      ++p;
   }

   *width = (int)x;
   #endif
}

RoadMapPen roadmap_canvas_select_pen (RoadMapPen pen)
{
   RoadMapPen old_pen = CurrentPen;
   dbg_time_start(DBG_TIME_SELECT_PEN);

   CurrentPen = pen;

   if (graphicsBuffer)
         NOPH_Graphics_setColor
            (graphicsBuffer, pen->color[0], pen->color[1], pen->color[2]);

   dbg_time_end(DBG_TIME_SELECT_PEN);

   return old_pen;
}

RoadMapPen roadmap_canvas_create_pen (const char *name)
{
   struct roadmap_canvas_pen *pen;

   for (pen = RoadMapPenList; pen != NULL; pen = pen->next) {
      if (strcmp(pen->name, name) == 0) break;
   }

   if (pen == NULL) {

      pen = (struct roadmap_canvas_pen *)
         malloc (sizeof(struct roadmap_canvas_pen));
      roadmap_check_allocated(pen);

      pen->name = strdup (name);
      memset (&pen->color, 0, sizeof(pen->color));
      pen->thickness = 1;
      pen->next = RoadMapPenList;

      RoadMapPenList = pen;
   }

   roadmap_canvas_select_pen (pen);

   return pen;
}

void roadmap_canvas_set_foreground (const char *color) {

   int i;
   if (!CurrentPen) return;

   if (*color != '#') return;
   color++;

   for (i=0; i<3; i++) {
      int val = 0;
      int j;
      for (j=0; j<2; j++) {
         val = val * 16;
         if (isdigit(color[j])) val += color[j] - 48;
         else val += (tolower(color[j]) - 87);
      }

      CurrentPen->color[i] = val;
      color += 2;
   }

   roadmap_canvas_select_pen(CurrentPen);
}

int  roadmap_canvas_get_thickness  (RoadMapPen pen) {

   if (pen == NULL) return 0;

   return pen->thickness;
}

void roadmap_canvas_set_thickness (int thickness) {

   if (CurrentPen && (CurrentPen->thickness != thickness)) {
      CurrentPen->thickness = thickness;
   }
}

void roadmap_canvas_set_opacity (int opacity) {

   return;
#if 0
   if (!CurrentPen) return;
   CurrentPen->color.a = opacity;
   roadmap_canvas_select_pen(CurrentPen);
#endif   
}

void roadmap_canvas_erase (void) {

   roadmap_log (ROADMAP_DEBUG, "in roadmap_canvas_erase: canvas: 0x%x\n", canvas);
   NOPH_Graphics_fillRect (graphicsBuffer,
                           0, 0,
                           NOPH_GameCanvas_getWidth(canvas),
                           NOPH_GameCanvas_getHeight(canvas));
}

void roadmap_canvas_erase_area (const RoadMapGuiRect *rect) {

   NOPH_Graphics_fillRect (graphicsBuffer,
                           rect->minx, rect->miny, rect->maxx, rect->maxy);
}

void roadmap_canvas_draw_string (RoadMapGuiPoint *position,
                                 int corner,
                                 const char *text) {
   return;
#if 0   
   int x;
   int y;
   int text_width;
   int text_ascent;
   int text_descent;
   int text_height;

   roadmap_canvas_get_text_extents 
         (text, -1, &text_width, &text_ascent, &text_descent, NULL);

   text_height = text_ascent + text_descent;

   switch (corner) {

   case ROADMAP_CANVAS_TOPLEFT:
      y = position->y;
      x = position->x;
      break;

   case ROADMAP_CANVAS_TOPRIGHT:
      y = position->y;
      x = position->x - text_width;
      break;

   case ROADMAP_CANVAS_BOTTOMRIGHT:
      y = position->y - text_height;
      x = position->x - text_width;
      break;

   case ROADMAP_CANVAS_BOTTOMLEFT:
      y = position->y - text_height;
      x = position->x;
      break;

   case ROADMAP_CANVAS_CENTER:
      y = position->y - (text_height / 2);
      x = position->x - (text_width / 2);
      break;

   default:
      return;
   }

   RoadMapGuiPoint start = {x, y+text_height};
   roadmap_canvas_draw_string_angle (&start, position, 0, -1, text);
#endif   
}

void roadmap_canvas_draw_multiple_points (int count, RoadMapGuiPoint *points) {

   int i;

   for (i=0; i<count; i++) {

      NOPH_Graphics_drawLine
         (graphicsBuffer, points[i].x, points[i].y, points[i].x, points[i].y);
   }
}

void roadmap_canvas_draw_multiple_lines (int count, int *lines,
      RoadMapGuiPoint *points, int fast_draw) {

   int i;

   dbg_time_start(DBG_TIME_DRAW_LINES);

   for (i = 0; i < count; ++i) {

      int count_of_points = *lines;
      int j;

      if (count_of_points < 2) continue;

      roadmap_log (ROADMAP_DEBUG, "Drawing a line:\n");
      for (j=0; j<count_of_points-1; j++) {

         RoadMapGuiPoint *to_point = points+1;
         roadmap_log (ROADMAP_DEBUG, "From: %d,%d To %d,%d\n",
                      points->x, points->y, to_point->x, to_point->y);

         NOPH_Graphics_drawLine
            (graphicsBuffer, points->x, points->y, to_point->x, to_point->y);
         points++;
      }
      points++;

      lines += 1;
   }

   dbg_time_end(DBG_TIME_DRAW_LINES);
}

void roadmap_canvas_draw_multiple_polygons
         (int count, int *polygons, RoadMapGuiPoint *points, int filled,
          int fast_draw) {

   int i;
   int count_of_points;
   int *x_points = NULL;
   int *y_points = NULL;
   int array_size = 0;

   for (i = 0; i < count; ++i) {
      int j;

      count_of_points = *polygons;
      if (array_size < count_of_points) {
         array_size = count_of_points;

         if (x_points) {
            free(x_points);
            free(y_points);
         }

         x_points = malloc(count_of_points * sizeof(int));
         y_points = malloc(count_of_points * sizeof(int));
      }

      for (j=0; j<count_of_points; j++) {

         x_points[j] = points->x;
         y_points[j] = points->y;
         points++;
      }

      if (filled) {
         NOPH_PolygonGraphics_fillPolygon
                (graphicsBuffer, x_points, y_points, count_of_points);
      } else {
         NOPH_PolygonGraphics_drawPolygon
                (graphicsBuffer, x_points, y_points, count_of_points);
      }

      polygons += 1;
   }

   if (x_points) {
      free(x_points);
      free(y_points);
   }
}

void roadmap_canvas_draw_multiple_circles
        (int count, RoadMapGuiPoint *centers, int *radius, int filled,
         int fast_draw) {

   int i;

   for (i = 0; i < count; ++i) {

      int r = radius[i];

      int x = centers[i].x - r;
      int y = centers[i].y - r;

      r *= 2;

      roadmap_log (ROADMAP_DEBUG, "circle: x:%d, y:%d, r:%d, filled:%d\n",
                                  x, y, r, filled);
      if (filled) {

         NOPH_Graphics_fillArc (graphicsBuffer, x, y, r, r, 0, 360);

      } else {

         NOPH_Graphics_drawArc (graphicsBuffer, x, y, r, r, 0, 360);
      }
   }
}

void roadmap_canvas_register_button_pressed_handler
                    (RoadMapCanvasMouseHandler handler) {

   RoadMapCanvasMouseButtonPressed = handler;
}

void roadmap_canvas_register_button_released_handler
                    (RoadMapCanvasMouseHandler handler) {

   RoadMapCanvasMouseButtonReleased = handler;
}

void roadmap_canvas_register_mouse_move_handler
                    (RoadMapCanvasMouseHandler handler) {

   RoadMapCanvasMouseMoved = handler;
}

void roadmap_canvas_register_configure_handler
                    (RoadMapCanvasConfigureHandler handler) {

   RoadMapCanvasConfigure = handler;
}

int roadmap_canvas_width (void) {
   return NOPH_GameCanvas_getWidth (canvas);
}

int roadmap_canvas_height (void) {
   return NOPH_GameCanvas_getHeight (canvas);
}

void roadmap_canvas_save_screenshot (const char* filename) {
   /* NOT IMPLEMENTED. */
}

void roadmap_canvas_draw_string_angle (const RoadMapGuiPoint *position,
                                       RoadMapGuiPoint *center,
                                       int angle, int size,
                                       const char *text)
{

   return;
#if 0   
   if (RoadMapCanvasFontLoaded != 1) return;

   dbg_time_start(DBG_TIME_TEXT_FULL);      
   dbg_time_start(DBG_TIME_TEXT_CNV);

   wchar_t wstr[255];
   int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);
   if (length <=0) return;

#ifdef USE_FRIBIDI
   wchar_t *bidi_text = bidi_string(wstr);
   const wchar_t* p = bidi_text;
#else   
   const wchar_t* p = wstr;
#endif

   ren_solid.color(CurrentPen->color);
   dbg_time_end(DBG_TIME_TEXT_CNV);

   double x  = 0;
   double y  = 0;

   if ((angle > -5) && (angle < 5)) {

      if (size < 0) size = 15;

      /* Use faster drawing for text with no angle */
      x  = position->x;
      y  = position->y;

//      ren_solid.color(agg::rgba8(0, 0, 0));

      m_image_feng.height(size);
      m_image_feng.width(size);

      while(*p) {
         const agg::glyph_cache* glyph = m_image_fman.glyph(*p);

         if(glyph) {
            m_image_fman.init_embedded_adaptors(glyph, x, y);

            agg::render_scanlines(m_image_fman.gray8_adaptor(), 
                  m_image_fman.gray8_scanline(), 
                  ren_solid);      

            // increment pen position
            x += glyph->advance_x;
            y += glyph->advance_y;
         }
         ++p;
      }
   }

   while(*p) {
      dbg_time_start(DBG_TIME_TEXT_ONE_LETTER);
      dbg_time_start(DBG_TIME_TEXT_GET_GLYPH);
      const agg::glyph_cache* glyph = m_fman.glyph(*p);
      dbg_time_end(DBG_TIME_TEXT_GET_GLYPH);

      if(glyph) {
         m_fman.init_embedded_adaptors(glyph, x, y);

         //agg::conv_curve<font_manager_type::path_adaptor_type> stroke(m_fman.path_adaptor());

         agg::trans_affine mtx;
         if (abs(angle) > 5) {
            mtx *= agg::trans_affine_rotation(agg::deg2rad(angle));
         }
         mtx *= agg::trans_affine_translation(position->x, position->y);

         agg::conv_transform<font_manager_type::path_adaptor_type> tr(m_fman.path_adaptor(), mtx);

         agg::conv_curve<agg::conv_transform<font_manager_type::path_adaptor_type> > fill(tr);

         //agg::conv_stroke<
            //agg::conv_curve<agg::conv_transform<font_manager_type::path_adaptor_type> > > 
         //stroke(fill);

         //agg::conv_contour<agg::conv_transform<font_manager_type::path_adaptor_type> >contour(tr);
         //contour.width(2);

         //agg::conv_stroke< agg::conv_contour<agg::conv_transform<font_manager_type::path_adaptor_type> > > stroke(contour);
         //agg::conv_stroke< agg::conv_transform<font_manager_type::path_adaptor_type> > stroke(tr);

         dbg_time_start(DBG_TIME_TEXT_ONE_RAS);

#ifdef WIN32_PROFILE
         ResumeCAPAll();
#endif
         ras.reset();
         ras.add_path(tr);
         agg::render_scanlines(ras, sl, ren_solid);
         //ras.add_path(fill);
         //ras.add_path(stroke);
         //ren_solid.color(agg::rgba8(255, 255, 255));
         //agg::render_scanlines(ras, sl, ren_solid);
         //ras.add_path(tr);
         //ren_solid.color(agg::rgba8(0, 0, 0));
         //agg::render_scanlines(ras, sl, ren_solid);

#ifdef WIN32_PROFILE
         SuspendCAPAll();
#endif

         dbg_time_end(DBG_TIME_TEXT_ONE_RAS);

         // increment pen position
         x += glyph->advance_x;
         y += glyph->advance_y;
         dbg_time_end(DBG_TIME_TEXT_ONE_LETTER);
      }
      ++p;
   }

#ifdef USE_FRIBIDI
   free(bidi_text);
#endif

   dbg_time_end(DBG_TIME_TEXT_FULL);
#endif
}

RoadMapImage roadmap_canvas_load_image (const char *path,
                                        const char* file_name) {
   return NULL;
}

void roadmap_canvas_free_image (RoadMapImage image) {

   return;
}

void roadmap_canvas_draw_image (RoadMapImage image, const RoadMapGuiPoint *pos,
                                int opacity, int mode) {

   return;

#if 0   

   if ((mode == IMAGE_SELECTED) || (opacity <= 0) || (opacity >= 255)) {
      opacity = 255;
   }

   agg_renb.blend_from(image->pixfmt, 0, pos->x, pos->y, opacity);

   if (mode == IMAGE_SELECTED) {
      static RoadMapPen selection;

      if (!selection) {
         selection = roadmap_canvas_create_pen("selection");
         roadmap_canvas_set_foreground ("#000000");
      }

      RoadMapGuiPoint points[5] = {
         {pos->x, pos->y},
         {pos->x + image->rbuf.width(), pos->y},
         {pos->x + image->rbuf.width(), pos->y + image->rbuf.height()},
         {pos->x, pos->y + image->rbuf.height()},
         {pos->x, pos->y}};

      int num_points = 5;

      RoadMapPen current = roadmap_canvas_select_pen (selection);
      roadmap_canvas_draw_multiple_lines (1, &num_points, points, 0);
      roadmap_canvas_select_pen (current);
   }
#endif
}

void roadmap_canvas_copy_image (RoadMapImage dst_image,
                                const RoadMapGuiPoint *pos,
                                const RoadMapGuiRect  *rect,
                                RoadMapImage src_image, int mode) {

   return;
#if 0
   agg::renderer_base<agg::pixfmt_rgba32> renb(dst_image->pixfmt);

   agg::rect_i agg_rect;
   agg::rect_i *agg_rect_p = NULL;

   if (rect) {
      agg_rect.x1 = rect->minx;
      agg_rect.y1 = rect->miny;
      agg_rect.x2 = rect->maxx;
      agg_rect.y2 = rect->maxy;

      agg_rect_p = &agg_rect;
   }

   if (mode == CANVAS_COPY_NORMAL) {
      renb.copy_from(src_image->rbuf, agg_rect_p, pos->x, pos->y);
   } else {
      renb.blend_from(src_image->pixfmt, agg_rect_p, pos->x, pos->y, 255);
   }
#endif   
}

int  roadmap_canvas_image_width  (const RoadMapImage image) {

   return 0;
}

int  roadmap_canvas_image_height (const RoadMapImage image) {

   return 0;
}

void roadmap_canvas_draw_image_text (RoadMapImage image,
                                     const RoadMapGuiPoint *position,
                                     int size, const char *text) {

   return;
#if 0
   if (RoadMapCanvasFontLoaded != 1) return;

   wchar_t wstr[255];
   int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);
   if (length <=0) return;

#ifdef USE_FRIBIDI
   wchar_t *bidi_text = bidi_string(wstr);
   const wchar_t* p = bidi_text;
#else   
   const wchar_t* p = wstr;
#endif

   double x  = position->x;
   double y  = position->y + size - 7;

   agg::renderer_base<agg::pixfmt_rgba32> renb(image->pixfmt);
   agg::renderer_scanline_aa_solid< agg::renderer_base<agg::pixfmt_rgba32> > ren_solid (renb);

   ren_solid.color(agg::rgba8(0, 0, 0));

   m_image_feng.height(size);
   m_image_feng.width(size);

   while(*p) {
      const agg::glyph_cache* glyph = m_image_fman.glyph(*p);

      if(glyph) {
         m_image_fman.init_embedded_adaptors(glyph, x, y);

         agg::render_scanlines(m_image_fman.gray8_adaptor(), 
               m_image_fman.gray8_scanline(), 
               ren_solid);      

         // increment pen position
         x += glyph->advance_x;
         y += glyph->advance_y;
      }
      ++p;
   }

#ifdef USE_FRIBIDI
   free(bidi_text);
#endif
#endif
}

#if 0
void roadmap_canvas_button_pressed(POINT *data) {
   RoadMapGuiPoint point;

   point.x = (short)data->x;
   point.y = (short)data->y;

   (*RoadMapCanvasMouseButtonPressed) (&point);

}

void roadmap_canvas_button_released(POINT *data) {
   RoadMapGuiPoint point;

   point.x = (short)data->x;
   point.y = (short)data->y;

   (*RoadMapCanvasMouseButtonReleased) (&point);

}

void roadmap_canvas_mouse_moved(POINT *data) {
   RoadMapGuiPoint point;

   point.x = (short)data->x;
   point.y = (short)data->y;

   (*RoadMapCanvasMouseMoved) (&point);

}

#endif

void roadmap_canvas_refresh (void) {

   dbg_time_start(DBG_TIME_FLIP);

   if (graphics != graphicsBuffer) {
   }

   NOPH_GameCanvas_flushGraphics(canvas);

   dbg_time_end(DBG_TIME_FLIP);
}

void roadmap_canvas_configure (void) {

   roadmap_log (ROADMAP_DEBUG, "***** In roadmap_canvas_configure *****\n");
   canvas = NOPH_GameCanvas_get();
   graphics = NOPH_GameCanvas_getGraphics(canvas);
   graphicsBuffer = graphics;

   (*RoadMapCanvasConfigure) ();
}

--- NEW FILE: roadmap_main.c ---
/* roadmap_main.c - The main function of the RoadMap application.
 *
 * LICENSE:
 *
 *   Copyright 2007 Ehud Shabtai
 *
 *   This file is part of RoadMap.
 *
 *   RoadMap is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   RoadMap is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with RoadMap; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * SYNOPSYS:
 *
 *   int main (int argc, char **argv);
 */

#include <java/lang.h>
#include <javax/microedition/lcdui.h>
#include <javax/microedition/lcdui/game.h>
#include <command_mgr.h>
#include <gps_manager.h>

#include <stdlib.h>
#include <string.h>

#include "roadmap.h"
#include "roadmap_path.h"
#include "roadmap_start.h"
#include "roadmap_config.h"
#include "roadmap_history.h"
#include "roadmap_canvas.h"

#include "roadmap_main.h"

extern void roadmap_canvas_configure (void);

struct roadmap_main_io {
   int id;
   RoadMapIO io;
   RoadMapInput callback;
};

#define ROADMAP_MAX_IO 16
static struct roadmap_main_io RoadMapMainIo[ROADMAP_MAX_IO];

struct roadmap_main_timer {
   int id;
   RoadMapCallback callback;
};

#define ROADMAP_MAX_TIMER 16
static struct roadmap_main_timer RoadMapMainPeriodicTimer[ROADMAP_MAX_TIMER];

static char *RoadMapMainTitle = NULL;

static RoadMapKeyInput RoadMapMainInput = NULL;

volatile static int command_addr = 0;
static NOPH_GpsManager_t gps_mgr = 0;

static void roadmap_start_event (int event) {
   switch (event) {
   case ROADMAP_START_INIT:
      break;
   }
}

static void roadmap_main_process_key (int keys) {

   char *k = NULL;

   if (keys & NOPH_GameCanvas_LEFT_PRESSED)
           k = "J";
   else if (keys & NOPH_GameCanvas_RIGHT_PRESSED)
           k = "K";
   else if (keys & NOPH_GameCanvas_UP_PRESSED)
           k = "+";
   else if (keys & NOPH_GameCanvas_DOWN_PRESSED)
           k = "-";
   else if (keys & NOPH_GameCanvas_FIRE_PRESSED)
           k = "Q";
   else if (keys & NOPH_GameCanvas_GAME_A_PRESSED)
           k = "Button-Left";
   else if (keys & NOPH_GameCanvas_GAME_B_PRESSED)
           k = "Button-Right";
   else if (keys & NOPH_GameCanvas_GAME_C_PRESSED)
           k = "Button-Up";
   else if (keys & NOPH_GameCanvas_GAME_D_PRESSED)
           k = "Button-Down";

   roadmap_log (ROADMAP_DEBUG, "In roadmap_main_process_key, keys:%d, k:%s, RoadMapMainInput:0x%x\n",
                keys, k, RoadMapMainInput);

   if ((k != NULL) && (RoadMapMainInput != NULL)) {
      (*RoadMapMainInput) (k);
   }
}

void roadmap_main_toggle_full_screen (void) {

   static int RoadMapIsFullScreen = 0;

   if (RoadMapIsFullScreen) {
   } else {
   }
}

void roadmap_main_new (const char *title, int width, int height) {
}

void roadmap_main_set_keyboard (struct RoadMapFactoryKeyMap *bindings,
                                RoadMapKeyInput callback) {
   RoadMapMainInput = callback;
}

RoadMapMenu roadmap_main_new_menu (void) {

   return NULL;
}

void roadmap_main_free_menu (RoadMapMenu menu) {

}

void roadmap_main_add_menu (RoadMapMenu menu, const char *label) {

}

void roadmap_main_add_menu_item (RoadMapMenu menu,
                                 const char *label,
                                 const char *tip,
                                 RoadMapCallback callback) {

   NOPH_CommandMgr_t cm = NOPH_CommandMgr_getInstance();
   NOPH_CommandMgr_addCommand(cm, label, (void *)callback);
}

void roadmap_main_popup_menu (RoadMapMenu menu, int x, int y) {

}

void roadmap_main_add_separator (RoadMapMenu menu) {

   roadmap_main_add_menu_item (menu, NULL, NULL, NULL);
}

void roadmap_main_add_tool (const char *label,
                            const char *icon,
                            const char *tip,
                            RoadMapCallback callback) {
}

void roadmap_main_add_tool_space (void) {

}

void roadmap_main_add_canvas (void) {
   roadmap_canvas_configure ();
}

void roadmap_main_add_status (void) {

}

void roadmap_main_show (void) {

}

void roadmap_main_set_input (RoadMapIO *io, RoadMapInput callback) {

   if (io->subsystem == ROADMAP_IO_SERIAL) {
      /* We currently only support GPS input */
      if (!gps_mgr) gps_mgr = NOPH_GpsManager_getInstance();
      RoadMapMainIo[0].io = *io;
      RoadMapMainIo[0].callback = callback;
      NOPH_GpsManager_start(gps_mgr);
   }

#if 0
   int i;
   int fd = io->os.serial;

   for (i = 0; i < ROADMAP_MAX_IO; ++i) {
      if (RoadMapMainIo[i].io.subsystem == ROADMAP_IO_INVALID) {
         RoadMapMainIo[i].io = *io;
         RoadMapMainIo[i].callback = callback;
         RoadMapMainIo[i].id = 0;
         break;
      }
   }
#endif
}

void roadmap_main_remove_input (RoadMapIO *io) {

   if (io->subsystem == ROADMAP_IO_SERIAL) {
      /* We currently only support GPS input */
      if (gps_mgr) NOPH_GpsManager_stop(gps_mgr);
      RoadMapMainIo[0].callback = NULL;
      RoadMapMainIo[0].io.subsystem = ROADMAP_IO_INVALID;
   }

#if 0
   int i;
   int fd = io->os.file; /* All the same on UNIX. */

   for (i = 0; i < ROADMAP_MAX_IO; ++i) {
      if (RoadMapMainIo[i].io.os.file == fd) {
         RoadMapMainIo[i].io.os.file = -1;
         RoadMapMainIo[i].io.subsystem = ROADMAP_IO_INVALID;
         break;
      }
   }
#endif
}

void roadmap_main_set_periodic (int interval, RoadMapCallback callback) {

   int index;
   struct roadmap_main_timer *timer = NULL;

   for (index = 0; index < ROADMAP_MAX_TIMER; ++index) {

      if (RoadMapMainPeriodicTimer[index].callback == callback) {
         return;
      }
      if (timer == NULL) {
         if (RoadMapMainPeriodicTimer[index].callback == NULL) {
            timer = RoadMapMainPeriodicTimer + index;
         }
      }
   }

   if (timer == NULL) {
      roadmap_log (ROADMAP_FATAL, "Timer table saturated");
   }

   timer->id = 0;
   timer->callback = callback;
}

void roadmap_main_remove_periodic (RoadMapCallback callback) {

   int index;

   for (index = 0; index < ROADMAP_MAX_TIMER; ++index) {

      if (RoadMapMainPeriodicTimer[index].callback == callback) {

         RoadMapMainPeriodicTimer[index].callback = NULL;

         return;
      }
   }

   roadmap_log (ROADMAP_ERROR, "timer 0x%08x not found", callback);
}

void roadmap_main_set_status (const char *text) {

}

void roadmap_main_flush (void) {

}

void roadmap_main_exit (void) {

   roadmap_start_exit ();
}

void roadmap_main_set_cursor (int cursor) {}

/* Wait until some key is pressed */
static int wait_for_events(NOPH_GameCanvas_t canvas)
{
  static int counter = 0;
  int out = 0;

  while (1) {
     counter++;
     if (command_addr) break; /* Menu command */
     if (gps_mgr) {
       while ((RoadMapMainIo[0].io.subsystem != ROADMAP_IO_INVALID) &&
       	      (NOPH_GpsManager_read(gps_mgr, 0, 0) != 0)) {
         /* GPS data is ready */
         RoadMapInput callback = RoadMapMainIo[0].callback;
         if (callback) (*callback)(&RoadMapMainIo[0].io);
       }
     }
     if ((out = NOPH_GameCanvas_getKeyStates(canvas)) != 0) break;
     if ((counter % 300) == 0) {
       int i;
       for (i=0; i<ROADMAP_MAX_TIMER; i++) {
         if (RoadMapMainPeriodicTimer[i].callback) {
	   (*RoadMapMainPeriodicTimer[i].callback) ();
	 }  
       }
     }

     NOPH_Thread_sleep( 10 );
  }

  return out;
}

#define SLEEP_PERIOD 100
int main (int argc, char **argv) {

   int i;
   int should_exit = 0;
   NOPH_GameCanvas_t canvas;

   printf ("**** test: %d\n", strlen("sdfsdf"));

   for (i = 0; i < ROADMAP_MAX_IO; ++i) {
      RoadMapMainIo[i].io.os.file = -1;
      RoadMapMainIo[i].io.subsystem = ROADMAP_IO_INVALID;
   }

   canvas = NOPH_GameCanvas_get();

   roadmap_start_subscribe (roadmap_start_event);
   roadmap_start (argc, argv);

   if (NOPH_exception) {
      NOPH_Throwable_printStackTrace(NOPH_exception);
      exit(1);
   }

   NOPH_CommandMgr_setResultMem(NOPH_CommandMgr_getInstance(), &command_addr);

   /* The main game loop */
   while(!should_exit)
   {
      int keys;

      /* Wait for a keypress */
      keys = wait_for_events(canvas);

      if (command_addr) {
        ((RoadMapCallback)command_addr)();
	command_addr = 0;
      }

      roadmap_main_process_key (keys);
   }

   return 0;
}

2005	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov (92)	Dec (141)
2006	Jan (126)	Feb (72)	Mar (31)	Apr (200)	May (81)	Jun (130)	Jul (112)	Aug (134)	Sep (76)	Oct (89)	Nov (153)	Dec (9)
2007	Jan (59)	Feb (82)	Mar (50)	Apr (20)	May (9)	Jun (81)	Jul (41)	Aug (109)	Sep (91)	Oct (87)	Nov (33)	Dec (60)
2008	Jan (21)	Feb (15)	Mar (38)	Apr (75)	May (59)	Jun (46)	Jul (30)	Aug (20)	Sep (35)	Oct (32)	Nov (34)	Dec (19)
2009	Jan (29)	Feb (71)	Mar (54)	Apr (17)	May (4)	Jun	Jul (3)	Aug	Sep	Oct	Nov	Dec (3)
2010	Jan	Feb	Mar	Apr	May	Jun	Jul (3)	Aug (58)	Sep (7)	Oct (7)	Nov (12)	Dec (18)
2011	Jan (17)	Feb (29)	Mar (11)	Apr (5)	May (1)	Jun	Jul	Aug (11)	Sep	Oct	Nov	Dec
2012	Jan (2)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2014	Jan	Feb	Mar	Apr	May	Jun (87)	Jul	Aug	Sep	Oct	Nov	Dec
2015	Jan	Feb	Mar	Apr	May (44)	Jun (79)	Jul (16)	Aug (31)	Sep	Oct (51)	Nov	Dec
2016	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep (2)	Oct	Nov	Dec

roadmap-commit Mailing List for RoadMap (Page 71)

roadmap-commit — track CVS commits