Exemplo n.º 1
0
        static void ShowExtLineInfo(StringBuilder info,
                                    AllSubdivInfo asi,
                                    GarminCore.Files.StdFile_RGN rgn,
                                    TreeViewData tvd,
                                    NodeContent.Content4File filedata,
                                    int lineidx,
                                    int tab,
                                    out int hexlen,
                                    out long firsthexadr)
        {
            GarminCore.Files.StdFile_RGN.ExtRawPolyData poly = asi.GetExtLine(lineidx);
            GarminCore.DataBlock block = asi.GetDataBlock4ExtLine(lineidx);

            firsthexadr  = rgn.ExtLinesBlock.Offset;
            firsthexadr += block.Offset;
            hexlen       = (int)block.Length;

            info.AppendLine(FillWithSpace("Type             (1 Byte) (Bit 0..6)", tab, false, DecimalAndHexAndBinary(poly.Type)));
            info.AppendLine(FillWithSpace("Subtype          (1 Byte) (Bit 0..4)", tab, false, DecimalAndHexAndBinary(poly.Subtype)));
            info.AppendLine(FillWithSpace("HasLabel                  (Bit 5)", tab, false, poly.HasLabel.ToString()));
            info.AppendLine(FillWithSpace("HasUnknownFlag            (Bit 6)", tab, false, poly.HasUnknownFlag.ToString()));
            info.AppendLine(FillWithSpace("HasExtraBytes             (Bit 7)", tab, false, poly.HasExtraBytes.ToString()));
            info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLongitude.Value) + ", " + poly.RawDeltaLongitude.ValueDegree.ToString() + "°"));
            info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLatitude.Value) + ", " + poly.RawDeltaLatitude.ValueDegree.ToString() + "°"));
            info.AppendLine(FillWithSpace("RawBitStreamLengthBytes (" + poly.RawBitStreamLengthBytes.Length.ToString() + " Byte)", tab, false, HexString(poly.RawBitStreamLengthBytes)));
            info.AppendLine(FillWithSpace("   BitStreamLength", tab, false, poly.BitstreamLength.ToString()));
            info.AppendLine(FillWithSpace("BitstreamInfo    (1 Byte)", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo)));
            info.AppendLine(FillWithSpace("   basebits4lat", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo >> 4)));
            info.AppendLine(FillWithSpace("   basebits4lon", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo & 0xF)));
            if (poly.HasLabel)
            {
                info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(poly.LabelOffsetInLBL)));
                GarminCore.Files.StdFile_LBL lbl = tvd.GetLBL(filedata.Basename);
                if (lbl != null)
                {
                    info.AppendLine(FillWithSpace("   Text (from LBL)", tab, true, lbl.GetText(poly.LabelOffsetInLBL, true) + "'"));
                }
            }
            if (poly.HasExtraBytes)
            {
                int len = 7 + poly.RawBitStreamLengthBytes.Length;
                if (poly.HasLabel)
                {
                    len += 3;
                }
                filedata.BinaryReader.Seek(block.Offset + (uint)len);
                info.AppendLine(FillWithSpace("ExtraBytes", tab, false, HexString(filedata.BinaryReader.ReadBytes((int)block.Length - len))));
            }
            info.AppendLine("Deltas:");
            List <GarminCore.Files.StdFile_RGN.GeoDataBitstream.RawPoint> points = poly.GetRawPoints();

            for (int i = 0; i < points.Count; i++)
            {
                info.AppendLine("   " + points[i].ToString() + " / " + points[0].GetMapUnitPoint(rgn.TREFile.MaplevelList[asi.MaplevelNo].CoordBits, asi.SubdivfInfo.Center).ToString());
            }
        }
