roadmap-commit — track CVS commits

[Roadmap-commit] roadmap/src Makefile,1.130,1.131

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv15472

Modified Files:
	Makefile 
Log Message:
fix tarball creation


Index: Makefile
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/Makefile,v
retrieving revision 1.130
retrieving revision 1.131
diff -C2 -d -r1.130 -r1.131
*** Makefile	16 Oct 2008 19:38:45 -0000	1.130
--- Makefile	7 Nov 2008 23:32:06 -0000	1.131
***************
*** 335,339 ****
  # isn't common, so we distribute both.  (this version is slightly
  # different than that built in the web subdirectory.)
! MANUAL = manual.html
  
  # more products
--- 335,339 ----
  # isn't common, so we distribute both.  (this version is slightly
  # different than that built in the web subdirectory.)
! MANUAL = usermanual.html
  
  # more products
***************
*** 488,492 ****
  
  $(MANUAL): ../README
! 	-aptconvert -pi html showTitle yes -toc -enc ASCII $@ $<
  
  uninstall:
--- 488,494 ----
  
  $(MANUAL): ../README
! 	expand $< | \
! 	(cd ../doc; txt2tags --target html \
! 	    --toc --infile - --outfile - ) >$@
  
  uninstall:
***************
*** 571,576 ****
  
  # source files from "..", i.e. the real top-level.  these go into tarball.
! UPPER_SRC = README README.osm README.iphone \
!     STATUS AUTHORS BUGS TODO CHANGES COPYING INSTALL howtos/makemaps.txt 
  
  tarball: $(RELNAME)-src.tar.gz
--- 573,580 ----
  
  # source files from "..", i.e. the real top-level.  these go into tarball.
! UPPER_SRC = README COPYING 
! DOC_SRC = Bugs ChangeLog Coding Configuration Developer-Guide \
! 	Installation Map-Building Map-Designing Map-Format \
! 	OpenStreetMap Platforms Quickstart Status ToDo Usage
  
  tarball: $(RELNAME)-src.tar.gz
***************
*** 582,585 ****
--- 586,590 ----
  	@tar --dereference -czvf $(RELNAME)-src.tar.gz \
  	    $(addprefix $(RELNAME)/, $(UPPER_SRC)) \
