00001
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifndef lint
00034 static char vcid[] = "$Id: objects.c,v 1.8 2004/06/13 07:44:46 clavelei Exp $";
00035 #endif
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 };
00055
00056
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
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;
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
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;
00182 StrNCopySafe (pcust->ident, p100->ident, i + 2);
00183 LEtoHOST32 ((byte *) & (pcust->posn.lat), p100->lat);
00184 LEtoHOST32 ((byte *) & (pcust->posn.lon), p100->lon);
00185 StrNCopySafe (pcust->cmnt, p100->cmnt, sizeof (p100->cmnt));
00186 return (sizeof (Custom_Wpt_Type));
00187 }
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), ' ');
00205 MemMove (p100->ident, pcust->ident, StrLen (pcust->ident));
00206 HOSTtoLE32 (p100->lat, (byte *) & (pcust->posn.lat));
00207 HOSTtoLE32 (p100->lon, (byte *) & (pcust->posn.lon));
00208 MemSet (p100->cmnt, sizeof (p100->cmnt), ' ');
00209 MemMove (p100->cmnt, pcust->cmnt, StrLen (pcust->cmnt));
00210 return (sizeof (Raw_D100_Wpt_Type));
00211 }
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);
00228 LEtoHOST16 ((byte *) & (pcust->smbl), p102->smbl);
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));
00247 HOSTtoLE16 (p102->smbl, (byte *) & (pcust->smbl));
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);
00267 pcust->dspl = p103->dspl;
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);
00286 p103->dspl = pcust->dspl;
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;
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;
00323 return (sizeof (Raw_D104_Wpt_Type));
00324 }
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);
00342 LEtoHOST32 ((byte *) & (pcust->posn.lon), p105->lon);
00343 LEtoHOST16 ((byte *) & (pcust->smbl), p105->smbl);
00344 StrNCopySafe (pcust->ident, p105->wpt_ident, sizeof (pcust->ident));
00345 return (sizeof (Custom_Wpt_Type));
00346 }
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));
00366 HOSTtoLE32 (p105->lat, (byte *) & (pcust->posn.lat));
00367 HOSTtoLE32 (p105->lon, (byte *) & (pcust->posn.lon));
00368 HOSTtoLE16 (p105->smbl, (byte *) & (pcust->smbl));
00369 return (p - (char *) p105);
00370 }
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);
00387 pcust->color = p107->color;
00388 return (sizeof (Custom_Wpt_Type));
00389 }
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));
00406 p107->color = pcust->color;
00407 return (sizeof (Raw_D107_Wpt_Type));
00408 }
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
00429 namep = (char *) (p108 + 1);
00430 if (StrLen (namep) < 51)
00431 {
00432 StrNCopySafe (pcust->ident, namep, sizeof (pcust->ident));
00433 commentp = namep + StrLen (namep) + 1;
00434 StrNCopySafe (pcust->cmnt, commentp, sizeof (pcust->cmnt));
00435 }
00436 LEtoHOST32 ((byte *) & (pcust->posn.lat), p108->lat);
00437 LEtoHOST32 ((byte *) & (pcust->posn.lon), p108->lon);
00438 LEtoHOST32 ((byte *) & (pcust->dst), p108->dist);
00439 LEtoHOST32 ((byte *) & (pcust->alt), p108->alt);
00440 LEtoHOST16 ((byte *) & (pcust->smbl), p108->smbl);
00441 pcust->dspl = p108->dspl;
00442 pcust->color = p108->color;
00443 return (sizeof (Custom_Wpt_Type));
00444 }
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;
00476 p += StrLen (p);
00477 p += StrLen (p);
00478 if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00479 StrNCopySafe (facility, p, sizeof (facility));
00480 p += StrLen (p);
00481 if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00482 StrNCopySafe (city, p, sizeof (city));
00483 p += StrLen (p);
00484 if (p < ((char *) p108 + sizeof (B108_Wpt_Type)))
00485 StrNCopySafe (addr, p, sizeof (addr));
00486 p += StrLen (p);
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));
00490 p = StrNCopySafe (p, pcust->cmnt, sizeof (p108->comment));
00491 p = StrNCopySafe (p, facility, sizeof (p108->facility));
00492 p = StrNCopySafe (p, city, sizeof (p108->city));
00493 p = StrNCopySafe (p, addr, sizeof (p108->addr));
00494 p = StrNCopySafe (p, cross_road, sizeof (p108->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));
00502 p = StrNCopySafe (p108->ident, pcust->ident, sizeof (p108->ident));
00503 p = StrNCopySafe (p, pcust->cmnt, sizeof (p108->comment));
00504 p += 4;
00505 }
00506 p108->w.color = pcust->color;
00507 p108->w.dspl = pcust->dspl;
00508 HOSTtoLE16 (p108->w.smbl, (byte *) & (pcust->smbl));
00509 HOSTtoLE32 (p108->w.lat, (byte *) & (pcust->posn.lat));
00510 HOSTtoLE32 (p108->w.lon, (byte *) & (pcust->posn.lon));
00511 HOSTtoLE32 (p108->w.dist, (byte *) & (pcust->dst));
00512 HOSTtoLE32 (p108->w.alt, (byte *) & (pcust->alt));
00513 return (p - (char *) p108);
00514 }
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));
00538 commentp = namep + StrLen (namep) + 1;
00539 StrNCopySafe (pcust->cmnt, commentp, sizeof (pcust->cmnt));
00540 }
00541 LEtoHOST32 ((byte *) & (pcust->posn.lat), p109->lat);
00542 LEtoHOST32 ((byte *) & (pcust->posn.lon), p109->lon);
00543 LEtoHOST32 ((byte *) & (pcust->dst), p109->dist);
00544 LEtoHOST32 ((byte *) & (pcust->alt), p109->alt);
00545 LEtoHOST16 ((byte *) & (pcust->smbl), p109->smbl);
00546 pcust->dspl = (p109->dspl_color & 0x60) >> 5;
00547 pcust->color = p109->dspl_color & 0xf;
00548 return (sizeof (Custom_Wpt_Type));
00549 }
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;
00581 p += StrLen (p);
00582 p += StrLen (p);
00583 if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00584 StrNCopySafe (facility, p, sizeof (facility));
00585 p += StrLen (p);
00586 if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00587 StrNCopySafe (city, p, sizeof (city));
00588 p += StrLen (p);
00589 if (p < ((char *) p109 + sizeof (B109_Wpt_Type)))
00590 StrNCopySafe (addr, p, sizeof (addr));
00591 p += StrLen (p);
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));
00595 p = StrNCopySafe (p, pcust->cmnt, sizeof (p109->comment));
00596 p = StrNCopySafe (p, facility, sizeof (p109->facility));
00597 p = StrNCopySafe (p, city, sizeof (p109->city));
00598 p = StrNCopySafe (p, addr, sizeof (p109->addr));
00599 p = StrNCopySafe (p, cross_road, sizeof (p109->cross_road));
00600 }
00601
00602 else
00603 {
00604 MemSet (p109, sizeof (B109_Wpt_Type), 0);
00605 p109->w.dtyp = 0x01;
00606 p109->w.attr = 0x70;
00607 (void) MemMove (p109->w.subclass, &default_subclass, sizeof (p109->w.subclass));
00608 MemSet (p109->w.ete, sizeof (p109->w.ete), 0xff);
00609 p = StrNCopySafe (p109->ident, pcust->ident, sizeof (p109->ident));
00610 p = StrNCopySafe (p, pcust->cmnt, sizeof (p109->comment));
00611 p += 4;
00612 }
00613 p109->w.dspl_color = pcust->color;
00614 p109->w.dspl_color |= (pcust->dspl << 5);
00615 HOSTtoLE16 (p109->w.smbl, (byte *) & (pcust->smbl));
00616 HOSTtoLE32 (p109->w.lat, (byte *) & (pcust->posn.lat));
00617 HOSTtoLE32 (p109->w.lon, (byte *) & (pcust->posn.lon));
00618 HOSTtoLE32 (p109->w.dist, (byte *) & (pcust->dst));
00619 HOSTtoLE32 (p109->w.alt, (byte *) & (pcust->alt));
00620 return (p - (char *) p109);
00621 }
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 }
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
00735
00736
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 }
00774
00775 return (0);
00776 }
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)
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 }
00838 return (to);
00839 }
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 }
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 }
00877
00878
00879
00880
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);
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 }
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 }
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 }
01000
01001
01011 ObjectPtr
01012 AnyToAnyRteHdr (ObjectPtr from, ObjectPtr to, LocalFormatID toformat)
01013 {
01014 Custom_Rte_Hdr_Type cust;
01015
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 }
01027
01028
01029
01030
01031
01032
01033 #if defined __palmos__
01034
01042 UInt16
01043 TrkptsInTrkDB (MemHandle rech)
01044 {
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
01059 MemHandleUnlock (rech);
01060 debug (32, ("TrkptsInTrkDB(%ld)->%d", rech, n));
01061 return (n);
01062 }
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);
01078 LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);
01079 LEtoHOST32 ((byte *) & (to->time), from->time);
01080 LEtoHOST32 ((byte *) & (to->alt), from->alt);
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);
01097 LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);
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);
01114 LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);
01115 LEtoHOST32 ((byte *) & (to->time), from->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);
01133 LEtoHOST32 ((byte *) & (to->posn.lon), from->lon);
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 {
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 {
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 }
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
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
01289
01290 #ifdef __m68000
01291
01292
01302 static void
01303 LEtoHOST32 (byte * pto, byte * pfrom)
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)
01323 {
01324 *(pto + 1) = *(pfrom++);
01325 *pto = *pfrom;
01326 }
01327
01328 #else // i386
01329
01330 static void
01331 LEtoHOST32 (byte * pto, byte * pfrom)
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)
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 }