Exemplo n.º 2
0
        static void ShowExtPointInfo(StringBuilder info,
                                     AllSubdivInfo asi,
                                     GarminCore.Files.StdFile_RGN rgn,
                                     TreeViewData tvd,
                                     NodeContent.Content4File filedata,
                                     int pointidx,
                                     int tab,
                                     out int hexlen,
                                     out long firsthexadr)
        {
            GarminCore.Files.StdFile_RGN.ExtRawPointData point = asi.GetExtPoint(pointidx);
            GarminCore.DataBlock block = asi.GetDataBlock4ExtPoint(pointidx);

            firsthexadr  = rgn.ExtLinesBlock.Offset;
            firsthexadr += block.Offset;
            hexlen       = (int)block.Length;

            info.AppendLine(FillWithSpace("Type             (1 Byte) (Bit 0..6)", tab, false, DecimalAndHexAndBinary(point.Type)));
            info.AppendLine(FillWithSpace("Subtype          (1 Byte) (Bit 0..4)", tab, false, DecimalAndHexAndBinary(point.Subtype)));
            info.AppendLine(FillWithSpace("HasLabel                  (Bit 5)", tab, false, point.HasLabel.ToString()));
            info.AppendLine(FillWithSpace("HasUnknownFlag            (Bit 6)", tab, false, point.HasUnknownFlag.ToString()));
            info.AppendLine(FillWithSpace("HasExtraBytes             (Bit 7)", tab, false, point.HasExtraBytes.ToString()));
            info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLongitude.Value) + ", " + point.RawDeltaLongitude.ValueDegree.ToString() + "°"));
            info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLatitude.Value) + ", " + point.RawDeltaLatitude.ValueDegree.ToString() + "°"));
            if (point.HasLabel)
            {
                info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(point.LabelOffsetInLBL)));
                GarminCore.Files.StdFile_LBL lbl = tvd.GetLBL(filedata.Basename);
                if (lbl != null)
                {
                    info.AppendLine(FillWithSpace("   Text (from LBL)", tab, true, lbl.GetText(point.LabelOffsetInLBL, true)));
                }
            }
            if (point.HasExtraBytes)
            {
                int len = 6;
                if (point.HasLabel)
                {
                    len += 3;
                }
                filedata.BinaryReader.Seek(firsthexadr + (uint)len);
                info.AppendLine(FillWithSpace("ExtraBytes", tab, false, HexString(filedata.BinaryReader.ReadBytes(point.ExtraBytes))));
            }
            if (point.HasUnknownFlag)
            {
                info.AppendLine(FillWithSpace("UnknownKey", tab, false, HexString(point.UnknownKey)));
                if (point.UnknownBytes != null && point.UnknownBytes.Length > 0)
                {
                    info.AppendLine(FillWithSpace("UnknownBytes", tab, false, HexString(point.UnknownBytes)));
                }
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Funktion für alle TRE-Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_TRE tre = filedata.GetGarminFileAsTRE();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;
            GarminCore.Files.StdFile_LBL lbl;
            GarminCore.DataBlock         block;

            switch (nodetype)
            {
            case NodeContent.NodeType.TRE_DescriptionList:
                firsthexadr = tre.MapDescriptionBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("MapDescriptionList: " + tre.MapDescriptionList.Count.ToString());
                    info.AppendLine("  Block:            " + tre.MapDescriptionBlock.ToString());
                    hexlen = (int)tre.MapDescriptionBlock.Length;
                }
                else
                {
                    string mapdescription = tre.MapDescriptionList[idx];
                    info.AppendLine("MapDescription: " + tre.MapDescriptionList[idx]);
                    for (int i = 0; i < idx; i++)
                    {
                        firsthexadr += tre.MapDescriptionList[i].Length + 1;
                    }
                    hexlen = tre.MapDescriptionList[idx].Length + 1;
                }
                break;

            case NodeContent.NodeType.TRE_MaplevelBlock:
                firsthexadr = tre.MaplevelBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("Maplevel: " + tre.MaplevelList.Count.ToString());
                    info.AppendLine("  Block:  " + tre.MaplevelBlock.ToString());
                    hexlen = (int)tre.MaplevelBlock.Length;
                    if (hexlen > 0 && tre.MaplevelList.Count == 0)
                    {
                        info.AppendLine("data propably encrypted");
                    }
                }
                else
                {
                    GarminCore.Files.StdFile_TRE.MapLevel maplevel = tre.MaplevelList[idx];
                    info.AppendLine("SymbolicScaleDenominator (Bit 0..3):         " + DecimalAndHexAndBinary((ulong)maplevel.SymbolicScaleDenominator));
                    info.AppendLine("(SymbolicScaleDenominator) Bit 4:            " + maplevel.Bit4.ToString());
                    info.AppendLine("(SymbolicScaleDenominator) Bit 5:            " + maplevel.Bit5.ToString());
                    info.AppendLine("(SymbolicScaleDenominator) Bit 6:            " + maplevel.Bit6.ToString());
                    info.AppendLine("(SymbolicScaleDenominator) Bit 7, Inherited: " + maplevel.Inherited.ToString());
                    info.AppendLine("CoordBits (1 Byte):                          " + DecimalAndHexAndBinary((ulong)maplevel.CoordBits));
                    info.AppendLine("SubdivInfos (2 Byte):                        " + DecimalAndHexAndBinary(maplevel.SubdivInfos));
                    firsthexadr += idx * 4;
                    hexlen       = 4;
                }
                break;

            case NodeContent.NodeType.TRE_SubdivisionBlock:
                firsthexadr = tre.SubdivisionBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("Subdivision: " + tre.SubdivInfoList.Count.ToString());
                    info.AppendLine("  Block:     " + tre.SubdivisionBlock.ToString());
                    hexlen = (int)tre.SubdivisionBlock.Length;
                    if (hexlen > 0 && tre.MaplevelList.Count == 0)
                    {
                        info.AppendLine("data propably encrypted");
                    }
                }
                else
                {
                    block        = SampleInfo4SubdivInfo(info, tre, idx);
                    firsthexadr += block.Offset;
                    hexlen       = (int)block.Length;
                }
                break;

            case NodeContent.NodeType.TRE_CopyrightBlock:
                firsthexadr = tre.CopyrightBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("Copyrights: " + tre.CopyrightOffsetsList.Count.ToString());
                    info.AppendLine("  Block:    " + tre.CopyrightBlock.ToString());
                    hexlen = (int)tre.CopyrightBlock.Length;
                }
                else
                {
                    info.AppendLine("Offset in LBL (" + tre.CopyrightBlock.Recordsize.ToString() + " Byte): " + DecimalAndHexAndBinary(tre.CopyrightOffsetsList[idx]));
                    lbl = tvd.GetLBL(filedata.Basename);
                    if (lbl != null)
                    {
                        info.AppendLine("   Text (from LBL): '" + lbl.GetText(tre.CopyrightOffsetsList[idx], true) + "'");
                    }
                    firsthexadr += idx * tre.CopyrightBlock.Recordsize;
                    hexlen       = tre.CopyrightBlock.Recordsize;
                }
                break;

            case NodeContent.NodeType.TRE_LineOverviewBlock:
                firsthexadr = tre.LineOverviewBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("LineOverview: " + (tre.LineOverviewBlock.Length / tre.LineOverviewBlock.Recordsize).ToString());
                    info.AppendLine("  Block:      " + tre.LineOverviewBlock.ToString());
                    hexlen = (int)tre.LineOverviewBlock.Length;
                }
                else
                {
                    GarminCore.Files.StdFile_TRE.OverviewObject2Byte ov = tre.LineOverviewList[idx];
                    info.AppendLine("Type     (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.Type));
                    info.AppendLine("MaxLevel (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.MaxLevel));
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject3Byte ||
                        ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("SubType  (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject3Byte).SubType));
                    }
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("Unknown  (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject4Byte).Unknown));
                    }

                    firsthexadr += idx * tre.LineOverviewBlock.Recordsize;
                    hexlen       = tre.LineOverviewBlock.Recordsize;
                }
                break;

            case NodeContent.NodeType.TRE_AreaOverviewBlock:
                firsthexadr = tre.AreaOverviewBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("AreaOverview: " + (tre.AreaOverviewBlock.Length / tre.AreaOverviewBlock.Recordsize).ToString());
                    info.AppendLine("  Block:      " + tre.AreaOverviewBlock.ToString());
                    hexlen = (int)tre.AreaOverviewBlock.Length;
                }
                else
                {
                    GarminCore.Files.StdFile_TRE.OverviewObject2Byte ov = tre.AreaOverviewList[idx];
                    info.AppendLine("Type     (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.Type));
                    info.AppendLine("MaxLevel (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.MaxLevel));
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject3Byte ||
                        ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("SubType (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject3Byte).SubType));
                    }
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("Unknown (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject4Byte).Unknown));
                    }

                    firsthexadr = idx * tre.AreaOverviewBlock.Recordsize;
                    hexlen      = tre.AreaOverviewBlock.Recordsize;
                }
                break;

            case NodeContent.NodeType.TRE_PointOverviewBlock:
                firsthexadr = tre.PointOverviewBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("PointOverview: " + (tre.PointOverviewBlock.Length / tre.PointOverviewBlock.Recordsize).ToString());
                    info.AppendLine("  Block:       " + tre.PointOverviewBlock.ToString());
                    hexlen = (int)tre.PointOverviewBlock.Length;
                }
                else
                {
                    GarminCore.Files.StdFile_TRE.OverviewObject2Byte ov = tre.PointOverviewList[idx];
                    info.AppendLine("Type     (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.Type));
                    info.AppendLine("MaxLevel (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.MaxLevel));
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject3Byte ||
                        ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("SubType (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject3Byte).SubType));
                    }
                    if (ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                    {
                        info.AppendLine("Unknown (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject4Byte).Unknown));
                    }

                    firsthexadr = idx * tre.PointOverviewBlock.Recordsize;
                    hexlen      = tre.PointOverviewBlock.Recordsize;
                }
                break;

            case NodeContent.NodeType.TRE_ExtTypeOffsetsBlock:
                firsthexadr = tre.ExtTypeOffsetsBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("ExtTypeOffsets: " + (tre.ExtTypeOffsetsBlock.Length / tre.ExtTypeOffsetsBlock.Recordsize).ToString());
                    info.AppendLine("  Block:        " + tre.ExtTypeOffsetsBlock.ToString());
                    hexlen = (int)tre.ExtTypeOffsetsBlock.Length;
                }
                else
                {
                    firsthexadr += idx * tre.ExtTypeOffsetsBlock.Recordsize;
                    hexlen       = tre.ExtTypeOffsetsBlock.Recordsize;

                    GarminCore.Files.StdFile_TRE.ExtendedTypeOffsets extoffs = new GarminCore.Files.StdFile_TRE.ExtendedTypeOffsets();
                    filedata.BinaryReader.Seek(firsthexadr);
                    extoffs.Read(filedata.BinaryReader, tre.ExtTypeOffsetsBlock.Recordsize);
                    info.AppendLine("Offsets in RGN for each Subdiv");
                    info.AppendLine("AreasOffset  (4 Byte): " + DecimalAndHexAndBinary((ulong)extoffs.AreasOffset));
                    info.AppendLine("LinesOffset  (4 Byte): " + DecimalAndHexAndBinary((ulong)extoffs.LinesOffset));
                    info.AppendLine("PointsOffset (4 Byte): " + DecimalAndHexAndBinary((ulong)extoffs.PointsOffset));
                    if (extoffs.DataLength > 12)
                    {
                        info.AppendLine("Kinds (1 Byte): " + DecimalAndHexAndBinary((ulong)extoffs.Kinds));
                    }
                }
                break;

            case NodeContent.NodeType.TRE_ExtTypeOverviewsBlock:
                firsthexadr = tre.ExtTypeOverviewsBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("TRE_ExtTypeOverviews: " + (tre.ExtTypeOverviewsBlock.Length / tre.ExtTypeOverviewsBlock.Recordsize).ToString());
                    info.AppendLine("  Block:              " + tre.ExtTypeOverviewsBlock.ToString());
                    info.AppendLine("ExtLineOverviewList:  " + tre.ExtLineOverviewList.Count.ToString());
                    info.AppendLine("ExtAreaOverviewList:  " + tre.ExtAreaOverviewList.Count.ToString());
                    info.AppendLine("ExtPointOverviewList: " + tre.ExtPointOverviewList.Count.ToString());
                    hexlen = (int)tre.ExtTypeOverviewsBlock.Length;
                }
                else
                {
                    firsthexadr += idx * tre.ExtTypeOverviewsBlock.Recordsize;
                    hexlen       = tre.ExtTypeOverviewsBlock.Recordsize;

                    GarminCore.Files.StdFile_TRE.OverviewObject2Byte ov = null;
                    if (idx < tre.ExtLineCount && idx < tre.ExtLineOverviewList.Count)
                    {
                        info.AppendLine("ExtLine");
                        ov = tre.ExtLineOverviewList[idx];
                    }
                    else if (idx < tre.ExtLineCount + tre.ExtAreaCount && idx - tre.ExtLineOverviewList.Count < tre.ExtAreaOverviewList.Count)
                    {
                        idx -= tre.ExtLineCount;
                        info.AppendLine("ExtArea");
                        ov = tre.ExtAreaOverviewList[idx];
                    }
                    else if (idx - tre.ExtLineOverviewList.Count - tre.ExtAreaOverviewList.Count < tre.ExtPointOverviewList.Count)
                    {
                        idx -= tre.ExtLineCount + tre.ExtAreaCount;
                        info.AppendLine("ExtPoint");
                        ov = tre.ExtPointOverviewList[idx];
                    }
                    if (ov != null)
                    {
                        info.AppendLine("Type     (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.Type));
                        info.AppendLine("MaxLevel (1 Byte): " + DecimalAndHexAndBinary((ulong)ov.MaxLevel));
                        info.AppendLine("SubType  (1 Byte): " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject3Byte).SubType));
                        if (ov is GarminCore.Files.StdFile_TRE.OverviewObject4Byte)
                        {
                            info.AppendLine("Unknown (1 Byte):  " + DecimalAndHexAndBinary((ulong)(ov as GarminCore.Files.StdFile_TRE.OverviewObject4Byte).Unknown));
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TRE_UnknownBlock_xAE:
                if (idx < 0)
                {
                    info.AppendLine("UnknownBlock 0xAE: " + tre.UnknownBlock_xAE.ToString());
                    firsthexadr = tre.UnknownBlock_xAE.Offset;
                    hexlen      = (int)tre.UnknownBlock_xAE.Length;
                }
                else
                {
                }
                break;

            case NodeContent.NodeType.TRE_UnknownBlock_xBC:
                if (idx < 0)
                {
                    info.AppendLine("UnknownBlock 0xBC: " + tre.UnknownBlock_xBC.ToString());
                    firsthexadr = tre.UnknownBlock_xAE.Offset;
                    hexlen      = (int)tre.UnknownBlock_xAE.Length;
                }
                else
                {
                }
                break;

            case NodeContent.NodeType.TRE_UnknownBlock_xE3:
                if (idx < 0)
                {
                    info.AppendLine("UnknownBlock 0xE3: " + tre.UnknownBlock_xE3.ToString());
                    firsthexadr = tre.UnknownBlock_xAE.Offset;
                    hexlen      = (int)tre.UnknownBlock_xAE.Length;
                }
                else
                {
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.File_MPS mps = filedata.GetGarminFileAsMPS();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;
            GarminCore.DataBlock block;

            switch (nodetype)
            {
            case NodeContent.NodeType.MPS_MapEntry:
                if (idx < 0)
                {
                    info.AppendLine("MapEntrys: " + mps.Maps.Count);
                }
                else
                {
                    block       = MapEntryBlock(mps, idx);
                    firsthexadr = block.Offset;
                    hexlen      = (int)block.Length;

                    GarminCore.Files.File_MPS.MapEntry mapentry = mps.Maps[idx];
                    info.AppendLine("Typ         (1 Byte): " + mapentry.Typ + " / " + DecimalAndHexAndBinary((byte)mapentry.Typ));
                    info.AppendLine("BlockLength (2 Byte): " + DecimalAndHexAndBinary(block.Length - 3));
                    switch (mapentry.Typ)
                    {
                    case 'L':
                        info.AppendLine("ProductID   (2 Byte): " + DecimalAndHexAndBinary(mapentry.ProductID));
                        info.AppendLine("FamilyID    (2 Byte): " + DecimalAndHexAndBinary(mapentry.FamilyID));
                        info.AppendLine("MapNumber   (2 Byte): " + DecimalAndHexAndBinary(mapentry.MapNumber));
                        info.AppendLine("Names:");
                        for (int i = 0; i < mapentry.Name.Count; i++)
                        {
                            info.AppendLine("            (" + (mapentry.Name[i].Length + 1).ToString() + " Byte): '" + mapentry.Name[i] + "'");
                        }
                        info.AppendLine("Unknown0    (4 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown0));
                        info.AppendLine("Unknown1    (4 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown1));
                        break;

                    case 'P':
                        info.AppendLine("ProductID   (2 Byte): " + DecimalAndHexAndBinary(mapentry.ProductID));
                        info.AppendLine("FamilyID    (2 Byte): " + DecimalAndHexAndBinary(mapentry.FamilyID));
                        info.AppendLine("Unknown2    (2 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown2));
                        info.AppendLine("Unknown3    (2 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown3));
                        info.AppendLine("Unknown4    (2 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown4));
                        break;

                    case 'F':
                        info.AppendLine("ProductID   (2 Byte): " + DecimalAndHexAndBinary(mapentry.ProductID));
                        info.AppendLine("FamilyID    (2 Byte): " + DecimalAndHexAndBinary(mapentry.FamilyID));
                        info.AppendLine("Names:");
                        for (int i = 0; i < mapentry.Name.Count; i++)
                        {
                            info.AppendLine("            (" + (mapentry.Name[i].Length + 1).ToString() + " Byte): '" + mapentry.Name[i] + "'");
                        }
                        break;

                    case 'V':
                        info.AppendLine("Names:");
                        for (int i = 0; i < mapentry.Name.Count; i++)
                        {
                            info.AppendLine("            (" + (mapentry.Name[i].Length + 1).ToString() + " Byte): '" + mapentry.Name[i] + "'");
                        }
                        info.AppendLine("Unknown5    (1 Byte): " + DecimalAndHexAndBinary(mapentry.Unknown5));
                        break;

                    default:
                        break;
                    }
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.File_TDB tdb = filedata.GetGarminFileAsTDB();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;
            GarminCore.DataBlock block;

            switch (nodetype)
            {
            case NodeContent.NodeType.TDB_Header:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Header);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;

                info.AppendLine("ProductID             (2 Byte): " + DecimalAndHexAndBinary(tdb.Head.ProductID));
                info.AppendLine("FamilyID              (2 Byte): " + DecimalAndHexAndBinary(tdb.Head.FamilyID));
                info.AppendLine("TDBVersion            (2 Byte): " + DecimalAndHexAndBinary(tdb.Head.TDBVersion));
                info.AppendLine("MapSeriesName         (" + (tdb.Head.MapSeriesName.Length + 1).ToString() + " Byte): '" + tdb.Head.MapSeriesName + "'");
                info.AppendLine("ProductVersion        (2 Byte): " + DecimalAndHexAndBinary(tdb.Head.ProductVersion));
                info.AppendLine("MapFamilyName         (" + (tdb.Head.MapFamilyName.Length + 1).ToString() + " Byte): '" + tdb.Head.MapFamilyName + "'");
                if (tdb.Head.TDBVersion >= 407)
                {
                    info.AppendLine("Unknown1              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown1));
                    info.AppendLine("MaxCoordbits4Overview (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.MaxCoordbits4Overview));
                    info.AppendLine("Unknown2              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown2));
                    info.AppendLine("Unknown3              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown3));
                    info.AppendLine("Unknown4              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown4));
                    info.AppendLine("Unknown5              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown5));
                    info.AppendLine("Unknown6              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown6));
                    info.AppendLine("Unknown7              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown7));
                    info.AppendLine("Unknown8              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown8));
                    info.AppendLine("Unknown9              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown9));
                    info.AppendLine("HighestRoutable       (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.HighestRoutable));
                    info.AppendLine("Unknown10             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown10));
                    info.AppendLine("Unknown11             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown11));
                    info.AppendLine("Unknown12             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown12));
                    info.AppendLine("Unknown13             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown13));
                    info.AppendLine("Unknown14             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown14));
                    info.AppendLine("Unknown15             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown15));
                    info.AppendLine("Unknown16             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown16));
                    info.AppendLine("Unknown17             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown17));
                    info.AppendLine("Unknown18             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown18));
                    info.AppendLine("Unknown19             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown19));
                    info.AppendLine("Unknown20             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown20));
                    info.AppendLine("Unknown21             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown21));
                    info.AppendLine("Unknown22             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown22));
                    info.AppendLine("Unknown23             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown23));
                    info.AppendLine("Unknown24             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown24));
                    info.AppendLine("Unknown25             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown25));
                    info.AppendLine("Unknown26             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown26));
                    info.AppendLine("Unknown27             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown27));
                    info.AppendLine("Unknown28             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown28));
                    info.AppendLine("CodePage              (4 Byte): " + DecimalAndHexAndBinary(tdb.Head.CodePage));
                    info.AppendLine("Unknown29             (4 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown29));
                    info.AppendLine("Routable              (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Routable));
                    info.AppendLine("HasProfileInformation (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.HasProfileInformation));
                    info.AppendLine("HasDEM                (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.HasDEM));
                    if (tdb.Head.TDBVersion >= 411)
                    {
                        info.AppendLine("Unknown30             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown30));
                        info.AppendLine("Unknown31             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown31));
                        info.AppendLine("Unknown32             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown32));
                        info.AppendLine("Unknown33             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown33));
                        info.AppendLine("Unknown34             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown34));
                        info.AppendLine("Unknown35             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown35));
                        info.AppendLine("Unknown36             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown36));
                        info.AppendLine("Unknown37             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown37));
                        info.AppendLine("Unknown38             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown38));
                        info.AppendLine("Unknown39             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown39));
                        info.AppendLine("Unknown40             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown40));
                        info.AppendLine("Unknown41             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown41));
                        info.AppendLine("Unknown42             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown42));
                        info.AppendLine("Unknown43             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown43));
                        info.AppendLine("Unknown44             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown44));
                        info.AppendLine("Unknown45             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown45));
                        info.AppendLine("Unknown46             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown46));
                        info.AppendLine("Unknown47             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown47));
                        info.AppendLine("Unknown48             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown48));
                        info.AppendLine("Unknown49             (1 Byte): " + DecimalAndHexAndBinary(tdb.Head.Unknown49));
                    }
                }
                break;

            case NodeContent.NodeType.TDB_Copyright:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Copyright);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;
                if (idx < 0)
                {
                    info.AppendLine("Segmente: " + tdb.Copyright.Segments.Count.ToString());
                }
                else
                {
                    GarminCore.Files.File_TDB.SegmentedCopyright.Segment segment = tdb.Copyright.Segments[idx];
                    info.AppendLine("CopyrightCode   (1 Byte): " + segment.CopyrightCode.ToString() + " / " + DecimalAndHexAndBinary((byte)segment.CopyrightCode));
                    info.AppendLine("WhereCode       (1 Byte): " + segment.WhereCode.ToString() + " / " + DecimalAndHexAndBinary((byte)segment.WhereCode));
                    info.AppendLine("ExtraProperties (2 Byte): " + DecimalAndHexAndBinary(segment.ExtraProperties));
                    info.AppendLine("Copyright       (" + (segment.Copyright.Length + 1).ToString() + " Byte): '" + segment.Copyright + "'");
                    for (int i = 0; i < tdb.Copyright.Segments.Count && i < idx; i++)
                    {
                        firsthexadr += (uint)(4 + tdb.Copyright.Segments[i].Copyright.Length + 1);
                    }
                    hexlen = 4 + segment.Copyright.Length + 1;
                }
                break;

            case NodeContent.NodeType.TDB_Crc:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Crc);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;
                info.AppendLine("Unknown1 (2 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown1));
                info.AppendLine("A        (1 Byte): " + DecimalAndHexAndBinary(tdb.Crc.A));
                info.AppendLine("Unknown2 (4 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown2));
                info.AppendLine("Unknown3 (2 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown3));
                info.AppendLine("B        (1 Byte): " + DecimalAndHexAndBinary(tdb.Crc.B));
                info.AppendLine("Unknown4 (2 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown4));
                info.AppendLine("C        (1 Byte): " + DecimalAndHexAndBinary(tdb.Crc.C));
                info.AppendLine("Unknown5 (4 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown5));
                info.AppendLine("D        (1 Byte): " + DecimalAndHexAndBinary(tdb.Crc.D));
                info.AppendLine("Unknown6 (2 Byte): " + DecimalAndHexAndBinary(tdb.Crc.Unknown6));
                break;

            case NodeContent.NodeType.TDB_Description:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Description);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;
                info.AppendLine("Unknown1       (1 Byte): " + DecimalAndHexAndBinary(tdb.Mapdescription.Unknown1));
                info.AppendLine("Mapdescription (" + (tdb.Mapdescription.Text.Length + 1).ToString() + " Byte): '" + tdb.Mapdescription.Text + "'");
                break;

            case NodeContent.NodeType.TDB_Overviewmap:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Overviewmap);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;
                info.AppendLine("Mapnumber       (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.Mapnumber));
                info.AppendLine("ParentMapnumber (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.ParentMapnumber));
                info.AppendLine("North           (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.north) + "; " + tdb.Overviewmap.North.ToString() + "°");
                info.AppendLine("East            (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.east) + "; " + tdb.Overviewmap.East.ToString() + "°");
                info.AppendLine("South           (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.south) + "; " + tdb.Overviewmap.South.ToString() + "°");
                info.AppendLine("West            (4 Byte): " + DecimalAndHexAndBinary(tdb.Overviewmap.west) + "; " + tdb.Overviewmap.West.ToString() + "°");
                info.AppendLine("Description     (" + (tdb.Overviewmap.Description.Length + 1).ToString() + " Byte): '" + tdb.Overviewmap.Description + "'");
                break;

            case NodeContent.NodeType.TDB_Tilemap:
                if (idx < 0)
                {
                    info.AppendLine("Tilemaps: " + tdb.Tilemap.Count);
                }
                else
                {
                    block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Tilemap, idx);
                    firsthexadr = block.Offset;
                    hexlen      = (int)block.Length;

                    int readlen = 0;
                    GarminCore.Files.File_TDB.TileMap tilemap = tdb.Tilemap[idx];
                    info.AppendLine("Mapnumber       (4 Byte): " + DecimalAndHexAndBinary(tilemap.Mapnumber));
                    info.AppendLine("ParentMapnumber (4 Byte): " + DecimalAndHexAndBinary(tilemap.ParentMapnumber));
                    info.AppendLine("North           (4 Byte): " + DecimalAndHexAndBinary(tilemap.north) + "; " + tilemap.North.ToString() + "°");
                    info.AppendLine("East            (4 Byte): " + DecimalAndHexAndBinary(tilemap.east) + "; " + tilemap.East.ToString() + "°");
                    info.AppendLine("South           (4 Byte): " + DecimalAndHexAndBinary(tilemap.south) + "; " + tilemap.South.ToString() + "°");
                    info.AppendLine("West            (4 Byte): " + DecimalAndHexAndBinary(tilemap.west) + "; " + tilemap.West.ToString() + "°");
                    readlen += 6 * 4;
                    info.AppendLine("Description     (" + (tilemap.Description.Length + 1).ToString() + " Byte): '" + tilemap.Description + "'");
                    readlen += tilemap.Description.Length + 1;
                    info.AppendLine("Unknown1        (2 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown1));
                    info.AppendLine("SubCount        (2 Byte): " + DecimalAndHexAndBinary(tilemap.SubCount));
                    info.AppendLine("Size:");
                    for (int i = 0; i < tilemap.DataSize.Count; i++)
                    {
                        info.AppendLine("                (4 Byte): " + DecimalAndHexAndBinary(tilemap.DataSize[i]));
                    }
                    readlen += 2 * 2 + tilemap.DataSize.Count * 4;
                    if (block.Length - readlen >= 7)
                    {
                        info.AppendLine("HasCopyright    (1 Byte): " + DecimalAndHexAndBinary(tilemap.HasCopyright));
                        info.AppendLine("Unknown2        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown2));
                        info.AppendLine("Unknown3        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown3));
                        info.AppendLine("Unknown4        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown4));
                        info.AppendLine("Unknown5        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown5));
                        info.AppendLine("Unknown6        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown6));
                        info.AppendLine("Unknown7        (1 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown7));
                        readlen += 7;
                        if (block.Length - readlen > 0)
                        {
                            info.AppendLine("Name:");
                            for (int i = 0; i < tilemap.Name.Count; i++)
                            {
                                info.AppendLine("                (" + (tilemap.Name[i].Length + 1).ToString() + " Byte): '" + tilemap.Name[i] + "'");
                            }
                            if (block.Length - readlen >= 2)
                            {
                                info.AppendLine("Unknown8        (8 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown8));
                                info.AppendLine("Unknown9        (9 Byte): " + DecimalAndHexAndBinary(tilemap.Unknown9));
                            }
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TDB_Unknown:
                block       = TDBBlock(tdb, GarminCore.Files.File_TDB.BlockHeader.Typ.Unknown);
                firsthexadr = block.Offset;
                hexlen      = (int)block.Length;
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Funktion für alle RGN-Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype"></param>
        /// <param name="idx"></param>
        /// <param name="tvd"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_RGN rgn = filedata.GetGarminFileAsRGN(tvd.GetTRE(filedata.Basename));
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;
            AllSubdivInfo asi = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.RGN_PostHeaderData:
                firsthexadr = rgn.PostHeaderDataBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("PostHeaderDataBlock: " + rgn.PostHeaderDataBlock.ToString());
                    hexlen = (int)rgn.PostHeaderDataBlock.Length;
                }
                break;

            case NodeContent.NodeType.RGN_SubdivContentBlock:
                firsthexadr = rgn.SubdivContentBlock.Offset;
                if (idx < 0)
                {
                    int tab = 22;
                    info.AppendLine(FillWithSpace("SubdivContent", tab, false, rgn.SubdivList.Count.ToString()));
                    info.AppendLine(FillWithSpace("  Block", tab, false, rgn.SubdivContentBlock.ToString()));
                    hexlen = (int)rgn.SubdivContentBlock.Length;
                    if (hexlen > 0 && rgn.SubdivList.Count == 0)
                    {
                        info.AppendLine("data propably encrypted");
                    }
                }
                else
                {
                    asi = new AllSubdivInfo(rgn, filedata.BinaryReader, idx);

                    info.AppendLine("Info from TRE:");
                    DataTRE.SampleInfo4SubdivInfo(info, rgn.TREFile, idx);
                    info.AppendLine();

                    info.AppendLine("Info from RGN:");
                    GarminCore.DataBlock block = SampleInfo4SubdivData(info, rgn, asi);
                    firsthexadr += block.Offset;
                    hexlen       = (int)block.Length;
                }
                break;

            case NodeContent.NodeType.RGN_ExtAreasBlock:
                firsthexadr = rgn.ExtAreasBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("ExtAreas");
                    info.AppendLine("  Block:  " + rgn.ExtAreasBlock.ToString());
                    hexlen = (int)rgn.ExtAreasBlock.Length;
                }
                else
                {
                    int subdividx = -1;
                    int count     = 0;
                    idx &= RGN_IDX_MASK; // Gesamt-Index des ExtArea
                    for (subdividx = 0; subdividx < rgn.SubdivList.Count; subdividx++)
                    {
                        count += rgn.SubdivList[subdividx].ExtAreaList.Count;
                        if (idx < count)
                        {
                            break;
                        }
                    }
                    if (subdividx < rgn.SubdivList.Count)
                    {
                        asi = new AllSubdivInfo(rgn, filedata.BinaryReader, subdividx);
                        int idx2 = asi.SubdivData.ExtAreaList.Count - (count - idx);
                        info.AppendLine("ExtArea " + idx2.ToString() + " from Subdiv " + subdividx.ToString());
                        ShowExtAreaInfo(info, asi, rgn, tvd, filedata, idx2, 40, out hexlen, out firsthexadr);
                    }
                }
                break;

            case NodeContent.NodeType.RGN_ExtLinesBlock:
                firsthexadr = rgn.ExtLinesBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("ExtLines");
                    info.AppendLine("  Block:  " + rgn.ExtLinesBlock.ToString());
                    hexlen = (int)rgn.ExtLinesBlock.Length;
                }
                else
                {
                    int subdividx = -1;
                    int count     = 0;
                    idx &= RGN_IDX_MASK; // Gesamt-Index des ExtArea
                    for (subdividx = 0; subdividx < rgn.SubdivList.Count; subdividx++)
                    {
                        count += rgn.SubdivList[subdividx].ExtLineList.Count;
                        if (idx < count)
                        {
                            break;
                        }
                    }
                    if (subdividx < rgn.SubdivList.Count)
                    {
                        asi = new AllSubdivInfo(rgn, filedata.BinaryReader, subdividx);
                        int idx2 = asi.SubdivData.ExtLineList.Count - (count - idx);
                        info.AppendLine("ExtLine " + idx2.ToString() + " from Subdiv " + subdividx.ToString());
                        ShowExtLineInfo(info, asi, rgn, tvd, filedata, idx2, 40, out hexlen, out firsthexadr);
                    }
                }
                break;

            case NodeContent.NodeType.RGN_ExtPointsBlock:
                firsthexadr = rgn.ExtPointsBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("ExtPoints");
                    info.AppendLine("  Block:  " + rgn.ExtPointsBlock.ToString());
                    hexlen = (int)rgn.ExtPointsBlock.Length;
                }
                else
                {
                    int subdividx = -1;
                    int count     = 0;
                    idx &= RGN_IDX_MASK; // Gesamt-Index des ExtArea
                    for (subdividx = 0; subdividx < rgn.SubdivList.Count; subdividx++)
                    {
                        count += rgn.SubdivList[subdividx].ExtPointList.Count;
                        if (idx < count)
                        {
                            break;
                        }
                    }
                    if (subdividx < rgn.SubdivList.Count)
                    {
                        asi = new AllSubdivInfo(rgn, filedata.BinaryReader, subdividx);
                        int idx2 = asi.SubdivData.ExtPointList.Count - (count - idx);
                        info.AppendLine("ExtPoint " + idx2.ToString() + " from Subdiv " + subdividx.ToString());
                        ShowExtPointInfo(info, asi, rgn, tvd, filedata, idx2, 40, out hexlen, out firsthexadr);
                    }
                }
                break;

            case NodeContent.NodeType.RGN_UnknownBlock_0x71:
                firsthexadr = rgn.UnknownBlock_0x71.Offset;
                if (idx < 0)
                {
                    info.AppendLine("UnknownBlock 0x71");
                    info.AppendLine("  Block:  " + rgn.UnknownBlock_0x71.ToString());
                    hexlen = (int)rgn.UnknownBlock_0x71.Length;
                }
                break;

            case NodeContent.NodeType.Index:
                if (tvd.TreeView.SelectedNode != null)
                {
                    int subdividx = -1;

                    // etwas tricky ...
                    NodeContent nc = NodeContent4TreeNode(tvd.TreeView.SelectedNode.Parent);
                    switch (nc.Type)
                    {
                    case NodeContent.NodeType.Index:  // wenn der übergeordnete Knoten ein Index ist, dann ist es ein Subdiv-Index
                        subdividx = (int)nc.Data;
                        if (subdividx >= 0)
                        {
                            asi = new AllSubdivInfo(rgn, filedata.BinaryReader, subdividx);
                        }
                        break;
                    }
                }

                if (asi != null)
                {
                    if ((idx & RGN_IDX_POINT1) != 0)
                    {
                        idx &= RGN_IDX_MASK;
                        int tab = 40;

                        GarminCore.Files.StdFile_RGN.RawPointData point = asi.GetPoint(idx);
                        GarminCore.Files.StdFile_LBL lbl = tvd.GetLBL(filedata.Basename);

                        info.AppendLine(FillWithSpace("Type             (1 Byte)", tab, false, DecimalAndHexAndBinary(point.Type)));
                        info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(point.LabelOffsetInLBL)));
                        if (lbl != null)
                        {
                            info.AppendLine(FillWithSpace("   Text (from LBL)", tab, true, point.GetText(lbl, true)));
                        }
                        info.AppendLine(FillWithSpace("HasSubtype                (Bit 23)", tab, false, point.HasSubtype.ToString()));
                        info.AppendLine(FillWithSpace("IsPoiOffset               (Bit 22)", tab, false, point.IsPoiOffset.ToString()));
                        info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLongitude.Value) + ", " + point.RawDeltaLongitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLatitude.Value) + ", " + point.RawDeltaLatitude.ValueDegree.ToString() + "°"));
                        if (point.HasSubtype)
                        {
                            info.AppendLine(FillWithSpace("Subtype        (1 Byte)", tab, false, DecimalAndHexAndBinary(point.Subtype)));
                        }

                        GarminCore.DataBlock block = asi.GetDataBlock4Object(GarminCore.Files.StdFile_TRE.SubdivInfoBasic.SubdivContent.poi, idx);
                        firsthexadr  = rgn.SubdivContentBlock.Offset;
                        firsthexadr += block.Offset;
                        hexlen       = (int)block.Length;
                    }
                    else if ((idx & RGN_IDX_POINT2) != 0)
                    {
                        idx &= RGN_IDX_MASK;
                        int tab = 40;

                        GarminCore.Files.StdFile_RGN.RawPointData point = asi.GetIdxPoint(idx);
                        GarminCore.Files.StdFile_LBL lbl = tvd.GetLBL(filedata.Basename);

                        info.AppendLine(FillWithSpace("Type             (1 Byte)", tab, false, DecimalAndHexAndBinary(point.Type)));
                        info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(point.LabelOffsetInLBL)));
                        if (lbl != null)
                        {
                            info.AppendLine(FillWithSpace("   Text (from LBL)", tab, true, point.GetText(lbl, true)));
                        }
                        info.AppendLine(FillWithSpace("HasSubtype                (Bit 23)", tab, false, point.HasSubtype.ToString()));
                        info.AppendLine(FillWithSpace("IsPoiOffset               (Bit 22)", tab, false, point.IsPoiOffset.ToString()));
                        info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLongitude.Value) + ", " + point.RawDeltaLongitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)point.RawDeltaLatitude.Value) + ", " + point.RawDeltaLatitude.ValueDegree.ToString() + "°"));
                        if (point.HasSubtype)
                        {
                            info.AppendLine(FillWithSpace("Subtype          (1 Byte)", tab, false, DecimalAndHexAndBinary(point.Subtype)));
                        }

                        GarminCore.DataBlock block = asi.GetDataBlock4Object(GarminCore.Files.StdFile_TRE.SubdivInfoBasic.SubdivContent.idxpoi, idx);
                        firsthexadr  = rgn.SubdivContentBlock.Offset;
                        firsthexadr += block.Offset;
                        hexlen       = (int)block.Length;
                    }
                    else if ((idx & RGN_IDX_LINE) != 0)
                    {
                        idx &= RGN_IDX_MASK;
                        int tab = 40;

                        GarminCore.Files.StdFile_RGN.RawPolyData poly = asi.GetLine(idx);
                        GarminCore.Files.StdFile_LBL             lbl  = tvd.GetLBL(filedata.Basename);
                        GarminCore.Files.StdFile_NET             net  = tvd.GetNET(filedata.Basename);

                        info.AppendLine(FillWithSpace("Type             (1 Byte) (Bit 0..5)", tab, false, DecimalAndHexAndBinary(poly.Type)));
                        info.AppendLine(FillWithSpace("TwoByteLength             (Bit 7)", tab, false, poly.TwoByteLength.ToString()));
                        if (!poly.IsPolygon)
                        {
                            info.AppendLine(FillWithSpace("Direction                 (Bit 6)", tab, false, poly.DirectionIndicator.ToString()));
                        }
                        info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(poly.LabelOffsetInLBL)));

                        if (!poly.LabelInNET)
                        {
                            if (lbl != null)
                            {
                                info.AppendLine(FillWithSpace("Text (from LBL)", tab, true, poly.GetText(lbl, true)));
                            }
                        }
                        else
                        {
                            if (net != null)
                            {
                                GarminCore.Files.StdFile_NET.RoadData rd = net.GetRoadData(poly.LabelOffsetInLBL);
                                if (rd != null)
                                {
                                    info.AppendLine(FillWithSpace("Text (from NET, LBL)", tab, true, rd.GetText(lbl, true)));
                                }
                            }
                        }

                        info.AppendLine(FillWithSpace("WithExtraBit              (Bit 22)", tab, false, poly.WithExtraBit.ToString()));
                        info.AppendLine(FillWithSpace("LabelInNET                (Bit 23)", tab, false, poly.LabelInNET.ToString()));
                        info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLongitude.Value) + ", " + poly.RawDeltaLongitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLatitude.Value) + ", " + poly.RawDeltaLatitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("BitstreamInfo    (1 Byte)", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo)));
                        info.AppendLine(FillWithSpace("   basebits4lat", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo >> 4)));
                        info.AppendLine(FillWithSpace("   basebits4lon", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo & 0xF)));
                        info.AppendLine(FillWithSpace("BitstreamLength (" + (poly.TwoByteLength ? "2" : "1") + " Byte)", tab, false, DecimalAndHexAndBinary(poly.bitstream.Length)));
                        if (poly.WithExtraBit)
                        {
                            info.AppendLine(FillWithSpace("ExtraBitList", tab, false, AllSubdivInfo.ExtraBits(poly)));
                        }
                        info.AppendLine("Deltas:");
                        List <GarminCore.Files.StdFile_RGN.GeoDataBitstream.RawPoint> points = poly.GetRawPoints();
                        for (int i = 0; i < points.Count; i++)
                        {
                            info.AppendLine("   " + points[i].ToString() + " / " + points[0].GetMapUnitPoint(rgn.TREFile.MaplevelList[asi.MaplevelNo].CoordBits, asi.SubdivfInfo.Center).ToString());
                        }

                        GarminCore.DataBlock block = asi.GetDataBlock4Object(GarminCore.Files.StdFile_TRE.SubdivInfoBasic.SubdivContent.line, idx);
                        firsthexadr  = rgn.SubdivContentBlock.Offset;
                        firsthexadr += block.Offset;
                        hexlen       = (int)block.Length;
                    }
                    else if ((idx & RGN_IDX_AREA) != 0)
                    {
                        idx &= RGN_IDX_MASK;
                        int tab = 40;

                        GarminCore.Files.StdFile_RGN.RawPolyData poly = asi.GetArea(idx);
                        GarminCore.Files.StdFile_LBL             lbl  = tvd.GetLBL(filedata.Basename);
                        GarminCore.Files.StdFile_NET             net  = tvd.GetNET(filedata.Basename);

                        info.AppendLine(FillWithSpace("Type             (1 Byte) (Bit 0..6) ", tab, false, DecimalAndHexAndBinary(poly.Type)));
                        info.AppendLine(FillWithSpace("TwoByteLength             (Bit 7)", tab, false, poly.TwoByteLength.ToString()));
                        info.AppendLine(FillWithSpace("LabelOffsetInLBL (3 Byte) (Bit 0..21)", tab, false, DecimalAndHexAndBinary(poly.LabelOffsetInLBL)));

                        if (!poly.LabelInNET)
                        {
                            if (lbl != null)
                            {
                                info.AppendLine(FillWithSpace("Text (from LBL)", tab, true, poly.GetText(lbl, true)));
                            }
                        }
                        else
                        {
                            if (net != null)
                            {
                                GarminCore.Files.StdFile_NET.RoadData rd = net.GetRoadData(poly.LabelOffsetInLBL);
                                if (rd != null)
                                {
                                    info.AppendLine(FillWithSpace("Text (from NET, LBL)", tab, true, rd.GetText(lbl, true)));
                                }
                            }
                        }

                        info.AppendLine(FillWithSpace("WithExtraBit              (Bit 22)", tab, false, poly.WithExtraBit.ToString()));
                        info.AppendLine(FillWithSpace("LabelInNET                (Bit 23)", tab, false, poly.LabelInNET.ToString()));
                        info.AppendLine(FillWithSpace("DeltaLongitude   (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLongitude.Value) + ", " + poly.RawDeltaLongitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("DeltaLatitude    (2 Byte)", tab, false, DecimalAndHexAndBinary((short)poly.RawDeltaLatitude.Value) + ", " + poly.RawDeltaLatitude.ValueDegree.ToString() + "°"));
                        info.AppendLine(FillWithSpace("BitstreamInfo    (1 Byte)", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo)));
                        info.AppendLine(FillWithSpace("   basebits4lat", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo >> 4)));
                        info.AppendLine(FillWithSpace("   basebits4lon", tab, false, DecimalAndHexAndBinary(poly.bitstreamInfo & 0xF)));
                        info.AppendLine(FillWithSpace("BitstreamLength (" + (poly.TwoByteLength ? "2" : "1") + " Byte)", tab, false, DecimalAndHexAndBinary(poly.bitstream.Length)));
                        if (poly.WithExtraBit)
                        {
                            info.AppendLine(FillWithSpace("ExtraBitList", tab, false, AllSubdivInfo.ExtraBits(poly)));
                        }
                        info.AppendLine("Deltas:");
                        List <GarminCore.Files.StdFile_RGN.GeoDataBitstream.RawPoint> points = poly.GetRawPoints();
                        for (int i = 0; i < points.Count; i++)
                        {
                            info.AppendLine("   " + points[i].ToString() + " / " + points[0].GetMapUnitPoint(rgn.TREFile.MaplevelList[asi.MaplevelNo].CoordBits, asi.SubdivfInfo.Center).ToString());
                        }

                        GarminCore.DataBlock block = asi.GetDataBlock4Object(GarminCore.Files.StdFile_TRE.SubdivInfoBasic.SubdivContent.area, idx);
                        firsthexadr  = rgn.SubdivContentBlock.Offset;
                        firsthexadr += block.Offset;
                        hexlen       = (int)block.Length;
                    }
                    else if ((idx & RGN_IDX_EXTPOINT) != 0)
                    {
                        ShowExtPointInfo(info, asi, rgn, tvd, filedata, idx & RGN_IDX_MASK, 40, out hexlen, out firsthexadr);
                    }
                    else if ((idx & RGN_IDX_EXTLINE) != 0)
                    {
                        ShowExtLineInfo(info, asi, rgn, tvd, filedata, idx & RGN_IDX_MASK, 40, out hexlen, out firsthexadr);
                    }
                    else if ((idx & RGN_IDX_EXTAREA) != 0)
                    {
                        ShowExtAreaInfo(info, asi, rgn, tvd, filedata, idx & RGN_IDX_MASK, 40, out hexlen, out firsthexadr);
                    }
                }


                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.File_MDX mdx = filedata.GetGarminFileAsMDX();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.MDX_MapEntry:
                if (idx < 0)
                {
                    firsthexadr = 0;
                    hexlen      = 14;
                    info.AppendLine("           (6 Bytes):  'Midxd'");
                    info.AppendLine("Unknown1   (2 Bytes): " + DecimalAndHexAndBinary(mdx.Unknown1));
                    info.AppendLine("Unknown2   (2 Bytes): " + DecimalAndHexAndBinary(mdx.Unknown2));
                    info.AppendLine("MapEntrys  (4 Bytes): " + DecimalAndHexAndBinary(mdx.Maps.Count));
                }
                else
                {
                    firsthexadr = 14 + idx * 12;
                    hexlen      = 12;

                    GarminCore.Files.File_MDX.MapEntry mapentry = mdx.Maps[idx];
                    info.AppendLine("MapID       (4 Byte): " + DecimalAndHexAndBinary(mapentry.MapID));
                    info.AppendLine("ProductID   (2 Byte): " + DecimalAndHexAndBinary(mapentry.ProductID));
                    info.AppendLine("FamilyID    (2 Byte): " + DecimalAndHexAndBinary(mapentry.FamilyID));
                    info.AppendLine("MapNumber   (4 Byte): " + DecimalAndHexAndBinary(mapentry.MapNumber));
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_TYP typ = filedata.GetGarminFileAsTYP();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.TYP_PolygoneTableBlock:
                firsthexadr = 0x15 + 2 + 3 * 8 + 2 * 2 + 2 * 10; // Daten aus dem Header
                hexlen      = 20;
                if (idx < 0)
                {
                    info.AppendLine("PolygoneTableBlock");
                    info.AppendLine("Offset:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneTableBlock.Offset));
                    info.AppendLine("Recordsize:          (2 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneTableBlock.Recordsize));
                    info.AppendLine("Length:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneTableBlock.Length));
                }
                break;

            case NodeContent.NodeType.TYP_PolygoneTable:
                firsthexadr = typ.PolygoneTableBlock.Offset;
                hexlen      = (int)typ.PolygoneTableBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("PolygoneTableBlock: " + typ.PolygoneTableBlock.ToString());
                }
                else
                {
                    GarminCore.Files.Typ.Polygone poly = typ.GetPolygone(idx);

                    GarminCore.Files.Typ.TableItem ti = typ.PolygonTableItems[idx];
                    info.AppendLine("TableItem " + idx.ToString() + " at position " + DecimalAndHexAndBinary(typ.PolygoneTableBlock.Offset + idx * typ.PolygoneTableBlock.Recordsize));
                    info.AppendLine("rawtype       (2 Byte):              " + DecimalAndHexAndBinary(ti.rawtype, 16));
                    info.AppendLine("   Subtype            (Bit 0..4):    " + DecimalAndHexAndBinary(ti.Subtype, 5));
                    info.AppendLine("   Type               (Bit 5..15):   " + DecimalAndHexAndBinary(ti.Type, 11));
                    info.AppendLine("Offset        (" + (typ.PolygoneTableBlock.Recordsize - 2).ToString() + " Byte):              " + DecimalAndHexAndBinary(ti.Offset));
                    info.AppendLine();

                    firsthexadr = typ.PolygoneDatablock.Offset + ti.Offset;
                    hexlen      = idx < typ.PolygonCount - 1 ? typ.PolygonTableItems[idx + 1].Offset - ti.Offset :
                                  (int)typ.PolygoneTableBlock.Offset - (ti.Offset + (int)typ.PolygoneDatablock.Offset);

                    info.AppendLine("Polygon " + idx.ToString() + " at position " + DecimalAndHexAndBinary(firsthexadr));
                    info.AppendLine("Options          (1 Byte):           " + DecimalAndHexAndBinary(poly.Options));
                    info.AppendLine("   Colortype             (Bit 0..4): " + poly.Colortype.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.Colortype));
                    // Farbdef. des Polygontyps
                    switch (poly.Colortype)
                    {
                    case GarminCore.Files.Typ.Polygone.ColorType.Day1:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.Day1_Night1:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("NightColor1      (3 Byte):           " + DecimalAndHex(poly.NightColor1));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day2:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):           " + DecimalAndHex(poly.DayColor2));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day2_Night2:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):           " + DecimalAndHex(poly.DayColor2));
                        info.AppendLine("NightColor1      (3 Byte):           " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("NightColor2      (3 Byte):           " + DecimalAndHex(poly.NightColor2));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        info.AppendLine("XBitmapNight:");
                        info.AppendLine("   " + PixMapText(poly.XBitmapNight));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day1_Night2:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("NightColor1      (3 Byte):           " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("NightColor2      (3 Byte):           " + DecimalAndHex(poly.NightColor2));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        info.AppendLine("XBitmapNight:");
                        info.AppendLine("   " + PixMapText(poly.XBitmapNight));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day2_Night1:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):           " + DecimalAndHex(poly.DayColor2));
                        info.AppendLine("NightColor1      (3 Byte):           " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        info.AppendLine("XBitmapNight:");
                        info.AppendLine("   " + PixMapText(poly.XBitmapNight));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day1:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        break;

                    case GarminCore.Files.Typ.Polygone.ColorType.BM_Day1_Night1:
                        info.AppendLine("DayColor1        (3 Byte):           " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("NightColor1      (3 Byte):           " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                        info.AppendLine("XBitmapNight:");
                        info.AppendLine("   " + PixMapText(poly.XBitmapNight));
                        break;
                    }

                    if (poly.WithString)
                    {
                        GarminCore.Files.Typ.MultiText mt = poly.Text;
                        int len = mt.GetIdentificationLength() + mt.GetRealLength();
                        info.AppendLine("Text             (" + DecimalAndHexAndBinary(len) + " Byte):");
                        for (int i = 0; i < mt.Count; i++)
                        {
                            GarminCore.Files.Typ.Text txt = mt.Get(i);
                            info.AppendLine("   " + txt.Language.ToString() + " / " + DecimalAndHexAndBinary((byte)txt.Language) + ": '" + txt.Txt + "'");
                        }
                    }

                    if (poly.WithExtendedOptions)
                    {
                        info.AppendLine("ExtOptions       (1 Byte):           " + DecimalAndHexAndBinary(poly.ExtOptions));
                        info.AppendLine("   FontType              (Bit 0..2): " + poly.FontType.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.FontType));
                        info.AppendLine("   FontColType           (Bit 3,4):  " + poly.FontColType.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.FontColType));
                        switch (poly.FontColType)
                        {
                        case GarminCore.Files.Typ.GraphicElement.FontColours.Day: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor1       (3 Byte):           " + DecimalAndHex(poly.FontColor1));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.Night: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor2       (3 Byte):           " + DecimalAndHex(poly.FontColor2));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.DayAndNight: // es folgen noch 2 Farben
                            info.AppendLine("FontColor1       (3 Byte):           " + DecimalAndHex(poly.FontColor1));
                            info.AppendLine("FontColor2       (3 Byte):           " + DecimalAndHex(poly.FontColor2));
                            break;
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TYP_PolygoneDraworderTable:
                firsthexadr = typ.PolygoneDraworderTableBlock.Offset;
                hexlen      = (int)typ.PolygoneDraworderTableBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("PolygoneDraworderTableBlock");
                    info.AppendLine("Offset:     (4 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneDraworderTableBlock.Offset));
                    info.AppendLine("Recordsize: (2 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneDraworderTableBlock.Recordsize));
                    info.AppendLine("Length:     (4 Byte):  " + DecimalAndHexAndBinary(typ.PolygoneDraworderTableBlock.Length));
                }
                else
                {
                    hexlen       = typ.PolygoneDraworderTableBlock.Recordsize;
                    firsthexadr += idx * hexlen;

                    GarminCore.Files.Typ.PolygonDraworderTableItem doi = typ.PolygonDraworderTableItems[idx];
                    if (doi.Type > 0)
                    {
                        info.AppendLine("Level:             " + doi.Level.ToString());
                        info.AppendLine("Type     (1 Byte): " + DecimalAndHexAndBinary(doi.Type));
                        filedata.BinaryReader.Seek(firsthexadr + 1);
                        byte[] st   = filedata.BinaryReader.ReadBytes(typ.PolygoneDraworderTableBlock.Recordsize - 1);
                        uint   styp = 0;
                        for (int i = 0; i < st.Length; i++)
                        {
                            styp <<= 8;
                            styp  += st[i];
                        }
                        info.AppendLine("Subtypes (" + st.Length.ToString() + " Byte): " + HexString(st) + " / 0b" + Binary(styp));
                        for (int j = 0; j < doi.Subtypes.Count; j++)
                        {
                            info.AppendLine("Subtype:           " + DecimalAndHexAndBinary(doi.Subtypes[j]));
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TYP_PolylineTableBlock:
                firsthexadr = 0x15 + 2 + 3 * 8 + 2 * 2 + 1 * 10; // Daten aus dem Header
                hexlen      = 10;
                if (idx < 0)
                {
                    info.AppendLine("PolylineTableBlock");
                    info.AppendLine("Offset:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PolylineTableBlock.Offset));
                    info.AppendLine("Recordsize:          (2 Byte):  " + DecimalAndHexAndBinary(typ.PolylineTableBlock.Recordsize));
                    info.AppendLine("Length:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PolylineTableBlock.Length));
                }
                break;

            case NodeContent.NodeType.TYP_PolylineTable:
                firsthexadr = typ.PolylineTableBlock.Offset;
                hexlen      = (int)typ.PolylineTableBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("PolylineTableBlock: " + typ.PolylineTableBlock.ToString());
                }
                else
                {
                    GarminCore.Files.Typ.Polyline poly = typ.GetPolyline(idx);

                    GarminCore.Files.Typ.TableItem ti = typ.PolylineTableItems[idx];
                    info.AppendLine("TableItem " + idx.ToString() + " at position " + DecimalAndHexAndBinary(typ.PolylineTableBlock.Offset + idx * typ.PolylineTableBlock.Recordsize));
                    info.AppendLine("rawtype          (2 Byte):            " + DecimalAndHexAndBinary(ti.rawtype, 16));
                    info.AppendLine("   Subtype               (Bit 0..4):  " + DecimalAndHexAndBinary(ti.Subtype, 5));
                    info.AppendLine("   Type                  (Bit 5..15): " + DecimalAndHexAndBinary(ti.Type, 11));
                    info.AppendLine("Offset           (" + (typ.PolylineTableBlock.Recordsize - 2).ToString() + " Byte):            " + DecimalAndHexAndBinary(ti.Offset));
                    info.AppendLine();

                    firsthexadr = typ.PolylineDatablock.Offset + ti.Offset;
                    hexlen      = idx < typ.PolylineCount - 1 ? typ.PolylineTableItems[idx + 1].Offset - ti.Offset :
                                  (int)typ.PolylineTableBlock.Offset - (ti.Offset + (int)typ.PolylineDatablock.Offset);

                    info.AppendLine("Polyline " + idx.ToString() + " at position " + DecimalAndHexAndBinary(firsthexadr));
                    info.AppendLine("Options          (1 Byte):            " + DecimalAndHexAndBinary(poly.Options));
                    info.AppendLine("   Polylinetype          (Bit 0..2):  " + poly.Polylinetype.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.Polylinetype));
                    info.AppendLine("   BitmapHeight          (Bit 3..7):  " + DecimalAndHexAndBinary(poly.BitmapHeight));
                    info.AppendLine("Options2         (1 Byte):            " + DecimalAndHexAndBinary(poly.Options2));
                    info.AppendLine("   WithString            (Bit 0):     " + poly.WithString.ToString());
                    info.AppendLine("   WithTextRotation      (Bit 1):     " + poly.WithTextRotation.ToString());
                    info.AppendLine("   WithExtendedOptions   (Bit 2):     " + poly.WithExtendedOptions.ToString());

                    switch (poly.Polylinetype)
                    {
                    case GarminCore.Files.Typ.Polyline.PolylineType.Day2:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):            " + DecimalAndHex(poly.DayColor2));
                        break;

                    case GarminCore.Files.Typ.Polyline.PolylineType.Day2_Night2:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):            " + DecimalAndHex(poly.DayColor2));
                        info.AppendLine("NightColor1      (3 Byte):            " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("NightColor2      (3 Byte):            " + DecimalAndHex(poly.NightColor2));
                        break;

                    case GarminCore.Files.Typ.Polyline.PolylineType.Day1_Night2:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("NightColor1      (3 Byte):            " + DecimalAndHex(poly.NightColor1));
                        info.AppendLine("NightColor2      (3 Byte):            " + DecimalAndHex(poly.NightColor2));
                        break;

                    case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day2_Night1:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("DayColor2        (3 Byte):            " + DecimalAndHex(poly.DayColor2));
                        info.AppendLine("NightColor1      (3 Byte):            " + DecimalAndHex(poly.NightColor1));
                        break;

                    case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day1:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        break;

                    case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day1_Night1:
                        info.AppendLine("DayColor1        (3 Byte):            " + DecimalAndHex(poly.DayColor1));
                        info.AppendLine("NightColor1      (3 Byte):            " + DecimalAndHex(poly.NightColor1));
                        break;
                    }

                    if (poly.BitmapHeight == 0)
                    {
                        switch (poly.Polylinetype)
                        {
                        case GarminCore.Files.Typ.Polyline.PolylineType.Day2:
                        case GarminCore.Files.Typ.Polyline.PolylineType.Day2_Night2:
                        case GarminCore.Files.Typ.Polyline.PolylineType.Day1_Night2:
                            info.AppendLine("InnerWidth       (1 Byte):            " + DecimalAndHexAndBinary(poly.InnerWidth));
                            if (poly.InnerWidth > 0)
                            {
                                info.AppendLine("Width            (1 Byte):            " + DecimalAndHexAndBinary(2 * poly.BorderWidth + poly.InnerWidth));
                            }
                            break;

                        case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day2_Night1:
                        case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day1:
                        case GarminCore.Files.Typ.Polyline.PolylineType.NoBorder_Day1_Night1:
                            info.AppendLine("InnerWidth       (1 Byte):            " + DecimalAndHexAndBinary(poly.InnerWidth));
                            break;
                        }
                    }
                    else
                    {
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poly.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poly.XBitmapDay));
                    }

                    if (poly.WithString)
                    {
                        GarminCore.Files.Typ.MultiText mt = poly.Text;
                        int len = mt.GetIdentificationLength() + mt.GetRealLength();
                        info.AppendLine("Text             (" + DecimalAndHexAndBinary(len) + " Byte):");
                        for (int i = 0; i < mt.Count; i++)
                        {
                            GarminCore.Files.Typ.Text txt = mt.Get(i);
                            info.AppendLine("   " + txt.Language.ToString() + " / " + DecimalAndHexAndBinary((byte)txt.Language) + ": '" + txt.Txt + "'");
                        }
                    }

                    if (poly.WithExtendedOptions)
                    {
                        info.AppendLine("ExtOptions       (1 Byte):            " + DecimalAndHexAndBinary(poly.ExtOptions));
                        info.AppendLine("   FontType              (Bit 0..2):  " + poly.FontType.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.FontType));
                        info.AppendLine("   FontColType           (Bit 3,4):   " + poly.FontColType.ToString() + " / " + DecimalAndHexAndBinary((byte)poly.FontColType));
                        switch (poly.FontColType)
                        {
                        case GarminCore.Files.Typ.GraphicElement.FontColours.Day: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor1       (3 Byte):            " + DecimalAndHex(poly.FontColor1));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.Night: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor2       (3 Byte):            " + DecimalAndHex(poly.FontColor2));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.DayAndNight: // es folgen noch 2 Farben
                            info.AppendLine("FontColor1       (3 Byte):            " + DecimalAndHex(poly.FontColor1));
                            info.AppendLine("FontColor2       (3 Byte):            " + DecimalAndHex(poly.FontColor2));
                            break;
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TYP_PointTableBlock:
                firsthexadr = 0x15 + 2 + 3 * 8 + 2 * 2; // Daten aus dem Header
                hexlen      = 10;
                if (idx < 0)
                {
                    info.AppendLine("PointTableBlock");
                    info.AppendLine("Offset:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PointTableBlock.Offset));
                    info.AppendLine("Recordsize:          (2 Byte):  " + DecimalAndHexAndBinary(typ.PointTableBlock.Recordsize));
                    info.AppendLine("Length:              (4 Byte):  " + DecimalAndHexAndBinary(typ.PointTableBlock.Length));
                }
                break;

            case NodeContent.NodeType.TYP_PointTable:
                firsthexadr = typ.PointTableBlock.Offset;
                hexlen      = (int)typ.PointTableBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("PointTableBlock: " + typ.PointTableBlock.ToString());
                }
                else
                {
                    GarminCore.Files.Typ.POI poi = typ.GetPoi(idx);

                    GarminCore.Files.Typ.TableItem ti = typ.PointTableItems[idx];
                    info.AppendLine("TableItem " + idx.ToString() + " at position " + DecimalAndHexAndBinary(typ.PointTableBlock.Offset + idx * typ.PointTableBlock.Recordsize));
                    info.AppendLine("rawtype          (2 Byte):            " + DecimalAndHexAndBinary(ti.rawtype, 16));
                    info.AppendLine("   Subtype               (Bit 0..4):  " + DecimalAndHexAndBinary(ti.Subtype, 5));
                    info.AppendLine("   Type                  (Bit 5..15): " + DecimalAndHexAndBinary(ti.Type, 11));
                    info.AppendLine("Offset           (" + (typ.PointTableBlock.Recordsize - 2).ToString() + " Byte):            " + DecimalAndHexAndBinary(ti.Offset));
                    info.AppendLine();

                    firsthexadr = typ.PointDatablock.Offset + ti.Offset;
                    hexlen      = idx < typ.PoiCount - 1 ? typ.PointTableItems[idx + 1].Offset - ti.Offset :
                                  (int)typ.PointTableBlock.Offset - (ti.Offset + (int)typ.PointDatablock.Offset);

                    info.AppendLine("Point " + idx.ToString() + " at position " + DecimalAndHexAndBinary(firsthexadr));
                    info.AppendLine("Options          (1 Byte):            " + DecimalAndHexAndBinary(poi.Options));
                    info.AppendLine("   NightXpmHasData       (Bit 0):     " + poi.NightXpmHasData.ToString());
                    info.AppendLine("   WithNightXpm          (Bit 1):     " + poi.WithNightXpm.ToString());
                    info.AppendLine("   WithString            (Bit 2):     " + poi.WithString.ToString());
                    info.AppendLine("   WithExtendedOptions   (Bit 3):     " + poi.WithExtendedOptions.ToString());
                    info.AppendLine("Width            (1 Byte):            " + DecimalAndHexAndBinary(poi.Width));
                    info.AppendLine("Height           (1 Byte):            " + DecimalAndHexAndBinary(poi.Height));
                    info.AppendLine("ColorsDay        (1 Byte):            " + DecimalAndHexAndBinary(poi.colsday));
                    info.AppendLine("ColormodeDay     (1 Byte):            " + poi.ColormodeDay.ToString() + " / " + DecimalAndHexAndBinary((byte)poi.ColormodeDay));
                    info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poi.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                    info.AppendLine("   " + PixMapText(poi.XBitmapDay));
                    if (poi.WithNightXpm)
                    {
                        info.AppendLine("ColorsNight      (1 Byte):            " + DecimalAndHexAndBinary(poi.colsnight));
                        info.AppendLine("ColormodeDay     (1 Byte):            " + poi.ColormodeNight.ToString() + " / " + DecimalAndHexAndBinary((byte)poi.ColormodeNight));
                        info.AppendLine("BitmapDay        (" + DecimalAndHexAndBinary(poi.XBitmapDay.data.rawimgdata.Length) + " Byte):");
                        info.AppendLine("   " + PixMapText(poi.XBitmapDay));
                        if (poi.NightXpmHasData)
                        {
                            info.AppendLine("BitmapNight      (" + DecimalAndHexAndBinary(poi.XBitmapNight.data.rawimgdata.Length) + " Byte):");
                        }
                        else
                        {
                            info.AppendLine("BitmapNight:");
                        }
                        info.AppendLine("   " + PixMapText(poi.XBitmapNight));
                    }

                    if (poi.WithString)
                    {
                        GarminCore.Files.Typ.MultiText mt = poi.Text;
                        int len = mt.GetIdentificationLength() + mt.GetRealLength();
                        info.AppendLine("Text             (" + DecimalAndHexAndBinary(len) + " Byte):");
                        for (int i = 0; i < mt.Count; i++)
                        {
                            GarminCore.Files.Typ.Text txt = mt.Get(i);
                            info.AppendLine("   " + txt.Language.ToString() + " / " + DecimalAndHexAndBinary((byte)txt.Language) + ": '" + txt.Txt + "'");
                        }
                    }

                    if (poi.WithExtendedOptions)
                    {
                        info.AppendLine("ExtOptions       (1 Byte):            " + DecimalAndHexAndBinary(poi.ExtOptions));
                        info.AppendLine("   FontType              (Bit 0..2):  " + poi.FontType.ToString() + " / " + DecimalAndHexAndBinary((byte)poi.FontType));
                        info.AppendLine("   FontColType           (Bit 3,4):   " + poi.FontColType.ToString() + " / " + DecimalAndHexAndBinary((byte)poi.FontColType));
                        switch (poi.FontColType)
                        {
                        case GarminCore.Files.Typ.GraphicElement.FontColours.Day: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor1       (3 Byte):            " + DecimalAndHex(poi.FontColor1));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.Night: // es folgt noch 1 Farbe
                            info.AppendLine("FontColor2       (3 Byte):            " + DecimalAndHex(poi.FontColor2));
                            break;

                        case GarminCore.Files.Typ.GraphicElement.FontColours.DayAndNight: // es folgen noch 2 Farben
                            info.AppendLine("FontColor1       (3 Byte):            " + DecimalAndHex(poi.FontColor1));
                            info.AppendLine("FontColor2       (3 Byte):            " + DecimalAndHex(poi.FontColor2));
                            break;
                        }
                    }
                }
                break;

            case NodeContent.NodeType.TYP_NT_PointDatabtable:
                firsthexadr = typ.NT_PointTableBlock.Offset;
                hexlen      = (int)typ.NT_PointTableBlock.Length;
                info.AppendLine("NT PointTableBlock: " + typ.NT_PointTableBlock.ToString());
                break;

            case NodeContent.NodeType.TYP_NT_PointDatablock:
                firsthexadr = typ.NT_PointDatablock.Offset;
                hexlen      = (int)typ.NT_PointDatablock.Length;
                info.AppendLine("NT PointDatablock: " + typ.NT_PointDatablock.ToString());
                break;

            case NodeContent.NodeType.TYP_NT_PointLabelblock:
                firsthexadr = typ.NT_PointLabelblock.Offset;
                hexlen      = (int)typ.NT_PointLabelblock.Length;
                info.AppendLine("NT PointLabelblock: " + typ.NT_PointLabelblock.ToString());
                break;

            case NodeContent.NodeType.TYP_NT_LabelblockTable1:
                firsthexadr = typ.NT_LabelblockTable1.Offset;
                hexlen      = (int)typ.NT_LabelblockTable1.Length;
                info.AppendLine("NT LabelblockTable1: " + typ.NT_LabelblockTable1.ToString());
                break;

            case NodeContent.NodeType.TYP_NT_LabelblockTable2:
                firsthexadr = typ.NT_LabelblockTable2.Offset;
                hexlen      = (int)typ.NT_LabelblockTable2.Length;
                info.AppendLine("NT LabelblockTable2: " + typ.NT_LabelblockTable2.ToString());
                break;

            //case NodeContent.NodeType.TRE_CopyrightBlock:
            //   firsthexadr = tre.CopyrightBlock.Offset;
            //   if (idx < 0) {
            //      info.AppendLine("Copyrights: " + tre.CopyrightOffsetsList.Count.ToString());
            //      info.AppendLine("  Block:    " + tre.CopyrightBlock.ToString());
            //      hexlen = (int)tre.CopyrightBlock.Length;
            //   } else {
            //      info.AppendLine("Offset in LBL (" + tre.CopyrightBlock.Recordsize.ToString() + " Byte): " + DecimalAndHexAndBinary(tre.CopyrightOffsetsList[idx]));
            //      lbl = tvd.GetLBL(filedata.Basename);
            //      if (lbl != null)
            //         info.AppendLine("   Text (from LBL): '" + lbl.GetText(tre.CopyrightOffsetsList[idx], true) + "'");
            //      firsthexadr += idx * tre.CopyrightBlock.Recordsize;
            //      hexlen = tre.CopyrightBlock.Recordsize;
            //   }
            //   break;

            //case NodeContent.NodeType.TRE_UnknownBlock_xBC:
            //   if (idx < 0) {
            //      info.AppendLine("UnknownBlock 0xBC: " + tre.UnknownBlock_xBC.ToString());
            //      firsthexadr = tre.UnknownBlock_xAE.Offset;
            //      hexlen = (int)tre.UnknownBlock_xAE.Length;
            //   } else {
            //   }
            //   break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 9
0
        /// <summary>
        /// Funktion für alle NET-Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype"></param>
        /// <param name="idx"></param>
        /// <param name="tvd"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_NET net = filedata.GetGarminFileAsNET(tvd.GetLBL(filedata.Basename));
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;
            int tab = 20;

            switch (nodetype)
            {
            case NodeContent.NodeType.RGN_PostHeaderData:
                firsthexadr = net.PostHeaderDataBlock.Offset;
                if (idx < 0)
                {
                    info.AppendLine("PostHeaderDataBlock: " + net.PostHeaderDataBlock.ToString());
                    hexlen = (int)net.PostHeaderDataBlock.Length;
                }
                break;

            case NodeContent.NodeType.NET_RoadDefinitionsBlock:
                firsthexadr = net.RoadDefinitionsBlock.Offset;
                if (idx < 0)
                {
                    tab = 15;
                    info.AppendLine("RoadDefinitionsBlock");
                    info.AppendLine(FillWithSpace("  Block", tab, false, net.RoadDefinitionsBlock.ToString()));
                    info.AppendLine(FillWithSpace("  Roads", tab, false, net.Roaddata.Count.ToString()));
                    hexlen = (int)net.RoadDefinitionsBlock.Length;
                }
                else    // einzelnes Element
                {
                    if ((idx & NET_IDX_ROAD) != 0)
                    {
                        idx &= NET_IDX_MASK;
                        tab  = 25;

                        GarminCore.Files.StdFile_NET.RoadData rd = net.Roaddata[idx];

                        //info.AppendLine(rd.ToString());
                        string labels = rd.LabelInfo.Count.ToString();
                        if (rd.LabelInfo.Count > 0)
                        {
                            labels += " -> ";
                            for (int i = 0; i < rd.LabelInfo.Count; i++)
                            {
                                if (i > 0)
                                {
                                    labels += ", ";
                                }
                                labels += DecimalAndHexAndBinary(rd.LabelInfo[i]);
                            }
                        }
                        info.AppendLine(FillWithSpace("Labels", tab, false, labels));
                        for (int i = 0; i < rd.LabelInfo.Count; i++)
                        {
                            info.AppendLine(FillWithSpace("   Label (LBL)" + i.ToString(), tab, true, rd.GetText(net.Lbl, i, false)));
                        }

                        info.AppendLine(FillWithSpace("Roaddatainfos", tab, false, rd.Roaddatainfos.ToString()));
                        info.AppendLine(FillWithSpace("RoadLength", tab, false, rd.RoadLength.ToString() + "m"));

                        info.AppendLine(FillWithSpace("RgnIndexOverviews", tab, false, rd.RgnIndexOverview.Count.ToString()));
                        for (int i = 0, j = 0; i < rd.RgnIndexOverview.Count; i++)
                        {
                            info.Append(FillWithSpace("   RgnIndexOverview " + i.ToString(), tab, false, rd.RgnIndexOverview[i].ToString()));
                            if (rd.RgnIndexOverview[i] > 0)
                            {
                                info.Append(" -> ");
                                for (int k = 0; k < rd.RgnIndexOverview[i]; k++)
                                {
                                    info.Append(" " + rd.Indexdata[j++].ToString());
                                }
                            }
                            info.AppendLine();
                        }
                        info.AppendLine(FillWithSpace("SegmentedRoadOffsets", tab, false, rd.SegmentedRoadOffsets.Count.ToString()));
                        for (int i = 0; i < rd.SegmentedRoadOffsets.Count; i++)
                        {
                            info.AppendLine(FillWithSpace("   SegmentedRoadOffsets " + i.ToString(), tab, false, DecimalAndHexAndBinary(rd.SegmentedRoadOffsets[i])));
                        }

                        if (rd.HasRoadDataInfo(GarminCore.Files.StdFile_NET.RoadData.RoadDataInfo.has_street_address_info))
                        {
                            // Bit 0..9 'NodeCount', Bits 10,11 für Zip; Bits 12,13 für City; Bits 14,15 für Nummbers
                            info.AppendLine(FillWithSpace("NodeCountAndFlags", tab, false, DecimalAndHexAndBinary(rd.NodeCountAndFlags, 16)));
                            info.AppendLine(FillWithSpace("   NodeCount", tab, false, rd.NodeCount.ToString()));
                            info.AppendLine(FillWithSpace("   ZipFlag", tab, false, DecimalAndHexAndBinary(rd.ZipFlag)));
                            for (int side = 0; side < rd.ZipIndex4Node.Count; side++)
                            {
                                if (rd.ZipIndex4Node[side].Count > 0)
                                {
                                    info.AppendLine(FillWithSpace(side == 0 ?
                                                                  "      Left (LBL)" :
                                                                  "      Right (LBL)", tab, true,
                                                                  rd.GetZipText(net.Lbl,
                                                                                side == 0 ?
                                                                                GarminCore.Files.StdFile_NET.RoadData.Side.Left :
                                                                                GarminCore.Files.StdFile_NET.RoadData.Side.Right,
                                                                                false)));
                                }
                            }
                            info.AppendLine(FillWithSpace("   CityFlag", tab, false, DecimalAndHexAndBinary(rd.CityFlag)));
                            for (int side = 0; side < rd.CityIndex4Node.Count; side++)
                            {
                                if (rd.CityIndex4Node[side].Count > 0)
                                {
                                    info.AppendLine(FillWithSpace(side == 0 ?
                                                                  "      Left (LBL)" :
                                                                  "      Right (LBL)", tab, true,
                                                                  rd.GetCityText(net.Lbl,
                                                                                 tvd.GetRGN(filedata.Basename),
                                                                                 side == 0 ?
                                                                                 GarminCore.Files.StdFile_NET.RoadData.Side.Left :
                                                                                 GarminCore.Files.StdFile_NET.RoadData.Side.Right,
                                                                                 false)));
                                }
                            }

                            string bin = "";
                            for (int i = 0; i < rd.NumberStream.Length; i++)
                            {
                                bin += Binary(rd.NumberStream[i]);
                            }

                            bin = Binary(rd.NumberStream);
                            info.AppendLine(FillWithSpace("   NumberFlag, -stream", tab, false, DecimalAndHexAndBinary(rd.NumberFlag) + "   " + HexString(rd.NumberStream) + "   " + bin));
                            if (rd.NumberStream.Length > 0)
                            {
                                GarminCore.Files.StdFile_NET.RoadData.Housenumbers numbers = new GarminCore.Files.StdFile_NET.RoadData.Housenumbers(rd.NumberStream);
                                for (int n = 0; n < numbers.Numbers.Count; n++)
                                {
                                    info.AppendLine(new string(' ', tab + 3) + numbers.Numbers[n].ToString() + " (raw: " + numbers.Numbers[n].rawdata.ToString() + ")");
                                }
                            }
                        }



                        if (rd.HasRoadDataInfo(GarminCore.Files.StdFile_NET.RoadData.RoadDataInfo.has_nod_info))
                        {
                            info.AppendLine(FillWithSpace("NODFlag", tab, false, rd.NODFlag.ToString()));
                            info.AppendLine(FillWithSpace("NOD_Offset", tab, false, DecimalAndHexAndBinary(rd.NOD_Offset)));
                        }

                        // für die Hex-Anzeige
                        firsthexadr = net.RoadDefinitionsBlock.Offset;
                        for (int i = 0; i < idx; i++)
                        {
                            firsthexadr += net.Roaddata[i].RawBytes;
                        }
                        hexlen = (int)net.Roaddata[idx].RawBytes;
                    }
                }
                break;

            case NodeContent.NodeType.NET_SegmentedRoadsBlock:
                firsthexadr = net.RoadDefinitionsBlock.Offset;
                if (idx < 0)
                {
                    tab = 15;
                    info.AppendLine("SegmentedRoadsBlock");
                    info.AppendLine(FillWithSpace("  Block", tab, false, net.SegmentedRoadsBlock.ToString()));
                    hexlen = (int)net.SegmentedRoadsBlock.Length;
                }
                else    // einzelnes Element



                {
                }
                break;

            case NodeContent.NodeType.NET_SortedRoadsBlock:
                firsthexadr = net.RoadDefinitionsBlock.Offset;
                if (idx < 0)
                {
                    tab = 15;
                    info.AppendLine("SortedRoadsBlock");
                    info.AppendLine(FillWithSpace("  Block", tab, false, net.SortedRoadsBlock.ToString()));
                    info.AppendLine(FillWithSpace("  Offsets", tab, false, net.SortedOffsets.Count.ToString()));
                    hexlen = (int)net.SortedRoadsBlock.Length;

                    List <uint> t1 = new List <uint>(net.SortedOffsets);
                    t1.Sort();
                }
                else    // einzelnes Element
                {
                    tab = 20;
                    if ((idx & NET_IDX_SORTEDOFFSET) != 0)
                    {
                        idx &= NET_IDX_MASK;
                        info.AppendLine(FillWithSpace("Offset", tab, false, DecimalAndHexAndBinary(net.SortedOffsets[idx])));
                        int offs = (int)net.SortedOffsets[idx];
                        for (int i = 0; i < net.Roaddata.Count; i++)
                        {
                            offs -= net.Roaddata[i].RawBytes;
                            if (offs == 0)
                            {
                                info.AppendLine(FillWithSpace("Roaddata-Index", tab, false, i.ToString()));
                                break;
                            }
                            else if (offs < 0)
                            {
                                info.AppendLine("Roaddata-Index not found -> error ?");
                                break;
                            }
                        }
                    }
                }
                break;



            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_MDR mdr = filedata.GetGarminFileAsMDR();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.MDR_MDR1:
                firsthexadr = mdr.Mdr1.Offset;
                hexlen      = (int)mdr.Mdr1.Length;
                info.AppendLine("Mdr1: " + mdr.Mdr1.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR2:
                firsthexadr = mdr.Mdr2.Offset;
                hexlen      = (int)mdr.Mdr2.Length;
                info.AppendLine("Mdr2: " + mdr.Mdr2.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR3:
                firsthexadr = mdr.Mdr3.Offset;
                hexlen      = (int)mdr.Mdr3.Length;
                info.AppendLine("Mdr3: " + mdr.Mdr3.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR4:
                firsthexadr = mdr.Mdr4.Offset;
                hexlen      = (int)mdr.Mdr4.Length;
                info.AppendLine("Mdr4: " + mdr.Mdr4.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR5:
                firsthexadr = mdr.Mdr5.Offset;
                hexlen      = (int)mdr.Mdr5.Length;
                info.AppendLine("Mdr5: " + mdr.Mdr5.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR6:
                firsthexadr = mdr.Mdr6.Offset;
                hexlen      = (int)mdr.Mdr6.Length;
                info.AppendLine("Mdr6: " + mdr.Mdr6.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR7:
                firsthexadr = mdr.Mdr7.Offset;
                hexlen      = (int)mdr.Mdr7.Length;
                info.AppendLine("Mdr7: " + mdr.Mdr7.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR8:
                firsthexadr = mdr.Mdr8.Offset;
                hexlen      = (int)mdr.Mdr8.Length;
                info.AppendLine("Mdr8: " + mdr.Mdr8.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR9:
                firsthexadr = mdr.Mdr9.Offset;
                hexlen      = (int)mdr.Mdr9.Length;
                info.AppendLine("Mdr9: " + mdr.Mdr9.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR10:
                firsthexadr = mdr.Mdr10.Offset;
                hexlen      = (int)mdr.Mdr10.Length;
                info.AppendLine("Mdr10: " + mdr.Mdr10.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR11:
                firsthexadr = mdr.Mdr11.Offset;
                hexlen      = (int)mdr.Mdr11.Length;
                info.AppendLine("Mdr11: " + mdr.Mdr11.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR12:
                firsthexadr = mdr.Mdr12.Offset;
                hexlen      = (int)mdr.Mdr12.Length;
                info.AppendLine("Mdr12: " + mdr.Mdr12.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR13:
                firsthexadr = mdr.Mdr13.Offset;
                hexlen      = (int)mdr.Mdr13.Length;
                info.AppendLine("Mdr13: " + mdr.Mdr13.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR14:
                firsthexadr = mdr.Mdr14.Offset;
                hexlen      = (int)mdr.Mdr14.Length;
                info.AppendLine("Mdr14: " + mdr.Mdr14.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR15:
                firsthexadr = mdr.Mdr15.Offset;
                hexlen      = (int)mdr.Mdr15.Length;
                info.AppendLine("Mdr15: " + mdr.Mdr15.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR16:
                firsthexadr = mdr.Mdr16.Offset;
                hexlen      = (int)mdr.Mdr16.Length;
                info.AppendLine("Mdr16: " + mdr.Mdr16.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR17:
                firsthexadr = mdr.Mdr17.Offset;
                hexlen      = (int)mdr.Mdr17.Length;
                info.AppendLine("Mdr17: " + mdr.Mdr17.ToString());
                break;

            case NodeContent.NodeType.MDR_MDR18:
                firsthexadr = mdr.Mdr18.Offset;
                hexlen      = (int)mdr.Mdr18.Length;
                info.AppendLine("Mdr18: " + mdr.Mdr18.ToString());
                break;



            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Daten für den akt. Node anzeigen
        /// <para>aus dem akt. und ev. den darüber liegenden Nodes wird bestimmt, welche Daten anzuzeigen sind</para>
        /// </summary>
        /// <param name="tn"></param>
        /// <param name="tpd"></param>
        void ShowData4Node(TreeNode tn, TabPageData tpd)
        {
            byte[] hex         = null;
            long   firsthexadr = 0;

            tpd.Hexwin.ClearContent();
            tpd.Info.Clear();
            StringBuilder info = new StringBuilder();

            NodeContent  nc  = Data.NodeContent4TreeNode(tn);
            TreeViewData tvd = TreeViewData.GetTreeViewData(tn);

            switch (nc.Type)
            {
            case NodeContent.NodeType.PhysicalFile:
                if (nc.Data is NodeContent.Content4PhysicalFile)
                {
                    Data.RegisterCoreFiles(tvd, (nc.Data as NodeContent.Content4PhysicalFile).Filename);
                    Data.ShowData4Node_PhysicalFile(info, out hex, out firsthexadr, nc.Data as NodeContent.Content4PhysicalFile, tvd);
                }
                break;

            case NodeContent.NodeType.SimpleFilesystem:
                nc = Data.NodeContent4TreeNode(tn.Parent); // es muss eine physische Datei übergeordnet sein
                if (nc.Data is NodeContent.Content4PhysicalFile)
                {
                    DataSimpleFilesystem.ShowData(info, out hex, out firsthexadr, nc.Data as NodeContent.Content4PhysicalFile, tvd);
                }
                break;

            case NodeContent.NodeType.LogicalFile:
                if (nc.Data is NodeContent.Content4LogicalFile)
                {
                    Data.RegisterCoreFiles(tvd, (nc.Data as NodeContent.Content4LogicalFile).Filename);
                    Data.ShowData4Node_LogicalFile(info, out hex, out firsthexadr, nc.Data as NodeContent.Content4LogicalFile, tvd);
                }
                break;

            case NodeContent.NodeType.GarminCommonHeader:
                nc = Data.NodeContent4TreeNode(tn.Parent); // es muss eine physische oder logische Datei übergeordnet sein
                if (nc.Data is NodeContent.Content4File)
                {
                    Data.ShowData4Node_GarminCommonHeader(info, out hex, out firsthexadr, nc.Data as NodeContent.Content4File, tvd);
                }
                break;

            case NodeContent.NodeType.GarminSpecialHeader:
                nc = Data.NodeContent4TreeNode(tn.Parent); // es muss eine physische oder logische Datei übergeordnet sein
                if (nc.Data is NodeContent.Content4File)
                {
                    Data.ShowData4Node_GarminSpecialHeader(info, out hex, out firsthexadr, nc.Data as NodeContent.Content4File, tvd);
                }
                break;

            case NodeContent.NodeType.Index:
                if (tn.Parent != null)
                {
                    Data.ShowData4Node_GarminStdFile(info, out hex, out firsthexadr, Data.GetNextContent4File(tn), Data.NodeContent4TreeNode(tn.Parent).Type, (int)nc.Data, tvd);
                }
                break;

            case NodeContent.NodeType.DataRange:
                NodeContent.Content4DataRange c4dr = nc.Data as NodeContent.Content4DataRange;
                info.AppendLine(c4dr.Info);
                hex         = c4dr.Bytes;
                firsthexadr = c4dr.FirstAdr;
                break;

            default:
                NodeContent.Content4File c4f = Data.GetNextContent4File(tn);
                Data.RegisterCoreFiles(tvd, c4f.Filename);
                Data.ShowData4Node_GarminStdFile(info, out hex, out firsthexadr, c4f, nc.Type, -1, tvd);
                break;
            }

            tpd.Info.AppendText(info.ToString());
            tpd.Info.Select(0, 0);
            tpd.Info.ScrollToCaret();

            if (hex != null)
            {
                tpd.Hexwin.SetContent(hex, (ulong)firsthexadr);
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_DEM dem = filedata.GetGarminFileAsDEM();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.DEM_Zoomlevel:
                firsthexadr = dem.PtrZoomlevel;
                if (idx < 0)
                {
                    info.AppendLine("ZoomlevelCount:       " + DecimalAndHexAndBinary(dem.ZoomlevelCount));
                    info.AppendLine("ZoomlevelRecordSize:  " + DecimalAndHexAndBinary(dem.ZoomlevelRecordSize));
                    hexlen = dem.ZoomlevelRecordSize * dem.ZoomlevelCount;
                }
                else
                {
                    GarminCore.Files.DEM.ZoomlevelTableitem record = dem.ZoomLevel[idx].ZoomlevelItem;

                    info.AppendLine("SpecType                (1 Byte): " + DecimalAndHexAndBinary(record.SpecType));
                    info.AppendLine("Number                  (1 Byte): " + DecimalAndHexAndBinary(record.No));
                    info.AppendLine("Tilesize horizontal     (4 Byte): " + DecimalAndHexAndBinary(record.PointsHoriz));
                    info.AppendLine("Tilesize vertical       (4 Byte): " + DecimalAndHexAndBinary(record.PointsVert));
                    info.AppendLine("LastRowHeight           (4 Byte): " + DecimalAndHexAndBinary(record.LastRowHeight));
                    info.AppendLine("LastColWidth            (4 Byte): " + DecimalAndHexAndBinary(record.LastColWidth));
                    info.AppendLine("Unknown12               (2 Byte): " + DecimalAndHexAndBinary(record.Unknown12));
                    info.AppendLine("MaxIdxHoriz             (4 Byte): " + DecimalAndHexAndBinary(record.MaxIdxHoriz));
                    info.AppendLine("MaxIdxVert              (4 Byte): " + DecimalAndHexAndBinary(record.MaxIdxVert));
                    info.AppendLine("Structure               (2 Byte): " + DecimalAndHexAndBinary(record.Structure, 16));
                    info.AppendLine("   OffsetSize              (Bit 0,1) +1: " + record.Structure_OffsetSize + " Byte");
                    info.AppendLine("   BaseheightSize          (Bit 2) +1:   " + record.Structure_BaseheightSize + " Byte");
                    info.AppendLine("   DiffSize                (Bit 3) +1:   " + record.Structure_DiffSize + " Byte");
                    info.AppendLine("   CodingtypeSize          (Bit 4):      " + record.Structure_CodingtypeSize + " Byte");
                    info.AppendLine("SubtileTableitemSize    (2 Byte): " + DecimalAndHexAndBinary(record.SubtileTableitemSize));
                    info.AppendLine("SubtileTableOffset      (4 Byte): " + DecimalAndHexAndBinary(record.PtrSubtileTable));
                    info.AppendLine("HeightdataOffset        (4 Byte): " + DecimalAndHexAndBinary(record.PtrHeightdata));
                    info.AppendLine("Left                    (4 Byte): " + DecimalAndHexAndBinary(record.west) + "; " + record.West.ToString() + "°");
                    info.AppendLine("Top                     (4 Byte): " + DecimalAndHexAndBinary(record.north) + "; " + record.North.ToString() + "°");
                    info.AppendLine("PointDistanceVertical   (4 Byte): " + DecimalAndHexAndBinary(record.pointDistanceVert) + "; " + record.PointDistanceVert.ToString() + "°");
                    info.AppendLine("PointDistanceHorizontal (4 Byte): " + DecimalAndHexAndBinary(record.pointDistanceHoriz) + "; " + record.PointDistanceHoriz.ToString() + "°");
                    info.AppendLine("MinHeight               (2 Byte): " + DecimalAndHexAndBinary(record.MinHeight));
                    info.AppendLine("MaxHeight               (2 Byte): " + DecimalAndHexAndBinary(record.MaxHeight));

                    firsthexadr += idx * dem.ZoomlevelRecordSize;
                    hexlen       = dem.ZoomlevelRecordSize;
                }
                break;

            case NodeContent.NodeType.Index:
                // etwas tricky, aber nc.Data des übergeordneten Knotens ist der ZoomLevel-Index
                if (tvd.TreeView.SelectedNode != null)
                {
                    int         zoomlevelidxidx = -1;
                    NodeContent nc = NodeContent4TreeNode(tvd.TreeView.SelectedNode.Parent);
                    if (nc.Type == NodeContent.NodeType.Index)
                    {
                        zoomlevelidxidx = (int)nc.Data;
                    }
                    if (zoomlevelidxidx >= 0)
                    {
                        GarminCore.Files.DEM.ZoomlevelTableitem zoomlevel = dem.ZoomLevel[zoomlevelidxidx].ZoomlevelItem;
                        GarminCore.Files.DEM.SubtileTableitem   subtile   = dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].Tableitem;
                        info.AppendLine("Offset     (" + zoomlevel.Structure_OffsetSize + " Byte): " + DecimalAndHexAndBinary(subtile.Offset));
                        info.AppendLine("Baseheight (" + zoomlevel.Structure_BaseheightSize + " Byte): " + DecimalAndHexAndBinary(subtile.Baseheight));
                        info.AppendLine("Diff       (" + zoomlevel.Structure_DiffSize + " Byte): " + DecimalAndHexAndBinary(subtile.Diff));
                        if (zoomlevel.Structure_CodingtypeSize > 0)
                        {
                            info.AppendLine("Type       (" + zoomlevel.Structure_CodingtypeSize + " Byte): " + DecimalAndHexAndBinary(subtile.Type));
                        }
                        info.AppendLine();
                        info.AppendLine("coded data (" + DecimalAndHexAndBinary(dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].DataLength) + " Bytes):");

                        firsthexadr = zoomlevel.PtrHeightdata + subtile.Offset;
                        hexlen      = dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].DataLength;
                    }
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_SRT srt = filedata.GetGarminFileAsSRT();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.SRT_ContentsBlock:
                firsthexadr = srt.ContentsBlock.Offset;
                hexlen      = srt.ContentsBlock.Length;
                info.AppendLine("ContentsBlock:                (6 Byte): " + srt.ContentsBlock.ToString());
                info.AppendLine("   DescriptionBlock:                    " + srt.DescriptionBlock.ToString());
                info.AppendLine("   CharacterLookupTableBlock:           " + srt.CharacterLookupTableBlock.ToString());
                break;

            case NodeContent.NodeType.SRT_DescriptionBlock:
                firsthexadr = srt.DescriptionBlock.Offset;
                hexlen      = (int)srt.DescriptionBlock.Length;
                info.AppendLine("Description: (" + srt.DescriptionBlock.Length.ToString() + " Byte): '" + srt.Description + "'");
                break;

            case NodeContent.NodeType.SRT_CharacterLookupTableBlock:
                firsthexadr = srt.CharacterLookupTableBlock.Offset;
                hexlen      = (int)srt.CharacterLookupTableBlock.Length;
                info.AppendLine("Headerlength    (2 Byte): " + DecimalAndHexAndBinary(srt.Sortheader.Headerlength));
                info.AppendLine("Id1             (2 Byte): " + DecimalAndHexAndBinary(srt.Sortheader.Id1));
                info.AppendLine("Id2             (2 Byte): " + DecimalAndHexAndBinary(srt.Sortheader.Id2));
                info.AppendLine("Codepage        (2 Byte): " + DecimalAndHexAndBinary(srt.Sortheader.Codepage));
                info.AppendLine("Unknown1        (" + srt.Sortheader.Unknown1.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown1));
                info.AppendLine("Unknown2        (" + srt.Sortheader.Unknown2.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown2));
                info.AppendLine("CharTabBlock    (10 Byte): " + srt.Sortheader.CharTabBlock.ToString());
                info.AppendLine("Unknown3        (" + srt.Sortheader.Unknown3.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown3));
                info.AppendLine("ExpansionsBlock (10 Byte): " + srt.Sortheader.ExpansionsBlock.ToString());
                info.AppendLine("Unknown4        (" + srt.Sortheader.Unknown4.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown4));
                info.AppendLine("CharTabOffset   (4 Byte): " + DecimalAndHexAndBinary(srt.Sortheader.CharTabOffset));
                info.AppendLine("Unknown5        (" + srt.Sortheader.Unknown5.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown5));
                info.AppendLine("Unknown6        (" + srt.Sortheader.Unknown6.Length.ToString() + " Byte): " + HexString(srt.Sortheader.Unknown6));
                break;

            case NodeContent.NodeType.SRT_CharTabBlock:
                firsthexadr = srt.Sortheader.CharTabBlock.Offset;
                hexlen      = (int)srt.Sortheader.CharTabBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("Count: " + (srt.Sortheader.CharTabBlock.Length / srt.Sortheader.CharTabBlock.Recordsize).ToString());
                }
                else
                {
                    hexlen      = srt.Sortheader.CharTabBlock.Recordsize;
                    firsthexadr = srt.Sortheader.CharTabBlock.Offset + idx * hexlen;
                }
                break;

            case NodeContent.NodeType.SRT_ExpansionsBlock:
                firsthexadr = srt.Sortheader.ExpansionsBlock.Offset;
                hexlen      = (int)srt.Sortheader.ExpansionsBlock.Length;
                if (idx < 0)
                {
                    info.AppendLine("Count: " + (srt.Sortheader.ExpansionsBlock.Length / srt.Sortheader.ExpansionsBlock.Recordsize).ToString());
                }
                else
                {
                    hexlen      = srt.Sortheader.ExpansionsBlock.Recordsize;
                    firsthexadr = srt.Sortheader.ExpansionsBlock.Offset + idx * hexlen;
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }