Main Page | File List | Globals | Related Pages

objects.c

Go to the documentation of this file.
00001 
00012 /* 
00013    Copyright (C) 1999-2004 Christian Claveleira (Christian.Claveleira@cru.fr)
00014 
00015    This program is free software; you can redistribute it and/or
00016    modify it under the terms of the GNU General Public License
00017    as published by the Free Software Foundation; either version 2
00018    of the License, or (at your option) any later version.
00019    
00020    This program is distributed in the hope that it will be useful,
00021    but WITHOUT ANY WARRANTY; without even the implied warranty of
00022    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023    GNU General Public License for more details.
00024    
00025    You should have received a copy of the GNU General Public License
00026    along with this program; if not, write to the Free Software
00027    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00028    
00029  */
00030 
00031 /*      $Id: objects.c,v 1.8 2004/06/13 07:44:46 clavelei Exp $  */
00032 
00033 #ifndef lint
00034 static char vcid[] = "$Id: objects.c,v 1.8 2004/06/13 07:44:46 clavelei Exp $";
00035 #endif /* lint */
00036 
00037 #if defined __palmos__ 
00038 # include <PalmOS.h>
00039 # define min(a, b) (((a) < (b)) ? (a) : (b))
00040 #elif defined GLIB
00041 # include <glib.h>
00042 # include <string.h>
00043 #endif
00044 
00045 #include "Garmin.h"
00046 #include "types.h"
00047 #include "log.h"
00048 #include "gpsutil.h"
00049 
00050 static const UInt16 smbl2ST[16] =
00051     { sym_wpt_dot, sym_house, sym_fuel, sym_car, sym_fish, sym_wreck, sym_anchor, sym_wreck,
00052     sym_user_exit, sym_skull, sym_flag, sym_camp, sym_circle_x, sym_deer, sym_1st_aid,
00053     sym_trcbck
00054 };                                     /* mapping between Symbol_Type and smbl */
00055 
00056 // mapping of symbols id between Garmin id and local bitmap index :
00057 static const UInt16 SymbolMap[][3] = {
00058     {sym_anchor, sym_rbcn, 0},
00059     {sym_boat_ramp, sym_circle_x, 38},
00060     {sym_is_hwy, sym_border, 68},
00061     {sym_airport, sym_seaplane, 131}
00062 };
00063 #define S_BEGIN 0                                          // begin of segment
00064 #define S_END 1                                            // end of segment
00065 #define S_LOCAL 2                                          // local bitmap index for begining of segment
00066 #define S_DEFAULT_LID  sym_null                            // defaultbitmap index
00067 
00068 #define HOSTtoLE32(to,from) LEtoHOST32((to),(from))
00069 #define HOSTtoLE16(to,from) LEtoHOST16((to),(from))
00070 
00071 static void RawD301ToCustomTrkPt (Raw_D301_Trk_Point_Type * from, Custom_Trk_Point_Type * to) UTIL_SECTION;
00072 static void RawD301ToCompactTrkPt (Raw_D301_Trk_Point_Type * from, Compact_Trk_Point_Type * to) UTIL_SECTION;
00073 static void RawD300ToCustomTrkPt (Raw_D300_Trk_Point_Type * from, Custom_Trk_Point_Type * to) UTIL_SECTION;
00074 static void RawD300ToCompactTrkPt (Raw_D300_Trk_Point_Type * from, Compact_Trk_Point_Type * to) UTIL_SECTION;
00075 static void LEtoHOST32 (byte * pto, byte * pfrom) UTIL_SECTION;
00076 static void LEtoHOST16 (byte * pto, byte * pfrom) UTIL_SECTION;
00077 
00078 
00079                           // *********     GPilotS custom objects management :
00080 
00081 
00089 UInt16
00090 SizeOfObject (ObjectPtr p)
00091 {
00092     UInt16 s;
00093     debug_in (128, ("->SizeOfObject(%ld)", p));
00094     s = p->header.size;
00095     s += (4 - s % 4) & 0x3;                                /* pour obtenir size multiple de 4 (pb alignements) */
00096     s += sizeof (p->header);
00097     debug_out (128, ("<->SizeOfObjec (%ld)= %d", p, s));
00098     return (s);
00099 }
00100 
00101 
00102 #if defined __palmos__
00103 
00111 UInt16
00112 ObjectsInRec (MemHandle RecH)
00113 {
00114     byte *p,
00115      *stop;
00116     Int16 i = 0;
00117 
00118     debug (32, ("ObjectsInRec(%ld)", RecH));
00119     if (!RecH)
00120         return (0);
00121     p = MemHandleLock (RecH);
00122     for (stop = p + MemHandleSize (RecH); p < stop; p += SizeOfObject ((ObjectPtr) p))
00123         i++;
00124     MemHandleUnlock (RecH);
00125     debug (32, ("<->ObjectsInRec (%ld)=%d", RecH, i));
00126     return (i);
00127 }
00128 
00129 
00139 UInt16
00140 OffsetOfObjectInRec (MemHandle RecH, UInt16 n)
00141 {
00142     byte *p,
00143      *start,
00144      *stop;
00145 
00146     if (!RecH)
00147         return (0);
00148     debug_in (32, ("->OffsetOfObjectInRec(n=%d)", n));
00149     start = p = MemHandleLock (RecH);
00150     for (stop = p + MemHandleSize (RecH); n && (p < stop); p += SizeOfObject ((ObjectPtr) p))
00151         n--;
00152     MemHandleUnlock (RecH);
00153     debug_out (32, ("<-OffsetOfObjectInRec returns %d", p - start));
00154     return (p - start);
00155 }
00156 
00157 #endif
00158 
00159 
00160                        // *********  Waypoint objects management :
00161 
00162 
00171 UInt16
00172 G100ToCustom (Raw_D100_Wpt_Type * p100, Custom_Wpt_Type * pcust)
00173 {
00174     Int16 i;
00175 
00176     if (!p100 || !pcust)
00177         return (0);
00178     MemSet (pcust, sizeof (Custom_Wpt_Type), 0);
00179     for (i = sizeof (p100->ident) - 1; i >= 0; i--)
00180         if (p100->ident[i] != ' ')
00181             break;                                         /* to strip blanks */
00182     StrNCopySafe (pcust->ident, p100->ident, i + 2);       /* name */
00183     LEtoHOST32 ((byte *) & (pcust->posn.lat), p100->lat);          /* latitude */
00184     LEtoHOST32 ((byte *) & (pcust->posn.lon), p100->lon);          /* longitude */
00185     StrNCopySafe (pcust->cmnt, p100->cmnt, sizeof (p100->cmnt));        /* comment */
00186     return (sizeof (Custom_Wpt_Type));
00187 }                                                          /* G100ToCustom */
00188 
00189 
00198 UInt16
00199 CustomToG100 (Custom_Wpt_Type * pcust, Raw_D100_Wpt_Type * p100)
00200 {
00201     if (!p100 || !pcust)
00202         return (0);
00203     MemSet (p100, sizeof (Raw_D100_Wpt_Type), 0);
00204     MemSet (p100->ident, sizeof (p100->ident), ' ');       /* name */
00205     MemMove (p100->ident, pcust->ident, StrLen (pcust->ident));
00206     HOSTtoLE32 (p100->lat, (byte *) & (pcust->posn.lat));          /* latitude */
00207     HOSTtoLE32 (p100->lon, (byte *) & (pcust->posn.lon));          /* longitude */
00208     MemSet (p100->cmnt, sizeof (p100->cmnt), ' ');         /* comment */
00209     MemMove (p100->cmnt, pcust->cmnt, StrLen (pcust->cmnt));
00210     return (sizeof (Raw_D100_Wpt_Type));
00211 }                                                          /* CustomToG100 */
00212 
00213 
00222 UInt16
00223 G102ToCustom (Raw_D102_Wpt_Type * p102, Custom_Wpt_Type * pcust)
00224 {
00225     if (!G100ToCustom ((Raw_D100_Wpt_Type *) p102, pcust))
00226         return (0);
00227     LEtoHOST32 ((byte *) & (pcust->dst), p102->dst);               /* distance */
00228     LEtoHOST16 ((byte *) & (pcust->smbl), p102->smbl);     /* symbol id */
00229     return (sizeof (Custom_Wpt_Type));
00230 }
00231 
00232 
00241 UInt16
00242 CustomToG102 (Custom_Wpt_Type * pcust, Raw_D102_Wpt_Type * p102)
00243 {
00244     if (!CustomToG100 (pcust, (Raw_D100_Wpt_Type *) p102))
00245         return (0);
00246     HOSTtoLE32 (p102->dst, (byte *) & (pcust->dst));               /* distance */
00247     HOSTtoLE16 (p102->smbl, (byte *) & (pcust->smbl));     /* symbol id */
00248     return (sizeof (Raw_D102_Wpt_Type));
00249 }
00250 
00251 
00260 UInt16
00261 G103ToCustom (Raw_D103_Wpt_Type * p103, Custom_Wpt_Type * pcust)
00262 {
00263 
00264     if (!G100ToCustom ((Raw_D100_Wpt_Type *) p103, pcust))
00265         return (0);
00266     pcust->smbl = smblToSymbolType (p103->smbl);           /* symbol id */
00267     pcust->dspl = p103->dspl;                              /* display option */
00268     return (sizeof (Custom_Wpt_Type));
00269 }
00270 
00271 
00280 UInt16
00281 CustomToG103 (Custom_Wpt_Type * pcust, Raw_D103_Wpt_Type * p103)
00282 {
00283     if (!CustomToG100 (pcust, (Raw_D100_Wpt_Type *) p103))
00284         return (0);
00285     p103->smbl = SymbolTypeTosmbl (pcust->smbl);           /* symbol id */
00286     p103->dspl = pcust->dspl;                              /* display option */
00287     return (sizeof (Raw_D103_Wpt_Type));
00288 }
00289 
00290 
00299 UInt16
00300 G104ToCustom (Raw_D104_Wpt_Type * p104, Custom_Wpt_Type * pcust)
00301 {
00302     if (!G102ToCustom ((Raw_D102_Wpt_Type *) p104, pcust))
00303         return (0);
00304     pcust->dspl = p104->dspl;                              /* display option */
00305     return (sizeof (Custom_Wpt_Type));
00306 }
00307 
00308 
00317 UInt16
00318 CustomToG104 (Custom_Wpt_Type * pcust, Raw_D104_Wpt_Type * p104)
00319 {
00320     if (!CustomToG102 (pcust, (Raw_D102_Wpt_Type *) p104))
00321         return (0);
00322     p104->dspl = pcust->dspl;                              /* display option */
00323     return (sizeof (Raw_D104_Wpt_Type));
00324 }                                                          /* CustomToG104 */
00325 
00326 
00335 UInt16
00336 G105ToCustom (Raw_D105_Wpt_Type * p105, Custom_Wpt_Type * pcust)
00337 {
00338     if (!p105 || !pcust)
00339         return (0);
00340     MemSet (pcust, sizeof (Custom_Wpt_Type), 0);
00341     LEtoHOST32 ((byte *) & (pcust->posn.lat), p105->lat);          /* latitude */
00342     LEtoHOST32 ((byte *) & (pcust->posn.lon), p105->lon);          /* longitude */
00343     LEtoHOST16 ((byte *) & (pcust->smbl), p105->smbl);     /* symbol id */
00344     StrNCopySafe (pcust->ident, p105->wpt_ident, sizeof (pcust->ident));        /* name */
00345     return (sizeof (Custom_Wpt_Type));
00346 }                                                          /* G105ToCustom */
00347 
00348 
00357 UInt16
00358 CustomToG105 (Custom_Wpt_Type * pcust, Raw_D105_Wpt_Type * p105)
00359 {
00360     char *p;
00361 
00362     if (!p105 || !pcust)
00363         return (0);
00364     MemSet (p105, sizeof (Raw_D105_Wpt_Type), 0);
00365     p = StrNCopySafe (p105->wpt_ident, pcust->ident, sizeof (p105->wpt_ident)); /* ident */
00366     HOSTtoLE32 (p105->lat, (byte *) & (pcust->posn.lat));          /* latitude */
00367     HOSTtoLE32 (p105->lon, (byte *) & (pcust->posn.lon));          /* longitude */
00368     HOSTtoLE16 (p105->smbl, (byte *) & (pcust->smbl));     /* symbol id */
00369     return (p - (char *) p105);
00370 }                                                          /* CustomToG105 */
00371 
00372 
00381 UInt16
00382 G107ToCustom (Raw_D107_Wpt_Type * p107, Custom_Wpt_Type * pcust)
00383 {
00384     if (!G103ToCustom ((Raw_D103_Wpt_Type *) p107, pcust))
00385         return (0);
00386     LEtoHOST32 ((byte *) & (pcust->dst), p107->dst);               /* distance */
00387     pcust->color = p107->color;                            /* color */
00388     return (sizeof (Custom_Wpt_Type));
00389 }                                                          /* G107ToCustom */
00390 
00391 
00400 UInt16
00401 CustomToG107 (Custom_Wpt_Type * pcust, Raw_D107_Wpt_Type * p107)
00402 {
00403     if (!CustomToG103 (pcust, (Raw_D103_Wpt_Type *) p107))
00404         return (0);
00405     HOSTtoLE32 (p107->dst, (byte *) & (pcust->dst));               /* distance */
00406     p107->color = pcust->color;                            /* color */
00407     return (sizeof (Raw_D107_Wpt_Type));
00408 }                                                          /* CustomToG107 */
00409 
00410 
00419 UInt16
00420 G108ToCustom (Raw_D108_Wpt_Type * p108, Custom_Wpt_Type * pcust)
00421 {
00422     char *namep,
00423      *commentp;
00424 
00425     if (!p108 || !pcust)
00426         return (0);
00427     MemSet (pcust, sizeof (Custom_Wpt_Type), 0);
00428     //    namep = (char *) (&(p108->cc) + sizeof (p108->cc));
00429     namep = (char *) (p108 + 1);
00430     if (StrLen (namep) < 51)
00431       {
00432           StrNCopySafe (pcust->ident, namep, sizeof (pcust->ident));    /* name */
00433           commentp = namep + StrLen (namep) + 1;
00434           StrNCopySafe (pcust->cmnt, commentp, sizeof (pcust->cmnt));   /* comment */
00435       }
00436     LEtoHOST32 ((byte *) & (pcust->posn.lat), p108->lat);          /* latitude */
00437     LEtoHOST32 ((byte *) & (pcust->posn.lon), p108->lon);          /* longitude */
00438     LEtoHOST32 ((byte *) & (pcust->dst), p108->dist);      /* distance */
00439     LEtoHOST32 ((byte *) & (pcust->alt), p108->alt);               /* altitude */
00440     LEtoHOST16 ((byte *) & (pcust->smbl), p108->smbl);     /* symbol id */
00441     pcust->dspl = p108->dspl;                              /* display option */
00442     pcust->color = p108->color;                            /* color */
00443     return (sizeof (Custom_Wpt_Type));
00444 }                                                          /* G108ToCustom */
00445 
00446 
00457 UInt16
00458 CustomToB108 (Custom_Wpt_Type * pcust, B108_Wpt_Type * p108, Boolean merge)
00459 {
00460     static byte default_subclass[18] =
00461         { 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
00462         0xFF
00463     };
00464     char facility[32],
00465       city[26],
00466       addr[52],
00467       cross_road[52],
00468      *p;
00469 
00470     if (!p108 || !pcust)
00471         return (0);
00472 
00473     if (merge)
00474       {
00475           p = p108->ident;                                 /* ident */
00476           p += StrLen (p);                                 /* comment */
00477           p += StrLen (p);                                 /* facility */
00478           if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00479               StrNCopySafe (facility, p, sizeof (facility));
00480           p += StrLen (p);                                 /* city */
00481           if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00482               StrNCopySafe (city, p, sizeof (city));
00483           p += StrLen (p);                                 /* address */
00484           if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00485               StrNCopySafe (addr, p, sizeof (addr));
00486           p += StrLen (p);                                 /* cross_road */
00487           if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00488               StrNCopySafe (cross_road, p, sizeof (cross_road));
00489           p = StrNCopySafe (p108->ident, pcust->ident, sizeof (p108->ident));   /* ident */
00490           p = StrNCopySafe (p, pcust->cmnt, sizeof (p108->comment));    /* comment */
00491           p = StrNCopySafe (p, facility, sizeof (p108->facility));      /* facility */
00492           p = StrNCopySafe (p, city, sizeof (p108->city)); /* city */
00493           p = StrNCopySafe (p, addr, sizeof (p108->addr)); /* address */
00494           p = StrNCopySafe (p, cross_road, sizeof (p108->cross_road));  /* cross_road */
00495       }
00496 
00497     else
00498       {
00499           MemSet (p108, sizeof (B108_Wpt_Type), 0);
00500           p108->w.attr = 0x60;
00501           (void) MemMove (p108->w.subclass, &default_subclass, sizeof (p108->w.subclass));      /* default subclass */
00502           p = StrNCopySafe (p108->ident, pcust->ident, sizeof (p108->ident));   /* ident */
00503           p = StrNCopySafe (p, pcust->cmnt, sizeof (p108->comment));    /* comment */
00504           p += 4;                                          /* 4 empty strings */
00505       }
00506     p108->w.color = pcust->color;                          /* color */
00507     p108->w.dspl = pcust->dspl;                            /* display option */
00508     HOSTtoLE16 (p108->w.smbl, (byte *) & (pcust->smbl));           /* symbol id */
00509     HOSTtoLE32 (p108->w.lat, (byte *) & (pcust->posn.lat));        /* latitude */
00510     HOSTtoLE32 (p108->w.lon, (byte *) & (pcust->posn.lon));        /* longitude */
00511     HOSTtoLE32 (p108->w.dist, (byte *) & (pcust->dst));    /* distance */
00512     HOSTtoLE32 (p108->w.alt, (byte *) & (pcust->alt));     /* altitude */
00513     return (p - (char *) p108);
00514 }                                                          /* CustomToB108 */
00515 
00516 
00525 UInt16
00526 G109ToCustom (Raw_D109_Wpt_Type * p109, Custom_Wpt_Type * pcust)
00527 {
00528     char *namep,
00529      *commentp;
00530 
00531     if (!p109 || !pcust)
00532         return (0);
00533     MemSet (pcust, sizeof (Custom_Wpt_Type), 0);
00534     namep = (char *) (p109 + 1);
00535     if (StrLen (namep) < 51)
00536       {
00537           StrNCopySafe (pcust->ident, namep, sizeof (pcust->ident));    /* name */
00538           commentp = namep + StrLen (namep) + 1;
00539           StrNCopySafe (pcust->cmnt, commentp, sizeof (pcust->cmnt));   /* comment */
00540       }
00541     LEtoHOST32 ((byte *) & (pcust->posn.lat), p109->lat);          /* latitude */
00542     LEtoHOST32 ((byte *) & (pcust->posn.lon), p109->lon);          /* longitude */
00543     LEtoHOST32 ((byte *) & (pcust->dst), p109->dist);      /* distance */
00544     LEtoHOST32 ((byte *) & (pcust->alt), p109->alt);               /* altitude */
00545     LEtoHOST16 ((byte *) & (pcust->smbl), p109->smbl);     /* symbol id */
00546     pcust->dspl = (p109->dspl_color & 0x60) >> 5;          /* display option */
00547     pcust->color = p109->dspl_color & 0xf;                 /* color */
00548     return (sizeof (Custom_Wpt_Type));
00549 }                                                          /* G109ToCustom */
00550 
00551 
00562 UInt16
00563 CustomToB109 (Custom_Wpt_Type * pcust, B109_Wpt_Type * p109, Boolean merge)
00564 {
00565     static byte default_subclass[18] =
00566         { 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
00567         0xFF
00568     };
00569     char facility[32],
00570       city[26],
00571       addr[52],
00572       cross_road[52],
00573      *p;
00574 
00575     if (!p109 || !pcust)
00576         return (0);
00577 
00578     if (merge)
00579       {
00580           p = p109->ident;                                 /* ident */
00581           p += StrLen (p);                                 /* comment */
00582           p += StrLen (p);                                 /* facility */
00583           if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00584               StrNCopySafe (facility, p, sizeof (facility));
00585           p += StrLen (p);                                 /* city */
00586           if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00587               StrNCopySafe (city, p, sizeof (city));
00588           p += StrLen (p);                                 /* address */
00589           if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00590               StrNCopySafe (addr, p, sizeof (addr));
00591           p += StrLen (p);                                 /* cross_road */
00592           if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00593               StrNCopySafe (cross_road, p, sizeof (cross_road));
00594           p = StrNCopySafe (p109->ident, pcust->ident, sizeof (p109->ident));   /* ident */
00595           p = StrNCopySafe (p, pcust->cmnt, sizeof (p109->comment));    /* comment */
00596           p = StrNCopySafe (p, facility, sizeof (p109->facility));      /* facility */
00597           p = StrNCopySafe (p, city, sizeof (p109->city)); /* city */
00598           p = StrNCopySafe (p, addr, sizeof (p109->addr)); /* address */
00599           p = StrNCopySafe (p, cross_road, sizeof (p109->cross_road));  /* cross_road */
00600       }
00601 
00602     else
00603       {
00604           MemSet (p109, sizeof (B109_Wpt_Type), 0);
00605           p109->w.dtyp = 0x01;                             /* data packet type */
00606           p109->w.attr = 0x70;                             /* attributes */
00607           (void) MemMove (p109->w.subclass, &default_subclass, sizeof (p109->w.subclass));      /* default subclass */
00608           MemSet (p109->w.ete, sizeof (p109->w.ete), 0xff);     /* outbound link ete */
00609           p = StrNCopySafe (p109->ident, pcust->ident, sizeof (p109->ident));   /* ident */
00610           p = StrNCopySafe (p, pcust->cmnt, sizeof (p109->comment));    /* comment */
00611           p += 4;                                          /* 4 empty strings */
00612       }
00613     p109->w.dspl_color = pcust->color;                     /* color */
00614     p109->w.dspl_color |= (pcust->dspl << 5);              /* display option */
00615     HOSTtoLE16 (p109->w.smbl, (byte *) & (pcust->smbl));           /* symbol id */
00616     HOSTtoLE32 (p109->w.lat, (byte *) & (pcust->posn.lat));        /* latitude */
00617     HOSTtoLE32 (p109->w.lon, (byte *) & (pcust->posn.lon));        /* longitude */
00618     HOSTtoLE32 (p109->w.dist, (byte *) & (pcust->dst));    /* distance */
00619     HOSTtoLE32 (p109->w.alt, (byte *) & (pcust->alt));     /* altitude */
00620     return (p - (char *) p109);
00621 }                                                          /* CustomToB109 */
00622 
00623 
00632 LocalFormatID
00633 PtrToCustomWpt (ObjectPtr recp, Custom_Wpt_Type * pcust)
00634 {
00635     debug (32, ("PtrToCustomWpt()"));
00636     if (!recp)
00637         return (Unknown);
00638     switch (recp->header.type)
00639       {
00640       case G100Type:
00641           G100ToCustom (&(recp->d.g.d100), pcust);
00642           return (G100Type);
00643 
00644       case G102Type:
00645           G102ToCustom (&(recp->d.g.d102), pcust);
00646           return (G102Type);
00647 
00648       case G103Type:
00649           G103ToCustom (&(recp->d.g.d103), pcust);
00650           return (G103Type);
00651 
00652       case G104Type:
00653           G104ToCustom (&(recp->d.g.d104), pcust);
00654           return (G104Type);
00655 
00656       case G105Type:
00657           G105ToCustom (&(recp->d.g.d105), pcust);
00658           return (G105Type);
00659 
00660       case G107Type:
00661           G107ToCustom (&(recp->d.g.d107), pcust);
00662           return (G107Type);
00663 
00664       case G108Type:
00665           G108ToCustom (&(recp->d.g.d108), pcust);
00666           return (G108Type);
00667 
00668       case G109Type:
00669           G109ToCustom (&(recp->d.g.d109), pcust);
00670           return (G109Type);
00671 
00672       default:
00673           return (Unknown);
00674       }
00675 }
00676 
00677 
00686 LocalFormatID
00687 HandleToCustomWpt (ObjectHandle RecH, Custom_Wpt_Type * pcust)
00688 {
00689     LocalFormatID f = Unknown;
00690 
00691     debug (32, ("HandleToCustomWpt()"));
00692     if (!RecH)
00693         MemSet (pcust, sizeof (Custom_Wpt_Type), 0);
00694     else
00695       {
00696           ObjectPtr RecP = MemHandleLock ((MemHandle) RecH);
00697           f = PtrToCustomWpt (RecP, pcust);
00698           MemHandleUnlock ((MemHandle) RecH);
00699       }
00700     return (f);
00701 }                                                          /* HandleToCustomWpt */
00702 
00703 #if defined __palmos__
00704 
00713 LocalFormatID
00714 IndexToCustomWpt (UInt16 index, DmOpenRef DB, Custom_Wpt_Type * pcust)
00715 {
00716     return (HandleToCustomWpt ((ObjectHandle) DmQueryRecord (DB, index), pcust));
00717 }
00718 
00719 #endif
00720 
00731 Err
00732 CustomToAnyWpt (Custom_Wpt_Type * pcust, LocalFormatID format, ObjectPtr newp, Boolean merge)
00733 {
00734     //    Err error;
00735     //    UInt16 size;
00736     //    LocalFormatID type;
00737 
00738     debug (32, ("CustomToAnyWpt(format=%d, merge=%s)", format, merge ? "1" : "0"));
00739     newp->header.type = format;
00740 
00741     switch (format)
00742       {
00743       case G100Type:
00744           newp->header.size = CustomToG100 (pcust, &(newp->d.g.d100));
00745           break;
00746 
00747       case G102Type:
00748           newp->header.size = CustomToG102 (pcust, &(newp->d.g.d102));
00749           break;
00750 
00751       case G104Type:
00752           newp->header.size = CustomToG104 (pcust, &(newp->d.g.d104));
00753           break;
00754 
00755       case G105Type:
00756           newp->header.size = CustomToG105 (pcust, &(newp->d.g.d105));
00757           break;
00758 
00759       case G107Type:
00760           newp->header.size = CustomToG107 (pcust, &(newp->d.g.d107));
00761           break;
00762 
00763       case G108Type:
00764           newp->header.size = CustomToB108 (pcust, &(newp->d.b108), merge);
00765           break;
00766 
00767       case G109Type:
00768           newp->header.size = CustomToB109 (pcust, &(newp->d.b109), merge);
00769           break;
00770 
00771       default:
00772           newp->header.size = CustomToG103 (pcust, &(newp->d.g.d103));
00773       }                                                    /* switch (format) */
00774 
00775     return (0);
00776 }                                                          /* CustomToAnyWpt */
00777 
00778 
00788 ObjectPtr
00789 AnyToAnyWpt (ObjectPtr from, ObjectPtr to, LocalFormatID toformat)
00790 {
00791     Custom_Wpt_Type cust;
00792 
00793     debug (32, ("AnyToAnyWpt(toformat=%d)", toformat));
00794     if (from->header.type == toformat)
00795       {
00796           MemMove (to, from, SizeOfObject (from));
00797           return (to);
00798       }
00799     to->header.type = toformat;
00800     PtrToCustomWpt (from, &cust);
00801     switch (toformat)                                      // factorisable $$
00802       {
00803       case G100Type:
00804           to->header.size = CustomToG100 (&cust, &(to->d.g.d100));
00805           break;
00806 
00807       case G102Type:
00808           to->header.size = CustomToG102 (&cust, &(to->d.g.d102));
00809           break;
00810 
00811       case G103Type:
00812           to->header.size = CustomToG103 (&cust, &(to->d.g.d103));
00813           break;
00814 
00815       case G104Type:
00816           to->header.size = CustomToG104 (&cust, &(to->d.g.d104));
00817           break;
00818 
00819       case G105Type:
00820           to->header.size = CustomToG105 (&cust, &(to->d.g.d105));
00821           break;
00822 
00823       case G107Type:
00824           to->header.size = CustomToG107 (&cust, &(to->d.g.d107));
00825           break;
00826 
00827       case G108Type:
00828           to->header.size = CustomToB108 (&cust, &(to->d.b108), 0);
00829           break;
00830 
00831       case G109Type:
00832           to->header.size = CustomToB109 (&cust, &(to->d.b109), 0);
00833           break;
00834 
00835       default:
00836           to=NULL;
00837       }                                                    /* switch (format) */
00838     return (to);
00839 }                                                          /* AnyToAnyWpt */
00840 
00841 
00849 UInt16
00850 symb_gid2lid (Symbol_Type gid)
00851 {
00852     Int16 i;
00853 
00854     for (i = 0; i < 4; i++)
00855         if ((gid >= SymbolMap[i][S_BEGIN]) && (gid <= SymbolMap[i][S_END]))
00856             return (SymbolMap[i][S_LOCAL] + (gid - SymbolMap[i][S_BEGIN]));
00857     return (S_DEFAULT_LID);
00858 }                                                          /* symb_gid2lid */
00859 
00860 
00868 Symbol_Type
00869 symb_lid2gid (UInt16 lid)
00870 {
00871     Int16 i;
00872     for (i = 0; i < 4; i++)
00873         if (lid <= (SymbolMap[i][S_LOCAL] + SymbolMap[i][S_END] - SymbolMap[i][S_BEGIN]))
00874             return (SymbolMap[i][S_BEGIN] + (lid - SymbolMap[i][S_LOCAL]));
00875     return (S_DEFAULT_LID);
00876 }                                                          /* symb_lid2gid */
00877 
00878 
00879 
00880                        // *********  Routes objects management :
00881 
00882 #if defined __palmos__
00883 
00891 UInt16
00892 WptsInRteDB (MemHandle RecH)
00893 {
00894     UInt16 i;
00895     debug_in (32, ("->WptsInRteDB(%ld)", RecH));
00896     i = ObjectsInRec (RecH);
00897     debug_out (32, ("<-WptsInRteDB returns %d", i > 0 ? i - 1 : 0));
00898     return (i > 0 ? i - 1 : 0);                            /* # of waypoints = # of objects - 1 (header) */
00899 }
00900 
00901 #endif
00902 
00911 LocalFormatID
00912 PtrToCustomRteHdr (ObjectPtr recp, Custom_Rte_Hdr_Type * pcust)
00913 {
00914     debug (32, ("PtrToCustomRteHdr()"));
00915     if (!recp)
00916         return (Unknown);
00917     MemSet (pcust, sizeof (Custom_Rte_Hdr_Type), 0);
00918     switch (recp->header.type)
00919       {
00920       case G201Type:
00921           pcust->nmbr = recp->d.g.d201.nmbr;
00922           StrNCopySafe (pcust->cmnt, recp->d.g.d201.cmnt, sizeof (recp->d.g.d201.cmnt));
00923           return (G201Type);
00924 
00925       case G202Type:
00926           pcust->nmbr = 1;
00927           StrNCopySafe (pcust->cmnt, recp->d.g.d202.rte_ident, sizeof (pcust->cmnt));
00928           return (G202Type);
00929 
00930       case CustomRteHdr:
00931           MemMove (pcust, &recp->d.CustRteHdr, sizeof (Custom_Rte_Hdr_Type));
00932           return (CustomRteHdr);
00933 
00934       default:
00935           return (Unknown);
00936       }
00937 }                                                          /* PtrToCustomRteHdr */
00938 
00939 
00948 LocalFormatID
00949 HandleToCustomRteHdr (MemHandle RecH, Custom_Rte_Hdr_Type * pcust)
00950 {
00951     LocalFormatID f;
00952     MemPtr RecP;
00953 
00954     debug (32, ("HandleToCustomRteHdr()"));
00955     if (!RecH)
00956         return (Unknown);
00957     RecP = MemHandleLock (RecH);
00958     f = PtrToCustomRteHdr (RecP, pcust);
00959     MemHandleUnlock (RecH);
00960     return (f);
00961 }                                                          /* HandleToCustomRteHdr */
00962 
00963 
00973 ObjectPtr
00974 CustomToRteHdrObj (Custom_Rte_Hdr_Type * pcust, ObjectPtr o, LocalFormatID toformat)
00975 {
00976     debug (32, ("CustomToRteHdrObj()"));
00977     if (!pcust || !o)
00978         return (o);
00979 
00980     switch (toformat)
00981       {
00982       case G202Type:
00983           o->header.type = G202Type;
00984           StrNCopySafe (o->d.g.d202.rte_ident, pcust->cmnt, sizeof (o->d.g.d202.rte_ident));
00985           o->header.size = StrLen (o->d.g.d202.rte_ident);
00986           break;
00987 
00988       case G201Type:
00989       default:
00990           o->header.type = G201Type;
00991           o->header.size = sizeof (D201_Rte_Hdr_Type);
00992           o->d.g.d201.nmbr = pcust->nmbr;
00993           MemSet (o->d.g.d201.cmnt, sizeof (o->d.g.d201.cmnt), ' ');
00994           MemMove (o->d.g.d201.cmnt, pcust->cmnt,
00995                    min (StrLen (pcust->cmnt), sizeof (o->d.g.d201.cmnt)));
00996           break;
00997       }
00998     return (o);
00999 }                                                          /* CustomToRteHdrObj */
01000 
01001 
01011 ObjectPtr
01012 AnyToAnyRteHdr (ObjectPtr from, ObjectPtr to, LocalFormatID toformat)
01013 {
01014     Custom_Rte_Hdr_Type cust;
01015     //  ObjectPtr o;
01016 
01017     debug (32, ("AnyToAnyRteHdr()"));
01018     if (from->header.type == toformat)
01019         MemMove (to, from, SizeOfObject (from));
01020     else
01021       {
01022           PtrToCustomRteHdr (from, &cust);
01023           CustomToRteHdrObj (&cust, to, toformat);
01024       }
01025     return (to);
01026 }                                                          /* AnyToAnyRteHdr */
01027 
01028 
01029 
01030 
01031                       // *********  Track objects management :
01032 
01033 #if defined __palmos__
01034 
01042 UInt16
01043 TrkptsInTrkDB (MemHandle rech)
01044 {                                                          /* nombre de trackpoints dans une trace */
01045     ObjectPtr RecP;
01046     UInt32 size = 0;
01047     UInt16 n = 0;
01048 
01049     if (!rech)
01050         return (0);
01051     RecP = MemHandleLock (rech);
01052     if (RecP->d.CustTrkHdr.type == CustomTrkPt)
01053         size = sizeof (Custom_Trk_Point_Type);
01054     else if (RecP->d.CustTrkHdr.type == CompactTrkPt)
01055         size = sizeof (Compact_Trk_Point_Type);
01056     if (size)
01057         n = (MemHandleSize (rech) - SizeOfObject (RecP)) / size;
01058     //  return ((MemHandleSize (rech) - sizeof (Custom_Trk_Hdr_Type)-sizeof(((ObjectPtr)0)->header)) / sizeof (Custom_Trk_Point_Type))    ;
01059     MemHandleUnlock (rech);
01060     debug (32, ("TrkptsInTrkDB(%ld)->%d", rech, n));
01061     return (n);
01062 }               /* TrkptsInTrkDB */
01063 
01064 #endif
01065 
01074 void
01075 RawD301ToCustomTrkPt (Raw_D301_Trk_Point_Type * from, Custom_Trk_Point_Type * to)
01076 {
01077     LEtoHOST32 ((byte *) & (to->posn.lat), from->lat);     /* latitude */
01078     LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);     /* longitude */
01079     LEtoHOST32 ((byte *) & (to->time), from->time);                /* time */
01080     LEtoHOST32 ((byte *) & (to->alt), from->alt);                  /* altitude */
01081     to->new_trk = from->new_trk;
01082 }
01083 
01084 
01093 void
01094 RawD301ToCompactTrkPt (Raw_D301_Trk_Point_Type * from, Compact_Trk_Point_Type * to)
01095 {
01096     LEtoHOST32 ((byte *) & (to->posn.lat), from->lat);     /* latitude */
01097     LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);     /* longitude */
01098     to->new_trk = from->new_trk;
01099 }
01100 
01101 
01110 void
01111 RawD300ToCustomTrkPt (Raw_D300_Trk_Point_Type * from, Custom_Trk_Point_Type * to)
01112 {
01113     LEtoHOST32 ((byte *) & (to->posn.lat), from->lat);     /* latitude */
01114     LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);     /* longitude */
01115     LEtoHOST32 ((byte *) & (to->time), from->time);                /* time */
01116     to->alt = 1.0e25;
01117     to->new_trk = from->new_trk;
01118 }
01119 
01120 
01129 void
01130 RawD300ToCompactTrkPt (Raw_D300_Trk_Point_Type * from, Compact_Trk_Point_Type * to)
01131 {
01132     LEtoHOST32 ((byte *) & (to->posn.lat), from->lat);     /* latitude */
01133     LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);     /* longitude */
01134     to->new_trk = from->new_trk;
01135 }
01136 
01137 
01148 UInt16
01149 AnyRawToAnyTrkPt (LocalFormatID in_format, LocalFormatID out_format, GarminObject * from,
01150                   TrkPts * to)
01151 {
01152 
01153     if (out_format == CompactTrkPt)
01154       {                                                    /* format compact */
01155           switch (in_format)
01156             {
01157             case G301Type:
01158                 RawD301ToCompactTrkPt (&(from->d301), &(to->compact));
01159                 break;
01160             case G300Type:
01161                 RawD300ToCompactTrkPt (&(from->d300), &(to->compact));
01162                 break;
01163             default:
01164                 return (0);
01165             }
01166           return (sizeof (Compact_Trk_Point_Type));
01167       }
01168     else
01169       {                                                    /* format standard */
01170           switch (in_format)
01171             {
01172             case G301Type:
01173                 RawD301ToCustomTrkPt (&(from->d301), &(to->custom));
01174                 break;
01175             case G300Type:
01176                 RawD300ToCustomTrkPt (&(from->d300), &(to->custom));
01177                 break;
01178             default:
01179                 return (0);
01180             }
01181           return (sizeof (Custom_Trk_Point_Type));
01182       }
01183     return (0);
01184 }                                                          /* AnyRawToAnyTrkPt */
01185 
01186 
01195 void
01196 CustomToRawD301TrkPt (Custom_Trk_Point_Type * from, Raw_D301_Trk_Point_Type * to)
01197 {
01198     MemSet (to, sizeof (Raw_D301_Trk_Point_Type), 0);
01199     HOSTtoLE32 (to->lat, (byte *) & (from->posn.lat));
01200     HOSTtoLE32 (to->lon, (byte *) & (from->posn.lon));
01201     HOSTtoLE32 (to->time, (byte *) & (from->time));
01202     HOSTtoLE32 (to->alt, (byte *) & (from->alt));
01203     to->new_trk = from->new_trk;
01204 }
01205 
01206 
01215 void
01216 CompactToRawD301TrkPt (Compact_Trk_Point_Type * from, Raw_D301_Trk_Point_Type * to)
01217 {
01218     MemSet (to, sizeof (Raw_D301_Trk_Point_Type), 0);
01219     HOSTtoLE32 (to->lat, (byte *) & (from->posn.lat));
01220     HOSTtoLE32 (to->lon, (byte *) & (from->posn.lon));
01221     to->new_trk = from->new_trk;
01222 }
01223 
01224 
01233 void
01234 CustomToRawD300TrkPt (Custom_Trk_Point_Type * from, Raw_D300_Trk_Point_Type * to)
01235 {
01236     //  MemSet(to, sizeof(Raw_D301_Trk_Point_Type),0);
01237     HOSTtoLE32 (to->lat, (byte *) & (from->posn.lat));
01238     HOSTtoLE32 (to->lon, (byte *) & (from->posn.lon));
01239     HOSTtoLE32 (to->time, (byte *) & (from->time));
01240     to->new_trk = from->new_trk;
01241 }
01242 
01243 
01252 void
01253 CompactToRawD300TrkPt (Compact_Trk_Point_Type * from, Raw_D300_Trk_Point_Type * to)
01254 {
01255     MemSet (to, sizeof (Raw_D301_Trk_Point_Type), 0);
01256     HOSTtoLE32 (to->lat, (byte *) & (from->posn.lat));
01257     HOSTtoLE32 (to->lon, (byte *) & (from->posn.lon));
01258     to->new_trk = from->new_trk;
01259 }
01260 
01261 
01270 void
01271 CustomTrkHdrToD310 (ObjectPtr trkhdr, D310_Trk_Hdr_Type * d310)
01272 {
01273     d310->dspl = trkhdr->d.CustTrkHdr.dspl;
01274     d310->color = trkhdr->d.CustTrkHdr.color;
01275     StrNCopySafe (d310->trk_ident, trkhdr->d.CustTrkHdr.name, sizeof (d310->trk_ident));
01276 }
01277 
01278 
01288                       // *********  miscellaneous :
01289 
01290 #ifdef __m68000
01291 
01292 
01302 static void
01303 LEtoHOST32 (byte * pto, byte * pfrom)       /* swap of 4 bytes */
01304 {
01305     pto += 3;
01306     *(pto--) = *(pfrom++);
01307     *(pto--) = *(pfrom++);
01308     *(pto--) = *(pfrom++);
01309     *(pto--) = *(pfrom++);
01310 }
01311 
01312 
01321 static void
01322 LEtoHOST16 (byte * pto, byte * pfrom)       /* swap of 2 bytes */
01323 {
01324     *(pto + 1) = *(pfrom++);
01325     *pto = *pfrom;
01326 }
01327 
01328 #else  // i386
01329 
01330 static void
01331 LEtoHOST32 (byte * pto, byte * pfrom)       /* no-swap of 4 bytes */
01332 {
01333   UInt32 * fromp= (UInt32 *) pfrom;
01334   UInt32 * top = (UInt32 *)pto;
01335   *top=*fromp;
01336 }
01337 
01338 
01347 static void
01348 LEtoHOST16 (byte * pto, byte * pfrom)       /* no-swap of 2 bytes */
01349 {
01350     *pto = *(pfrom++);
01351     *(pto + 1) = *pfrom;
01352 }
01353 
01354 #endif
01355 
01363 Symbol_Type
01364 smblToSymbolType (byte smbl)
01365 {
01366     return (smbl2ST[smbl]);
01367 }
01368 
01369 
01378 byte
01379 SymbolTypeTosmbl (Symbol_Type smbl)
01380 {
01381     Int16 i;
01382 
01383     for (i = 0; i < 16; i++)
01384         if (smbl == smbl2ST[i])
01385             return (i);
01386     return (smbl_dot);
01387 }

Generated on Sun Aug 29 11:00:41 2004 for GPilotS by doxygen 1.3.4