+ 	    $(addprefix $(RELNAME)/doc/, $(DOC_SRC)) \
  	    $(addprefix $(RELNAME)/src/, $(shell \
  		  $(MAKE) -C $(RELNAME)/src --no-print-directory sourcelist) \

[Roadmap-commit] roadmap/doc Platforms,1.2,1.3

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/doc
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv14586/doc

Modified Files:
	Platforms 
Log Message:
XO builds only in CVS


Index: Platforms
===================================================================
RCS file: /cvsroot/roadmap/roadmap/doc/Platforms,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Platforms	7 Nov 2008 21:01:20 -0000	1.2
--- Platforms	7 Nov 2008 23:27:12 -0000	1.3
***************
*** 105,116 ****
    - Building the RoadMap.xo activity
  
!     Start with a relatively clean copy of the RoadMap source tree, and
!     change directory to "sugar", at the top-level of the tree.  From
!     there, simply run the script "mk_activity" -- this will build an
!     appropriately-configured copy of RoadMap, and adds the system
!     and user config to the the .zip-formatted archive that OLPC calls
!     a ".xo" bundle.  Just a few maps may be added to that bundle if
!     you have your maps installed in /usr/local/share/roadmap/maps --
!     otherwise no maps will be provided.
  
    - Installing maps
--- 105,116 ----
    - Building the RoadMap.xo activity
  
!     Start with a relatively clean copy of the RoadMap source tree from CVS
!     (not the tarball), and change directory to "sugar", at the top-level of
!     the tree.  From there, simply run the script "mk_activity" -- this will
!     build an appropriately-configured copy of RoadMap, and adds the system
!     and user config to the the .zip-formatted archive that OLPC calls a
!     ".xo" bundle.  Just a few maps may be added to that bundle if you have
!     your maps installed in /usr/local/share/roadmap/maps -- otherwise no
!     maps will be provided.
  
    - Installing maps

[Roadmap-commit] roadmap/doc ChangeLog,1.1,1.2

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/doc
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv13949/doc

Modified Files:
	ChangeLog 
Log Message:
bring changelog further up to date


Index: ChangeLog
===================================================================
RCS file: /cvsroot/roadmap/roadmap/doc/ChangeLog,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ChangeLog	7 Nov 2008 13:46:54 -0000	1.1
--- ChangeLog	7 Nov 2008 23:23:52 -0000	1.2
***************
*** 5,19 ****
  Roadmap v1.2.0 (??)
  
!  This list is current as of 3/17/2008, created with the help of
! 
  ```
!    cvs2cl.pl -l "-rv1_1_0::HEAD"
  ```
  
   Items marked (*) originated on Ehud Shabtai's roadmap_editor code branch.
  
  
    - Make the screen much more responsive when lengthy rendering is in
!   progress.  User "type-ahead" can now interrupt rendering.
  
    - Added a progress bar to show expected duration of lengthy repaints.
--- 5,96 ----
  Roadmap v1.2.0 (??)
  
!  This list is current as of 11/7/2008, created with the help of
  ```
!    cvs2cl.pl -l "-d2008/03/17<2008/11/30"
  ```
  
   Items marked (*) originated on Ehud Shabtai's roadmap_editor code branch.
  
+   - Refactored the documentation into more files for easier maintenance.
+     Switched to "txt2tags" (from "aptconvert") for generating online
+     copies of docs.
+ 
+   - Added "advanced style" support, which adds many new line types etc.
+     Currently still disabled via ifdef.
+ 
+   - Allow fatal message popups that occur very early to actually be seen. 
+     (Previously we were exiting before they were made visible.
+ 
+   - Added license message to About menu.
+ 
+   - Added ability to suppress on-screen errors entirely. (Joshua Layne)
+ 
+   - Added ability to auto-build makefile dependencies.
+ 
+   - Many source files now support doxygen format function and file headers.
+ 
+   - Added commandline arguments for setting the system and user config, and
+   the icon path.
+ 
+   - RoadGPS console now shows sun and moon positions.  (from Morten Bek)
+ 
+   - Tooltips now include key-binding help.
+ 
+   - Added support for OLPC XO laptop, in the form of scripts to bundle
+   RoadMap as an activity.
+ 
+   - Allow suppressing the "Lost Satellite" message with a timeout parameter.
+ 
+   - Resurrection of WinCE support, from Danny Backx (uses minw32ce).
+     Includes GPS autodetection.
+ 
+   - Added several revisions' worth of support for Apple iPhone and iPod,
+   from Morten Bek.
+ 
+   - Remove many redundant repaints, for better performance on slower
+     machines.
+ 
+   - Preserve label, dynamic orientation, and 2D/3D preferences.  (Joshua Layne)
+ 
+   - Add timeout which allows map to stop tracking the GPS after a short
+     delay if it's now off-screen.  (Useful when you pan away from the
+     GPS, to stop the map from continuing to move.)
+ 
+   - Rationalized the units used for storing and passing altitude.
+ 
+   - Improve handling of GPS devices that come and go.
+ 
+   - Added GPS time to GPS console screen.
+ 
+   - Merged RoadGPS functionality into RoadMap, so separate executable
+     is no longer necessary (though still available).
+ 
+   - "North Up" is now the default mode.  It's much more efficient.
+ 
+   - Code can now more easily destroy previously displayed message boxes.
+ 
+   - Can now handle many more satellites, and satellites with bigger ID
+     numbers, in RoadGPS.
+ 
+   - Fixed issue with new fields appearing in gpsd2 protocol sentences.  We
+     should now be tolerant of such changes in the future.
+ 
+   - Improved handling of messages that pop up when the GPS reception is
+   poor.
+ 
+   - Added ability to scale sprites, either individually, or all at once.
+ 
+   - Added font size control for RoadGPS.
+ 
+   - config files can now have CR ('\r') characters at end of line.
+ 
+   - Added ability to disable progress bar display, and configure its delay.
+ 
+   - Improved efficiency of map paths specified with "/..." -- the trees
+   are now only walked when needed.
  
    - Make the screen much more responsive when lengthy rendering is in
!   progress.  User "type-ahead" (or "mouse-ahead") can now interrupt
!   rendering.
  
    - Added a progress bar to show expected duration of lengthy repaints.
***************
*** 24,31 ****
    specified without editing any distributed files.
  
!   - New "--icons" command-line argument to accompany "--config" and
!   "--maps".  If specified, the values of "--icons" and "--config" are
!   passed to roadgps when it is started, so that it can find its config and
!   icons in the same places.
  
    - Modify what what focus is saved on shutdown -- if the focus
--- 101,108 ----
    specified without editing any distributed files.
  
!   - New "--user" and "--icons" command-line arguments to accompany
!   "--config" and "--maps".  If specified, the values of the "--icons" and
!   the "--config" options are passed to roadgps when it is started, so that
!   it can find its config and icons in the same places.
  
    - Modify what what focus is saved on shutdown -- if the focus

[Roadmap-commit] roadmap/doc Platforms,1.1,1.2

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/doc
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv16867/doc

Modified Files:
	Platforms 
Log Message:
add XO laptop section


Index: Platforms
===================================================================
RCS file: /cvsroot/roadmap/roadmap/doc/Platforms,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Platforms	7 Nov 2008 13:46:54 -0000	1.1
--- Platforms	7 Nov 2008 21:01:20 -0000	1.2
***************
*** 82,86 ****
             + \Program Files\roadmap\maps
             + \Storage Card\roadmap\maps (preferred path)
!            +
  
  
--- 82,128 ----
             + \Program Files\roadmap\maps
             + \Storage Card\roadmap\maps (preferred path)
! 
! 
! == OLPC XO Laptop Support ==
! 
! The XO laptop, created by the One Laptop per Child project, has a
! large high resolution (900x1200) sunlight-readable screen, making
! it attractive for use with RoadMap.
! 
! If the XO is running a "standard" linux distribution (Debian, Ubuntu,
! and Fedora are all available) then RoadMap installs just as it does
! on any other linux.  But if the laptop is running the OLPC "Sugar"
! system, then RoadMap must be packaged as a Sugar "activity", which
! adds some extra requirements to its environment.
! 
! A pre-built copy of RoadMap.xo is available at the OLPC Activities 
! page:
! 
!             http://wiki.laptop.org/go/RoadMap 
! 
! If that copy is inappropriate or unavailable, you can build your own.
! 
!   - Building the RoadMap.xo activity
! 
!     Start with a relatively clean copy of the RoadMap source tree, and
!     change directory to "sugar", at the top-level of the tree.  From
!     there, simply run the script "mk_activity" -- this will build an
!     appropriately-configured copy of RoadMap, and adds the system
!     and user config to the the .zip-formatted archive that OLPC calls
!     a ".xo" bundle.  Just a few maps may be added to that bundle if
!     you have your maps installed in /usr/local/share/roadmap/maps --
!     otherwise no maps will be provided.
! 
!   - Installing maps
! 
!     RoadMap will look for maps in a directory called
!     "RoadMap.maps" on any external media (SD or USB) that's
!     mounted in the standard /media/NAME location on the XO. 
! 
!     The default Map.Path on the XO is:
!          + SUGAR_BUNDLE_PATH/maps (i.e. below the installation directory)
!          + SUGAR_BUNDLE_PATH/maps/??
!          + /media/*/RoadMap.maps
!          + /media/*/RoadMap.maps/??
  
  
***************
*** 111,115 ****
  
         The iPhone binaries should be compiled using the unofficial iPhone
!        toolchain ({{http://code.google.com/p/iphone-dev/wiki/Building}}). 
         It should be possible to get the toolchain up and running on both
         OSX, Linux and MS Windows.  In config.mk set the DESKTOP to iphone
--- 153,157 ----
  
         The iPhone binaries should be compiled using the unofficial iPhone
!        toolchain (http://code.google.com/p/iphone-dev/wiki/Building). 
         It should be possible to get the toolchain up and running on both
         OSX, Linux and MS Windows.  In config.mk set the DESKTOP to iphone
***************
*** 119,128 ****
  
  ```
!           /tmp/Applications/RoadMap.app
  ```
  
         The binaries will have references to
  ```
!           /Application/RoadMap.app/resources
  ```
         so be sure to install in that location - or change your settings
--- 161,170 ----
  
  ```
!        /tmp/Applications/RoadMap.app
  ```
  
         The binaries will have references to
  ```
!        /Application/RoadMap.app/resources
  ```
         so be sure to install in that location - or change your settings
***************
*** 140,144 ****
         If you use the example options, simply use:
  ```
!           scp -r /tmp/Applications/RoadMap.app ro...@yo...:/Applications
  ```
         Notice that roadmap installs many additional binaries in
--- 182,186 ----
         If you use the example options, simply use:
  ```
!        scp -r /tmp/Applications/RoadMap.app ro...@yo...:/Applications
  ```
         Notice that roadmap installs many additional binaries in
***************
*** 149,153 ****
         Maps need to be placed in
  ```
!           /Applications/RoadMap.app/resources/maps
  ```
         Maps are in a binary format and sometimes need to be converted to or
--- 191,195 ----
         Maps need to be placed in
  ```
!        /Applications/RoadMap.app/resources/maps
  ```
         Maps are in a binary format and sometimes need to be converted to or
***************
*** 195,203 ****
      - Removing a prior installation of RoadMap
  
!        Since RoadMap 1.0.4 the path to the maps has changed. In addition there is
!        no more package for the maps (the maps are too big for that and there was
!        only one example map anyway). Therefore the roadmap-sfca package should be
!        removed first
! 
  ```
         ipkg remove roadmap-sfca
--- 237,244 ----
      - Removing a prior installation of RoadMap
  
!        Since RoadMap 1.0.4 the path to the maps has changed.  In addition
!        there is no more package for the maps (the maps are too big for that
!        and there was only one example map anyway).  Therefore the
!        roadmap-sfca package should be removed first
  ```
         ipkg remove roadmap-sfca
***************
*** 206,243 ****
         The name of the RoadMap package has also changed from roadmap-gtk2 to
         roadmap. Therefore the roadmap-gtk2 package should be removed:
- 
  ```
         ipkg remove roadmap-gtk2
  ```
  
- 
      - Making room for RoadMap
  
!        On a PDA with 32Mb of RAM, GPE takes most of the available space and less
!        than 2Mb of RAM is left available. For RoadMap to work one need to make
!        some room. The author recommends removing xstroke and the GPE help from
!        the bottom panel.
  
!        Another problem is a bug in the Familiar X server that causes the file
!        ~/.xsession-errors to grow infinitely in the ramdisk, eating up all the
!        available RAM in a matter of days.
         
!        The work-around is to not start the ipaq-sleep daemon. To do this,
         comment out the line "/etc/init.d/ipaq-sleep start" in the file:
- 
  ```
!                /etc/X11/Xsession.d/69ipaq-sleep
  ```
- 
- 
      - Installing gpsd
  
         RoadMap depends on gpsd for receiving data from the GPS device. Therefore
         the gpsd package must be installed:
- 
  ```
         ipkg install gpsd
  ```
- 
         Once this has been done, the serial line must be configured for using gpsd
         (see the serial line configuration tool in the Settings folder).
--- 247,277 ----
         The name of the RoadMap package has also changed from roadmap-gtk2 to
         roadmap. Therefore the roadmap-gtk2 package should be removed:
  ```
         ipkg remove roadmap-gtk2
  ```
  
      - Making room for RoadMap
  
!        On a PDA with 32Mb of RAM, GPE takes most of the available space and
!        less than 2Mb of RAM is left available.  For RoadMap to work one
!        need to make some room.  The author recommends removing xstroke and
!        the GPE help from the bottom panel.
  
!        Another problem is a bug in the Familiar X server that causes the
!        file ~/.xsession-errors to grow infinitely in the ramdisk, eating up
!        all the available RAM in a matter of days.
         
!        The work-around is to not start the ipaq-sleep daemon.  To do this,
         comment out the line "/etc/init.d/ipaq-sleep start" in the file:
  ```
!            /etc/X11/Xsession.d/69ipaq-sleep
  ```
      - Installing gpsd
  
         RoadMap depends on gpsd for receiving data from the GPS device. Therefore
         the gpsd package must be installed:
  ```
         ipkg install gpsd
  ```
         Once this has been done, the serial line must be configured for using gpsd
         (see the serial line configuration tool in the Settings folder).
***************
*** 252,256 ****
         the executable file. The problem is more where to find the executable..
  
- 
    - INSTALLING ROADMAP
  
--- 286,289 ----
***************
*** 268,282 ****
  
         If RoadMap is available from your feed:
- 
  ```
!           ipkg install roadmap
  ```
- 
         If you downloaded the ipk files on the iPAQ:
- 
  ```
!           ipkg install roadmap_X.Y.Z_arm.ipk
  ```
- 
         RoadMap is useless without maps. The maps can be downloaded from the
         web site (http://roadmap.sourceforge.net/maps.html or mirrors) or
--- 301,311 ----
  
         If RoadMap is available from your feed:
  ```
!        ipkg install roadmap
  ```
         If you downloaded the ipk files on the iPAQ:
  ```
!        ipkg install roadmap_X.Y.Z_arm.ipk
  ```
         RoadMap is useless without maps. The maps can be downloaded from the
         web site (http://roadmap.sourceforge.net/maps.html or mirrors) or
***************
*** 304,308 ****
         tarball. See the next section for more details.
  
- 
      - Installing maps
  
--- 333,336 ----

[Roadmap-commit] roadmap/web navbar.html,1.7,1.8

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/web
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv12644/web

Modified Files:
	navbar.html 
Log Message:
add the platform doc to the navbar


Index: navbar.html
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/navbar.html,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** navbar.html	7 Nov 2008 13:46:54 -0000	1.7
--- navbar.html	7 Nov 2008 15:15:10 -0000	1.8
***************
*** 9,12 ****
--- 9,13 ----
     <a class="navitem2" href="quickstart.html">Quickstart</a> <span class="invisible">|</span>
     <a class="navitem2" href="usermanual.html">User Manual</a> <span class="invisible">|</span>
+    <a class="navitem2" href="platforms.html">Platform-specifics</a> <span class="invisible">|</span>
     <a class="navitem2" href="devguide.html">Developers Guide</a> <span class="invisible">|</span>
     <a class="navitem2" href="buglist.html">Bug list</a> <span class="invisible">|</span>

[Roadmap-commit] roadmap/doc Bugs, NONE, 1.1 ChangeLog, NONE, 1.1 Coding, NONE, 1.1 Configuration, NONE, 1.1 Developer-Guide, NONE, 1.1 Installation, NONE, 1.1 Map-Building, NONE, 1.1 Map-Designing, NONE, 1.1 Map-Format, NONE, 1.1 OpenStreetMap, NONE, 1.1 Platforms, NONE, 1.1 Quickstart, NONE, 1.1 Status, NONE, 1.1 ToDo, NONE, 1.1 Usage, NONE, 1.1

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/doc
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv31569/doc

Added Files:
	Bugs ChangeLog Coding Configuration Developer-Guide 
	Installation Map-Building Map-Designing Map-Format 
	OpenStreetMap Platforms Quickstart Status ToDo Usage 
Log Message:
major documentation refactoring.  "chapters", written in txt2tags
format, are now under the doc subdirectory, and are presented on
the web in some cases as standalone docs, and in other cases combined.
and 


--- NEW FILE: Status ---
Project Status
Paul Fox, current RoadMap maintainer
November 2008

= New Release 1.2.0 =

    RoadMap has another new release.  It's been over a year
    since 1.1.0 was released.  Lots of work has been done since
    then, both in terms of features, and platform support.

    Major new developments in 1.2.0 include;

        - Support for OpenStreetMap maps, both geographically-based
          (i.e., arbitrary rectangular tiles) and political (i.e.,
          country-based).  The ability to use OSM maps moves RoadMap
          from being a highly US-centric program to one which can
          be useful worldwide.

        - Resurrection of the Windows CE port.  Since the port is
          supported via cross-compilation with ming32w, maintenance
          is much easier for the developers.

        - Initial support of the iPhone.
        


    There's more detail in the changelog.

= Two Branches =

    Not much progress has been made in merging code from the forked
    "roadmap_editor" branch, but some work has been ongoing.
    (Managed by Ehud Shabtai "roadmap_editor" has
    added the ability to create and edit maps, and to upload the
    results to a central postgres database.  Since the maps as
    created can contain the meta-data needed for successful
    auto-navigation, that feature has been added to the
    roadmap_editor branch as well.  This codebase is being used
    very successfully in the FreeMap Israel project.
    
        http://www.freemap.co.il

    (Sadly for many of us, google doesn't yet translate Hebrew.)

= Help Wanted! =

    If you know something about GIS and want to help with the
    conversion of new map sources, or are just a good coder who
    wants better open-source mapping capabilities, please join
    the list and we'll figure out how you can help!



--- NEW FILE: OpenStreetMap ---
RoadMap and OpenStreetMap map data

November 2008


= Using OpenStreetMap Maps =

This information is preliminary, since OSM support is
work-in-progress.  It does work, but may change in detail.

  - Indexed maps

    The maps that RoadMap renders come from several sources (TIGER, various
    shapefile formats, OpenStreetMap). They all need to be indexed for use
    by RoadMap for several reasons. First, we don't want to overload RoadMap
    to be with several ways to interpret the same data. Second, there's not
    always a direct mapping between the coordinates on the screen where
    RoadMap is trying to displaya map, and the name of the map file(s) that
    contain(s) information for that region.

  - File name formats

    The map files are named in a way that depends on how the data was
    obtained and therefore, how the data is organized.  A map file called
    "usc25027.rdm" contains contains data from county 27 in state 25).  A
    map file called iso-be.rdm contains the whole country "be".  A third
    map file format is based on QuadTiles.

    The files contain some information that RoadMap can use to figure out
    where it is -- an index is made using this information so that RoadMap
    doesn't need to continually look in all the files.  That index is
    currently called "usdir.rdm".

  - QuadTiles, RoadMap tileid values, and filenames

    If the name of the file holding the map data encoded its position and size
    somehow, then an index wouldn't be needed (at least for positioning --
    there are other reasons an index is useful, but none are as critical to
    rendering).  For maps whose data source is organized by geography (i.e.,
    latitude/longitude) rather than politics (i.e.  country name), it's
    possible to do such an encoding.

    The encoding used by RoadMap for OpenStreetMap (OSM) maps is known as
    "quadtile" encoding.  There's a good description of quadtiles as they
    relate to OSM on the OSM wiki, here:

       http://wiki.openstreetmap.org/index.php/QuadTiles

    (There's also a more general article on Wikipedia.) The OSM quadtile
    scheme uses a full 32 bits worth of addressing in a "tileid", and can
    reference tiles as small as 600 meters on a side (at the equator --
    they're narrower further north and south).  RoadMap doesn't need such
    fine-grained resolution, and uses fewer bits for RoadMap tileids.  This
    frees those bits to be used for other purposes, and RoadMap uses only 27
    bits to address quadtiles (the smallest addressable tile is about 2.4km on
    a side).  Of the 5 bits remaining in a 32 bit word, RoadMap uses one bit
    internally to distinguish a tileid from one of the "FIPS" county
    identifiers that represent RoadMaps other maps, and the other 4 are used
    to encode how many bits of the 27 address bits are currently in use -- the
    4 bits are used to represent "bit count" values of 12 through 27, maximum
    and a minimum tile sizes that RoadMap can handle of from 2.4km up to 320km
    on a side.

    The encoded RoadMap tileid is used directly to form the filename
    representing the data for that OSM quadtile.  The tileid is represented in
    hexadecimal.  The lowest 4 bits (the least-significant hex digit) is 12
    less than the bit level -- so a 19 bit tile would have a '7' in that
    digit.  The OSM quadtile value appears in the other 7 hex digits.  Its
    value is "left-justified" -- i.e., as more bits are added to the quadtile
    address, the address grows to the right. 

    As an example, to RoadMap encoding of the 19 bit OSM quadtile id of
    251833, would be 0x3d7b9007.  (251833 is 0x3d7b9 in hex).

  - Fetching OpenStreetMap data by QuadTile

    OSM map data is available from servers on the web, using a simple API.  As
    simple as it is, though, it can produce a lot of data in XML format, very
    quickly.  While it might not be a problem for desktop systems with
    high-speed connections, if RoadMap is to be able to do on-demand loading
    of OSM data, an alternative protocol is preferable.  Conveniently, work
    has already been done to specify just such a compact profile.  Known as
    the "OSM Mobile Binary Protocol", it is documented here: 

       http://wiki.openstreetmap.org/index.php/OSM_Mobile_Binary_Protocol

    Roadmap comes with code which can provide data in this format, which can
    be run in two different ways:  either as a a command-line program, or as a
    proxy server implemented as a CGI script.  The two programs share most of
    their code, and are written in PHP.

    Converting the "Mobile Binary" data to a format useable directly by
    RoadMap is handled by the command "buildmap_osm".  Given some information
    about position and area, the size of the quadtiles desired, and the source
    of the data, buildmap_osm will produce the RoadMap .rdm files necessary
    for displaying that region.

    buildmap_osm can be given two lat/lon pairs, to specify a bounding box, or
    a single lat/lon pair plus a radius in miles or km (it's not really a
    radius -- the distance again actually describes a square bounding box). 
    The size of the quadtile to fetch is specified in "bits" (see the previous
    section), and the source of the data is specified either as the PHP
    "osmgetbmap" command, or as a URL referring to an installed version of the
    PHP cgi script.

    A sample command looks like:
```
        buildmap_osm -m /tmp/maps -s osmgetbmap 48.135,17.125:20km
```
    which will fetch 40 km square worth of maps centered on Bratislava.  Using
    the web proxy, the same request might look like:
```
        buildmap_osm -m /tmp/maps -s http://localhost:801/cgi-bin/bmap.php \
            48.135,17.125:20km
```

  - Fetching OpenStreetMap data in large chunks

    The OpenStreetMap servers only allow obtaining a limited amount of map
    info per query. Access via the OSM Mobile Binary Protocol is subject to
    such limitations.

    Other services (e.g. http://download.geofabrik.de/osm/europe/) provide
    access to large chunks of OSM data in a single file, e.g. a file per
    country, like the maps used in many commercial GPS devices.

    The buildmap_osm command was extended to be able to process those files.
    A sample command looks like
```
      buildmap_osm -i iso-be.osm -o iso-be.rdm
```
    which will convert one file into the other.

    The file name format is twofold : iso-xx.rdm or iso-xx-yyy.rdm . The former
    is a file per country (xx is the ISO two-character code for the country).
    The latter format allows for country subdivisions (yyy is a subdivision of
    country xx). The codes xx and yyy are defined in the ISO-3166-1 (country)
    and ISO-3166-2 (country subdivision). Note that the latter is incomplete.

  - Limitations
    
    - Because the OSM maps are loaded based on geographic location, they
      currently have no notion of political locality.  This means that
      searching by address or intersection can't currently work.

    - There's no way currently to do on-demand loading of OSM maps.  Work
      needs to be done to integrate a buildmap_osm "method" into RoadMap's map
      download scheme.

    - When a tile is fetched, it will include all roads (and other lines --
      "ways" in OSM parlance) which start or end in that tile.  This leads to
      two interesting issues:

      + The true bounding box of the data in a fetched tile is probably not
        going to line up with the presumed dimensions of that tile.  The
        bounding box may be smaller (if there is very little data, all within
        the bounds of the tile), or larger (as a result of roads and other
        features extending past the tile "boundaries").

      + When a neighboring tile is fetched, it may include the same line, if
        the other end of the line is in that tile.  In order to reduce the
        amount of duplicated data, when tiles are fetched via the "mobile
        binary" protocol, we tell the server that we already have tiles to the
        south and east, but not to the north and west.  This way, if you load
        a full set of tiles, you should get just one copy of any line.  The
        osmgetbmap code, however, doesn't do a perfect job of figuring out
        what not to give you based on what you say you already have, so you
        may get duplicated data, particularly around the edges of the area
        requested.  The order in which RoadMap fetches tiles might need to be
        changed to help with this problem, as well.

    - Because tiles can provide overlapping data, map rendering near the edges
      of tiles can be somewhat messy -- the lines on one tile may be
      rendered before the polygons of the next, for instance, and labels
      placed when rendering one may collide with labels placed when
      rendering the next.  For this reason, tiles should be kept fairly
      large -- RoadMap already has the means to make rendering relatively
      large areas efficiently.  The only reason to choose small tiles is to
      reduce "latency" when requesting data on-demand.




--- NEW FILE: Map-Designing ---
Creating a Map for RoadMap HOWTO
Pascal Martin (pas...@po...)
December 2005


= INTRODUCTION =

   This HOWTO describes how to create a new map for RoadMap. The intent is
   not to provide a complete description of the RoadMap map format, only
   to guide the authors of new maps in the complicated process of gathering
   and organizing the data.

   Some programming is usually necessary, as the map data may come in
   various forms. In this document the term "RoadMap code" always make
   reference to the source of the buildmap programs. In no circumstance
   should the roadmap program itself be modified, as this would break
   compatibility with pre-existing maps.


= OVERVIEW =

   There are four major phases involved when creating maps for RoadMap:

   - One must decide how the maps will be organized. It is important to
   have a good idea of how the country is organized and how individual
   addresses are formatted (the format of addresses will have an influence
   on the maps organization).

   - Then the format of the data source must be identified and analyzed.
   Knowing the data come in a shape file is not enough, as there are many
   different ways of organizing shape file data. Typical questions to answer
   are: what are the layers? What field describes the layer for a specific
   feature? How does the data source layers match the Roadmap layers?

   - A map builder input module may need to be modified or customized to
   handle the specific format used by the data source.

   - The map builder application must be run and the map indexes created.

- PLANNING THE MAP ORGANIZATION

   The preliminary step when building a map is always to decide how the
   data will be organized. There are a many different cases, among them
   the main ones are:

   - The map will represent a new class of features.

   - The map will cover a new country.

   - The map will cover an existing country and represent existing features.

   Even in the more complex cases when the map to be built represents new
   features for a new country, it is recommended to reduce the problem by
   separating these two steps: first define a new class of features and
   then define a new country.

   It is strongly recommended to reuse existing classes as much as possible,
   even if that requires to split the data in more RoadMap map files.

   If maps already exist for this country, the existing country subdivision
   system must be reused as is. Changing the way the country's maps are
   organized would require to regenerate the existing maps and would cause
   the new set of maps to be incompatible with maps from other authors.

   RoadMap use index files to retrieve which map files to use to represent
   the visible area or to locate a given address. These index files represent
   a hierachical organization that provide RoadMap with a fast search and
   access mechanism to the maps. Many of the constraint regarding the
   organization of the maps are direct consequences of the way the index
   files are organized.

- DATA SOURCE FORMAT

   There are two main situations: either the format of the data source is
   or is not supported by the RoadMap map builder (buildmap).

   In the first case, a new buildmap module must be created (see the section
   IMPLEMENTING A NEW BUILDMAP MODULE).

   In the second case the odds are that your data implements a <<variant>>
   of the supported format and the existing support code in RoadMap must be
   modified.

   Why is it that way? Lets consider the ESRI "shape file" format. This
   format defines two files: the shape file itself (.shp) describes the
   lines and polygons. This is where all the geometry information is stored.
   A database file (.dbf) describes the attributes associated with each
   feature described in the shape file. This is actually a DBASE III file.
   It seems that different data sources describe the features using
   different fields and conventions, so the RoadMap code must be modified
   to access the correct fields. Also, each data source defines its own
   set of layers and thus the mapping of these layers to the RoadMap layers
   must be customized as well.

   Most map data organization is kind of complicated, especially the way
   attributes are organized. So one would be wise to take some time to
   understand what is exactly the data he is going to process.

   It is common for the layers to be split in separate file sets. The RoadMap
   code is not really organized to handle this. So either the RoadMap code
   must be modified, or else the data must be merged using standard GIS tools.

- BUILDMAP INPUT MODULES

   A buildmap input module must provide the following function:

```
   buildmap_xxx_process (const char *input, const char *class);
```

   This function must be called in buildmap_main.c

   The input parameter indicates the file or files to load the data from.
   This name follows whatever conventions are specific to the format of
   the data. The class parameter indicates which Roadmap class is to be
   processed.

   Note that no output name is provided: the output map has already been setup
   by buildmap and the input module should call the appropriate buildmap
   table modules. The buildmap table modules are documented in the RoadMap
   documentation.


= LAYERS =

- LAYER CLASS

   Every feature stored in a RoadMap map file belongs to one layer. Layers
   are organized in classes. Each map file provides features that belong to
   layers within a single class.

   In other words, a class describes all the layers provided in one set
   of map files. A typical example would be a class representing all roads
   or a class representing all land uses (city area, national parks, etc..)


- DEFINING A NEW LAYER CLASS

   A layer class is made of two lists of layers:

   - One list for all line features (for example: streets).

   - One list for all polygon features (for example: lakes).

   Each list is an ordered sequence of layers. The order in the sequence
   defines the drawing order. Note that all polygons are drawn before any
   line, no matter what class these belong to.

   Each class is described in a class description file. This is a text file
   that contains a list of properties. This is where the lists of lines and
   polygons are defined, as well as the colors and width used for each feature.

   At a minimum there must be one class description file, representing the
   "default" representation of the class, or else there can be two such files,
   one defining the daylight time representation and the other the night
   time representation.

   Note that one can create alternate skins by redefining a complete set
   of description files for all classes. These alternate skins must implement
   the same classes and features as in the default description files.

   The drawing order across classes is defined by defining sorting criteria:
   the "before" and "after" properties. The "before" property lists classes
   that this class must be before of, i.e. the current class must be drawn
   before the listed classes. The "after" property lists classes that this
   class must be after of, i.e. the current class must be drawn after the
   listed classes.

   Note that all maps for a given territory are treated as one set in the
   index files. In other words, the index system stops at the territory:
   Roadmap will scan all the maps files for that territory with no or little
   optimizations.


= MAP ORGANIZATION =

   RoadMap divides earth into territories, usually defined by administrative
   boundaries (international borders, local goverment with one country,
   etc...). Other organizations are possible (such as maps defined by a
   geographical location) but are not yet supported.

   The territories are organized in a tree fashion, where the top level is
   the country, as defined by its international borders. The rational for
   this division of the world is that the source of most map data is usually
   defined by country (most of the time the data is provided by a government
   body).

   The country level follows the agreed (or not so agreed on) international
   borders. If the list of countries changes, the organization of the maps
   must change. That the least of the problems that are to be faced when
   this happens...

   The territory tree can have 2 or more levels, depending on the country.
   The top and middle levels must have a name and are usually called
   "authority" within Roadmap. Each item at the lowest level defines one
   territory covered by one set of map files. The top and middle levels
   only exist in the index files.

   In order to limit the size of each individual maps, the low level
   territories should represent a entity of a limited size. 

   A RoadMap map file will represent a class of features for a given low
   level territory.  Example of feature classes are: roads, water area,
   elevation lines, etc..


- MAPS IDENTIFICATION

   [ This section proposes an unimplemented design. ]

   It is important to understand how maps are identified. RoadMap uses a
   32 bits integer named World Territory ID (wtid) and defined as follow:

    - The wtid is made of 10 decimal digits. There are two major classes
    of wtid format: one is defined by legal boundaries and the other is
    defined by a longitude/latitude grid. At that time, only the legal
    boundaries class of wtid is supported in RoadMap.

    - the legal-boundaries wtid for countries has the format 0CCCCXXXXX,
    where CCCC is the telephone dialing code for the country covered by the
    maps and XXXXX is a subdivision inside that country, wich format depends
    on the country's legal organization. A XXXXX of 00000 represents the
    whole country.
 
    - The legal-boundaries wtid for the USA has the format 00000SSCCC where
    SSCCC is the county's FIPS code. Note that, in this case, the value of
    the wtid exactly matches the value of the FIPS code. A CCC of 000 means
    the whole state. A wtid value of 00000 represents the whole US.

    - The grid wtid have the format: 1CCLLLLllll where LLLL is a number that
    represents the longitude span covered by the map and llll is a number
    that represents the latitude covered by the map. CC identifies the type
    of grid used to define the map; value 00 represents the USGS "quad" grid.
    When the USGS quad grid is used, LLLL and llll are formatted as DDDQ,
    where DDD is the decimal degree (range 0-360 for longitude and 0-180
    for latitude) and Q is the quad index (range 1-8, where 1 represents
    the low order longitude or latitude value and 8 the high order value).
 
   The details of the format of the wtid is never used by RoadMap: its
   sole purpose is to ensure the generation of a unique and consistent
   map identification code.
 
   An individual map will be uniquely identified in RoadMap using two
   integers: the wtid and the class index. The class index is defined using
   the list of classes when RoadMap loads the class description files and
   is never stored on disk. The wtid is predefined (see above) and is stored
   in the map files.

   The international dialing codes are defined in the ITU Operational
   Bulletin No. 835. For more information, go to:

      http://www.itu.int/itu-t/bulletin/annex.html

   RoadMap also use names to identify authorities (such as when it searches
   for the location of a given address). These names mimics the wtid using
   ASCII official codes for the countries and sub-territories. The format
   is <country> / <sub-authority>, where sub-authority may also be a slash-
   separated list of legal entities. For example, the format of the code
   name for the US is: us/<state code> (the code name for California is
   thus "us/ca"). The code name must be suitable for address search.
   The country code name follow the iso 3166-1 standard. See:

      http://www.iso.org/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html

   The sub-authority levels must follow the local country convention for
   postal addresses and city identification.

   Each country can also be subdivided into a single level list of territories
   (flat model) or using multiple levels (subtree model). For example the US
   is split into its individual states, and each state is split into counties,
   so that the tree is: country (US) / state / county. Only the lowest
   territory level is represented by map files. The upper levels (named
   "authority" levels in RoadMap) only exist in the RoadMap index files.

   As a general rule, the choice between a flat or sub-tree model should
   be directed by the format of a street address, especially how a city
   is identified. For example, a country like France has a single authority
   that administers city name, so a name like "Lyon" identifies a single
   city in France and a flat model should be used. This is not true in
   the US, where the city names are managed at the state level, so that
   a US city name must be suffixed using the state symbol. In the case of
   the US a two-level model should be used.

   Note that one index file may contains 1 or 2 levels of the tree: one
   authority level only (a "grand index"), the territory level only (a map
   index) or both (a multilevel index). The index itself belongs to its
   own parent authority (as described in the metadata table), like any other
   map file. This parent authority is the common upper level authority above
   all listed authority, or the common level above the listed territories
   (if there is no authority table).

   Continuing with the US example, the US can be represented in two ways:

     - as a single index, which belongs to the US country, authorities are
     the US states and territories are the counties.

     - as a two-level tree of indexes: the top-level index lists the states
     as authorities and contains no territory, map or cities tables; each
     lower level index represents one state, lists counties as territories
     and contain no authority table.

   Usually the world is represented using a grand index that contains the
   list of countries as authorities.


- DEFINING A NEW COUNTRY

   If the country was not represented in RoadMap yet, the division of the
   country into sub-territories must be decided. There are several criteria
   to consider:

      - The territories must be compatible with the way postal addresses
      are organized. The major requirements are that city names should be
      unique inside a map file. If possible, the middle level authority levels
      defined for that country, if any, should match the country's postal
      convention as well.

      - The territories should be compatible with the way the data source is
      organized. It is possible to reorganize the data according to different
      criteria, for example by splitting or merging files, but this introduces
      a new level of complexity and should be avoided when possible.

   Once this is achieved, a numerical identification system must be decided.
   It is recommended to use the country identification scheme when it exists.
   Many countries have defined a numerical ID for each legal entity and that
   ID should be as much as possible the basis for the encoding of the wtid.

   Names must be defined for each authority. Postal conventions must be used
   when they exist. An authority is identified using either a short symbol
   (such as "CA" for Califoria), or a full name ("California" to follow with
   our previous example). When RoadMap will try to locate an address, it
   will assume that the names in the address either match the symbols or
   full name of authorities. The best performances will be achieved if the
   authority tree for that country matches the postal conventions exactly.

   For example, if the address reads "san francisco, ca, usa", RoadMap will
   search for a top level authority identified as "usa", then a lower level
   authority identified as "ca". Some defaults might be used, depending on
   the current location (so that "san francisco, ca" would also search through
   California if you happen to be in the USA). Some confusions may be avoided
   by using full names (such as "vancouver, canada").

   A new country must be described in the file countries.txt. Here is an
   example  of a countries.txt file describing the US and canada:

```
       # List of countries, format: iso 3166-1, itu E.164A (except USA), name
       us,0,USA
       ca,1,Canada
```

   The country's list of parent territories must be described in a separate
   file for each country, so that each country can be maintained independently.
   The file's name must follow the convention: country-<country-symbol>.txt
   (for example, "country-us.txt" for the US).

   The format of the file is:

```
        wtid,symbol,name[,parent-authority-symbol]
```

   The wtid must be empty if an authority is described (since no map file
   exists for an authority) and the parent authority's symbol must be empty
   if the authority is the country itself. The symbol item is usually empty
   for the territory level, but this is not required.

   Here is an example that describes the state of Rhode Island (USA):

```
        ,RI,RHODE ISLAND
        44001,,Bristol,RI
        44003,,Kent,RI
        44005,,Newport,RI
        44007,,Providence,RI
        44009,,Washington,RI
```

   For large countries it is recommended to locate the official description
   of legal entities and to write a tool to translates it's original format
   into the format assumed by RoadMap. This saves from painful updates when
   the list changes.


--- NEW FILE: Installation ---
RoadMap Installation

November 2008

= Full Installation Guide =

  - DEPENDENCIES

     - GPS and gpsd

       RoadMap communicates with a GPS receiver using the NMEA 0183 protocol.
       RoadMap has been tested with a Garmin 38.  The GPS receiver must be
       configured with the datum set to either NAD83 or WGS 84.

       RoadMap can connect directly to the GPS receiver using a serial port (or an
       emulated serial port in the case of USB receivers), but RoadMap usually
       communicates with the GPS receiver through gpsd, a GPS communication daemon
       for UNIX.  Going through the intermediate daemon insulates RoadMap from
       some of the GPS configuration, and lets more than one program use the
       GPS device at once.  It also allows RoadMap to use a GPS device which is
       connected to a different computer.  The most typical setup is to have
       gpsd on the same computer, in which case the GPS source should be set as
       "gpsd://localhost".

          http://gpsd.berlios.de

       gpsd is not required when building RoadMap, and RoadMap can run without
       gpsd as a static map viewer or address finder.

     - Desktop toolkit

       RoadMap usually uses one flavor or another of GTK or QT for its user
       interface.  One of these toolkits must be installed.  RoadMap can be built
       for QT/QPE, but the RoadMap makefile for QT must be modified.

     - Voice support

       RoadMap optionally uses flite (festival lite) to generate voice messages.
       See the section "VOICE INTERFACE" for more information.

     - Optional libraries

       RoadMap uses the expat library to load GPX trip and landmark files.
       RoadMap can be built without expat, with some loss of functionality, by
       changing config.mk to say:  EXPAT = NO.  (On Debian or Ubuntu linux
       systems, use "apt-get install libexpat1-dev" to install the expat
       library.)

       Likewise, RoadMap can sometimes use the agg library to render anti-
       aliased maps and street label text.  If you don't have agg, RoadMap will
       only create horizontal labels.  (Angled labels are available using a
       relatively crude built-in font.  To use agg, you need to change the
       default "AGG = NO" in config.mk to choose one of the options listed
       there.  Unfortunately those options ("rgb565", "rgba32", "bgra32",
       "rgb24", "bgr24") cannot currently be auto-detected, so there may be
       some trial-and-error involved to get the setting right.  See the
       comments in config.mk for more tips.  RoadMap requires version 2.4 or
       later of the agg library -- 2.3 is incompatible.  If your linux
       distribution includes 2.3, make sure that if you install 2.4 as well,
       that RoadMap finds both headers and libraries from 2.4.  Note:
       currently (as of August, 2006) the agg support is only available if
       you're using the GTK2 build of roadmap.  (On Debian or Ubuntu linux
       systems, use "apt-get install libagg-dev" to install the agg library.)

       The "buildmap" program uses the shapelib library to decode the "shapefile"
       format).  Currently, most of the maps used by RoadMap are not in that
       format, but some are: Canadian provinces, state boundaries, and the Digital
       Charts of the World.  If only US maps from the census bureau are used,
       or if only pre-built maps are used, then there is no need for shapelib:
       set SHAPEFILES = NO in config.mk.  (On Debian or Ubuntu linux systems, use
       "apt-get install libshp-dev" to install the shapefile library.)

     - Miscellaneous

       RoadMap uses "aptconvert" to format the documentation (see previous
       section) into HTML format.  Since this is an uncommon tool, a
       pre-converted copy of manual.html is provided in the RoadMap tarball.

       RoadMap can use the "convert" program from the ImageMagick package to
       generate the PNG versions of some of the icons on its toolbar.  Pre-built
       copies of these PNG files are distributed, so ImageMagick is optional,
       and in any case is only required for building RoadMap -- it is not
       necessary when running RoadMap.


  - DIRECTORIES

    RoadMap is to be installed in a few different directories, where each
    directory contains a specific type of file: commands, configuration files,
    icons and maps.

    Before you install RoadMap, you must choose what installation
    directories to use for these files.  Some of these choices are already
    made for you when you install a pre-built package, or are assigned
    default values in the makefiles (source package).  This section
    describes the whole thing, regardless of how you install RoadMap.  It
    also provides some information about the standard locations in the most
    common cases.

    RoadMap supports searching through lists of directories, instead of just
    a single location, for each type of file.

    One reason for RoadMap to support a list of directories is to define a
    default system-wide configuration, and at the same time to allow a
    specific user to install their own setup.  Another reason (for the map
    files on a PDA) is to let the users choose the type of hardware storage
    that is most convenient.

    Directory pathnames in most RoadMap path lists can include several
    "shortcut" characters:

      - If a path begins with '~', then the rest of the path is relative
        to the users home directory (i.e, $HOME).  This is similar to
        the behavior of many UNIX shell programs.

      - If a path begins with '&', then the rest of the path is relative
        to the RoadMap "user configuration" directory, which is $HOME/.roadmap.

      - If a list of pathnames includes a path ending with "/..." then that
        path, //plus// the entire sub-tree of (unhidden) directories beneath it
        are added to the list of pathnames.  So if Map.Path is set with:

```
        Map.Path: /etc/roadmap,&/maps/...
```

        and ~/.roadmap/maps/moremaps/foo and ~/.roadmap/maps/.secret/bar are
        both actual directories, then the final list of paths used when
        looking for maps will be:

          - /etc/roadmap
          - $HOME/.roadmap/maps
          - $HOME/.roadmap/maps/moremaps
          - $HOME/.roadmap/maps/moremaps/foo
          -

        /etc/roadmap will not be searched for subdirectories, because it was
        not specified with a trailing "/...", and nothing below
        ~/.roadmap/maps/.secret will be searched, because ".secret" is "hidden"
        in the traditional UNIX sense.  The subdirectory search will follow
        symlinks.

        This feature can be used, for instance, to help keep maps of a single
        region together, by letting them be more easily put into separate
        directories.  If a subdirectory may come and go while RoadMap is
        running, e.g. if it's on removeable media, then it should be named
        specifically in the preferences -- the complete list of
        subdirectories is only enumerated at startup.

  - EXECUTABLE FILES

    The RoadMap programs should be installed in a standard executable directory.
    This is an easy one: the only requirement is that this directory must appear
    in the PATH variable (either you choose an existing directory or you add your
    own).

  - CONFIGURATION FILES

    RoadMap comes with some critical configuration files (files sprites,
    preferences, etc..).  RoadMap can find these files in a few different
    places, but the list cannot be changed in the user preferences since it
    is used to load the preferences themselves.  The list can, however, be
    changed using the "--config=..." commandline option.

    On most UNIX systems this list is:

           + /etc/roadmap,
           + /usr/local/share/roadmap (preferred path),
           + /usr/share/roadmap
           + a site-specific directory chosen at compile time, and
           + ~/.roadmap (the "user configuration" directory, which can be
             referred to as '&' in other path references).  The specific value
             of the path to the "user configuration" directory is configurable,
             using the General.UserPath setting.  The "user configuration"
             directory can be changed using the "--userpath=..." commandline
             option.
           +

    These directories are searched sequentially: any configuration item found
    in one directory overrides all the same items found in the directories
    listed before. In other words, the configuration is loaded in the following
    order:

        + /usr/share/roadmap (installation defaults)
        + /usr/local/share/roadmap (local site defaults)
        + /etc/roadmap (local machine defaults)
        + ROADMAP_CONFIG_DIR, chosen at compile time
        + ~/.roadmap (current user configuration)
        +

    The directory ~/.roadmap contains the user configuration: any changes
    the user makes while running RoadMap are saved here.  The items in the
    user configuration take precedence over the "default" configuration
    defined in the "shared" directories.  The user configuration directory
    can be referred to with the shorthand '&' in other parts of the roadmap
    config.

    The user directory ~/.roadmap usually has two subdirectories:
    "trips" and "maps".  "Usually", because while the directory
    ~/.roadmap/trips is used as the default location for the trip files,
    it can be changed with the General.TripsPath setting.  Note that trip
    files can be stored anywhere, not just in that directory -- they're just
    more convenient for selection when stored there..

    The directory ~/.roadmap/maps contains map files specific for this
    user.  (As a general rule, users should probably share maps, since they
    can take a lot of space.)  This directory might be used when maps
    are downloaded on the fly, as shared maps might not be writeable by all
    users.

    These user configuration directories are created if they do not exist.

  - ICON FILES

    RoadMap (the GTK version, at least) needs some icons.  These icons must
    be placed in the operating system's standard locations.  On UNIX, this
    usually means:

           + ~/.roadmap/pixmaps,
           + ROADMAP_CONFIG_DIR/pixmaps, chosen at compile time,
           + /usr/local/share/pixmaps or
           + /usr/share/pixmaps.
           +

    This list can be changed using the General.IconPath setting.

  - MAP FILES

    RoadMap needs some map files to serve any useful purpose.

    The location for these map files can be redefined in the user preferences
    (item Map.Path). The maps are a problem of their own, since they may require
    a huge space (up to 1.8G Bytes for the full set). It is recommended that
    maps be shared between users.  Sharing across a network would probably
    be quite inefficient.  In addition, care must be taken since the map
    format may vary between systems of different architectures.  (Technically
    speaking, the maps contain endian-specific data.)

    Maps can be located in any directory mentioned in the Map.Path
    preferences setting.  The index file usdir.rdm must also be in one of
    those directories.

    RoadMap will only consult a single usdir.rdm file at a time.  The first
    usdir.rdm index file discovered by RoadMap must index any and all maps
    you might wish to view.  This means that if you've built a subset of the
    maps, and a corresponding usdir.rdm file (using "buildus"), then when
    you build more maps, you can't create and install a second usdir.rdm file
    and expect RoadMap to use them both.  A new usdir.rdm must be built which
    indexes all of the maps.

    RoadMap will only read the index file once, at startup, even if a newer
    version becomes available.  In contrast, new map files can be added to
    the Map.Path directories, and RoadMap will find them as needed.  This
    means that maps kept on removeable storage devices can be used fairly
    easily.  [ The one caveat when introducing replacement maps is that
    RoadMap will only try and find a map when it really needs to.  RoadMap
    will keep a number of maps open, for easy access -- the number is
    controlled by "Map.Cache".  You may have to visit that many other maps
    before RoadMap will need to reopen a map file which you've visited before
    but subsequently replaced.  ]

    (The map search paths referred to below may be changed using the "--maps=..."
    commandline option.)

    By default, RoadMap is built to search for the following directories on most
    UNIX systems:

           + ~/.roadmap/maps/... (a.k.a. "&/maps") and its subdirectories,
           + ROADMAP_MAP_DIR, chosen at compile time,
           + /var/lib/roadmap/... (preferred path) and its subdirectories, and
           + /usr/lib/roadmap/... and its subdirectories.
           +

    (Note that releases prior to 1.1.0 did not search subdirectories.)

    RoadMap also searches in /usr/local/share/roadmap and /usr/share/roadmap,
    but this is in violation of the FHS filesystem standard, since these maps
    are not architecture-independent.

    The architecture-dependent nature of the map files is not an issue with a
    PDA, as these machines tend to be used standalone and not to rely on network
    access.


  - DOWNLOADING ROADMAP AND MAPS

     RoadMap can be downloaded from the RoadMap web site:

           http://roadmap.sourceforge.net/download.html

     Previously, RoadMap came either as a set of sources, or as a set of binary
     files.  This is no longer the case -- it is not hard to build, and
     there are choices to be made when building, so the source tarball is all
     that is currently available.  (Specific systems or software distributions
     may offer pre-built packages.)

     Because installing a full set of maps can take some time (and space!), a
     quick way to get a feel for RoadMap is to download and install the the
     "demo" tar file which contains outlines of the US state boundaries, the
     detailed street map of San Francisco, and a minimal directory file which
     will let RoadMap use them.

           http://roadmap.digitalomaha.net/maps/demo_maps.tar.gz

     The complete set of maps, along with the complete index file that
     describes them, is available here:

           http://roadmap.sourceforge.net/maps.html

     The full RoadMap index file (usdir.rdm) must be downloaded
     to use any but the demo maps -- RoadMap will not work without it.

           http://roadmap.digitalomaha.net/maps/usdir.rdm.tar.gz

     Please refrain from downloading all the US states at once, as the map
     files are huge and the bandwidth is expensive.

     Installing the maps in one of the default directories (see the previous
     section) is recommended, but you can install them anywhere, assuming you
     set Map.Path accordingly in the RoadMap preferences.


  - INSTALLING FROM THE SOURCE TARBALL (UNIX)

     To build RoadMap from the source distribution:

     + Install the development libraries for GTK+ 1.2, GTK+ 2.0 or Qt.

     + Install the shapelib and expat development libraries.  Shapelib is
     required for building maps from some data sources (though not the US Tiger
     data).  The "expat" library is optional, except that you won't be able to
     save or restore route, waypoint, or track information.

     + Unpack RoadMap's tarball:

```
        tar xzvf <tarball>
```

     + Edit the config.mk file found in the src directory, and
     choose one of GTK, GTK2, QT, or QT4, along with other build
     options, described in the comments of that file.

     Simply typing "make" will build the default selection in config.mk.
     (GNU make is required.)

     The complete list of options for building RoadMap is as follow.
     These can all be modified by editing config.mk.

     : DESKTOP=GTK2|GPE|GTK|QT|QPE|QT4|QPE4|WINCE

     Compiles RoadMap for a specific GUI environment.  The GPE
     environment is a PDA variant of GTK2 and the QPE environment
     is a PDA variant of QT.  (WINCE will attempt to use the
     arm-wince-mingw32ce cross-compiler to build RoadMap for the
     Windows CE environment.)

     : SHAPEFILES=NO

     Do not link buildmap with the shapelib.  The side effect of
     this option is that some map sources cannot be converted to
     RoadMap files anymore.  These include the Digital Charts of
     the World, the Canadian RNF road maps, and the US State
     boundary outlines.  This option should only be used when the
     shapelib library is not available.

     : EXPAT=NO

     Do not link roadmap with the expat library.  The side effect
     is that you cannot load or save trips or landmarks anymore.

     : AGG=NO

     Do not try to link roadmap with the agg library.  This
     optional library, currently supported for the GTK2 and Win32
     desktops, can give much prettier (anti-aliased) lines and
     text.

     : MODE=DEBUG|PROFILE

     Compiles RoadMap in debug mode.  The PROFILE option also
     generates the necessary information and code for profiling.

     + run make to install roadmap:

```
        make install
```


  - A NOTE ABOUT THE ROADMAP ICONS

     The RoadMap toolbar uses road signs as icons. These icons come with
     the application (in directory src/icons). The icon source set is made
     of a mix of PNG and XPM files. The final icon files must all be PNG.

     A make script builds all the necessary files using the ImageMagick
     package. The icon files are built (or installed) when building (or
     installing) RoadMap.

     The PNG icon files must be installed in one of the following directories
     (the order below reflects the search order):

```
        ~/.roadmap/pixmaps
        /usr/local/share/pixmaps
        /usr/share/pixmaps
```


  - TROUBLESHOOTING THE INSTALLATION

     This section describes the most common problems encountered when installing
     RoadMap:

     - When running "make build"  a compiler error message appears, complaining
       that the file shapefil.h cannot be found. This typically happens if
       the shapelib library was not installed.  The shapelib library is only
       used to create some map formats -- neither the TIGER maps nor the
       OpenStreetMap maps require shapefile support.  It is possible to build
       RoadMap without the shapelib, using the option "SHAPEFILES=NO" in
       config.mk.

     - After RoadMap has been installed, the display only shows the message
       "No map available" or a blank screen. RoadMap must be provided with
       a position before it can show something meaningful. It is recommended
       to enter a known address to setup a position. Another way to feed a
       position is to install a GPS device RoadMap can talk to.

     - The display shows no street; lakes, parks, airport and hospitals
       appear as block areas. This is typical of a missing "class" file.
       This file, usuall "default/All", must be located in the RoadMap
       configuration directory.  It is likely the "make install" step was not
       performed.

     - The display is all black. RoadMap seems to find the map files and
       one can select streets on the screen, but it seems everything is
       drawn black on black. Be sure all of your configuration files are
       up to date, and that none are being "shadowed" by older files in your
       ~/.roadmap directory.  This may also happen on a QPE-based PDA:  this
       may be a problem with QPE not defining color names.  Try redefining all
       colors in schema using the RGB syntax ('#' followed by an hexadecimal
       RGB value).

     - Waypoints, the compass and the vehicle's location all appear as small
       black squares. This is typical of a missing "sprites" file. The "sprite"
       file must be located in one of the RoadMap configuration directories.
       It is likely the "make install" step was not performed.

     - If things do not go any better, start roadmap with the --debug option
       and check what roadmap tells you it is doing.




--- NEW FILE: Quickstart ---
RoadMap Quickstart

November 2008

= Quickstart =

   This section describes the most basic steps you'll need to perform
   in order to get RoadMap running on your system.  More detailed
   information is available in the Installation Guide section of the
   documentation.

   To build RoadMap for a "standard" linux/unix environment, follow
   the following steps:

     - Read the commentary in "config.mk", and edit the values there
       to select your build options.  For most users, no other
       configuration choices should be necessary.
       
     - Run "make".  (RoadMap requires GNU make, and may require gcc).
       
     - Run "make install".  This will install the executables as well
       as important data files.  It will _not_ install any map data,
       however.  At this point you should be able to run "roadmap",
       but it will tell you there are no maps.

     - To test drive RoadMap for the first time, download the
       "demo" maps from:

         http://roadmap.digitalomaha.net/maps/demo_maps.tar.gz

       This tarball contains state outlines for all of the continental
       USA, plus the detailed map of San Francisco county.  Unpack
       this file somewhere convenient, e.g. /tmp/demo_maps.

     - Start RoadMap, specifying the path that you chose above:

```
        roadmap --maps=/tmp/demo_maps
```

       Use the arrow keys (or drag with the mouse) to pan, and use the
       on-screen controls or the '+' and '-' keys to zoom.  RoadMap's
       help text is available in html format via the Help menu (which
       reads the installed copy of "manual.html") or in plaintext in
       the README file.  Use the 'q' key or the File->Quit menu
       item to quit.

     - When you're ready to download a more complete set of maps, get
       them from

         http://roadmap.sourceforge.net/maps.html

       Be sure to get the master index file in addition to any maps
       you may need.  Unpack these into a more permanent home than
       before -- under "/var/lib/roadmap", or in your home directory,
       under "~/.roadmap/maps".  If you choose a different directory
       than either of these, you'll need to navigate to the "Map"
       preferences panel (File-->Preferences->Map), and enter the 
       chosen path as Map.Path.


   For more complete installation and configuration information,
   please consult the "INSTALLATION" section of the README file.
   The README is on the web, here:

         http://roadmap.sourceforge.net/manual.html

   Good luck, and have fun!


--- NEW FILE: ChangeLog ---
RoadMap Changelog

November 2008

Roadmap v1.2.0 (??)

 This list is current as of 3/17/2008, created with the help of

```
   cvs2cl.pl -l "-rv1_1_0::HEAD"
```

 Items marked (*) originated on Ehud Shabtai's roadmap_editor code branch.


  - Make the screen much more responsive when lengthy rendering is in
  progress.  User "type-ahead" can now interrupt rendering.

  - Added a progress bar to show expected duration of lengthy repaints.
[...1095 lines suppressed...]
Roadmap v0.2 (September 2nd, 2002): 

  - Handle very large grids (more than 64k squares). 

  - Fixed the 32 bits street numbers bug. 

  - Create intermediate shape points when the existing ones are too far away 
  for a 16 bit delta. 

  - Fix a crash when the current position is out of any known map. 

  - Fix a crash when the city name has a typo. 

  - Save the selected destination and current location in the roadmap session 
  file, so we remember them on the next session. 

  - Changed the RoadMap defaults to make the demo map easy to use.

Roadmap v0.1 (august, 2002): First release of RoadMap.


--- NEW FILE: Map-Format ---
RoadMap Quickstart

November 2008


= Map Details =

   This section contains additional information for developers, knowledge
   that is not required for using RoadMap. It is here to answer some usual
   questions and help people who want to hack with the RoadMap code.

   - PROJECTION

     The maps used by RoadMap define all points using longitude/latitude
     coordinates (WGS 84 datum). This means the coordinates describe the
     position of the point on a reference elipsoid (as close to the Earth's
     potato-like shape as scientifically possible). On the other side the
     Computer (or PDA) screen is still a plane. Converting a longitude and
     latitude coordinate into a plane X/Y coordinate is traditionally called
     a "projection". There are several standard projection methods. RoadMap
     uses none of them that I know of.

     RoadMap first approximates the WGS 84 elipsoid to a sphere. Then it
     considers the point at the center of the screen and compute the scale
     at that point (i.e. delta(x)/longitude and delta(y)/latitude. After that
     the local area is approximated to the plane that is tangent to the sphere
     on that center point. Therefore a new projection is defined each time a
     new screen is drawn. Also the distorsion is probably very significant
     when zooming out. It is possible to zoom out to the point of seeing
     the full continental US on the screen, and it is still recognizable.
     This way of doing things seems to perturbate many people familiar with
     map projections..

     The RoadMap projection has one major advantage: after the scale has been
     computed (once per screen refresh), the only transformation left is
     a simple and fast "(center - position) * scale" conversion. There are
     two scales: one for longitude and one for latitude (the longitude's
     scale depends on the latitude). Most operations are performed using
     integer operations, including the pre-computed sine and cosine tables,
     so that RoadMap has decent performance on integer-only processors (such
     as most of the ARM CPUs). In order to do so the (precomputed) sine and
     cosine table has values that have been multiplied by 32768 and the final
     scale is being divided by 32768.

     This projection was chosen because of its speed, not really for its
     accuracy. As the Earth is not exactly a sphere, and certainly far from
     a plane, the RoadMap projection is going to cause a measurable distorsion.
     This is not a significant issue in RoadMap for several reasons:

      - most users are concerned with very small areas (a few street blocks),
     and the map distorsion is not going to be noticeable at this scale.

      - the schematic representation of the streets and geographical features
     is more important than a geometrically correct drawing.

      - the GPS position is also provided using WGS 84 coordinates and the same
     projection algorythm is used to represent the GPS position on the screen.
     The same distorsion effect applies to the GPS position, and thus the GPS
     position is correct relative to the street (at least when not considering
     map accuracy problems..).


  - MAP FILES AND INDEXES

     The maps are made of three types of files: the map files themselves
     contains the map data, the map indexes allow for fast retrieval of
     the map files to display and the class files describe the features
     stored in each map file.


     (See the file README.osm included with thre RoadMap source for
     information about file naming for OpenStreetMap files.)

     As indicated in several other places, the RoadMap map files (extension
     .rdm) are organized by administrative territories, such s a county per
     file in the US. The map files are retrieved using index files, which files
     themselves use a format similar to the map files. The index files contain
     only the list of map files, plus some indexes to accelerate the display of
     a specific area, or the search of an address.

     As for now, the names of the US county files follow the convention below:

```
      usc<fips>.rdm
```

     where "fips" is the federal identification number for that county, made
     of five digits: the first two digits identify the state and the last
     three digits identify the county within the state.

     As for now, there is a single index file, named usdir.rdm. This file
     must be in the same directory as the map files.

     This naming convention is likely to change in the near future!

     The rdm files are binary files and uses the local conventions for byte
     order and C structure layout. 
     
     [ //Future//:  In order to make it possible to share map files between
     different systems, an ASCII format is also defined, with the suffix
     .rdx; the rdmxchange program translates from one format to the other. 
     Note that the data stored in the rdx files is strictly equivalent to the
     one stored in the rdm files, and the organization of this data is very
     specific to the RoadMap application.  The rdx format was not designed to
     exchange data with other applications.  ]

     These two types of files, the map and index files, contain very different
     data but share the same general organization: these files contain
     multiple data tables organized in a tree fashion.

  - CLASS FILES

     A class file is a text file that describes the features of a set of map
     files, where the features are organized in layers. Each map file contains
     features that belong to one (and only one) class.

     An example of class would be roads. Roads would be organized in layers
     like freeways, highways, streets and trails. All map files describing
     roads will contain features organized using these same layers.

     The class files are stored in the RoadMap configuration directories,
     thus they can be customized by the user, independently from the map files.
     It must be noted, however, that the way the layers are organized must not
     be changed. Changing the list of layers would render the existing map files
     more or less useless.

     The preferred method for customizing a class is to create a new RoadMap
     skin directory, copy all the class files from an existing skin directory
     and then edit the class files in that new skin directory. The active
     RoadMap skin can be selected in the user preferences.

     The class files use the same format as the preference file. It defines
     the properties of the various layers that make a set of maps.

     The two differences with the preferences files are that there is no
     predefined layers in RoadMap (layers are entirely defined by the class
     files) and there is no default value.

     A class file contains general attributes and layer attributes.

     The general attributes are:

        : Class.Name
           The name of the class (the name of the file does not count).
           - //Format:// string

        : Class.Lines
           The line layers, ordered with the top layer first.
           - //Format:// a space separated list of layer names.

        : Class.Polygons
           The polygon layers, ordered with the top layer first.
           - //Format:// a space separated list of layer names.

        : Navigation.Car
           The list of layers to be used for car navigation.
           - //Format:// a space se...
 
[truncated message content]

[Roadmap-commit] roadmap/web Makefile, 1.12, 1.13 index.html, 1.32, 1.33 navbar.html, 1.6, 1.7

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/web
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv31569/web

Modified Files:
	Makefile index.html navbar.html 
Log Message:
major documentation refactoring.  "chapters", written in txt2tags
format, are now under the doc subdirectory, and are presented on
the web in some cases as standalone docs, and in other cases combined.
and 


Index: navbar.html
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/navbar.html,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** navbar.html	18 Oct 2007 15:07:25 -0000	1.6
--- navbar.html	7 Nov 2008 13:46:54 -0000	1.7
***************
*** 7,12 ****
     <a class="navitem2" href="status.html">Status</a> <span class="invisible">|</span>
    <a class="navitem" href="documentation.html">Documentation</a> <span class="invisible">|</span>
!    <a class="navitem2" href="manual.html">Manual</a> <span class="invisible">|</span>
!    <a class="navitem2" href="installation.html">Quickstart</a> <span class="invisible">|</span>
     <a class="navitem2" href="buglist.html">Bug list</a> <span class="invisible">|</span>
     <a class="navitem2" href="todolist.html">To-do list</a> <span class="invisible">|</span>
--- 7,13 ----
     <a class="navitem2" href="status.html">Status</a> <span class="invisible">|</span>
    <a class="navitem" href="documentation.html">Documentation</a> <span class="invisible">|</span>
!    <a class="navitem2" href="quickstart.html">Quickstart</a> <span class="invisible">|</span>
!    <a class="navitem2" href="usermanual.html">User Manual</a> <span class="invisible">|</span>
!    <a class="navitem2" href="devguide.html">Developers Guide</a> <span class="invisible">|</span>
     <a class="navitem2" href="buglist.html">Bug list</a> <span class="invisible">|</span>
     <a class="navitem2" href="todolist.html">To-do list</a> <span class="invisible">|</span>

Index: index.html
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/index.html,v
retrieving revision 1.32
retrieving revision 1.33
diff -C2 -d -r1.32 -r1.33
*** index.html	26 Oct 2008 17:43:47 -0000	1.32
--- index.html	7 Nov 2008 13:46:54 -0000	1.33
***************
*** 22,27 ****
  
  <P>RoadMap is an open source (GPL) program that provides a car navigation for
! Linux, UNIX and now Windows CE (a.k.a. PocketPC).
! ??? Something about iPhone ?
  
  <P> RoadMap displays a map of the streets, tracks the position provided by a
--- 22,26 ----
  
  <P>RoadMap is an open source (GPL) program that provides a car navigation for
! Linux, UNIX and now Windows CE (a.k.a. PocketPC) and the iPhone/iPod.
  
  <P> RoadMap displays a map of the streets, tracks the position provided by a
***************
*** 54,58 ****
  <P>The Windows CE (Windows Mobile, Pocket PC, ..) port is a native one
  and has been tested on several devices.
- ??? Something about iPhone ?
  
  <P>The on-screen user interface is very customizable.  All command actions
--- 53,56 ----

Index: Makefile
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/Makefile,v
retrieving revision 1.12
retrieving revision 1.13
diff -C2 -d -r1.12 -r1.13
*** Makefile	6 Nov 2008 20:23:07 -0000	1.12
--- Makefile	7 Nov 2008 13:46:54 -0000	1.13
***************
*** 2,18 ****
  # all this does is make it easier to keep the website in sync
  
! default: all
! 
! APT_WEBDOCS = \
  
- T2T_WEBDOCS = \
- 	manual.html \
- 	buglist.html \
- 	status.html \
- 	todolist.html \
- 	installation.html \
- 	changelog.html \
- 	makemaps.html
  
  PAGES = \
  	index.html \
--- 2,10 ----
  # all this does is make it easier to keep the website in sync
  
! all: webdoc
  
  
+ # These are the NON-txt2tags pages -- i.e., they're currently maintained
+ # as HTML by hand.
  PAGES = \
  	index.html \
***************
*** 45,50 ****
  	stamp-wince.jpg
  
  SUPPORT = \
- 	apt_toc.gif \
  	background2.jpg \
  	roadmap-right.png \
--- 37,76 ----
  	stamp-wince.jpg
  
+ # Most of the pages are are derived from the files in the doc
+ # directory.  We combine the available chapters of doc text into
+ # some standalone pages as well as some compilations.
+ T2T_WEBDOCS = \
+ 	usermanual.html \
+ 	devguide.html \
+ 	buglist.html \
+ 	status.html \
+ 	todolist.html \
+ 	changelog.html \
+ 	installation.html \
+ 	quickstart.html \
+ 	platforms.html
+ 
+ 
+ # should match the list of %!includes in README
+ USER_GUIDE_SECTIONS = \
+ 	Quickstart \
+ 	Installation \
+ 	Usage \
+ 	Configuration \
+ 	OpenStreetMap \
+ 	Map-Building
+ USER_GUIDE_SECTION_PATHS = $(addprefix ../doc/, $(USER_GUIDE_SECTIONS))
+ 
+ 
+ # should match the list of %!includes in Developer-Guide
+ DEVGUIDE_SECTIONS = \
+ 	Coding \
+ 	Map-Building \
+ 	Map-Format \
+ 	Map-Designing
+ DEVGUIDE_SECTION_PATHS = $(addprefix ../doc/, $(DEVGUIDE_SECTIONS))
+ 
+ 
  SUPPORT = \
  	background2.jpg \
  	roadmap-right.png \
***************
*** 56,67 ****
  
  
  SITESOURCE = $(SCREENSHOTS) $(T2T_WEBDOCS) $(PAGES) $(SUPPORT)
  
! all: webdoc
! 
! 
  SITESOURCE_COPIED = $(addprefix .copied$(SF)-, $(SITESOURCE))
- install: all $(SITESOURCE_COPIED)
- 
  
  # use 'make SF=1 install' to send to SF
--- 82,90 ----
  
  
+ # everything we'll install on the website
  SITESOURCE = $(SCREENSHOTS) $(T2T_WEBDOCS) $(PAGES) $(SUPPORT)
  
! # flag files that say we did the copy
  SITESOURCE_COPIED = $(addprefix .copied$(SF)-, $(SITESOURCE))
  
  # use 'make SF=1 install' to send to SF
***************
*** 95,144 ****
  
  # several parts of the RoadMap website are produced directly from
! # text files in the CVS tree, converted to html using aptconvert.
! # (http://www.xmlmind.com/aptconvert.html)
! 
! webdoc: $(T2T_WEBDOCS)
! 
! clean-webdoc:
! 	rm -f $(T2T_WEBDOCS)
  
  # use GNU make's target-specific variables to name the sourcefile
  # for each constructed web page.  the names are somewhat random,
  # so we can't simply use a pattern rule.
! manual.html: DOC_SOURCE=../README
! manual.html: ../README
  
! makemaps.html: DOC_SOURCE=../howtos/makemaps.txt
! makemaps.html: ../howtos/makemaps.txt
  
! buglist.html: DOC_SOURCE=../BUGS
! buglist.html: ../BUGS
  
! changelog.html: DOC_SOURCE=../CHANGES
! changelog.html: ../CHANGES
  
! todolist.html: DOC_SOURCE=../TODO
! todolist.html: ../TODO
  
! status.html: DOC_SOURCE=../STATUS
! status.html: ../STATUS
  
! installation.html: DOC_SOURCE=../INSTALL
! installation.html: ../INSTALL
  
! # here's the rule for building webpages from our
! # aptconvert-compatible text files.  we post-process, to add some
! # extra html at the top, to make the docs fit in with the rest of
! # the site.  we also remove absolute references to our own website,
! # so that the links all work properly when installed in a test tree.
  
- #$(APT_WEBDOCS):
- #	aptconvert -pi html showTitle yes -toc -enc ASCII $@ $(DOC_SOURCE)
- #	sed -i \
- #	    -e '/<head>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
- #	    -e '/<body>/a \
- #	    <!--#include virtual="navbar.html" -->' \
- #	    -e 's/<body>/<body class="roadmap-doc">/' \
- #	    -e 's;http://'$(OUR_SITE_REFERENCE)'/;;' $@ 
  
  # here's the rule for building webpages from our
--- 118,154 ----
  
  # several parts of the RoadMap website are produced directly from
! # text files in the CVS tree, converted to html using txt2tags.
! # (http://txt2tags.sourceforge.net)
  
  # use GNU make's target-specific variables to name the sourcefile
  # for each constructed web page.  the names are somewhat random,
  # so we can't simply use a pattern rule.
! usermanual.html: DOC_SOURCE = ../README
! usermanual.html: ../README $(USER_GUIDE_SECTION_PATHS)
  
! devguide.html: DOC_SOURCE = ../doc/Developer-Guide
! devguide.html: ../doc/Developer-Guide $(DEVGUIDE_SECTION_PATHS)
  
! buglist.html: DOC_SOURCE = ../doc/Bugs
! buglist.html: ../doc/Bugs
  
! changelog.html: DOC_SOURCE = ../doc/ChangeLog
! changelog.html: ../doc/ChangeLog
  
! todolist.html: DOC_SOURCE = ../doc/ToDo
! todolist.html: ../doc/ToDo
  
! status.html: DOC_SOURCE = ../doc/Status
! status.html: ../doc/Status
  
! installation.html: DOC_SOURCE = ../doc/Installation
! installation.html: ../doc/Installation
  
! quickstart.html: DOC_SOURCE = ../doc/Quickstart
! quickstart.html: ../doc/Quickstart
! 
! platforms.html: DOC_SOURCE = ../doc/Platforms
! platforms.html: ../doc/Platforms
  
  
  # here's the rule for building webpages from our
***************
*** 148,156 ****
  # also remove absolute references to our own website, so that the
  # links all work properly when installed in a test tree.
- 
  $(T2T_WEBDOCS):
  	expand $(DOC_SOURCE) | \
! 	txt2tags --target html \
! 	    --toc --infile - --outfile $@
  	sed -i \
  	    -e '/<HEAD>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
--- 158,165 ----
  # also remove absolute references to our own website, so that the
  # links all work properly when installed in a test tree.
  $(T2T_WEBDOCS):
  	expand $(DOC_SOURCE) | \
! 	(cd ../doc; txt2tags --target html \
! 	    --toc --infile - --outfile - ) >$@
  	sed -i \
  	    -e '/<HEAD>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
***************
*** 179,182 ****
--- 188,198 ----
  
  
+ webdoc: $(T2T_WEBDOCS)
+ 
+ install: webdoc $(SITESOURCE_COPIED)
+ 
+ clean-webdoc:
+ 	rm -f $(T2T_WEBDOCS)
+ 
  
  clean: clean-webdoc

[Roadmap-commit] roadmap README, 1.161, 1.162 AUTHORS, 1.2, NONE BUGS, 1.9, NONE CHANGES, 1.8, NONE INSTALL, 1.9, NONE README.iphone, 1.1, NONE README.osm, 1.2, NONE STATUS, 1.4, NONE TODO, 1.15, NONE

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv31569

Modified Files:
	README 
Removed Files:
	AUTHORS BUGS CHANGES INSTALL README.iphone README.osm STATUS 
	TODO 
Log Message:
major documentation refactoring.  "chapters", written in txt2tags
format, are now under the doc subdirectory, and are presented on
the web in some cases as standalone docs, and in other cases combined.
and 


--- STATUS DELETED ---

--- README.iphone DELETED ---

--- CHANGES DELETED ---

--- BUGS DELETED ---

--- INSTALL DELETED ---

--- AUTHORS DELETED ---

Index: README
===================================================================
RCS file: /cvsroot/roadmap/roadmap/README,v
retrieving revision 1.161
retrieving revision 1.162
diff -C2 -d -r1.161 -r1.162
*** README	6 Nov 2008 20:23:06 -0000	1.161
--- README	7 Nov 2008 13:46:54 -0000	1.162
***************
*** 44,49 ****
         old.
  
-      -
- 
     RoadMap uses a binary file format for representing maps that is
     compact enough to allow the storage of many maps on a Compact Flash or
--- 44,47 ----
***************
*** 52,58 ****
     the US Census bureau data into its own map format.
[...3977 lines suppressed...]
!     as specified in the fields line. The values of an array field are stored
!     sequentially, as if these were different fields. Value 0 may be represented
!     using an empty string. For example:
! 
!   ```
! 	5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,1,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,10,22
!   ```
  
--- 101,111 ----
  
  
  
! % -- CUT HERE --
! %!include: Quickstart
! %!include: Installation
! %!include: Usage
! %!include: Configuration
! %!include: OpenStreetMap
! %!include: Map-Building
  

--- README.osm DELETED ---

--- TODO DELETED ---

[Roadmap-commit] roadmap/doc - New directory

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/doc
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv31272/doc

Log Message:
Directory /cvsroot/roadmap/roadmap/doc added to the repository

[Roadmap-commit] roadmap/src roadmap_math.c, 1.56, 1.57 roadmap_math.h, 1.42, 1.43 roadmap_screen.c, 1.134, 1.135

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv3368

Modified Files:
	roadmap_math.c roadmap_math.h roadmap_screen.c 
Log Message:
chording fixups from morten bek (remove rotation support pending
reimplementation)


Index: roadmap_math.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.h,v
retrieving revision 1.42
retrieving revision 1.43
diff -C2 -d -r1.42 -r1.43
*** roadmap_math.h	4 Nov 2008 14:56:23 -0000	1.42
--- roadmap_math.h	6 Nov 2008 20:31:02 -0000	1.43
***************
*** 176,181 ****
  #define MILLIONTHS  6
  
- float roadmap_math_get_angle (RoadMapGuiPoint *point0, RoadMapGuiPoint *point1);
- 
  #endif // INCLUDED__ROADMAP_MATH__H
  
--- 176,179 ----

Index: roadmap_screen.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_screen.c,v
retrieving revision 1.134
retrieving revision 1.135
diff -C2 -d -r1.134 -r1.135
*** roadmap_screen.c	4 Nov 2008 14:56:23 -0000	1.134
--- roadmap_screen.c	6 Nov 2008 20:31:02 -0000	1.135
***************
*** 155,160 ****
  static int RoadMapScreenChordingEvent = 0;
  static RoadMapGuiPoint RoadMapScreenChordingAnchors[MAX_CHORDING_POINTS];
- static float RoadMapScreenChordingAngle;
- static int RoadMapScreenChordingIsRotating = 0;
  
  /* Define the buffers used to group all actual drawings. */
--- 155,158 ----
***************
*** 1700,1724 ****
        RoadMapGuiPoint *anchors = RoadMapScreenChordingAnchors;
             
!       if (anchors[2].x == 1) { //Rotate mode
!          //save angle
!          RoadMapScreenChordingIsRotating = 1;
!          RoadMapScreenChordingAngle =
! 	    roadmap_math_get_angle (&anchors[0], &anchors[1]);
!       } else { //Drag / zoom mode
!          point->x = abs(anchors[1].x - anchors[0].x) /2;
!          if (anchors[0].x > anchors[1].x) {
!             point->x += anchors[1].x;
!          } else {
!             point->x += anchors[0].x;
!          }
           
!          point->y = abs(anchors[1].y - anchors[0].y) /2;
!          if (anchors[0].y > anchors[1].y) {
!             point->y += anchors[1].y;
!          } else {
!             point->y += anchors[0].y;
!          }
!          RoadMapScreenPointerLocation = *point;
        }
  
     } else {
--- 1698,1715 ----
        RoadMapGuiPoint *anchors = RoadMapScreenChordingAnchors;
             
!       point->x = abs(anchors[1].x - anchors[0].x) /2;
!       if (anchors[0].x > anchors[1].x) {
!          point->x += anchors[1].x;
!       } else {
!          point->x += anchors[0].x;
!       }
           
!       point->y = abs(anchors[1].y - anchors[0].y) /2;
!       if (anchors[0].y > anchors[1].y) {
!          point->y += anchors[1].y;
!       } else {
!          point->y += anchors[0].y;
        }
+       RoadMapScreenPointerLocation = *point;
  
     } else {
***************
*** 1737,1741 ****
  
        RoadMapScreenChordingEvent = 0;
-       RoadMapScreenChordingIsRotating = 0;
  
     } else {
--- 1728,1731 ----
***************
*** 1758,1809 ****
     if (roadmap_canvas_is_chording() && RoadMapScreenChordingEvent) {
        RoadMapGuiPoint ChordingPt[MAX_CHORDING_POINTS];
        roadmap_canvas_get_chording_pt (ChordingPt);
        
!       if (!RoadMapScreenChordingIsRotating) {
!          // Calculate zoom change
! 	 long diag_new = roadmap_math_screen_distance
! 	 	(&ChordingPt[0], &ChordingPt[1], MATH_DIST_ACTUAL);
!          long diag_anch = roadmap_math_screen_distance
! 	 	(&RoadMapScreenChordingAnchors[0], &RoadMapScreenChordingAnchors[1], MATH_DIST_ACTUAL);
!          float scale = (float)diag_anch / (float)diag_new;
!          
!          roadmap_math_zoom_set (ceil(roadmap_math_get_zoom() * scale));
!          roadmap_layer_adjust ();
!          
!          // Calculate point position
!          point->x = abs(ChordingPt[1].x - ChordingPt[0].x) /2;
!          if (ChordingPt[0].x > ChordingPt[1].x) {
!             point->x += ChordingPt[1].x;
!          } else {
!             point->x += ChordingPt[0].x;
!          }
           
!          point->y = abs(ChordingPt[1].y - ChordingPt[0].y) /2;
!          if (ChordingPt[0].y > ChordingPt[1].y) {
!             point->y += ChordingPt[1].y;
!          } else {
!             point->y += ChordingPt[0].y;
!          }
           
!          roadmap_screen_record_move
!                      (RoadMapScreenPointerLocation.x - point->x,
!                       RoadMapScreenPointerLocation.y - point->y);
!                       
!          RoadMapScreenPointerLocation = *point;
        } else {
!          float angle_new = roadmap_math_get_angle (&ChordingPt[0], &ChordingPt[1]);
           
!          int angle_delta = ceil (angle_new - RoadMapScreenChordingAngle);
!          if (angle_delta > 15) {
!             roadmap_screen_rotate (15);
!             RoadMapScreenChordingAngle += 15;
!          } else if (angle_delta < -15) {
!             roadmap_screen_rotate (-15);
!             RoadMapScreenChordingAngle -= 15;
!          } else {
!             roadmap_screen_rotate (angle_delta);
!             RoadMapScreenChordingAngle += angle_delta;
!          }
        }
        
        RoadMapScreenChordingAnchors[0].x = ChordingPt[0].x;
--- 1748,1788 ----
     if (roadmap_canvas_is_chording() && RoadMapScreenChordingEvent) {
        RoadMapGuiPoint ChordingPt[MAX_CHORDING_POINTS];
+       long diag_new;
+       long diag_anch;
+       float scale;
+ 
        roadmap_canvas_get_chording_pt (ChordingPt);
        
!       // Calculate zoom change
!       diag_new = roadmap_math_screen_distance
!          	    (&ChordingPt[0], &ChordingPt[1], MATH_DIST_ACTUAL);
!       diag_anch = roadmap_math_screen_distance
!  	 	    (&RoadMapScreenChordingAnchors[0],
! 		     &RoadMapScreenChordingAnchors[1], MATH_DIST_ACTUAL);
!       scale = (float)diag_anch / (float)diag_new;
           
!       roadmap_math_zoom_set (ceil(roadmap_math_get_zoom() * scale));
!       roadmap_layer_adjust ();
           
!       // Calculate point position
!       point->x = abs(ChordingPt[1].x - ChordingPt[0].x) /2;
!       if (ChordingPt[0].x > ChordingPt[1].x) {
!          point->x += ChordingPt[1].x;
        } else {
!          point->x += ChordingPt[0].x;
!       }
           
!       point->y = abs(ChordingPt[1].y - ChordingPt[0].y) /2;
!       if (ChordingPt[0].y > ChordingPt[1].y) {
!          point->y += ChordingPt[1].y;
!       } else {
!          point->y += ChordingPt[0].y;
        }
+          
+       roadmap_screen_record_move
+                   (RoadMapScreenPointerLocation.x - point->x,
+                    RoadMapScreenPointerLocation.y - point->y);
+                       
+       RoadMapScreenPointerLocation = *point;
        
        RoadMapScreenChordingAnchors[0].x = ChordingPt[0].x;

Index: roadmap_math.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.c,v
retrieving revision 1.56
retrieving revision 1.57
diff -C2 -d -r1.56 -r1.57
*** roadmap_math.c	4 Nov 2008 14:56:23 -0000	1.56
--- roadmap_math.c	6 Nov 2008 20:31:02 -0000	1.57
***************
*** 1226,1236 ****
  }
  
- float roadmap_math_get_angle 
- 	(RoadMapGuiPoint *point0, RoadMapGuiPoint *point1) {
-    float delta_x = point0->x - point1->x + 1;
-    float delta_y = point0->y - point1->y + 1;
-    return (90 * (delta_y / (delta_x + delta_y)));
- }
- 
  void roadmap_math_to_position (const RoadMapGuiPoint *point,
                                 RoadMapPosition *position,
--- 1226,1229 ----

[Roadmap-commit] roadmap/howtos makemaps.txt,1.3,1.4

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/howtos
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv2766/howtos

Modified Files:
	makemaps.txt 
Log Message:
switch from aptconvert format to txt2tags (txt2tags.sourceforge.net) format.
aptconvert seems to be orphanced, txt2tags seems as capable, and is on
sourceforge and in debian.


Index: makemaps.txt
===================================================================
RCS file: /cvsroot/roadmap/roadmap/howtos/makemaps.txt,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** makemaps.txt	12 Dec 2007 16:56:01 -0000	1.3
--- makemaps.txt	6 Nov 2008 20:23:07 -0000	1.4
***************
*** 1,11 ****
!                                ---------
!                     Creating a Map for RoadMap HOWTO
!                                ---------
!                  Pascal Martin (pas...@po...)
!                                ---------
!                                                                                                             December 2005
  
  
! INTRODUCTION
  
     This HOWTO describes how to create a new map for RoadMap. The intent is
--- 1,8 ----
! Creating a Map for RoadMap HOWTO
! Pascal Martin (pas...@po...)
! December 2005
  
  
! = INTRODUCTION =
  
     This HOWTO describes how to create a new map for RoadMap. The intent is
***************
*** 21,34 ****
  
  
! OVERVIEW
  
     There are four major phases involved when creating maps for RoadMap:
  
!    * One must decide how the maps will be organized. It is important to
     have a good idea of how the country is organized and how individual
     addresses are formatted (the format of addresses will have an influence
     on the maps organization).
  
!    * Then the format of the data source must be identified and analyzed.
     Knowing the data come in a shape file is not enough, as there are many
     different ways of organizing shape file data. Typical questions to answer
--- 18,31 ----
  
  
! = OVERVIEW =
  
     There are four major phases involved when creating maps for RoadMap:
  
!    - One must decide how the maps will be organized. It is important to
     have a good idea of how the country is organized and how individual
     addresses are formatted (the format of addresses will have an influence
     on the maps organization).
  
!    - Then the format of the data source must be identified and analyzed.
     Knowing the data come in a shape file is not enough, as there are many
     different ways of organizing shape file data. Typical questions to answer
***************
*** 36,45 ****
     feature? How does the data source layers match the Roadmap layers?
  
!    * A map builder input module may need to be modified or customized to
     handle the specific format used by the data source.
  
!    * The map builder application must be run and the map indexes created.
  
! * PLANNING THE MAP ORGANIZATION
  
     The preliminary step when building a map is always to decide how the
--- 33,42 ----
     feature? How does the data source layers match the Roadmap layers?
  
!    - A map builder input module may need to be modified or customized to
     handle the specific format used by the data source.
  
!    - The map builder application must be run and the map indexes created.
  
! - PLANNING THE MAP ORGANIZATION
  
     The preliminary step when building a map is always to decide how the
***************
*** 47,55 ****
     the main ones are:
  
!    * The map will represent a new class of features.
  
!    * The map will cover a new country.
  
!    * The map will cover an existing country and represent existing features.
  
     Even in the more complex cases when the map to be built represents new
--- 44,52 ----
     the main ones are:
  
!    - The map will represent a new class of features.
  
!    - The map will cover a new country.
  
!    - The map will cover an existing country and represent existing features.
  
     Even in the more complex cases when the map to be built represents new
***************
*** 73,77 ****
     files are organized.
  
! * DATA SOURCE FORMAT
  
     There are two main situations: either the format of the data source is
--- 70,74 ----
     files are organized.
  
! - DATA SOURCE FORMAT
  
     There are two main situations: either the format of the data source is
***************
*** 104,114 ****
     must be modified, or else the data must be merged using standard GIS tools.
  
! * BUILDMAP INPUT MODULES
  
     A buildmap input module must provide the following function:
  
! ----
     buildmap_xxx_process (const char *input, const char *class);
! ----
  
     This function must be called in buildmap_main.c
--- 101,111 ----
     must be modified, or else the data must be merged using standard GIS tools.
  
! - BUILDMAP INPUT MODULES
  
     A buildmap input module must provide the following function:
  
! ```
     buildmap_xxx_process (const char *input, const char *class);
! ```
  
     This function must be called in buildmap_main.c
***************
*** 125,131 ****
  
  
! LAYERS
  
! * LAYER CLASS
  
     Every feature stored in a RoadMap map file belongs to one layer. Layers
--- 122,128 ----
  
  
! = LAYERS =
  
! - LAYER CLASS
  
     Every feature stored in a RoadMap map file belongs to one layer. Layers
***************
*** 138,148 ****
  
  
! * DEFINING A NEW LAYER CLASS
  
     A layer class is made of two lists of layers:
  
!    * One list for all line features (for example: streets).
  
!    * One list for all polygon features (for example: lakes).
  
     Each list is an ordered sequence of layers. The order in the sequence
--- 135,145 ----
  
  
! - DEFINING A NEW LAYER CLASS
  
     A layer class is made of two lists of layers:
  
!    - One list for all line features (for example: streets).
  
!    - One list for all polygon features (for example: lakes).
  
     Each list is an ordered sequence of layers. The order in the sequence
***************
*** 176,180 ****
  
  
! MAP ORGANIZATION
  
     RoadMap divides earth into territories, usually defined by administrative
--- 173,177 ----
  
  
! = MAP ORGANIZATION =
  
     RoadMap divides earth into territories, usually defined by administrative
***************
*** 208,222 ****
  
  
! * MAPS IDENTIFICATION
  
     It is important to understand how maps are identified. RoadMap uses a
     32 bits integer named World Territory ID (wtid) and defined as follow:
  
!     * The wtid is made of 10 decimal digits. There are two major classes
      of wtid format: one is defined by legal boundaries and the other is
      defined by a longitude/latitude grid. At that time, only the legal
      boundaries class of wtid is supported in RoadMap.
  
!     * the legal-boundaries wtid for countries has the format 0CCCCXXXXX,
      where CCCC is the telephone dialing code for the country covered by the
      maps and XXXXX is a subdivision inside that country, wich format depends
--- 205,219 ----
  
  
! - MAPS IDENTIFICATION
  
     It is important to understand how maps are identified. RoadMap uses a
     32 bits integer named World Territory ID (wtid) and defined as follow:
  
!     - The wtid is made of 10 decimal digits. There are two major classes
      of wtid format: one is defined by legal boundaries and the other is
      defined by a longitude/latitude grid. At that time, only the legal
      boundaries class of wtid is supported in RoadMap.
  
!     - the legal-boundaries wtid for countries has the format 0CCCCXXXXX,
      where CCCC is the telephone dialing code for the country covered by the
      maps and XXXXX is a subdivision inside that country, wich format depends
***************
*** 224,233 ****
      whole country.
   
!     * The legal-boundaries wtid for the USA has the format 00000SSCCC where
      SSCCC is the county's FIPS code. Note that, in this case, the value of
      the wtid exactly matches the value of the FIPS code. A CCC of 000 means
      the whole state. A wtid value of 00000 represents the whole US.
  
!     * The grid wtid have the format: 1CCLLLLllll where LLLL is a number that
      represents the longitude span covered by the map and llll is a number
      that represents the latitude covered by the map. CC identifies the type
--- 221,230 ----
      whole country.
   
!     - The legal-boundaries wtid for the USA has the format 00000SSCCC where
      SSCCC is the county's FIPS code. Note that, in this case, the value of
      the wtid exactly matches the value of the FIPS code. A CCC of 000 means
      the whole state. A wtid value of 00000 represents the whole US.
  
!     - The grid wtid have the format: 1CCLLLLllll where LLLL is a number that
      represents the longitude span covered by the map and llll is a number
      that represents the latitude covered by the map. CC identifies the type
***************
*** 251,255 ****
     Bulletin No. 835. For more information, go to:
  
!       {{http://www.itu.int/itu-t/bulletin/annex.html}}
  
     RoadMap also use names to identify authorities (such as when it searches
--- 248,252 ----
     Bulletin No. 835. For more information, go to:
  
!       http://www.itu.int/itu-t/bulletin/annex.html
  
     RoadMap also use names to identify authorities (such as when it searches
***************
*** 262,266 ****
     The country code name follow the iso 3166-1 standard. See:
  
!       {{http://www.iso.org/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html}}
  
     The sub-authority levels must follow the local country convention for
--- 259,263 ----
     The country code name follow the iso 3166-1 standard. See:
  
!       http://www.iso.org/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html
  
     The sub-authority levels must follow the local country convention for
***************
*** 293,300 ****
     Continuing with the US example, the US can be represented in two ways:
  
!      * as a single index, which belongs to the US country, authorities are
       the US states and territories are the counties.
  
!      * as a two-level tree of indexes: the top-level index lists the states
       as authorities and contains no territory, map or cities tables; each
       lower level index represents one state, lists counties as territories
--- 290,297 ----
     Continuing with the US example, the US can be represented in two ways:
  
!      - as a single index, which belongs to the US country, authorities are
       the US states and territories are the counties.
  
!      - as a two-level tree of indexes: the top-level index lists the states
       as authorities and contains no territory, map or cities tables; each
       lower level index represents one state, lists counties as territories
***************
*** 305,309 ****
  
  
! * DEFINING A NEW COUNTRY
  
     If the country was not represented in RoadMap yet, the division of the
--- 302,306 ----
  
  
! - DEFINING A NEW COUNTRY
  
     If the country was not represented in RoadMap yet, the division of the
***************
*** 311,315 ****
     to consider:
  
!       * The territories must be compatible with the way postal addresses
        are organized. The major requirements are that city names should be
        unique inside a map file. If possible, the middle level authority levels
--- 308,312 ----
     to consider:
  
!       - The territories must be compatible with the way postal addresses
        are organized. The major requirements are that city names should be
        unique inside a map file. If possible, the middle level authority levels
***************
*** 317,321 ****
        convention as well.
  
!       * The territories should be compatible with the way the data source is
        organized. It is possible to reorganize the data according to different
        criteria, for example by splitting or merging files, but this introduces
--- 314,318 ----
        convention as well.
  
!       - The territories should be compatible with the way the data source is
        organized. It is possible to reorganize the data according to different
        criteria, for example by splitting or merging files, but this introduces
***************
*** 345,353 ****
     example  of a countries.txt file describing the US and canada:
  
! ------
         # List of countries, format: iso 3166-1, itu E.164A (except USA), name
         us,0,USA
         ca,1,Canada
! ------
  
     The country's list of parent territories must be described in a separate
--- 342,350 ----
     example  of a countries.txt file describing the US and canada:
  
! ```
         # List of countries, format: iso 3166-1, itu E.164A (except USA), name
         us,0,USA
         ca,1,Canada
! ```
  
     The country's list of parent territories must be described in a separate
***************
*** 358,364 ****
     The format of the file is:
  
! ------
          wtid,symbol,name[,parent-authority-symbol]
! ------
  
     The wtid must be empty if an authority is described (since no map file
--- 355,361 ----
     The format of the file is:
  
! ```
          wtid,symbol,name[,parent-authority-symbol]
! ```
  
     The wtid must be empty if an authority is described (since no map file
***************
*** 369,373 ****
     Here is an example that describes the state of Rhode Island (USA):
  
! ------
          ,RI,RHODE ISLAND
          44001,,Bristol,RI
--- 366,370 ----
     Here is an example that describes the state of Rhode Island (USA):
  
! ```
          ,RI,RHODE ISLAND
          44001,,Bristol,RI
***************
*** 376,380 ****
          44007,,Providence,RI
          44009,,Washington,RI
! ------
  
     For large countries it is recommended to locate the official description
--- 373,377 ----
          44007,,Providence,RI
          44009,,Washington,RI
! ```
  
     For large countries it is recommended to locate the official description

[Roadmap-commit] roadmap/web Makefile,1.11,1.12

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/web
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv2766/web

Modified Files:
	Makefile 
Log Message:
switch from aptconvert format to txt2tags (txt2tags.sourceforge.net) format.
aptconvert seems to be orphanced, txt2tags seems as capable, and is on
sourceforge and in debian.


Index: Makefile
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/Makefile,v
retrieving revision 1.11
retrieving revision 1.12
diff -C2 -d -r1.11 -r1.12
*** Makefile	17 Mar 2008 20:21:08 -0000	1.11
--- Makefile	6 Nov 2008 20:23:07 -0000	1.12
***************
*** 5,14 ****
  
  APT_WEBDOCS = \
! 	status.html \
  	manual.html \
  	buglist.html \
! 	changelog.html \
! 	installation.html \
  	todolist.html \
  	makemaps.html
  
--- 5,16 ----
  
  APT_WEBDOCS = \
! 
! T2T_WEBDOCS = \
  	manual.html \
  	buglist.html \
! 	status.html \
  	todolist.html \
+ 	installation.html \
+ 	changelog.html \
  	makemaps.html
  
***************
*** 54,58 ****
  
  
! SITESOURCE = $(SCREENSHOTS) $(APT_WEBDOCS) $(PAGES) $(SUPPORT)
  
  all: webdoc
--- 56,60 ----
  
  
! SITESOURCE = $(SCREENSHOTS) $(T2T_WEBDOCS) $(PAGES) $(SUPPORT)
  
  all: webdoc
***************
*** 65,69 ****
  # use 'make SF=1 install' to send to SF
  ifeq ($(strip $(SF)),)
! OUR_SITE_REFERENCE = www.foxharp.boston.ma.us/tmp/nroadmap
  OUR_SITE_ACCESS = mulch:/var/web/home/tmp/nroadmap
  else
--- 67,71 ----
  # use 'make SF=1 install' to send to SF
  ifeq ($(strip $(SF)),)
! OUR_SITE_REFERENCE = roadmap.sourceforge.net
  OUR_SITE_ACCESS = mulch:/var/web/home/tmp/nroadmap
  else
***************
*** 82,86 ****
  	    $< >foo.html && \
  	scp foo.html $(OUR_SITE_ACCESS)/$<
! 	rm -f foo.html
  	touch $@
  
--- 84,88 ----
  	    $< >foo.html && \
  	scp foo.html $(OUR_SITE_ACCESS)/$<
! 	# rm -f foo.html
  	touch $@
  
***************
*** 96,126 ****
  # (http://www.xmlmind.com/aptconvert.html)
  
! webdoc: $(APT_WEBDOCS)
  
  clean-webdoc:
! 	rm -f $(APT_WEBDOCS)
  
  # use GNU make's target-specific variables to name the sourcefile
  # for each constructed web page.  the names are somewhat random,
  # so we can't simply use a pattern rule.
! manual.html: APT_SOURCE=../README
  manual.html: ../README
  
! makemaps.html: APT_SOURCE=../howtos/makemaps.txt
  makemaps.html: ../howtos/makemaps.txt
  
! buglist.html: APT_SOURCE=../BUGS
  buglist.html: ../BUGS
  
! changelog.html: APT_SOURCE=../CHANGES
  changelog.html: ../CHANGES
  
! todolist.html: APT_SOURCE=../TODO
  todolist.html: ../TODO
  
! status.html: APT_SOURCE=../STATUS
  status.html: ../STATUS
  
! installation.html: APT_SOURCE=../INSTALL
  installation.html: ../INSTALL
  
--- 98,128 ----
  # (http://www.xmlmind.com/aptconvert.html)
  
! webdoc: $(T2T_WEBDOCS)
  
  clean-webdoc:
! 	rm -f $(T2T_WEBDOCS)
  
  # use GNU make's target-specific variables to name the sourcefile
  # for each constructed web page.  the names are somewhat random,
  # so we can't simply use a pattern rule.
! manual.html: DOC_SOURCE=../README
  manual.html: ../README
  
! makemaps.html: DOC_SOURCE=../howtos/makemaps.txt
  makemaps.html: ../howtos/makemaps.txt
  
! buglist.html: DOC_SOURCE=../BUGS
  buglist.html: ../BUGS
  
! changelog.html: DOC_SOURCE=../CHANGES
  changelog.html: ../CHANGES
  
! todolist.html: DOC_SOURCE=../TODO
  todolist.html: ../TODO
  
! status.html: DOC_SOURCE=../STATUS
  status.html: ../STATUS
  
! installation.html: DOC_SOURCE=../INSTALL
  installation.html: ../INSTALL
  
***************
*** 131,141 ****
  # so that the links all work properly when installed in a test tree.
  
! $(APT_WEBDOCS):
! 	aptconvert -pi html showTitle yes -toc -enc ASCII $@ $(APT_SOURCE)
  	sed -i \
! 	    -e '/<head>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
! 	    -e '/<body>/a \
  	    <!--#include virtual="navbar.html" -->' \
! 	    -e 's/<body>/<body class="roadmap-doc">/' \
  	    -e 's;http://'$(OUR_SITE_REFERENCE)'/;;' $@ 
  
--- 133,161 ----
  # so that the links all work properly when installed in a test tree.
  
! #$(APT_WEBDOCS):
! #	aptconvert -pi html showTitle yes -toc -enc ASCII $@ $(DOC_SOURCE)
! #	sed -i \
! #	    -e '/<head>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
! #	    -e '/<body>/a \
! #	    <!--#include virtual="navbar.html" -->' \
! #	    -e 's/<body>/<body class="roadmap-doc">/' \
! #	    -e 's;http://'$(OUR_SITE_REFERENCE)'/;;' $@ 
! 
! # here's the rule for building webpages from our
! # txt2tags-compatible text files.  we expand tabs (since they can
! # confuse txt2tags) and post-process, to add some extra html at
! # the top, to make the docs fit in with the rest of the site.  we
! # also remove absolute references to our own website, so that the
! # links all work properly when installed in a test tree.
! 
! $(T2T_WEBDOCS):
! 	expand $(DOC_SOURCE) | \
! 	txt2tags --target html \
! 	    --toc --infile - --outfile $@
  	sed -i \
! 	    -e '/<HEAD>/s/$$/<link href="sitestandard.css" type=text\/css rel=stylesheet>/' \
! 	    -e '/<BODY .*>/a \
  	    <!--#include virtual="navbar.html" -->' \
! 	    -e 's/<BODY .*>/<body class="roadmap-doc">/' \
  	    -e 's;http://'$(OUR_SITE_REFERENCE)'/;;' $@ 
  

[Roadmap-commit] roadmap BUGS, 1.8, 1.9 CHANGES, 1.7, 1.8 INSTALL, 1.8, 1.9 README, 1.160, 1.161 STATUS, 1.3, 1.4 TODO, 1.14, 1.15

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv2766

Modified Files:
	BUGS CHANGES INSTALL README STATUS TODO 
Log Message:
switch from aptconvert format to txt2tags (txt2tags.sourceforge.net) format.
aptconvert seems to be orphanced, txt2tags seems as capable, and is on
sourceforge and in debian.


Index: STATUS
===================================================================
RCS file: /cvsroot/roadmap/roadmap/STATUS,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** STATUS	6 Nov 2008 03:31:56 -0000	1.3
--- STATUS	6 Nov 2008 20:23:06 -0000	1.4
***************
*** 1,11 ****
  
!                                ---------
!                             Project Status
!                                ---------
! 		    Paul Fox, current RoadMap maintainer
!                                ---------
!                              November 2008
! 
! New Release 1.2.0
  
      RoadMap has another new release.  It's been over a year
--- 1,7 ----
+ Project Status
+ Paul Fox, current RoadMap maintainer
+ November 2008
  
! = New Release 1.2.0 =
  
      RoadMap has another new release.  It's been over a year
***************
*** 15,33 ****
      Major new developments in 1.2.0 include;
  
! 	* Support for OpenStreetMap maps, both geographically-based
! 	  (i.e., arbitrary rectangular tiles) and political (i.e.,
! 	  country-based).  The ability to use OSM maps moves RoadMap
! 	  from being a highly US-centric program to one which can
! 	  be useful worldwide.
  
! 	* Resurrection of the Windows CE port.  Since the port is
! 	  supported via cross-compilation with ming32w, maintenance
! 	  is much easier for the developers.
  
- 	* Initial support of the iPhone.
  
      There's more detail in the changelog.
  
! Two Branches
  
      Not much progress has been made in merging code from the forked
--- 11,31 ----
      Major new developments in 1.2.0 include;
  
!         - Support for OpenStreetMap maps, both geographically-based
!           (i.e., arbitrary rectangular tiles) and political (i.e.,
!           country-based).  The ability to use OSM maps moves RoadMap
!           from being a highly US-centric program to one which can
!           be useful worldwide.
  
!         - Resurrection of the Windows CE port.  Since the port is
!           supported via cross-compilation with ming32w, maintenance
!           is much easier for the developers.
! 
!         - Initial support of the iPhone.
! 	
  
  
      There's more detail in the changelog.
  
! = Two Branches =
  
      Not much progress has been made in merging code from the forked
***************
*** 41,49 ****
      very successfully in the FreeMap Israel project.
      
! 	{{ http://www.freemap.co.il }}
  
      (Sadly for many of us, google doesn't yet translate Hebrew.)
  
! Help Wanted!
  
      If you know something about GIS and want to help with the
--- 39,47 ----
      very successfully in the FreeMap Israel project.
      
!         http://www.freemap.co.il
  
      (Sadly for many of us, google doesn't yet translate Hebrew.)
  
! = Help Wanted! =
  
      If you know something about GIS and want to help with the

Index: TODO
===================================================================
RCS file: /cvsroot/roadmap/roadmap/TODO,v
retrieving revision 1.14
retrieving revision 1.15
diff -C2 -d -r1.14 -r1.15
*** TODO	6 Nov 2008 03:31:56 -0000	1.14
--- TODO	6 Nov 2008 20:23:06 -0000	1.15
***************
*** 1,158 ****
!                                ---------
!                          To-do list for RoadMap
!                                ---------
!                                ---------
!                              October 2007
! 
!    This is a list of changes envisioned for future versions of RoadMap. 
!    Please feel free to contact the author(s) for more ideas.  Please
!    feel especially free to contact the author(s) with patches.  ;-)
! 
!    *  Better OpenStreetMap support
!       
!       RoadMap began as a rendering engine for the US Census bureau Tiger maps,
!       but it has now grown the ability to render OpenStreetMap data.  This
!       OSM support deserves to be fleshed out in many ways.
  
!    *  New Tiger map format
  
!       The census bureau has released data in its new shapefile format,
!       which replaces the previous TIGER format.  We could begin
!       implementing a new converter for that shapefile spec, or we could
!       ignore further TIGER updates, and concentrate on OSM, since OSM now
!       incorporates the TIGER maps.  If editing changes from the RoadMap
!       editor branch could be incorporated, RoadMap could in theory even
!       help contribute new OSM data.
  
!    *  Use checkbox widget in the menus and toolbars:
  
!       Some menu and toolbar entries are of the "start & stop" kind.  Instead
!       of having 2 entries it would be nice to use a single checkbox one. 
!       Other entries are already toggles, but their state can't be determined
!       visually.  In any case, RoadMap should be consistent (or at least clear)
!       about whether or not the change will affect startup preferences.
  
!    *  More message formats, and message data -- users have requested
!       that more types of data be available on-screen:
!       
!         * speed should be available all the time, not just when a
!           route is active
  
!         * course (bearing), altitude
  
!         * elapsed, and projected "trip time".  moving time, idle
!           (stopped) time.
  
!         * distance traveled since program start
  
!         * distance since route start
  
!         * perhaps a shell escape, for getting data from external
!           programs?
!       
!       In addition message signs that are too long should wrap, rather than
!       truncate.
  
!       Much of this information could be put into a canned trip statistics
!       screen, so it could all be made visible at once.  (Could such a screen
!       be constructed from the roadmap_display() basics?  Would need to
!       be able to create better-formatted output -- newlines, columns, etc.)
  
!    *  Add voice output for trip navigation.
     
!       The flite voice should read the routepoint comments that currently
!       appear on the screen.  Need to make the timing of the comments
!       speed-sensitive, and figure out what to do with routepoints that don't
!       have attached comments.  Probably if some routepoints do have comments,
!       then we should ignore those that don't, otherwise we should give
!       a directional indication since there are no "real" directions.
! 
!    *  Key bindings should be rebindable by the user.
!       
!       This would make the UI fully customizable.  Some support for this
!       appears in the roadmap_editor branch, but it's not complete.
  
!    *  Show GPS location
!       
!       There should be a way to easily display the current location.
  
!    *  Use GPS time and map's timezone
!       
!       The GPS receiver provides a reliable universal time as well as the
!       current location.  This is all what RoadMap needs to show the correct
!       local time.  (On the other hand, the user of the maps may not care about
!       the time in the place being examined.  Picture a desktop user, at home. 
!       In that case, all times should perhaps be local.)
!       
!         * Associate a timezone to each county.
  
!         * When showing a particular location on the map, display the
!           local time for this location.
  
!         * Show estimated time of arrival in the destination's timezone.
!       
!       One might think of setting the UNIX time and system timezone, but that
!       would be a bad idea:  this would cause a whole mess when replaying GPS
!       logs, RoadMap would need to be root or have the set UID bit set and
!       managing system setup is best left to system daemons.  In addition, gpsd
!       is now synchronizing the system time, so don't mess with that subject..
  
!    *  Modular map format
!       
!       RoadMap map format is such today that all the information must be
!       contained in a single file.  RoadMap should be able to display, and use,
!       data from multiple county files.  The benefits are that one can come
!       with his own additional information (such as railroad tracks) without
!       modifying the existing maps or making them larger.  In addition the
!       current set of maps could be cut in two (separating the street shapes
!       from the street names) to lower the amount of data mapped by RoadMap
!       when displaying the map on the screen (especially when zoomed out). 
!       Essentially, layers could be assigned to each of the split-up county
!       files.
  
!    *  Modular map rendering
!       
!       The RoadMap map rendering code should be made more modular so that a new
!       type of data can be defined, associated with a plugin to implement the
!       rendering code.
  
!    *  Track more than one GPS source
!       
!       RoadMap should allow the user to track alternate GPS sources as defined
!       by the user (like GpsDrive's friendsd).
  
!    *  Navigation
!       
!       While the TIGER data doesn't have the necessary data to make navigation
!       with RoadMap feasible currently, other datasets do, and the
!       roadmap_editor branch has proven that it can be done.  OpenStreetMap is
!       starting to work with TIGER maps, and perhaps that work can be used as a
!       shared resource for adding the necessary meta-data.
  
!       A precursor to this work would be to make the roadmap plugin API
!       match the roadmap_editor plugin API (again).  (Some progress has
!       been made on this.)
  
!    *  Places
!       
!       Work was begun to add "places" support (i.e.  landmark) names to the
!       RoadMap database.  This should be finished.
  
!    *  Interface with address book applications
!       
!       RoadMap should be able to interface with address book databases to get
!       street addresses from there.  Instead of specifying a destination
!       address, one would provide the name of a person.
  
!    *  Cross-platform widgets
!       
!       While the current home-grown widgets work pretty well, it's probably
!       time to implement a version of the RoadMap API in something like
!       WxWidgets.  If this were successful, and the extra cost of such a widget
!       set weren't too great, then over time we could switch to it exclusively.
  
-    *  Speed-sensitive zoom
  
-       While moving, there should be a mode where the zoom and 3D
-       horizon value are adjusted dynamically, to give longer range at
-       higher speeds.
--- 1,153 ----
! To-do list for RoadMap
  
! November 2008
  
! This is a list of changes envisioned for future versions of RoadMap. 
! Please feel free to contact the author(s) for more ideas.  Please
! feel especially free to contact the author(s) with patches.  ;-)
  
!  - Better OpenStreetMap support
!    
!    RoadMap began as a rendering engine for the US Census bureau Tiger maps,
!    but it has now grown the ability to render OpenStreetMap data.  This
!    OSM support deserves to be fleshed out in many ways.
  
!  - New Tiger map format
  
!    The census bureau has released data in its new shapefile format,
!    which replaces the previous TIGER format.  We could begin
!    implementing a new converter for that shapefile spec, or we could
!    ignore further TIGER updates, and concentrate on OSM, since OSM now
!    incorporates the TIGER maps.  If editing changes from the RoadMap
!    editor branch could be incorporated, RoadMap could in theory even
!    help contribute new OSM data.
  
!  - Use checkbox widget in the menus and toolbars:
  
!    Some menu and toolbar entries are of the "start & stop" kind.  Instead
!    of having 2 entries it would be nice to use a single checkbox one. 
!    Other entries are already toggles, but their state can't be determined
!    visually.  In any case, RoadMap should be consistent (or at least clear)
!    about whether or not the change will affect startup preferences.
  
!  - More message formats, and message data -- users have requested
!    that more types of data be available on-screen:
!    
!      - speed should be available all the time, not just when a
!        route is active
!      - course (bearing), altitude
!      - elapsed, and projected "trip time".  moving time, idle
!        (stopped) time.
!      - distance traveled since program start
!      - distance since route start
!      - perhaps a shell escape, for getting data from external
!        programs?
!      -
!    
!    In addition message signs that are too long should wrap, rather than
!    truncate.
  
!    Much of this information could be put into a canned trip statistics
!    screen, so it could all be made visible at once.  (Could such a screen
!    be constructed from the roadmap_display() basics?  Would need to
!    be able to create better-formatted output -- newlines, columns, etc.)
  
!  - Add voice output for trip navigation.
  
!    The flite voice should read the routepoint comments that currently
!    appear on the screen.  Need to make the timing of the comments
!    speed-sensitive, and figure out what to do with routepoints that don't
!    have attached comments.  Probably if some routepoints do have comments,
!    then we should ignore those that don't, otherwise we should give
!    a directional indication since there are no "real" directions.
  
!  - Key bindings should be rebindable by the user.
     
!    This would make the UI fully customizable.  Some support for this
!    appears in the roadmap_editor branch, but it's not complete.
  
!  - Show GPS location
!    
!    There should be a way to easily display the current location.
  
!  - Use GPS time and map's timezone
!    
!    The GPS receiver provides a reliable universal time as well as the
!    current location.  This is all what RoadMap needs to show the correct
!    local time.  (On the other hand, the user of the maps may not care about
!    the time in the place being examined.  Picture a desktop user, at home. 
!    In that case, all times should perhaps be local.)
!    
!      - Associate a timezone to each county.
!      - When showing a particular location on the map, display the
!        local time for this location.
!      - Show estimated time of arrival in the destination's timezone.
!      -
!    
!    One might think of setting the UNIX time and system timezone, but that
!    would be a bad idea:  this would cause a whole mess when replaying GPS
!    logs, RoadMap would need to be root or have the set UID bit set and
!    managing system setup is best left to system daemons.  In addition, gpsd
!    is now synchronizing the system time, so don't mess with that subject..
  
!  - Modular map format
!    
!    RoadMap map format is such today that all the information must be
!    contained in a single file.  RoadMap should be able to display, and use,
!    data from multiple county files.  The benefits are that one can come
!    with his own additional information (such as railroad tracks) without
!    modifying the existing maps or making them larger.  In addition the
!    current set of maps could be cut in two (separating the street shapes
!    from the street names) to lower the amount of data mapped by RoadMap
!    when displaying the map on the screen (especially when zoomed out). 
!    Essentially, layers could be assigned to each of the split-up county
!    files.
  
!  - Modular map rendering
!    
!    The RoadMap map rendering code should be made more modular so that a new
!    type of data can be defined, associated with a plugin to implement the
!    rendering code.
  
!  - Track more than one GPS source
!    
!    RoadMap should allow the user to track alternate GPS sources as defined
!    by the user (like GpsDrive's friendsd).
  
!  - Navigation
!    
!    While the TIGER data doesn't have the necessary data to make navigation
!    with RoadMap feasible currently, other datasets do, and the
!    roadmap_editor branch has proven that it can be done.  OpenStreetMap is
!    starting to work with TIGER maps, and perhaps that work can be used as a
!    shared resource for adding the necessary meta-data.
  
!    A precursor to this work would be to make the roadmap plugin API
!    match the roadmap_editor plugin API (again).  (Some progress has
!    been made on this.)
  
!  - Places
!    
!    Work was begun to add "places" support (i.e.  landmark) names to the
!    RoadMap database.  This should be finished.
  
!  - Interface with address book applications
!    
!    RoadMap should be able to interface with address book databases to get
!    street addresses from there.  Instead of specifying a destination
!    address, one would provide the name of a person.
  
!  - Cross-platform widgets
!    
!    While the current home-grown widgets work pretty well, it's probably
!    time to implement a version of the RoadMap API in something like
!    WxWidgets.  If this were successful, and the extra cost of such a widget
!    set weren't too great, then over time we could switch to it exclusively.
  
!  - Speed-sensitive zoom
  
!    While moving, there should be a mode where the zoom and 3D
!    horizon value are adjusted dynamically, to give longer range at
!    higher speeds.
  
  

Index: BUGS
===================================================================
RCS file: /cvsroot/roadmap/roadmap/BUGS,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** BUGS	13 Oct 2007 17:00:33 -0000	1.8
--- BUGS	6 Nov 2008 20:23:06 -0000	1.9
***************
*** 1,73 ****
!                                ---------
!                     Approximate bug list for RoadMap
!                                ---------
!                                ---------
!                              October 2007
  
  
! KNOWN BUGS -- patches welcome
  
  Desktop and rendering bugs:
  
!  * Gtk2 interface reports error:
  
     The following error message appears:
  
     (gtkroadmap:3487): WARNING **: Invalid UTF8 string passed to
          pango_layout_set_text()
  
!  * Long lines are sometimes incorrectly displayed
   
     The symptom is that all of a sudden a long straight line that you know
     isn't really present will appear from edge to edge of your screen.
  
!  * QT3,QT4 - no display periodic running
! 
!    Periodics seem to be attached to windows (?), so the new periodic started
!    in roadmap_display_initialize() doesn't commence since there's no window
!    yet.
! 
!  * QT3,QT4 - no signal handling
! 
!    No signal handling has been added to the QT versions.  This means user
!    changes to routes and waypoints, and the track log, can easily be lost.
! 
!    (The GTK versions handle signals properly, and so RoadMap will shut down
!    cleanly in the event of the user hitting ^C in the window from which
!    RoadMap was started, or if RoadMap is killed with SIGTERM, as when the
!    system is shutting down.)
! 
!  * WinCE,Win32 - Executables built with the arm-wince-mingw32ce
!    cross-compiler don't run.
!    
!    It would be great if someone could finish that work.  And win32 hasn't even
!    been attempted in cross-compilation.  Using a cross-compiler has big
!    advantages for the principal developers, so please don't just toss that
!    notion aside without some discussion.
! 
!  * GTK/GTK2 - Deprecated interfaces in use.
  
     Both flavors of GTK build make fairly heavy use of deprecated API pieces. 
     Someone with good GTK skills should clean these up.
  
!  * Edge cases.
   
     If you get too close to either the north or south pole, RoadMap will
     get confused, and may crash.  If you go past the 180th meridian, in either
     direction, RoadMap may or may not get confused, but you probably will.
-    
- Map building bugs:
- 
-  * Shape point are ignored when drawing polygons:
  
!    The Tiger files define polygons as delineated by a list of lines.
!    Any of these lines might be defined by a serie of shape points.
! 
!    RoadMap uses the shape points when drawing the lines, but not when
!    filling the polygons.
  
  Map data bugs:
  
!  * City search is broken:
  
     The roadmap files include a table to convert a place into a county
--- 1,45 ----
! Approximate bug list for RoadMap
  
+ November 2008
  
! //(patches welcome!)//
  
  Desktop and rendering bugs:
  
!  - Gtk2 interface reports error:
  
     The following error message appears:
  
+ ```
     (gtkroadmap:3487): WARNING **: Invalid UTF8 string passed to
          pango_layout_set_text()
+ ```
  
!  - Long lines are sometimes incorrectly displayed
   
     The symptom is that all of a sudden a long straight line that you know
     isn't really present will appear from edge to edge of your screen.
  
!  - GTK/GTK2 - Deprecated interfaces in use.
  
     Both flavors of GTK build make fairly heavy use of deprecated API pieces. 
     Someone with good GTK skills should clean these up.
  
!  - Edge cases.
   
     If you get too close to either the north or south pole, RoadMap will
     get confused, and may crash.  If you go past the 180th meridian, in either
     direction, RoadMap may or may not get confused, but you probably will.
  
!  - There are no errors reported when attempting to access features that
!    the current map data doesn't support.  For instance, there is no
!    address or political entity information in OpenStreetMap quadtile
!    data, but the Address searchbox will still let you try and look up
!    a city by name.
!    
  
  Map data bugs:
  
!  - City search is broken:
  
     The roadmap files include a table to convert a place into a county
***************
*** 75,79 ****
     across county subdivisions, with name clashes.
  
!  * The "address by ZIP" method does not work anymore:
  
     Since the automatic selection of the map, because the file usdir.rdm does
--- 47,51 ----
     across county subdivisions, with name clashes.
  
!  - The "address by ZIP" method does not work anymore:
  
     Since the automatic selection of the map, because the file usdir.rdm does
***************
*** 82,86 ****
     This feature has been hidden from the user interface  for now.
  
!  * Street address conflicts:
  
     A few street address conflicts appears when building maps.  Some seems to
--- 54,58 ----
     This feature has been hidden from the user interface  for now.
  
!  - Street address conflicts:
  
     A few street address conflicts appears when building maps.  Some seems to
***************
*** 91,95 ****
     database errors by the census bureau.
  
!  * Street numbers are not always numerical:
  
     Some street numbers include letters, which is not well supported by
--- 63,67 ----
     database errors by the census bureau.
  
!  - Street numbers are not always numerical:
  
     Some street numbers include letters, which is not well supported by
***************
*** 101,110 ****
     a practical case where this does not work.
  
!  * Some urban areas are missing:
  
     For example:  Woodland Hills (in Los Angeles county).  This is a TIGER file
     problem:  the string "WOODLAND HILLS" never appears in the LA county files.
  
!  * The maps for the state of Hawaii do not use the NAD83 datum:
  
     The offset can be significant (a few hundred feet), making these maps
--- 73,82 ----
     a practical case where this does not work.
  
!  - Some urban areas are missing:
  
     For example:  Woodland Hills (in Los Angeles county).  This is a TIGER file
     problem:  the string "WOODLAND HILLS" never appears in the LA county files.
  
!  - The maps for the state of Hawaii do not use the NAD83 datum:
  
     The offset can be significant (a few hundred feet), making these maps

Index: INSTALL
===================================================================
RCS file: /cvsroot/roadmap/roadmap/INSTALL,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** INSTALL	22 Oct 2007 21:23:08 -0000	1.8
--- INSTALL	6 Nov 2008 20:23:06 -0000	1.9
***************
*** 1,9 ****
!                           -----------
!     RoadMap Quickstart, and Installing on Familiar Linux / GPE
!                           -----------
!                           -----------
!                          October 2007
  
! INTRODUCTION
  
     This document describes the most basic steps you'll need to perform
--- 1,7 ----
! RoadMap Quickstart, and Installing on Familiar Linux / GPE
  
! November 2008
! 
! = INTRODUCTION =
  
     This document describes the most basic steps you'll need to perform
***************
*** 15,38 ****
  
  
! QUICKSTART
  
     To build RoadMap for a "standard" linux/unix environment, follow
     the following steps:
  
!      * Read the commentary in "config.mk", and edit the values there
         to select your build options.  For most users, no other
         configuration choices should be necessary.
         
!      * Run "make".  (RoadMap requires GNU make, and may require gcc).
         
!      * Run "make install".  This will install the executables as well
         as important data files.  It will _not_ install any map data,
         however.  At this point you should be able to run "roadmap",
         but it will tell you there are no maps.
  
!      * To test drive RoadMap for the first time, download the
         "demo" maps from:
  
! 	 {{http://roadmap.digitalomaha.net/maps/demo_maps.tar.gz}}
  
         This tarball contains state outlines for all of the continental
--- 13,36 ----
  
  
! = QUICKSTART =
  
     To build RoadMap for a "standard" linux/unix environment, follow
     the following steps:
  
!      - Read the commentary in "config.mk", and edit the values there
         to select your build options.  For most users, no other
         configuration choices should be necessary.
         
!      - Run "make".  (RoadMap requires GNU make, and may require gcc).
         
!      - Run "make install".  This will install the executables as well
         as important data files.  It will _not_ install any map data,
         however.  At this point you should be able to run "roadmap",
         but it will tell you there are no maps.
  
!      - To test drive RoadMap for the first time, download the
         "demo" maps from:
  
!          http://roadmap.digitalomaha.net/maps/demo_maps.tar.gz
  
         This tarball contains state outlines for all of the continental
***************
*** 40,48 ****
         this file somewhere convenient, e.g. /tmp/demo_maps.
  
!      * Start RoadMap, specifying the path that you chose above:
  
! ----
! 	roadmap --maps=/tmp/demo_maps
! ----
  
         Use the arrow keys (or drag with the mouse) to pan, and use the
--- 38,46 ----
         this file somewhere convenient, e.g. /tmp/demo_maps.
  
!      - Start RoadMap, specifying the path that you chose above:
  
! ```
!         roadmap --maps=/tmp/demo_maps
! ```
  
         Use the arrow keys (or drag with the mouse) to pan, and use the
***************
*** 53,60 ****
         item to quit.
  
!      * When you're ready to download a more complete set of maps, get
         them from
  
! 	 {{http://roadmap.sourceforge.net/maps.html}}
  
         Be sure to get the master index file in addition to any maps
--- 51,58 ----
         item to quit.
  
!      - When you're ready to download a more complete set of maps, get
         them from
  
!          http://roadmap.sourceforge.net/maps.html
  
         Be sure to get the master index file in addition to any maps
***************
*** 71,80 ****
     The README is on the web, here:
  
!          {{http://roadmap.sourceforge.net/manual.html}}
  
     Good luck, and have fun!
  
  
! INSTALLATION ON FAMILIAR
  
     The remaining sections of this document describe the installation
--- 69,78 ----
     The README is on the web, here:
  
!          http://roadmap.sourceforge.net/manual.html
  
     Good luck, and have fun!
  
  
! = INSTALLATION ON FAMILIAR =
  
     The remaining sections of this document describe the installation
***************
*** 85,195 ****
     Some of the instructions below are dated.  Proceed with caution.
  
! BEFORE THE INSTALL
  
! * Removing a prior installation of RoadMap
  
!    Since RoadMap 1.0.4 the path to the maps has changed. In addition there is
!    no more package for the maps (the maps are too big for that and there was
!    only one example map anyway). Therefore the roadmap-sfca package should be
!    removed first
  
! ----
!    ipkg remove roadmap-sfca
! ----
  
!    The name of the RoadMap package has also changed from roadmap-gtk2 to
!    roadmap. Therefore the roadmap-gtk2 package should be removed:
  
! ----
!    ipkg remove roadmap-gtk2
! ----
  
  
! * Making room for RoadMap
  
!    On a PDA with 32Mb of RAM, GPE takes most of the available space and less
!    than 2Mb of RAM is left available. For RoadMap to work one need to make
!    some room. The author recommends removing xstroke and the GPE help from
!    the bottom panel.
  
!    Another problem is a bug in the Familiar X server that causes the file
!    ~/.xsession-errors to grow infinitely in the ramdisk, eating up all the
!    available RAM in a matter of days.
!    
!    The work-around is to not start the ipaq-sleep daemon. To do this,
!    comment out the line "/etc/init.d/ipaq-sleep start" in the file:
  
! ----
!            /etc/X11/Xsession.d/69ipaq-sleep
! ----
  
  
! * Installing gpsd
  
!    RoadMap depends on gpsd for receiving data from the GPS device. Therefore
!    the gpsd package must be installed:
  
! ----
!    ipkg install gpsd
! ----
  
!    Once this has been done, the serial line must be configured for using gpsd
!    (see the serial line configuration tool in the Settings folder).
  
! * Installing flite
  
!    RoadMap uses flite for generating the voice announcements. RoadMap
!    can be used without flite, but it will stay silent then.
  
!    Note that flite is a very big program: it should be installed on the
!    MMC, SD or CompactFlash (CF) card. Installing flite is easy: just copy
!    the executable file. The problem is more where to find the executable..
  
  
! INSTALLING ROADMAP
  
!    There are three steps: first install the RoadMap package, then install
!    some maps and last setup your preferences if you installed RoadMap in
!    a custom way.
  
  
! * Installing the package
  
!    There is very little to say here. RoadMap takes less than 300Kb of space,
!    uncompressed. It installs itself in /usr/bin and /usr/share/pixmaps:
  
! ----
!    ipkg install roadmap                 (if your feed provides RoadMap)
!    ipkg install roadmap_X.Y.Z_arm.ipk   (if you transfered the package)
! ----
  
  
! * Installing maps
  
!    The RoadMap package is preconfigured for maps stored either in a MMC, SD or
!    CompactFlash (CF) card. The map files must be installed in a subdirectory
!    of the device's root directory named "share/roadmap". The reason for that
!    is to follow standard UNIX convention and make it easier to store other
!    types of data in the device (such as MP3 files).
  
!    The file system used for the device is indifferent (RoadMap maps comply
!    with the 8+3 limitation of the FAT file system) but VFAT is recommended
!    (if only because this is the factory default file system).
  
!    The map files can be retrieved from the RoadMap site:
  
!        * {{http://roadmap.sourceforge.net}}
  
!    The first file to install in the share/roadmap subdirectory is the file
!    named "usdir.rdm". This file is mandatory: this is the index used to
!    retrieve all other map files. All other files are optional: one can load
!    a limited subset of maps only. If a map is not available, RoadMap will
!    issue a warning message.
  
  
! * Setting the user preferences
  
!    Start Roadmap, select <<File / Preferences>>. The preferences dialog is
!    made of a (long) serie of tabbed screens. Most preferences do not need
!    to be modified.
  
--- 83,193 ----
     Some of the instructions below are dated.  Proceed with caution.
  
! - BEFORE THE INSTALL
  
!   - Removing a prior installation of RoadMap
  
!      Since RoadMap 1.0.4 the path to the maps has changed. In addition there is
!      no more package for the maps (the maps are too big for that and there was
!      only one example map anyway). Therefore the roadmap-sfca package should be
!      removed first
  
! ```
!      ipkg remove roadmap-sfca
! ```
  
!      The name of the RoadMap package has also changed from roadmap-gtk2 to
!      roadmap. Therefore the roadmap-gtk2 package should be removed:
  
! ```
!      ipkg remove roadmap-gtk2
! ```
  
  
!   - Making room for RoadMap
  
!      On a PDA with 32Mb of RAM, GPE takes most of the available space and less
!      than 2Mb of RAM is left available. For RoadMap to work one need to make
!      some room. The author recommends removing xstroke and the GPE help from
!      the bottom panel.
  
!      Another problem is a bug in the Familiar X server that causes the file
!      ~/.xsession-errors to grow infinitely in the ramdisk, eating up all the
!      available RAM in a matter of days.
!      
!      The work-around is to not start the ipaq-sleep daemon. To do this,
!      comment out the line "/etc/init.d/ipaq-sleep start" in the file:
  
! ```
!              /etc/X11/Xsession.d/69ipaq-sleep
! ```
  
  
!   - Installing gpsd
  
!      RoadMap depends on gpsd for receiving data from the GPS device. Therefore
!      the gpsd package must be installed:
  
! ```
!      ipkg install gpsd
! ```
  
!      Once this has been done, the serial line must be configured for using gpsd
!      (see the serial line configuration tool in the Settings folder).
  
!   - Installing flite
  
!      RoadMap uses flite for generating the voice announcements. RoadMap
!      can be used without flite, but it will stay silent then.
  
!      Note that flite is a very big program: it should be installed on the
!      MMC, SD or CompactFlash (CF) card. Installing flite is easy: just copy
!      the executable file. The problem is more where to find the executable..
  
  
! - INSTALLING ROADMAP
  
!      There are three steps: first install the RoadMap package, then install
!      some maps and last setup your preferences if you installed RoadMap in
!      a custom way.
  
  
!   - Installing the package
  
!      There is very little to say here. RoadMap takes less than 300Kb of space,
!      uncompressed. It installs itself in /usr/bin and /usr/share/pixmaps:
  
! ```
!      ipkg install roadmap                 (if your feed provides RoadMap)
!      ipkg install roadmap_X.Y.Z_arm.ipk   (if you transfered the package)
! ```
  
  
!   - Installing maps
  
!      The RoadMap package is preconfigured for maps stored either in a MMC, SD or
!      CompactFlash (CF) card. The map files must be installed in a subdirectory
!      of the device's root directory named "share/roadmap". The reason for that
!      is to follow standard UNIX convention and make it easier to store other
!      types of data in the device (such as MP3 files).
  
!      The file system used for the device is indifferent (RoadMap maps comply
!      with the 8+3 limitation of the FAT file system) but VFAT is recommended
!      (if only because this is the factory default file system).
  
!      The map files can be retrieved from the RoadMap site:
  
!          http://roadmap.sourceforge.net
  
!      The first file to install in the share/roadmap subdirectory is the file
!      named "usdir.rdm". This file is mandatory: this is the index used to
!      retrieve all other map files. All other files are optional: one can load
!      a limited subset of maps only. If a map is not available, RoadMap will
!      issue a warning message.
  
  
!   - Setting the user preferences
  
!      Start Roadmap, select **File / Preferences**. The preferences dialog is
!      made of a (long) serie of tabbed screens. Most preferences do not need
!      to be modified.
  

Index: README
===================================================================
RCS file: /cvsroot/roadmap/roadmap/README,v
retrieving revision 1.160
retrieving revision 1.161
diff -C2 -d -r1.160 -r1.161
*** README	4 Nov 2008 03:38:39 -0000	1.160
--- README	6 Nov 2008 20:23:06 -0000	1.161
***************
*** 1,10 ****
!                                ---------
!                     RoadMap - User Manual and README
!                                ---------
!                                ---------
!                              November 2008
  
  
! INTRODUCTION
  
     RoadMap is an open source program that displays street maps.
[...8147 lines suppressed...]
!     [Record]
  
!     The table name is the full path of the table, such as "range/bysquare".
  
!     The fields line is a comma separated list of fields. A field may
!     be suffixed with an array size indication. For example:
  
!   ```
!        excluded[32],included[32],start,count
!   ```
  
!     Each record line is a comma separated list of values, in the same order
!     as specified in the fields line. The values of an array field are stored
!     sequentially, as if these were different fields. Value 0 may be represented
!     using an empty string. For example:
  
!   ```
! 	5,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,1,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,10,22
!   ```
  

Index: CHANGES
===================================================================
RCS file: /cvsroot/roadmap/roadmap/CHANGES,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** CHANGES	17 Mar 2008 20:25:50 -0000	1.7
--- CHANGES	6 Nov 2008 20:23:06 -0000	1.8
***************
*** 1,82 ****
!                                ---------
!                             RoadMap Changelog
!                                ---------
!                                ---------
!                                ---------
  
! Roadmap v1.1.1 (??)
  
   This list is current as of 3/17/2008, created with the help of
  
[...2210 lines suppressed...]
  
  Roadmap v0.2 (September 2nd, 2002): 
  
!   - Handle very large grids (more than 64k squares). 
  
!   - Fixed the 32 bits street numbers bug. 
  
!   - Create intermediate shape points when the existing ones are too far away 
    for a 16 bit delta. 
  
!   - Fix a crash when the current position is out of any known map. 
  
!   - Fix a crash when the city name has a typo. 
  
!   - Save the selected destination and current location in the roadmap session 
    file, so we remember them on the next session. 
  
!   - Changed the RoadMap defaults to make the demo map easy to use.
  
  Roadmap v0.1 (august, 2002): First release of RoadMap.

[Roadmap-commit] roadmap/web sitestandard.css,1.6,1.7

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/web
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv2677

Modified Files:
	sitestandard.css 
Log Message:
give all pages a plain background for readability.  leave image background
in navbar.


Index: sitestandard.css
===================================================================
RCS file: /cvsroot/roadmap/roadmap/web/sitestandard.css,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** sitestandard.css	14 Oct 2007 20:34:19 -0000	1.6
--- sitestandard.css	6 Nov 2008 20:21:09 -0000	1.7
***************
*** 1,7 ****
  
  
  body.roadmap {
  	font-family:Times;
! 	background-image: url('background2.jpg');
  	margin-left:    250px;    /* leave room for navigation bar */
  	margin-right:    50px;
--- 1,9 ----
  
  
+ /* background-image: url('background2.jpg'); */
+ 
  body.roadmap {
  	font-family:Times;
! 	background-color: #48fbc4; /* matched to background2.jpg */
  	margin-left:    250px;    /* leave room for navigation bar */
  	margin-right:    50px;

[Roadmap-commit] roadmap STATUS,1.2,1.3 TODO,1.13,1.14

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv10292

Modified Files:
	STATUS TODO 
Log Message:
first cut at updates for 1.2


Index: STATUS
===================================================================
RCS file: /cvsroot/roadmap/roadmap/STATUS,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** STATUS	18 Oct 2007 22:16:47 -0000	1.2
--- STATUS	6 Nov 2008 03:31:56 -0000	1.3
***************
*** 5,42 ****
  		    Paul Fox, current RoadMap maintainer
                                 ---------
!                              October 2007
! 
! New Release 1.1.0
! 
!     RoadMap finally has a new public release!  It's been nearly two
!     years since 1.0.12 was released.  Though the next release was
!     delayed by developer turnover, and lack of time, there have been
!     a lot of improvements going on -- they just haven't made it into
!     a tarball until now, with the release of 1.1.0.
! 
!     Major new developments in 1.1.0 include;
  
! 	* The ability to import, export, edit, and follow on-screen
! 	  routes, the automatic saving of traversed track data, and
! 	  various facilities for storing waypoints, and other landmarks
! 	  and points of interest, all in the open GPX format.
  
! 	* On-screen labeling of streets and landmarks.
  
! 	* Much more flexibility in the user interface, including
! 	  fully customizable menus, toolbar, and active on-screen
! 	  objects.  The user can configure all of these, or even none: 
! 	  an initial command menu can be obtained simply from a
! 	  long-click on the screen if so desired, in order to free as
! 	  much of the screen for maps as possible.
  
! 	* New support for Canadian maps, and for display of state and
! 	  provincial boundaries, and railroads.
  
! 	* Anti-aliased map drawing, courtesy of the AGG library.
! 	
! 	* 3D perspective map rendering.
  
! 	* A more flexible database format.
  
      There's more detail in the changelog.
--- 5,29 ----
  		    Paul Fox, current RoadMap maintainer
                                 ---------
!                              November 2008
  
! New Release 1.2.0
  
!     RoadMap has another new release.  It's been over a year
!     since 1.1.0 was released.  Lots of work has been done since
!     then, both in terms of features, and platform support.
  
!     Major new developments in 1.2.0 include;
  
! 	* Support for OpenStreetMap maps, both geographically-based
! 	  (i.e., arbitrary rectangular tiles) and political (i.e.,
! 	  country-based).  The ability to use OSM maps moves RoadMap
! 	  from being a highly US-centric program to one which can
! 	  be useful worldwide.
  
! 	* Resurrection of the Windows CE port.  Since the port is
! 	  supported via cross-compilation with ming32w, maintenance
! 	  is much easier for the developers.
  
! 	* Initial support of the iPhone.
  
      There's more detail in the changelog.
***************
*** 44,57 ****
  Two Branches
  
!     In that same two-year time period, another branch of the project
!     managed by Ehud Shabtai (hosted in CVS as "roadmap_editor") has
      added the ability to create and edit maps, and to upload the
      results to a central postgres database.  Since the maps as
      created can contain the meta-data needed for successful
!     auto-navigation, that feature has been added to the roadmap_editor
!     branch as well.  The roadmap_editor branch also contains some
!     experimental UI features, better internationalization support,
!     more sound support, and other useful stuff.  This codebase is
!     being used very successfully in the FreeMap Israel project.
      
  	{{ http://www.freemap.co.il }}
--- 31,43 ----
  Two Branches
  
!     Not much progress has been made in merging code from the forked
!     "roadmap_editor" branch, but some work has been ongoing.
!     (Managed by Ehud Shabtai "roadmap_editor" has
      added the ability to create and edit maps, and to upload the
      results to a central postgres database.  Since the maps as
      created can contain the meta-data needed for successful
!     auto-navigation, that feature has been added to the
!     roadmap_editor branch as well.  This codebase is being used
!     very successfully in the FreeMap Israel project.
      
  	{{ http://www.freemap.co.il }}
***************
*** 59,86 ****
      (Sadly for many of us, google doesn't yet translate Hebrew.)
  
-     Ehud estimates that they have mapped 75% of Israeli roads, all
-     through user contributions.
- 
- Future
- 
-     But that leaves RoadMap with two codebases, somewhat (but not
-     completely) incompatible with each other at many levels.  (The
-     worst incompatibility right now is that the map databases are of
-     different formats, making it hard to easily switch from one
-     codebase to the other.)  Clearly the long-term ideal would be to
-     merge the two branches, and some progress has been made, on a
-     feature-by-feature basis.  Indeed, many of the features listed
-     above originated on the "editor" branch.  A full merge implies a
-     lot -- probably too much to expect in the short term.  But every
-     feature that gets migrated in one direction or the other is a
-     step in the right direction. 
- 
  Help Wanted!
  
      If you know something about GIS and want to help with the
!     conversion of new map sources, or know a lot about Win32 and want
!     to finish the WinCE or Win32 ports, or are just a good coder who
!     wants better open-source mapping capabilities, please join the
!     list and we'll figure out how you can help!
  
  
--- 45,54 ----
      (Sadly for many of us, google doesn't yet translate Hebrew.)
  
  Help Wanted!
  
      If you know something about GIS and want to help with the
!     conversion of new map sources, or are just a good coder who
!     wants better open-source mapping capabilities, please join
!     the list and we'll figure out how you can help!
  
  

Index: TODO
===================================================================
RCS file: /cvsroot/roadmap/roadmap/TODO,v
retrieving revision 1.13
retrieving revision 1.14
diff -C2 -d -r1.13 -r1.14
*** TODO	12 Oct 2007 19:12:27 -0000	1.13
--- TODO	6 Nov 2008 03:31:56 -0000	1.14
***************
*** 9,45 ****
     feel especially free to contact the author(s) with patches.  ;-)
  
!    *  International maps:
        
        RoadMap began as a rendering engine for the US Census bureau Tiger maps,
!       but it's clear that it can be more useful than that.  There is now
!       shapefile support, and other early work has been done for postgis and
!       shpmp support, but the RoadMap database itself is still strongly
!       US-centric -- all of the maps (even for the rest of the world) must be
!       given fake US county identifiers.  Work has been done to outline the
!       problem, but no work has been done to implement a solution as yet.
  
     *  New Tiger map format
  
!       The census bureau has published its spec for the new shapefile format
!       which will replace the existing tiger format in the future.  When a
!       sample map becomes available, we should begin implementing a new
!       converter for that shapefile spec.  This would also be a good time to
!       address other current issues, such as the polygon shape point issue,
!       placenames, perhaps others.
! 
!    *  Font size changes:
! 
!       Currently, the only font capable of appearing in different sizes on the
!       screen at once is the primitive internal "linefont".  Some work has been
!       done to add better font control for QT, but nothing has been done for
!       the other desktop toolkits.
! 
!    *  Error messages on screen:
! 
!       The error messages are logged on the standard output, and to individual
!       dialog boxes.  Standard output isn't very useful in a GUI app, and the
!       dialog boxes can multiply much too fast with recurring errors.  Some
!       sort of an "error log" window would be a good compromise.  (One issue is
!       fonts:  should be big enough to be readable in a car.)
  
     *  Use checkbox widget in the menus and toolbars:
--- 9,27 ----
     feel especially free to contact the author(s) with patches.  ;-)
  
!    *  Better OpenStreetMap support
        
        RoadMap began as a rendering engine for the US Census bureau Tiger maps,
!       but it has now grown the ability to render OpenStreetMap data.  This
!       OSM support deserves to be fleshed out in many ways.
  
     *  New Tiger map format
  
!       The census bureau has released data in its new shapefile format,
!       which replaces the previous TIGER format.  We could begin
!       implementing a new converter for that shapefile spec, or we could
!       ignore further TIGER updates, and concentrate on OSM, since OSM now
!       incorporates the TIGER maps.  If editing changes from the RoadMap
!       editor branch could be incorporated, RoadMap could in theory even
!       help contribute new OSM data.
  
     *  Use checkbox widget in the menus and toolbars:
***************
*** 91,98 ****
        appears in the roadmap_editor branch, but it's not complete.
  
!    *  Show GPS location and speed
        
!       The speed shows on RoadMap, but not on RoadGps.  The location shows on
!       none.  There should be a way to show the location, at least in RoadGps.
  
     *  Use GPS time and map's timezone
--- 73,79 ----
        appears in the roadmap_editor branch, but it's not complete.
  
!    *  Show GPS location
        
!       There should be a way to easily display the current location.
  
     *  Use GPS time and map's timezone
***************
*** 150,154 ****
  
        A precursor to this work would be to make the roadmap plugin API
!       match the roadmap_editor plugin API (again).
  
     *  Places
--- 131,136 ----
  
        A precursor to this work would be to make the roadmap plugin API
!       match the roadmap_editor plugin API (again).  (Some progress has
!       been made on this.)
  
     *  Places

[Roadmap-commit] roadmap/src roadmap_gps.c,1.47,1.48

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv10238/src

Modified Files:
	roadmap_gps.c 
Log Message:
add fixme note


Index: roadmap_gps.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_gps.c,v
retrieving revision 1.47
retrieving revision 1.48
diff -C2 -d -r1.47 -r1.48
*** roadmap_gps.c	14 Sep 2008 19:03:09 -0000	1.47
--- roadmap_gps.c	6 Nov 2008 03:31:03 -0000	1.48
***************
*** 848,851 ****
--- 848,855 ----
           roadmap_serial_open (device, "r", atoi(baud));
  
+ // FIXME -- maybe remove the conditional, to allow roadmap to
+ // detect serial devices that are attached after startup.  check
+ // on logging -- we should log at least one failure to open it. 
+ // in fact, we should log every close/reopen, or open failure.
        if (ROADMAP_SERIAL_IS_VALID(RoadMapGpsLink.os.serial)) {
           RoadMapGpsLink.subsystem = ROADMAP_IO_SERIAL;

[Roadmap-commit] roadmap/src roadmap_pointer.c,1.10,1.11

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv6993

Modified Files:
	roadmap_pointer.c 
Log Message:
return from the console screen on a click, not a release.  (morten bek)


Index: roadmap_pointer.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_pointer.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** roadmap_pointer.c	4 Apr 2008 13:38:55 -0000	1.10
--- roadmap_pointer.c	6 Nov 2008 02:22:17 -0000	1.11
***************
*** 73,77 ****
  
     if (!roadmap_start_map_active()) {
!       if (event == RELEASED)
            roadmap_start_return_to_map();
        return 0;
--- 73,84 ----
  
     if (!roadmap_start_map_active()) {
!       /* return to the map (from the gps console screen) if we're
!        * clicked.  note that this means we'll get the RELEASED event
!        * for this click on a different screen than where we started.
!        * keying off of RELEASED here would be better, but if we do
!        * that, we can't bring up the console by clicking a screen object,
!        * because the release will make us return right away.
!        */
!       if (event == SHORT_CLICK)
            roadmap_start_return_to_map();
        return 0;

[Roadmap-commit] roadmap/src config.mk,1.33,1.34

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv24616

Modified Files:
	config.mk 
Log Message:
make config.mk uniform with respect to using conditionals, or comments.


Index: config.mk
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/config.mk,v
retrieving revision 1.33
retrieving revision 1.34
diff -C2 -d -r1.33 -r1.34
*** config.mk	7 Oct 2008 00:42:20 -0000	1.33
--- config.mk	5 Nov 2008 13:52:02 -0000	1.34
***************
*** 31,55 ****
  # DESKTOP = IPHONE
  
  # If you select WINCE for your WinCE device, you'll need the
! # arm-wince-mingw32ce cross-compiler.  Support for WINCE is
! # still a work in progress.
! ifeq ($(DESKTOP), WINCE)
! CROSS=arm-mingw32ce-
! CFLAGS += -I/opt/wince/include
! LIBS += -L/opt/wince/lib
! endif
  
  # If you select IPHONE for your iPhone or iPod Touch, you'll
  # need the arm-apple-darwin cross-compiler. 
! # The following settings work for at least one iPhone. :-)
! ifeq ($(DESKTOP), IPHONE)
! #CROSS=/usr/local/bin/arm-apple-darwin-
! #CFLAGS += -I/path/to/expat/include
! #LIBS += -L/path/to/libexpat.a
! #ROADMAP_CONFIG_DIR = /Applications/RoadMap.app/resources/
! #ROADMAP_MAP_DIR = $(ROADMAP_CONFIG_DIR)/maps/...
! #INSTALLDIR = Applications/RoadMap.app
! #DESTDIR = /tmp
! endif
  
  # If you selected QT or QPE above, you might also want to set QTDIR
--- 31,52 ----
  # DESKTOP = IPHONE
  
+ # Support for WINCE is still a work in progress.
  # If you select WINCE for your WinCE device, you'll need the
! # arm-wince-mingw32ce cross-compiler.  Uncomment these 3
! # lines and adjust the paths.
! # CROSS=arm-mingw32ce-
! # CFLAGS += -I/opt/wince/include
! # LIBS += -L/opt/wince/lib
  
  # If you select IPHONE for your iPhone or iPod Touch, you'll
  # need the arm-apple-darwin cross-compiler. 
! # The following settings are a starting point, but may need adjustment:
! # CROSS=/usr/local/bin/arm-apple-darwin-
! # CFLAGS += -I/path/to/expat/include
! # LIBS += -L/path/to/libexpat.a
! # ROADMAP_CONFIG_DIR = /Applications/RoadMap.app/resources/
! # ROADMAP_MAP_DIR = $(ROADMAP_CONFIG_DIR)/maps/...
! # INSTALLDIR = Applications/RoadMap.app
! # DESTDIR = /tmp
  
  # If you selected QT or QPE above, you might also want to set QTDIR
***************
*** 148,153 ****
  # Basic building mode
  MODE =		# blank for "normal" build
! # MODE=DEBUG	# enables -g, disables -O, turns on mtrace leak detection
  # MODE=PROFILE	# sets up for profiling with gprof
  
  # You can add any other special local CFLAGS values here
--- 145,151 ----
  # Basic building mode
  MODE =		# blank for "normal" build
! # MODE=DEBUG	# enables -g, disables -O
  # MODE=PROFILE	# sets up for profiling with gprof
+ # CFLAGS += -DROADMAP_MTRACE  # enable mtrace leak detection
  
  # You can add any other special local CFLAGS values here

[Roadmap-commit] roadmap/src options.mk,1.29,1.30

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv23286

Modified Files:
	options.mk 
Log Message:
disable MTRACE from DEBUG by default


Index: options.mk
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/options.mk,v
retrieving revision 1.29
retrieving revision 1.30
diff -C2 -d -r1.29 -r1.30
*** options.mk	7 Oct 2008 00:42:20 -0000	1.29
--- options.mk	5 Nov 2008 13:25:52 -0000	1.30
***************
*** 135,139 ****
  	#  it works by replacing shared libraries.)
  	#
! 	CFLAGS += -DROADMAP_MTRACE
  
  	# ROADMAP_LISTS_TYPESAFE forces "type safety" for the
--- 135,139 ----
  	#  it works by replacing shared libraries.)
  	#
! 	# CFLAGS += -DROADMAP_MTRACE
  
  	# ROADMAP_LISTS_TYPESAFE forces "type safety" for the

[Roadmap-commit] roadmap/src roadmap_canvas.h, 1.12, 1.13 roadmap_math.c, 1.55, 1.56 roadmap_math.h, 1.41, 1.42 roadmap_screen.c, 1.133, 1.134

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv8277

Modified Files:
	roadmap_canvas.h roadmap_math.c roadmap_math.h 
	roadmap_screen.c 
Log Message:
support for chorded (multitouch) rotation and drag, on the iphone.
also support for bezier lines in iphone drawing routines.
(all from morten bek.)


Index: roadmap_canvas.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_canvas.h,v
retrieving revision 1.12
retrieving revision 1.13
diff -C2 -d -r1.12 -r1.13
*** roadmap_canvas.h	7 Oct 2008 00:42:20 -0000	1.12
--- roadmap_canvas.h	4 Nov 2008 14:56:23 -0000	1.13
***************
*** 33,36 ****
--- 33,38 ----
  #include "roadmap_gui.h"
  
+ #define MAX_CHORDING_POINTS 5
+ 
  enum { IMAGE_NORMAL,
         IMAGE_SELECTED
***************
*** 204,207 ****
--- 206,217 ----
                                       int size, const char *text);
  
+ #ifdef IPHONE
+ void roadmap_canvas_get_chording_pt (RoadMapGuiPoint points[MAX_CHORDING_POINTS]);
+ int roadmap_canvas_is_chording();
+ #else
+ void roadmap_canvas_get_chording_pt (RoadMapGuiPoint points[MAX_CHORDING_POINTS]);
+ #define roadmap_canvas_is_chording() 0
+ #endif
+ 
  #endif // INCLUDE__ROADMAP_CANVAS__H
  

Index: roadmap_math.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.c,v
retrieving revision 1.55
retrieving revision 1.56
diff -C2 -d -r1.55 -r1.56
*** roadmap_math.c	4 Nov 2008 14:32:02 -0000	1.55
--- roadmap_math.c	4 Nov 2008 14:56:23 -0000	1.56
***************
*** 1226,1230 ****
  }
  
- #ifdef IPHONE
  float roadmap_math_get_angle 
  	(RoadMapGuiPoint *point0, RoadMapGuiPoint *point1) {
--- 1226,1229 ----
***************
*** 1234,1240 ****
  }
  
- #endif
- 
- 
  void roadmap_math_to_position (const RoadMapGuiPoint *point,
                                 RoadMapPosition *position,
--- 1233,1236 ----

Index: roadmap_screen.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_screen.c,v
retrieving revision 1.133
retrieving revision 1.134
diff -C2 -d -r1.133 -r1.134
*** roadmap_screen.c	7 Oct 2008 19:45:59 -0000	1.133
--- roadmap_screen.c	4 Nov 2008 14:56:23 -0000	1.134
***************
*** 152,155 ****
--- 152,161 ----
  
  
+ // This is only supported for the iphone right now
+ static int RoadMapScreenChordingEvent = 0;
+ static RoadMapGuiPoint RoadMapScreenChordingAnchors[MAX_CHORDING_POINTS];
+ static float RoadMapScreenChordingAngle;
+ static int RoadMapScreenChordingIsRotating = 0;
+ 
  /* Define the buffers used to group all actual drawings. */
  
***************
*** 1688,1693 ****
  
     RoadMapScreenDragging = 1;
!    RoadMapScreenPointerLocation = *point;
     roadmap_screen_freeze (); /* We don't want to move with the GPS position. */
  
     return 1;
--- 1694,1732 ----
  
     RoadMapScreenDragging = 1;
! 
!    if (roadmap_canvas_is_chording() && !RoadMapScreenChordingEvent) {
!       RoadMapScreenChordingEvent = 1;
!       roadmap_canvas_get_chording_pt (RoadMapScreenChordingAnchors);
!       RoadMapGuiPoint *anchors = RoadMapScreenChordingAnchors;
!            
!       if (anchors[2].x == 1) { //Rotate mode
!          //save angle
!          RoadMapScreenChordingIsRotating = 1;
!          RoadMapScreenChordingAngle =
! 	    roadmap_math_get_angle (&anchors[0], &anchors[1]);
!       } else { //Drag / zoom mode
!          point->x = abs(anchors[1].x - anchors[0].x) /2;
!          if (anchors[0].x > anchors[1].x) {
!             point->x += anchors[1].x;
!          } else {
!             point->x += anchors[0].x;
!          }
!          
!          point->y = abs(anchors[1].y - anchors[0].y) /2;
!          if (anchors[0].y > anchors[1].y) {
!             point->y += anchors[1].y;
!          } else {
!             point->y += anchors[0].y;
!          }
!          RoadMapScreenPointerLocation = *point;
!       }
! 
!    } else {
! 
!       RoadMapScreenPointerLocation = *point;
!    }
! 
     roadmap_screen_freeze (); /* We don't want to move with the GPS position. */
+    roadmap_screen_refresh ();
  
     return 1;
***************
*** 1695,1705 ****
  
  static int roadmap_screen_drag_end (RoadMapGuiPoint *point) {
  
!    roadmap_screen_record_move
!       (RoadMapScreenPointerLocation.x - point->x,
!        RoadMapScreenPointerLocation.y - point->y);
  
     RoadMapScreenDragging = 0;
-    RoadMapScreenPointerLocation = *point;
     roadmap_screen_unfreeze ();
     roadmap_screen_refresh ();
--- 1734,1751 ----
  
  static int roadmap_screen_drag_end (RoadMapGuiPoint *point) {
+    if (RoadMapScreenChordingEvent) {
  
!       RoadMapScreenChordingEvent = 0;
!       RoadMapScreenChordingIsRotating = 0;
! 
!    } else {
! 
!       roadmap_screen_record_move
! 	 (RoadMapScreenPointerLocation.x - point->x,
! 	  RoadMapScreenPointerLocation.y - point->y);
  
+       RoadMapScreenPointerLocation = *point;
+    }
     RoadMapScreenDragging = 0;
     roadmap_screen_unfreeze ();
     roadmap_screen_refresh ();
***************
*** 1710,1728 ****
  static int roadmap_screen_drag_motion (RoadMapGuiPoint *point) {
  
!    if (RoadMapScreenViewMode == VIEW_MODE_3D) {
  
!       RoadMapGuiPoint p = *point;
!       RoadMapGuiPoint p2 = RoadMapScreenPointerLocation;
  
!       roadmap_math_unproject (&p);
!       roadmap_math_unproject (&p2);
  
!       roadmap_screen_record_move (p2.x - p.x, p2.y - p.y);
!       
!    } else {
  
!       roadmap_screen_record_move
!          (RoadMapScreenPointerLocation.x - point->x,
!           RoadMapScreenPointerLocation.y - point->y);
     }
  
--- 1756,1833 ----
  static int roadmap_screen_drag_motion (RoadMapGuiPoint *point) {
  
!    if (roadmap_canvas_is_chording() && RoadMapScreenChordingEvent) {
!       RoadMapGuiPoint ChordingPt[MAX_CHORDING_POINTS];
!       roadmap_canvas_get_chording_pt (ChordingPt);
!       
!       if (!RoadMapScreenChordingIsRotating) {
!          // Calculate zoom change
! 	 long diag_new = roadmap_math_screen_distance
! 	 	(&ChordingPt[0], &ChordingPt[1], MATH_DIST_ACTUAL);
!          long diag_anch = roadmap_math_screen_distance
! 	 	(&RoadMapScreenChordingAnchors[0], &RoadMapScreenChordingAnchors[1], MATH_DIST_ACTUAL);
!          float scale = (float)diag_anch / (float)diag_new;
!          
!          roadmap_math_zoom_set (ceil(roadmap_math_get_zoom() * scale));
!          roadmap_layer_adjust ();
!          
!          // Calculate point position
!          point->x = abs(ChordingPt[1].x - ChordingPt[0].x) /2;
!          if (ChordingPt[0].x > ChordingPt[1].x) {
!             point->x += ChordingPt[1].x;
!          } else {
!             point->x += ChordingPt[0].x;
!          }
!          
!          point->y = abs(ChordingPt[1].y - ChordingPt[0].y) /2;
!          if (ChordingPt[0].y > ChordingPt[1].y) {
!             point->y += ChordingPt[1].y;
!          } else {
!             point->y += ChordingPt[0].y;
!          }
!          
!          roadmap_screen_record_move
!                      (RoadMapScreenPointerLocation.x - point->x,
!                       RoadMapScreenPointerLocation.y - point->y);
!                       
!          RoadMapScreenPointerLocation = *point;
!       } else {
!          float angle_new = roadmap_math_get_angle (&ChordingPt[0], &ChordingPt[1]);
!          
!          int angle_delta = ceil (angle_new - RoadMapScreenChordingAngle);
!          if (angle_delta > 15) {
!             roadmap_screen_rotate (15);
!             RoadMapScreenChordingAngle += 15;
!          } else if (angle_delta < -15) {
!             roadmap_screen_rotate (-15);
!             RoadMapScreenChordingAngle -= 15;
!          } else {
!             roadmap_screen_rotate (angle_delta);
!             RoadMapScreenChordingAngle += angle_delta;
!          }
!       }
!       
!       RoadMapScreenChordingAnchors[0].x = ChordingPt[0].x;
!       RoadMapScreenChordingAnchors[0].y = ChordingPt[0].y;
!       RoadMapScreenChordingAnchors[1].x = ChordingPt[1].x;
!       RoadMapScreenChordingAnchors[1].y = ChordingPt[1].y;
  
!    } else {
  
!       if (RoadMapScreenViewMode == VIEW_MODE_3D) {
  
! 	 RoadMapGuiPoint p = *point;
! 	 RoadMapGuiPoint p2 = RoadMapScreenPointerLocation;
  
! 	 roadmap_math_unproject (&p);
! 	 roadmap_math_unproject (&p2);
! 
! 	 roadmap_screen_record_move (p2.x - p.x, p2.y - p.y);
! 	 
!       } else {
! 
! 	 roadmap_screen_record_move
! 	    (RoadMapScreenPointerLocation.x - point->x,
! 	     RoadMapScreenPointerLocation.y - point->y);
!       }
     }
  

Index: roadmap_math.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.h,v
retrieving revision 1.41
retrieving revision 1.42
diff -C2 -d -r1.41 -r1.42
*** roadmap_math.h	4 Nov 2008 14:32:02 -0000	1.41
--- roadmap_math.h	4 Nov 2008 14:56:23 -0000	1.42
***************
*** 176,182 ****
  #define MILLIONTHS  6
  
- #ifdef IPHONE
  float roadmap_math_get_angle (RoadMapGuiPoint *point0, RoadMapGuiPoint *point1);
! #endif
  #endif // INCLUDED__ROADMAP_MATH__H
  
--- 176,181 ----
  #define MILLIONTHS  6
  
  float roadmap_math_get_angle (RoadMapGuiPoint *point0, RoadMapGuiPoint *point1);
! 
  #endif // INCLUDED__ROADMAP_MATH__H
  

[Roadmap-commit] roadmap/src/iphone Makefile, 1.3, 1.4 roadmap_canvas.m, 1.3, 1.4 roadmap_iphonecanvas.h, 1.2, 1.3 roadmap_iphonemain.h, 1.2, 1.3 roadmap_iphonemessagebox.h, 1.1, 1.2 roadmap_main.m, 1.3, 1.4 roadmap_messagebox.m, 1.1, 1.2

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src/iphone
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv8277/iphone

Modified Files:
	Makefile roadmap_canvas.m roadmap_iphonecanvas.h 
	roadmap_iphonemain.h roadmap_iphonemessagebox.h roadmap_main.m 
	roadmap_messagebox.m 
Log Message:
support for chorded (multitouch) rotation and drag, on the iphone.
also support for bezier lines in iphone drawing routines.
(all from morten bek.)


Index: roadmap_iphonemessagebox.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_iphonemessagebox.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** roadmap_iphonemessagebox.h	4 May 2008 16:49:21 -0000	1.1
--- roadmap_iphonemessagebox.h	4 Nov 2008 14:56:23 -0000	1.2
***************
*** 32,35 ****
  }
  -(void)showWithTitle: (const char *) title text: (const char *) text modal: (int) modal;
! -(void)alertSheet:(UIAlertSheet*)sheet buttonClicked:(int)button;
  @end
--- 32,35 ----
  }
  -(void)showWithTitle: (const char *) title text: (const char *) text modal: (int) modal;
! -(void)alertSheet:(UIActionSheet*)sheet buttonClicked:(int)button;
  @end

Index: roadmap_canvas.m
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_canvas.m,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** roadmap_canvas.m	7 Oct 2008 00:42:21 -0000	1.3
--- roadmap_canvas.m	4 Nov 2008 14:56:23 -0000	1.4
***************
*** 5,8 ****
--- 5,9 ----
   *   Copyright 2002 Pascal F. Martin
   *   Copyright 2008 Morten Bek Ditlevsen
+  *   Copyright 2008 Avi Romano
   *
   *   This file is part of RoadMap.
***************
*** 33,37 ****
  #import <Foundation/Foundation.h>
  #import <GraphicsServices/GraphicsServices.h>
! #import <UIKit/CDStructures.h>
  
  #include "roadmap.h"
--- 34,38 ----
  #import <Foundation/Foundation.h>
  #import <GraphicsServices/GraphicsServices.h>
! #import <UIKit/UITouch.h>
  
  #include "roadmap.h"
***************
*** 39,46 ****
--- 40,50 ----
  #include "roadmap_gui.h"
  
+ #include "roadmap_path.h"
  #include "roadmap_canvas.h"
  #include "roadmap_iphonecanvas.h"
  #include "colors.h"
  
+ #define FONT_INC_FACTOR 1.3 //Trying to compensate the high PPI of iPhone screen
+ #define FONT_DEFAULT_SIZE 12
  extern int CGFontGetAscent(CGFontRef font);
  extern int CGFontGetDescent(CGFontRef font);
***************
*** 50,53 ****
--- 54,58 ----
  extern CGFontRef CGFontCreateWithFontName (CFStringRef name);
  
+ 
  struct RoadMapColor {
     float r;
***************
*** 67,80 ****
  };
  
  
  static struct roadmap_canvas_pen *RoadMapPenList = NULL;
  
! static RoadMapCanvasView  *RoadMapDrawingArea;
  static CGContextRef RoadMapGc;
- static LKLayer *mainLayer;
  static int CanvasWidth, CanvasHeight;
  
  static RoadMapPen CurrentPen;
  
  /* The canvas callbacks: all callbacks are initialized to do-nothing
   * functions, so that we don't care checking if one has been setup.
--- 72,90 ----
  };
  
+ #define ROADMAP_CANVAS_LAYER_COUNT 2
+ #define BEZIER_SMOOTH_VALUE 0.5
  
  static struct roadmap_canvas_pen *RoadMapPenList = NULL;
  
! RoadMapCanvasView  *RoadMapDrawingArea;
  static CGContextRef RoadMapGc;
  static int CanvasWidth, CanvasHeight;
  
  static RoadMapPen CurrentPen;
  
+ static CGPoint ChordingPoints[MAX_CHORDING_POINTS]; //Number of chording fingers. We actually use max of 2
+ static CGPoint touch1point, touch2point;
+ static UITouch *touch1, *touch2;
+ 
  /* The canvas callbacks: all callbacks are initialized to do-nothing
   * functions, so that we don't care checking if one has been setup.
***************
*** 107,111 ****
      while (points < end) {
          cgpoints->x = points->x;
!         cgpoints->y = CanvasHeight - points->y;
          cgpoints += 1;
          points += 1;
--- 117,121 ----
      while (points < end) {
          cgpoints->x = points->x;
!         cgpoints->y = points->y;
          cgpoints += 1;
          points += 1;
***************
*** 120,124 ****
      while (points < end) {
          rects->origin.x = points->x;
!         rects->origin.y = CanvasHeight - points->y;
          rects->size.width = 1.0;
          rects->size.height = 1.0;
--- 130,134 ----
      while (points < end) {
          rects->origin.x = points->x;
!         rects->origin.y = points->y;
          rects->size.width = 1.0;
          rects->size.height = 1.0;
***************
*** 128,136 ****
  }
  
  void roadmap_canvas_get_text_extents 
          (const char *text, int size, int *width,
           int *ascent, int *descent, int *can_tilt) 
  {
!     float size_f = (size * 1.0f);
      UniChar buf[2048];
      CGGlyph glyphs[2048];
--- 138,168 ----
  }
  
+ void set_fast_draw (int fast_draw) {
+     if (fast_draw) {
+       CGContextSetAllowsAntialiasing (RoadMapGc, NO);
+       CGContextSetInterpolationQuality  (RoadMapGc, kCGInterpolationNone);
+       CGContextSetLineCap(RoadMapGc, kCGLineCapButt);
+       CGContextSetLineJoin(RoadMapGc, kCGLineJoinMiter);
+    }
+ }
+ 
+ void end_fast_draw (int fast_draw) {
+     if (fast_draw) {
+       CGContextSetAllowsAntialiasing (RoadMapGc, YES);
+       CGContextSetInterpolationQuality  (RoadMapGc, kCGInterpolationDefault);
+       CGContextSetLineCap(RoadMapGc, kCGLineCapRound);
+       CGContextSetLineJoin(RoadMapGc, kCGLineJoinRound);
+    }
+ }
+ 
  void roadmap_canvas_get_text_extents 
          (const char *text, int size, int *width,
           int *ascent, int *descent, int *can_tilt) 
  {
!    if (size == -1)
!    {
!       size = FONT_DEFAULT_SIZE;
!    }
!    float size_f = (size * 1.0);
      UniChar buf[2048];
      CGGlyph glyphs[2048];
***************
*** 144,154 ****
      CFIndex length = CFStringGetLength(string);
      if (length >= 2048)
          return;
      CFStringGetCharacters (string, CFRangeMake(0, length), buf);
  
      CGFontGetGlyphsForUnichars(font, buf, glyphs, length);
  
      CGContextSetTextDrawingMode (RoadMapGc, kCGTextInvisible);
!     CGContextSetTextPosition(RoadMapGc, 0,0);
      CGContextShowGlyphs(RoadMapGc, glyphs, length);
      point = CGContextGetTextPosition(RoadMapGc);
--- 176,190 ----
      CFIndex length = CFStringGetLength(string);
      if (length >= 2048)
+    {
+       CFRelease (string);
          return;
+    }
      CFStringGetCharacters (string, CFRangeMake(0, length), buf);
+     CFRelease (string);
  
      CGFontGetGlyphsForUnichars(font, buf, glyphs, length);
  
      CGContextSetTextDrawingMode (RoadMapGc, kCGTextInvisible);
!     CGContextSetTextMatrix(RoadMapGc, CGAffineTransformIdentity);
      CGContextShowGlyphs(RoadMapGc, glyphs, length);
      point = CGContextGetTextPosition(RoadMapGc);
***************
*** 222,230 ****
  
      if (*color == '#') {
!         int ir, ig, ib;
!         sscanf(color, "#%2x%2x%2x", &ir, &ig, &ib);
          r = ir/255.0;
          g = ig/255.0;
          b = ib/255.0;
      } else {
          /* Do binary search on color table */
--- 258,272 ----
  
      if (*color == '#') {
!         int ir, ig, ib, ia;
!         int count;
!         count = sscanf(color, "#%2x%2x%2x%2x", &ir, &ig, &ib, &ia);
          r = ir/255.0;
          g = ig/255.0;
          b = ib/255.0;
+         
+         if (count == 4)
+         {
+             a = ia/255.0;
+         }
      } else {
          /* Do binary search on color table */
***************
*** 250,255 ****
      CurrentPen->stroke.g = g;
      CurrentPen->stroke.b = b;
!     CurrentPen->stroke.a = a;
  
  }
  
--- 292,298 ----
      CurrentPen->stroke.g = g;
      CurrentPen->stroke.b = b;
!     CurrentPen->stroke.a = a;  
  
+ 	roadmap_canvas_select_pen(CurrentPen);
  }
  
***************
*** 263,266 ****
--- 306,314 ----
  
  void roadmap_canvas_set_thickness  (int thickness) {
+    if (thickness < 0) {
+       //printf ("Warning: thickness %d changed to 0\n",thickness);
+       thickness = 0;
+    }
+    
     CurrentPen->lineWidth = thickness * 1.0;
  }
***************
*** 290,296 ****
  void roadmap_canvas_erase (void) {
     /* 'erase' means fill the canvas with the foreground color */
!    CGContextFillRect(RoadMapGc, [RoadMapDrawingArea frame]);
  }
  
  void roadmap_canvas_draw_string  (RoadMapGuiPoint *position,
                                    int corner,
--- 338,351 ----
  void roadmap_canvas_erase (void) {
     /* 'erase' means fill the canvas with the foreground color */
!    CGContextFillRect(RoadMapGc, [RoadMapDrawingArea bounds]);
! }
! 
! void roadmap_canvas_erase_area (const RoadMapGuiRect *rect)
! {
! 	CGRect imageRect = CGRectMake(rect->minx * 1.0f, rect->miny * 1.0f, (rect->maxx - rect->minx) * 1.0f, (rect->maxy - rect->miny) * 1.0f);
! 	CGContextFillRect(RoadMapGc, imageRect);
  }
  
+ 
  void roadmap_canvas_draw_string  (RoadMapGuiPoint *position,
                                    int corner,
***************
*** 301,307 ****
--- 356,364 ----
     int text_ascent;
     int text_descent;
+    int text_height;
     RoadMapGuiPoint start[1];
     roadmap_canvas_get_text_extents 
          (text, size, &text_width, &text_ascent, &text_descent, NULL);
+    text_height = text_ascent + text_descent;
     start->x = position->x;
     start->y = position->y;
***************
*** 325,331 ****
  {
      CGAffineTransform trans;
!     float angle_f = (angle * -1.0f) * M_PI / 180.0f;
      float x = center->x * 1.0f;
!     float y = CanvasHeight - center->y * 1.0f;
      float size_f = (size * 1.0f);
      UniChar buf[2048];
--- 382,388 ----
  {
      CGAffineTransform trans;
!     float angle_f = (angle - 180.0f) * M_PI / 180.0f;
      float x = center->x * 1.0f;
!     float y = center->y * 1.0f;
      float size_f = (size * 1.0f);
      UniChar buf[2048];
***************
*** 345,348 ****
--- 402,406 ----
  
      trans = CGAffineTransformMakeRotation(angle_f);
+     trans = CGAffineTransformScale (trans, -1.0, 1.0);
  
      CGContextSetTextMatrix(RoadMapGc, trans);
***************
*** 366,383 ****
  
  
  void roadmap_canvas_draw_multiple_lines 
  (int count, int *lines, RoadMapGuiPoint *points, int fast_draw) {
  
      int i;
      int count_of_points;
      CGPoint cgpoints[1024];
  
      for (i = 0; i < count; ++i) {
  
          count_of_points = *lines;
          while (count_of_points > 1024) {
              roadmap_canvas_convert_points (cgpoints, points, 1024);
              CGContextBeginPath(RoadMapGc);
!             CGContextAddLines(RoadMapGc, cgpoints, 1024);
              CGContextStrokePath(RoadMapGc);
              points += 1023;
--- 424,548 ----
  
  
+ static void roadmap_calc_bezier_controlpoints
+    (CGPoint *points, float *c1x, float *c1y, float *c2x, float *c2y)
+ {
+     float smooth = BEZIER_SMOOTH_VALUE;
+     short x0 = points[0].x;
+     short y0 = points[0].y;
+     short x1 = points[1].x;
+     short y1 = points[1].y;
+     short x2 = points[2].x;
+     short y2 = points[2].y;
+ 
+     float angle;
+ 
+     float xc1 = (x0 + x1) / 2.0;
+     float yc1 = (y0 + y1) / 2.0;
+     float xc2 = (x1 + x2) / 2.0;
+     float yc2 = (y1 + y2) / 2.0;
+ 
+     float len1 = sqrt((x1-x0) * (x1-x0) + (y1-y0) * (y1-y0));
+     float len2 = sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1));
+     float dot = (x1 - x0) * (x2 - x1) + (y1 - y0) * (y2 - y1);
+ 
+     angle = acos ( dot / (len1 * len2) );
+     if (dot < 0)
+     {
+        if (angle > 0)
+            angle += M_PI;
+        else
+            angle -= M_PI;
+     }
+ 
+     /* If the angle is less than a bit more than 90 degrees
+        _or_ if two of the points coincide - return the
+        mid point as control points (to cause a sharp
+        corner) */
+     if ((angle > 1.4 || angle < -1.4) ||
+         (len1 < 0.0001 && len1 > -0.001) ||
+         (len2 < 0.0001 && len2 > -0.001))
+     {
+         *c1x = x1;
+         *c1y = y1;
+ 
+         *c2x = x1;
+         *c2y = y1;
+         return;
+  }
+ 
+     float k = len1 / (len1 + len2);
+ 
+     float xm = xc1 + (xc2 - xc1) * k;
+     float ym = yc1 + (yc2 - yc1) * k;
+ 
+     *c1x = (xc1 - xm) * smooth + x1;
+     *c1y = (yc1 - ym) * smooth + y1;
+ 
+     *c2x = (xc2 - xm) * smooth + x1;
+     *c2y = (yc2 - ym) * smooth + y1;
+ }
+ 
+ static void roadmap_draw_bezier_path(CGPoint *p, int count)
+ {
+     int i = 0;
+     float c1x, c1y, c2x, c2y, p1x, p1y, p2x, p2y;
+     CGContextBeginPath(RoadMapGc);
+     CGContextMoveToPoint(RoadMapGc, p[0].x, p[0].y);
+     c1x = (p[1].x - p[0].x) / 2.0 + p[0].x;
+     c1y = (p[1].y - p[0].y) / 2.0 + p[0].y;
+     roadmap_calc_bezier_controlpoints(&(p[0]), &p1x, &p1y, &p2x, &p2y);
+     c2x = p1x; c2y = p1y;
+     CGContextAddCurveToPoint(RoadMapGc, c1x, c1y, c2x, c2y, p[i+1].x, p[i+1].y);
+     i = 0;
+     for (i = 1; i + 3 <= count; i++)
+     {
+         c1x = p2x; c1y = p2y;
+         roadmap_calc_bezier_controlpoints(&(p[i]), &p1x, &p1y, &p2x, &p2y);
+         c2x = p1x; c2y = p1y;
+         CGContextAddCurveToPoint(RoadMapGc, c1x, c1y, c2x, c2y, p[i+1].x, p[i+1].y);
+     }
+     if (count > 2)
+     {
+         c1x = p2x; c1y = p2y;
+ 
+         c2x = (p[i + 1].x - p[i].x) / 2.0 + p[i].x;
+         c2y = (p[i + 1].y - p[i].y) / 2.0 + p[i].y;
+         CGContextAddCurveToPoint(RoadMapGc, c1x, c1y, c2x, c2y, p[i+1].x, p[i+1].y);
+     }
+     CGContextStrokePath(RoadMapGc);
+ }
+ /*
+    Known graphic artifacts of the following function:
+    When drawing bezier lines - every 1024th point will
+    have a sharp corner.
+    Lines that are moving out of the screen will suddenly
+    change from being drawn with one control point to
+    two... To fix this, an extra line segment outside the
+    screen must always be included in the line paths to
+    be drawn.
+ */
  void roadmap_canvas_draw_multiple_lines 
  (int count, int *lines, RoadMapGuiPoint *points, int fast_draw) {
  
      int i;
+     int bezier = !fast_draw;
      int count_of_points;
      CGPoint cgpoints[1024];
+    set_fast_draw (fast_draw);
  
      for (i = 0; i < count; ++i) {
  
          count_of_points = *lines;
+         if (count_of_points < 2)
+            continue;
+ 
          while (count_of_points > 1024) {
              roadmap_canvas_convert_points (cgpoints, points, 1024);
              CGContextBeginPath(RoadMapGc);
!             if (bezier)
!                roadmap_draw_bezier_path(cgpoints, 1024);
!             else
!                CGContextAddLines(RoadMapGc, cgpoints, 1024);
! 
              CGContextStrokePath(RoadMapGc);
              points += 1023;
***************
*** 386,406 ****
  
          roadmap_canvas_convert_points (cgpoints, points, count_of_points);
- 
          CGContextBeginPath(RoadMapGc);
!         CGContextAddLines(RoadMapGc, cgpoints, count_of_points);
!         CGContextStrokePath(RoadMapGc);
  
          points += count_of_points;
          lines += 1;
      }
  }
  
  void roadmap_canvas_draw_multiple_polygons
           (int count, int *polygons, RoadMapGuiPoint *points, int filled,
              int fast_draw) {
      int i;
      int count_of_points;
      CGPoint cgpoints[1024];
!     for (i = 0; i < count; ++i) {
  
          count_of_points = *polygons;
--- 551,580 ----
  
          roadmap_canvas_convert_points (cgpoints, points, count_of_points);
          CGContextBeginPath(RoadMapGc);
!         if (bezier)
!            roadmap_draw_bezier_path(cgpoints, count_of_points);
!         else
!            CGContextAddLines(RoadMapGc, cgpoints, count_of_points);
  
+         CGContextStrokePath(RoadMapGc);
          points += count_of_points;
          lines += 1;
      }
+    
+    end_fast_draw (fast_draw);
  }
  
+ 
  void roadmap_canvas_draw_multiple_polygons
           (int count, int *polygons, RoadMapGuiPoint *points, int filled,
              int fast_draw) {
+ 
      int i;
      int count_of_points;
      CGPoint cgpoints[1024];
!     
!    set_fast_draw (fast_draw);
!    
! 	for (i = 0; i < count; ++i) {
  
          count_of_points = *polygons;
***************
*** 432,435 ****
--- 606,611 ----
          polygons += 1;
      }
+     
+    end_fast_draw (fast_draw);
  }
  
***************
*** 440,448 ****
     int i;
  
     for (i = 0; i < count; ++i) {
  
         int r = radius[i];
  
!        CGRect circle = CGRectMake(centers[i].x-r, (CanvasHeight - centers[i].y)-r, r*2, r*2);
         CGContextAddEllipseInRect(RoadMapGc, circle);
         if (filled)
--- 616,626 ----
     int i;
  
+    set_fast_draw (fast_draw);
+    
     for (i = 0; i < count; ++i) {
  
         int r = radius[i];
  
!        CGRect circle = CGRectMake(centers[i].x-r, (centers[i].y)-r, r*2, r*2);
         CGContextAddEllipseInRect(RoadMapGc, circle);
         if (filled)
***************
*** 452,455 ****
--- 630,635 ----
  
     }
+    
+    end_fast_draw (fast_draw);
  }
  
***************
*** 526,534 ****
      {
          CGImageRef image = CGBitmapContextCreateImage (RoadMapGc);
!         // save image
          CGImageRelease(image);
      }
  }
  
  @implementation RoadMapCanvasView
  
--- 706,821 ----
      {
          CGImageRef image = CGBitmapContextCreateImage (RoadMapGc);
!         // TODO: save image
          CGImageRelease(image);
      }
  }
  
+ int  roadmap_canvas_image_width  (const RoadMapImage image)
+ {
+    UIImage *img = (UIImage*)image;
+    if (img)
+       return img.size.width;
+    else
+       return 0;
+ }
+ 
+ int  roadmap_canvas_image_height (const RoadMapImage image)
+ {
+    UIImage *img = (UIImage*)image;
+    if (img)
+       return img.size.height;
+    else
+       return 0;
+ }
+ 
+ static char *roadmap_canvas_image_path (const char *name) {
+     unsigned int i;
+ 
+     if (name == NULL)
+         return NULL;
+ 
+     const char *image_file = roadmap_path_search_icon (name);
+     if (image_file == NULL)
+         return NULL;
+ 
+     for (i = 0; i < strlen(image_file); i++)
+     {
+         if (strncmp (image_file + i, "resources", 9) == 0)
+ 	{
+             return (char *)(image_file + i);
+ }	
+     }
+     return NULL;
+ }
+ 
+ RoadMapImage roadmap_canvas_load_image ( const char* path, const char* file_name)
+ {
+    char *imagePath;
+    NSString *nsImagePath;
+    imagePath = roadmap_canvas_image_path (file_name);
+ 
+     if (imagePath)
+     {
+         nsImagePath = [[NSString alloc] initWithUTF8String:imagePath];
+         UIImage *image = [UIImage imageNamed: nsImagePath];
+         return (RoadMapImage)image;
+     }
+     return NULL;
+ }
+ 
+ void roadmap_canvas_draw_image (RoadMapImage image, RoadMapGuiPoint *pos,
+                                 int opacity, int mode)
+ {
+    UIImage *img = (UIImage*)image;
+    CGPoint point;
+    point.x = pos->x;
+    point.y = pos->y; 
+    //NSLog (@"draw image with opacity: %i at %f %f", opacity, point.x, point.y);
+    if (img)
+  {
+       UIGraphicsPushContext(RoadMapGc);
+       [img drawAtPoint:point blendMode:kCGBlendModeNormal alpha:1.0f];
+       UIGraphicsPopContext();
+ }
+ }
+ 
+ void roadmap_canvas_copy_image (RoadMapImage dst_image,
+                                 const RoadMapGuiPoint *pos,
+                                 const RoadMapGuiRect  *rect,
+                                 RoadMapImage src_image, int mode)
+ {
+ }
+ 
+ void roadmap_canvas_draw_image_text (RoadMapImage image,
+                                      const RoadMapGuiPoint *position,
+                                      int size, const char *text)
+ {
+ }
+ 
+ void roadmap_canvas_layer_select(int layer)
+ {
+ /* remove me */
+ }
+ 
+ void roadmap_canvas_get_chording_pt (RoadMapGuiPoint points[MAX_CHORDING_POINTS])
+ {
+    points[0].x = ChordingPoints[0].x;
+    points[0].y = ChordingPoints[0].y;
+    
+    points[1].x = ChordingPoints[1].x;
+    points[1].y = ChordingPoints[1].y;
+    
+    points[2].x = ChordingPoints[2].x;
+    points[2].y = ChordingPoints[2].y;
+ }
+ 
+ int roadmap_canvas_is_chording()
+ {
+    return (ChordingPoints[0].x > -1);
+ }
+ 
+ 
+ 
+ 
  @implementation RoadMapCanvasView
  
***************
*** 539,543 ****
--- 826,835 ----
      self = [super initWithFrame: rect];
  
+ 
+     touch1 = nil;
+     touch2 = nil;
+ 
      RoadMapDrawingArea = self;
+     self.multipleTouchEnabled = TRUE;
  
      CGColorSpaceRef    imageColorSpace = CGColorSpaceCreateDeviceRGB();       
***************
*** 545,557 ****
      CGColorSpaceRelease(imageColorSpace);
  
!     CGFontRef font = CGFontCreateWithFontName((CFStringRef)@"arialuni") ;
      CGContextSetFont(RoadMapGc, font);
      CGContextSetTextDrawingMode (RoadMapGc, kCGTextFill);
      CGContextSetLineCap(RoadMapGc, kCGLineCapRound);
  
-     mainLayer = [[LKLayer layer] retain];
-     [mainLayer setFrame: rect];
- 
-     [self._layer addSublayer: mainLayer];
      (*RoadMapCanvasConfigure) ();
  
--- 837,845 ----
      CGColorSpaceRelease(imageColorSpace);
  
!     CGFontRef font = CGFontCreateWithFontName((CFStringRef)@"ArialUnicodeMS") ;
      CGContextSetFont(RoadMapGc, font);
      CGContextSetTextDrawingMode (RoadMapGc, kCGTextFill);
      CGContextSetLineCap(RoadMapGc, kCGLineCapRound);
  
      (*RoadMapCanvasConfigure) ();
  
***************
*** 566,602 ****
             so if we're lucky no copy is actually made! */
          CGImageRef ref = CGBitmapContextCreateImage(RoadMapGc);           
!         [mainLayer setContents: (id)ref];
          CGImageRelease(ref);
      }
  }
  
! - (void)mouseDown: (GSEvent*)event
  {
!     printf("mouseDown\n");
!     CGPoint location = GSEventGetLocationInWindow(event);
!     RoadMapGuiPoint point;
!     point.x = location.x;
!     point.y = location.y;
!     (*RoadMapCanvasMouseButtonPressed) (1, &point);
  }
  
! - (void) mouseUp:(GSEvent*)event
  {
!     printf("mouseUp\n");
!     CGPoint location = GSEventGetLocationInWindow(event);
!     RoadMapGuiPoint point;
!     point.x = location.x;
!     point.y = location.y;
!     (*RoadMapCanvasMouseButtonReleased) (1, &point);
  }
  
! - (void) mouseDragged:(GSEvent*)event
  {
!     printf("mouseMoved\n");
!     CGPoint location = GSEventGetLocationInWindow(event);
!     RoadMapGuiPoint point;
!     point.x = location.x;
!     point.y = location.y;
!     (*RoadMapCanvasMouseMoved) (0, &point);
  }
  
--- 854,947 ----
             so if we're lucky no copy is actually made! */
          CGImageRef ref = CGBitmapContextCreateImage(RoadMapGc);           
!         CGContextDrawImage(UIGraphicsGetCurrentContext(), rect, ref);
          CGImageRelease(ref);
      }
  }
  
! - (void)touchesBegan: (NSSet *) touches withEvent: (UIEvent*)event
  {
!    UITouch *touch = [touches anyObject];
!    CGPoint location =  [touch locationInView: touch.view];
!    RoadMapGuiPoint point;
!    point.x = location.x;
!    point.y = location.y;
!    for (UITouch *touch in touches) {
!       location =  [touch locationInView: touch.view];
!       if (touch1 == nil)
!       {
!          touch1 = touch;
!          touch1point = location;
!       }
!       else if (touch2 == nil)
!       {
!          touch2 = touch;
!          touch2point = location;
!       }
!    }	
!    if (touch1 != nil && touch2 != nil) {
!       ChordingPoints[0] = touch1point;
!       ChordingPoints[1] = touch2point;
!    } else {
!       ChordingPoints[0].x = -1;  
!    }
!          ChordingPoints[2].x = -1;
!    
!    (*RoadMapCanvasMouseButtonPressed) (1, &point);
  }
  
! - (void)touchesEnded: (NSSet *) touches withEvent: (UIEvent*)event
  {
!    UITouch *touch = [touches anyObject];
!    CGPoint location =  [touch locationInView: touch.view];
!    RoadMapGuiPoint point;
!    point.x = location.x;
!    point.y = location.y;
!    for (UITouch *touch in touches) {
!       if (touch == touch1)
!          touch1 = nil;
!       else if (touch == touch2)
!          touch2 = nil;
!    }	
!    
!    if (touch1 != nil && touch2 != nil) {
!       NSLog(@"chording !");
!       
!       ChordingPoints[0] = touch1point;
!       ChordingPoints[1] = touch2point;
!       
!       ChordingPoints[2].x = -1;
!    } else {
!       ChordingPoints[0].x = -1;
!    }
!    
!    (*RoadMapCanvasMouseButtonReleased) (1, &point);
  }
  
! - (void)touchesMoved: (NSSet *) touches withEvent: (UIEvent*)event
  {
!    UITouch *touch = [touches anyObject];
!    CGPoint location =  [touch locationInView: touch.view];
!    RoadMapGuiPoint point;
!    point.x = location.x;
!    point.y = location.y;
!    for (UITouch *touch in touches) {
!       location =  [touch locationInView: touch.view];
!       if (touch1 == touch)
!          touch1point = location;
!       else if (touch2 == touch)
!          touch2point = location;
!    }	
!    
!    if (touch1 != nil && touch2 != nil) {
!       
!       ChordingPoints[0] = touch1point;
!       ChordingPoints[1] = touch2point;
!             
!       ChordingPoints[2].x = -1;
!    } else {
!       ChordingPoints[0].x = -1;
!    }
!    
!    (*RoadMapCanvasMouseMoved) (0, &point);
  }
  

Index: roadmap_iphonecanvas.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_iphonecanvas.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** roadmap_iphonecanvas.h	20 Jun 2008 13:09:19 -0000	1.2
--- roadmap_iphonecanvas.h	4 Nov 2008 14:56:23 -0000	1.3
***************
*** 33,37 ****
  
  #import <UIKit/UIKit.h>
- #import <UIKit/UIButtonBar.h>
  
  @interface RoadMapCanvasView : UIView {
--- 33,36 ----

Index: Makefile
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/Makefile,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Makefile	28 Jun 2008 16:49:28 -0000	1.3
--- Makefile	4 Nov 2008 14:56:23 -0000	1.4
***************
*** 8,16 ****
  ROADMAP_BUNDLE=RoadMap.app
  ROADGPS_BUNDLE=RoadGps.app
! LIBS += 
! LDFLAGS += -L/home/ditlemor/usr/local/lib -lobjc -ObjC \
! 	-framework CoreFoundation -framework Foundation \
! 	-framework UIKit -framework LayerKit -framework CoreGraphics \
! 	-framework GraphicsServices
  
  # --- iPhone sources & targets -----------------------------------
--- 8,22 ----
  ROADMAP_BUNDLE=RoadMap.app
  ROADGPS_BUNDLE=RoadGps.app
! LIBS += -lobjc -lstdc++.6
! LDFLAGS += -fobjc-abi-version=2 \
! 	-L/home/ditlemor/dat/sys/usr/lib \
! 	-F/home/ditlemor/dat/sys/System/Library/Frameworks \
!         -framework CoreFoundation -framework CoreGraphics \
!         -framework Foundation \
! 	-framework UIKit -bind_at_load \
! #	-framework GraphicsServices
! #        -F/System/Library/Frameworks \
! #
! CFLAGS += -fobjc-abi-version=2
  
  # --- iPhone sources & targets -----------------------------------

Index: roadmap_messagebox.m
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_messagebox.m,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** roadmap_messagebox.m	4 May 2008 16:49:21 -0000	1.1
--- roadmap_messagebox.m	4 Nov 2008 14:56:23 -0000	1.2
***************
*** 27,31 ****
   */
  
! #import <UIKit/UIAlertSheet.h>
  
  #include "roadmap.h"
--- 27,31 ----
   */
  
! #import <UIKit/UIAlert.h>
  
  #include "roadmap.h"
***************
*** 42,55 ****
  -(void)showWithTitle: (const char *) title text: (const char *) text modal: (int) modal
  {
!     UIAlertSheet * zSheet;
      NSString *nstitle = [[NSString alloc] initWithUTF8String: title];
      NSString *nstext = [[NSString alloc] initWithUTF8String: text];
!     NSArray *buttons = [NSArray arrayWithObjects:@"OK", nil];
!     zSheet = [[UIAlertSheet alloc] initWithTitle:nstitle buttons:buttons defaultButtonIndex:1 delegate:self context:self];
!     [zSheet setBodyText: nstext];
!     [zSheet setRunsModal: true]; //I'm a big fan of running sheet modally
      
!     [zSheet popupAlertAnimated:YES]; //Displays
                //Pauses here until user taps the sheet closed
                
      [zSheet autorelease];
--- 42,54 ----
  -(void)showWithTitle: (const char *) title text: (const char *) text modal: (int) modal
  {
!     UIAlertView * zSheet;
      NSString *nstitle = [[NSString alloc] initWithUTF8String: title];
      NSString *nstext = [[NSString alloc] initWithUTF8String: text];
!     zSheet = [[UIAlertView alloc] initWithTitle:nstitle message: nstext delegate:self cancelButtonTitle: @"OK" otherButtonTitles: nil];
! //    [zSheet setRunsModal: true]; //I'm a big fan of running sheet modally
      
! //    [zSheet popupAlertAnimated:YES]; //Displays
                //Pauses here until user taps the sheet closed
+     [zSheet show];
                
      [zSheet autorelease];
***************
*** 58,64 ****
  }
  
! -(void)alertSheet:(UIAlertSheet*)sheet buttonClicked:(int)button
  {
!    [sheet dismiss];
  }
  @end
--- 57,63 ----
  }
  
! -(void)alertView:(UIAlertView*)sheet clickedButtonAtIndex:(NSInteger)button
  {
! //   [sheet dismiss];
  }
  @end
***************
*** 86,87 ****
--- 85,90 ----
     return roadmap_messagebox_show (title, message, 1);
  }
+ 
+ void roadmap_messagebox_die (const char *title, const char *message) {
+    (void)roadmap_messagebox_show (title, message, 1);
+ }

Index: roadmap_main.m
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_main.m,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** roadmap_main.m	12 Jul 2008 09:24:15 -0000	1.3
--- roadmap_main.m	4 Nov 2008 14:56:23 -0000	1.4
***************
*** 62,66 ****
  
  static RoadMapApp *TheApp;
! static int RoadMapMainToolbarAdded = 0;
  static int sArgc;
  static char ** sArgv;
--- 62,66 ----
  
  static RoadMapApp *TheApp;
! static int RoadMapMainTabBarAdded = 0;
  static int sArgc;
  static char ** sArgv;
***************
*** 87,101 ****
  
  static RoadMapKeyInput RoadMapMainInput = NULL;
- static UIWindow    *RoadMapMainWindow  = NULL;
  static UIView      *RoadMapMainBox     = NULL;
  static RoadMapCanvasView *RoadMapCanvasBox   = NULL;
  //static UIView      *RoadMapMainMenuBar = NULL;
! static UIButtonBar *RoadMapMainToolbar = NULL;
  //static UIView      *RoadMapMainStatus  = NULL;
! static NSArray     *RoadMapMainToolbarArray = NULL;
  static int          buttonCount = 0;
! static RoadMapCallback RoadMapMainToolbarCallbacks[6];
  
  
  static char *roadmap_main_toolbar_icon (const char *icon) {
      unsigned int i;
--- 87,113 ----
  
  static RoadMapKeyInput RoadMapMainInput = NULL;
  static UIView      *RoadMapMainBox     = NULL;
  static RoadMapCanvasView *RoadMapCanvasBox   = NULL;
  //static UIView      *RoadMapMainMenuBar = NULL;
! UIToolbar *RoadMapMainTabBar = NULL;
  //static UIView      *RoadMapMainStatus  = NULL;
! static NSArray     *RoadMapMainTabBarArray = NULL;
  static int          buttonCount = 0;
! static RoadMapCallback RoadMapMainTabBarCallbacks[6];
  
  
+ void roadmap_main_send_email(const char *subject, const char *contents, 
+                              const char *att_path, const char *att_name)
+ {
+     char text[4096];
+     if (att_path)
+         snprintf(text, 4096, "mailto:?subject=%s&body=%s&attachment=%s/%s", subject, contents, att_path, att_name);
+     else
+         snprintf(text, 4096, "mailto:?subject=%s&body=%s", subject, contents);
+     CFStringRef string = CFStringCreateWithCString(NULL, text, kCFStringEncodingUTF8);
+     CFStringRef urlString = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, string, NULL, NULL, kCFStringEncodingUTF8);
+     [TheApp openURL: [NSURL URLWithString: (NSString *)urlString]];
+ }
+ 
  static char *roadmap_main_toolbar_icon (const char *icon) {
      unsigned int i;
***************
*** 111,115 ****
--- 123,129 ----
      {
          if (strncmp (icon_file + i, "resources", 9) == 0)
+ 	{
              return (char *)(icon_file + i);
+ 	}
      }
      return NULL;
***************
*** 217,222 ****
  void roadmap_main_add_toolbar (const char *orientation) {
       NSLog (@"roadmap_main_add_toolbar orientation: %s\n", orientation);
!      RoadMapMainToolbarAdded = 1;
!      RoadMapMainToolbarArray = [[NSArray array] init];
  }
  
--- 231,236 ----
  void roadmap_main_add_toolbar (const char *orientation) {
       NSLog (@"roadmap_main_add_toolbar orientation: %s\n", orientation);
!      RoadMapMainTabBarAdded = 1;
!      RoadMapMainTabBarArray = [[NSArray array] init];
  }
  
***************
*** 228,232 ****
      NSString *nsicon, *nslabel;
  
!     NSLog (@"roadmap_main_add_tool label: %s icon: %s tip: %s\n", label, icon, tip);
      if (buttonCount >= 5)
      {
--- 242,246 ----
      NSString *nsicon, *nslabel;
  
! //    NSLog (@"roadmap_main_add_tool label: %s icon: %s tip: %s\n", label, icon, tip);
      if (buttonCount >= 5)
      {
***************
*** 234,260 ****
          return;
      }
-     buttonCount++;
  
!     NSArray *tmp = RoadMapMainToolbarArray;
      nslabel = [[NSString alloc] initWithUTF8String:icon];
      iconstr = roadmap_main_toolbar_icon(icon);
      if (iconstr)
          nsicon = [[NSString alloc] initWithUTF8String:iconstr];
      else
!         nsicon = @"";
  
!     RoadMapMainToolbarCallbacks[buttonCount] = callback;
!     NSDictionary *dict = [ NSDictionary dictionaryWithObjectsAndKeys:
!         @"buttonBarItemTapped:", kUIButtonBarButtonAction,
!         nsicon, kUIButtonBarButtonInfo,
!         @"imagedown.png", kUIButtonBarButtonSelectedInfo,
!         [ NSNumber numberWithInt: buttonCount], kUIButtonBarButtonTag,
!         TheApp, kUIButtonBarButtonTarget,
!         nslabel, kUIButtonBarButtonTitle,
!         //@"", kUIButtonBarButtonTitle,
!         @"0", kUIButtonBarButtonType,
!         nil
!     ];
!     RoadMapMainToolbarArray = [tmp arrayByAddingObject: dict];
  }
  
--- 248,273 ----
          return;
      }
  
!     NSArray *tmp = RoadMapMainTabBarArray;
      nslabel = [[NSString alloc] initWithUTF8String:icon];
      iconstr = roadmap_main_toolbar_icon(icon);
+     UIImage *image = NULL;
      if (iconstr)
+     {
          nsicon = [[NSString alloc] initWithUTF8String:iconstr];
+         image = [UIImage imageNamed: nsicon];
+     }
+ 
+     UIBarButtonItem *item = [UIBarButtonItem alloc];
+     if (image == NULL)
+        [item initWithTitle: nslabel style: UIBarButtonItemStylePlain target: TheApp action: @selector(buttonPressed:)];
      else
!        [item initWithImage: image style: UIBarButtonItemStylePlain target: TheApp action: @selector(buttonPressed:)];
!     item.tag = buttonCount;
!     item.width = 64.0f;
!     RoadMapMainTabBarCallbacks[buttonCount] = callback;
  
!     RoadMapMainTabBarArray = [tmp arrayByAddingObject: item];
!     buttonCount++;
  }
  
***************
*** 281,288 ****
  
  void roadmap_main_add_canvas (void) {
!     struct CGRect rect = [UIHardware fullScreenApplicationContentRect];
      rect.origin.x = 0.0f;
!     rect.origin.y = 0.0f;
!     if (RoadMapMainToolbarAdded)
         rect.size.height = 480.0f - 49.0f - 20.0f;
      else
--- 294,302 ----
  
  void roadmap_main_add_canvas (void) {
!     //struct CGRect rect = [UIHardware fullScreenApplicationContentRect];
!     struct CGRect rect = [RoadMapMainBox frame];
      rect.origin.x = 0.0f;
!     rect.origin.y = 20.0f;
!     if (RoadMapMainTabBarAdded)
         rect.size.height = 480.0f - 49.0f - 20.0f;
      else
***************
*** 302,309 ****
         configured, we use this to add the finalized
         toolbar to the main view */
!      if (RoadMapMainToolbarAdded)
       {
!         RoadMapMainToolbar = [TheApp createButtonBar];
!         [RoadMapMainBox addSubview: RoadMapMainToolbar]; 
       }
  }
--- 316,323 ----
         configured, we use this to add the finalized
         toolbar to the main view */
!      if (RoadMapMainTabBarAdded)
       {
!         RoadMapMainTabBar = [TheApp createButtonBar];
!         [RoadMapMainBox addSubview: RoadMapMainTabBar]; 
       }
  }
***************
*** 343,352 ****
  
  int roadmap_main_flush (void) {
!    if ([[NSNotificationCenter defaultCenter] isEmpty])
  
        return 0;
  
     return 1;
  //   NSLog (@"roadmap_main_flush\n");
  /*
     while (gtk_events_pending ()) {
--- 357,385 ----
  
  int roadmap_main_flush (void) {
! /*   if ([[NSNotificationCenter defaultCenter] isEmpty])
  
        return 0;
  
+    
+    NSLog (@"notificationcenter has notifications\n");
     return 1;
+ */
+ 
  //   NSLog (@"roadmap_main_flush\n");
+    //[[NSRunLoop currentRunLoop] run];
+    
+    double resolution = 0.0001;
+ 
+   
+ 
+        NSDate* next = [NSDate dateWithTimeIntervalSinceNow:resolution];
+ 
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+ 
+                    beforeDate:next];
+ 
+   
+ 
+ 
  /*
     while (gtk_events_pending ()) {
***************
*** 361,365 ****
  
  int roadmap_main_flush_synchronous (int deadline) {
!    NSLog (@"roadmap_main_flush_synchronous\n");
  
     long start_time, duration;
--- 394,398 ----
  
  int roadmap_main_flush_synchronous (int deadline) {
! //   NSLog (@"roadmap_main_flush_synchronous\n");
  
     long start_time, duration;
***************
*** 389,397 ****
  void roadmap_main_exit (void) {
  
!    static int exit_done;
  
     if (!exit_done++) {
        roadmap_start_exit ();
!    }
  }
  
--- 422,432 ----
  void roadmap_main_exit (void) {
  
!  /*  static int exit_done;
  
     if (!exit_done++) {
        roadmap_start_exit ();
! */
!       // YYYY [TheApp terminate];
!    exit(0);
  }
  
***************
*** 399,402 ****
--- 434,438 ----
      int i;
      int j = 0;
+     int returnCode;
      sArgc = argc;
      sArgv = (char **)malloc(argc * (sizeof (char*)));
***************
*** 417,469 ****
      roadmap_option (sArgc, sArgv, 0, NULL);
      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
!     return UIApplicationMain(sArgc, sArgv, [RoadMapApp class]);
      [pool release];
!     return 0;
  }
  
  @implementation RoadMapApp
  
! - (UIButtonBar *)createButtonBar {
!     UIButtonBar *buttonBar;
!     buttonBar = [ [ UIButtonBar alloc ]
!        initInView: RoadMapMainBox
!        withFrame: CGRectMake(0.0f, 480.0f - 49.0f - 20.0f, 320.0f, 49.0f)
!        withItemList: RoadMapMainToolbarArray ];
!     [buttonBar setDelegate:self];
!     [buttonBar setBarStyle:0];
!     [buttonBar setButtonBarTrackingMode: 1];
! 
!     int buttons[5] = { 1, 2, 3, 4, 5};
!     [buttonBar registerButtonGroup:0 withButtons:buttons withCount: buttonCount];
!     [buttonBar showButtonGroup: 0 withDuration: 0.0f];
!     int tag;
  
!     for(tag = 1; tag <= buttonCount; tag++) {
!         [ [ buttonBar viewWithTag:tag ]
!             setFrame:CGRectMake(2.0f + ((tag - 1) * 64.0f), 1.0f, 64.0f, 48.0f)
!         ];
!     }
  
      return buttonBar;
  }
  
! - (void)buttonBarItemTapped:(id) sender {
      int button = [ sender tag ];
!     printf("buttonclicked: %i\n", button);
!       (RoadMapMainToolbarCallbacks[button] ) ();
  }
  
  -(void) newWithTitle: (const char *)title andWidth: (int) width andHeight: (int) height
  {
!     if (RoadMapMainWindow == NULL) {
!         struct CGRect rect = [UIHardware fullScreenApplicationContentRect];
!         rect.origin.x = rect.origin.y = 0.0f;
!         RoadMapMainWindow = [[UIWindow alloc] initWithContentRect: rect];
!         RoadMapMainBox = [[UIView alloc] initWithFrame: rect];
!         [RoadMapMainWindow orderFront: self];
!         [RoadMapMainWindow makeKey: self];
!         [RoadMapMainWindow _setHidden: NO];
!         [RoadMapMainWindow setContentView: RoadMapMainBox];
!     }
  
      if (RoadMapMainTitle != NULL) {
--- 453,491 ----
      roadmap_option (sArgc, sArgv, 0, NULL);
      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
!     returnCode = UIApplicationMain(sArgc, sArgv, @"RoadMapApp", @"RoadMapApp");
      [pool release];
!     return returnCode;
  }
  
  @implementation RoadMapApp
+ @synthesize window, view;
  
! -(RoadMapApp *) init
! {
!   self = [super init];
!   return self;
! }
  
! - (UIToolbar *) createButtonBar {
!     UIToolbar *buttonBar;
!     buttonBar = [ [ UIToolbar alloc ]
!        initWithFrame: CGRectMake(0.0f, 480.0f - 49.0f, 320.0f, 49.0f)];
  
+     buttonBar.items = RoadMapMainTabBarArray;
      return buttonBar;
  }
  
! - (void)buttonPressed: (id) sender {
      int button = [ sender tag ];
!     (RoadMapMainTabBarCallbacks[button] ) ();
  }
  
  -(void) newWithTitle: (const char *)title andWidth: (int) width andHeight: (int) height
  {
!     self.window = [[UIWindow alloc] initWithFrame: [[UIScreen mainScreen] bounds]];
!     self.view = [[UIView alloc] initWithFrame: [[UIScreen mainScreen] bounds]];
!     [self.window addSubview: self.view];
!     [self.window makeKeyAndVisible];
!     RoadMapMainBox = self.view;
  
      if (RoadMapMainTitle != NULL) {
***************
*** 584,588 ****
  }
  
! - (void) applicationDidFinishLaunching: (id) unused
  {
      TheApp = self;
--- 606,610 ----
  }
  
! - (void) applicationDidFinishLaunching: (UIApplication *) application
  {
      TheApp = self;
***************
*** 594,599 ****
  
      roadmap_start (sArgc, sArgv);
! 
!     [self reportAppLaunchFinished];
  }
  
--- 616,621 ----
  
      roadmap_start (sArgc, sArgv);
!     
!   //YYY  [self reportAppLaunchFinished];
  }
  
***************
*** 601,605 ****
  {
   //  [self terminate];
!    printf("go to sleep\n");
  }
  
--- 623,627 ----
  {
   //  [self terminate];
! //   printf("go to sleep\n");
  }
  
***************
*** 612,617 ****
  - (void)applicationWillTerminate
  {
!     roadmap_main_exit();
!     [TheApp release];
  }
  
--- 634,643 ----
  - (void)applicationWillTerminate
  {
!     static int exit_done;
! 
!     if (!exit_done++) {
!       roadmap_start_exit ();
!     }
!     [self release];
  }
  

Index: roadmap_iphonemain.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/iphone/roadmap_iphonemain.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** roadmap_iphonemain.h	20 Jun 2008 13:09:19 -0000	1.2
--- roadmap_iphonemain.h	4 Nov 2008 14:56:23 -0000	1.3
***************
*** 34,42 ****
  #import <CoreFoundation/CoreFoundation.h>
  #import <Foundation/Foundation.h>
- #import <UIKit/CDStructures.h>
  #import <UIKit/UIWindow.h>
- #import <UIKit/UIView-Hierarchy.h>
- #import <UIKit/UIView-Geometry.h>
- #import <UIKit/UIHardware.h>
  #import <UIKit/UIKit.h>
  #import <UIKit/UIApplication.h>
--- 34,38 ----
***************
*** 44,55 ****
  #import <UIKit/UIImage.h>
  #import <UIKit/UITextView.h>
! #import <UIKit/UIButtonBarTextButton.h>
! #import <UIKit/UIPushButton.h>
! #import <UIKit/UIView-Geometry.h>
  
! @interface RoadMapApp : UIApplication {
  }
! -(void)buttonBarItemTapped:(id) sender;
! -(UIButtonBar *)createButtonBar;
  -(void) newWithTitle: (const char *)title andWidth: (int) width andHeight: (int) height;
  -(void) ioCallback: (id) notify;
--- 40,56 ----
  #import <UIKit/UIImage.h>
  #import <UIKit/UITextView.h>
! #import <UIKit/UITabBar.h>
  
! @interface RoadMapApp : UIApplication <UITabBarDelegate> {
!    UIWindow *window;
!    UIView *view;
  }
! 
! @property (nonatomic, retain) UIWindow *window;
! @property (nonatomic, retain) UIView *view;
! 
! //-(void)buttonBarItemTapped:(id) sender;
! //-(void)buttonPressed;
! -(UITabBar *)createButtonBar;
  -(void) newWithTitle: (const char *)title andWidth: (int) width andHeight: (int) height;
  -(void) ioCallback: (id) notify;

[Roadmap-commit] roadmap/src roadmap_county.c,1.19,1.20

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv8132

Modified Files:
	roadmap_county.c 
Log Message:
use new roadmap_math_get_zoom() routine


Index: roadmap_county.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_county.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -C2 -d -r1.19 -r1.20
*** roadmap_county.c	12 Jul 2008 14:10:14 -0000	1.19
--- roadmap_county.c	4 Nov 2008 14:53:21 -0000	1.20
***************
*** 531,535 ****
  int roadmap_county_get_decluttered(int fips) {
  
-    unsigned int zoom;
     int i;
  
--- 531,534 ----
***************
*** 547,553 ****
     }
  
!    roadmap_math_get_context(0, &zoom, 0);
! 
!    if (zoom >= RoadMapCountyActive->county_no_draw[i]) {
        return 1;
     }
--- 546,550 ----
     }
  
!    if (roadmap_math_get_zoom() >= RoadMapCountyActive->county_no_draw[i]) {
        return 1;
     }
***************
*** 576,580 ****
     }
  
!    roadmap_math_get_context(0, &zoom, 0);
  
     if (RoadMapCountyActive->county_no_draw[i] == 0 ||
--- 573,577 ----
     }
  
!    zoom = roadmap_math_get_zoom();
  
     if (RoadMapCountyActive->county_no_draw[i] == 0 ||

[Roadmap-commit] roadmap/src roadmap_math.c, 1.54, 1.55 roadmap_math.h, 1.40, 1.41

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv6836

Modified Files:
	roadmap_math.c roadmap_math.h 
Log Message:
add roadmap_math_get/set_zoom(), for new iphone support.
also add roadmap_math_get_angle(), but this may be redundant with
roadmap_math_angle().


Index: roadmap_math.h
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.h,v
retrieving revision 1.40
retrieving revision 1.41
diff -C2 -d -r1.40 -r1.41
*** roadmap_math.h	21 May 2008 13:28:12 -0000	1.40
--- roadmap_math.h	4 Nov 2008 14:32:02 -0000	1.41
***************
*** 50,53 ****
--- 50,54 ----
  int roadmap_math_zoom_reset   (void);
  void roadmap_math_compute_scale (void);
+ void roadmap_math_zoom_set     (int zoom);
  
  void roadmap_math_set_center      (const RoadMapPosition *position);
***************
*** 166,169 ****
--- 167,171 ----
  void roadmap_math_get_context
      (RoadMapPosition *position, unsigned int *zoom, RoadMapGuiPoint *lowerright);
+ int  roadmap_math_get_zoom (void);
  
  int roadmap_math_from_floatstring(const char *f, int fracdigits);
***************
*** 174,177 ****
--- 176,182 ----
  #define MILLIONTHS  6
  
+ #ifdef IPHONE
+ float roadmap_math_get_angle (RoadMapGuiPoint *point0, RoadMapGuiPoint *point1);
+ #endif
  #endif // INCLUDED__ROADMAP_MATH__H
  

Index: roadmap_math.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_math.c,v
retrieving revision 1.54
retrieving revision 1.55
diff -C2 -d -r1.54 -r1.55
*** roadmap_math.c	21 May 2008 13:28:12 -0000	1.54
--- roadmap_math.c	4 Nov 2008 14:32:02 -0000	1.55
***************
*** 1019,1022 ****
--- 1019,1034 ----
  }
  
+ void roadmap_math_zoom_set (int zoom) {
+ 
+    if (zoom < MIN_ZOOM_IN) {
+       zoom = MIN_ZOOM_IN;
+    } else if (zoom >= MAX_ZOOM_OUT) {
+       zoom = MAX_ZOOM_OUT - 1;
+    }
+    RoadMapContext->zoom = zoom;
+ 
+    roadmap_config_set_integer (&RoadMapConfigGeneralZoom, RoadMapContext->zoom);
+    roadmap_math_compute_scale ();
+ }
  
  int roadmap_math_zoom_reset (void) {
***************
*** 1214,1217 ****
--- 1226,1238 ----
  }
  
+ #ifdef IPHONE
+ float roadmap_math_get_angle 
+ 	(RoadMapGuiPoint *point0, RoadMapGuiPoint *point1) {
+    float delta_x = point0->x - point1->x + 1;
+    float delta_y = point0->y - point1->y + 1;
+    return (90 * (delta_y / (delta_x + delta_y)));
+ }
+ 
+ #endif
  
  
***************
*** 1913,1916 ****
--- 1934,1943 ----
  }
  
+ int  roadmap_math_get_zoom (void) {
+ 
+    return (int) RoadMapContext->zoom;
+ }
+ 
+ 
  static int powers_of_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000 };
  

[Roadmap-commit] roadmap README,1.159,1.160

[Paul F. <pg...@us...>]

Update of /cvsroot/roadmap/roadmap
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv1820

Modified Files:
	README 
Log Message:
cleanup pass over older parts of readme


Index: README
===================================================================
RCS file: /cvsroot/roadmap/roadmap/README,v
retrieving revision 1.159
retrieving revision 1.160
diff -C2 -d -r1.159 -r1.160
*** README	26 Oct 2008 17:51:05 -0000	1.159
--- README	4 Nov 2008 03:38:39 -0000	1.160
***************
*** 3,7 ****
                                 ---------
                                 ---------
!                              October 2008
  
  
--- 3,7 ----
                                 ---------
                                 ---------
!                              November 2008
  
[...1711 lines suppressed...]
***************
*** 3837,3840 ****
--- 3753,3759 ----
  * MAP FILES AND INDEXES
  
+    (See the file README.osm included with thre RoadMap source for
+    information about file naming for OpenStreetMap files.)
+ 
     As indicated in several other places, the RoadMap map files (extension
     .rdm) are organized by administrative territories, such s a county per
***************
*** 4307,4310 ****
--- 4226,4232 ----
  * THE EXCHANGE FORMAT
  
+    (As of November of 2008, the exchange format described here is not
+    supported -- the code is incomplete.)
+ 
     The rdx files are straight conversion of the rdm file in an ASCII format
     that is neither sensitive to the CPU byte order or the compiler's structure

[Roadmap-commit] roadmap/src roadmap_message.c,1.5,1.6

[Danny B. <dan...@us...>]

Update of /cvsroot/roadmap/roadmap/src
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv8815

Modified Files:
	roadmap_message.c 
Log Message:
Add doc


Index: roadmap_message.c
===================================================================
RCS file: /cvsroot/roadmap/roadmap/src/roadmap_message.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** roadmap_message.c	11 Oct 2007 21:47:47 -0000	1.5
--- roadmap_message.c	3 Nov 2008 18:25:10 -0000	1.6
***************
*** 1,4 ****
! /* roadmap_message.c - Manage screen signs.
!  *
   * LICENSE:
   *
--- 1,3 ----
! /*
   * LICENSE:
   *
***************
*** 20,27 ****
   *   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_message.h.
   */
  
--- 19,27 ----
   *   along with RoadMap; if not, write to the Free Software
   *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
!  */
! 
! /**
!  * @file
!  * @brief Manage screen signs.
   */
  
***************
*** 100,104 ****
  }
  
! 
  void roadmap_message_set (int parameter, const char *format, ...) {
      
--- 100,108 ----
  }
  
! /**
!  * @brief set a numbered message to the given string
!  * @param parameter indicates which message to set
!  * @param format this and the next parameters are printf-style
!  */
  void roadmap_message_set (int parameter, const char *format, ...) {