public void Write(BinaryReaderWriter wr)
{
wr.Write(MapID);
wr.Write(ProductID);
wr.Write(FamilyID);
wr.Write(MapNumber);
}
public void Write(BinaryReaderWriter bw, int iCodepage)
{
bw.Write(Options);
XBitmapDay.WriteAsPoi(bw);
if (WithNightXpm)
{
XBitmapNight.WriteAsPoi(bw);
}
if (WithString)
{
Text.Write(bw, iCodepage);
}
if (WithExtendedOptions)
{
bw.Write(ExtOptions);
switch (FontColType)
{
case FontColours.Day:
BinaryColor.WriteColor(bw, colFontColour[0]);
break;
case FontColours.Night:
BinaryColor.WriteColor(bw, colFontColour[1]);
break;
case FontColours.DayAndNight:
BinaryColor.WriteColorTable(bw, colFontColour);
break;
}
}
}
public void Write(BinaryReaderWriter bw, int codepage)
{
bw.Write((byte)Language);
byte[] txt = Encoding.Convert(Encoding.Unicode, Encoding.GetEncoding(codepage), Encoding.Unicode.GetBytes(Txt));
bw.Write(txt);
bw.Write((byte)0);
}
public void Write(BinaryReaderWriter wr)
{
wr.Write((byte)CopyrightCode);
wr.Write((byte)WhereCode);
wr.Write(ExtraProperties);
wr.WriteString(Copyright);
}
/// <summary>
/// schreibt eine Farbtabelle in den Stream
/// </summary>
/// <param name="bw"></param>
/// <param name="coltable"></param>
/// <param name="bWithAlpha"></param>
public static void WriteColorTable(BinaryReaderWriter bw, Color[] coltable, bool bWithAlpha = false)
{
if (!bWithAlpha)
{
for (int i = 0; i < coltable.Length; i++)
{
bw.Write(coltable[i].B);
bw.Write(coltable[i].G);
bw.Write(coltable[i].R);
}
}
else
{
// Länge der Farbtabelle ermitteln
int len = coltable.Length * 3 + coltable.Length / 2;
if (coltable.Length % 2 == 1)
{
len++;
}
// Farbtabelle erzeugen
byte[] colortable = new byte[len];
byte[] halfbytetable = new byte[2 * len];
for (int i = 0, j = 0; i < coltable.Length; i++)
{
halfbytetable[j++] = (byte)(coltable[i].B & 0xf);
halfbytetable[j++] = (byte)(coltable[i].B >> 4);
halfbytetable[j++] = (byte)(coltable[i].G & 0xf);
halfbytetable[j++] = (byte)(coltable[i].G >> 4);
halfbytetable[j++] = (byte)(coltable[i].R & 0xf);
halfbytetable[j++] = (byte)(coltable[i].R >> 4);
halfbytetable[j++] = (byte)(0xf - ((float)coltable[i].A / 0xff) * 0xf);
}
for (int i = 0; i < colortable.Length; i++)
{
colortable[i] = (byte)(halfbytetable[2 * i] | (halfbytetable[2 * i + 1] << 4));
}
//bool bMoveHalfbyte = false;
//for (int i = 0, dest = 0; i < coltable.Length; i++) {
// byte alpha = (byte)(~coltable[i].A / 255f * 15);
// if (bMoveHalfbyte) {
// colortable[dest++] |= (byte)(coltable[i].B << 4);
// colortable[dest] = (byte)(coltable[i].B >> 4);
// colortable[dest++] |= (byte)(coltable[i].G << 4);
// colortable[dest] = (byte)(coltable[i].G >> 4);
// colortable[dest++] |= (byte)(coltable[i].R << 4);
// colortable[dest] = (byte)(coltable[i].R >> 4);
// colortable[dest++] |= (byte)(alpha << 4);
// } else {
// colortable[dest++] = coltable[i].B;
// colortable[dest++] = coltable[i].G;
// colortable[dest++] = coltable[i].R;
// colortable[dest] = alpha;
// }
// bMoveHalfbyte = !bMoveHalfbyte;
//}
bw.Write(colortable);
}
}
/// <summary>
/// schreibe die aktuellen Daten als MDX-Datei
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
wr.Write(new byte[] { (byte)'M', (byte)'i', (byte)'d', (byte)'x', (byte)'d', 0 });
wr.Write(Unknown1);
wr.Write(Unknown2);
wr.Write((UInt32)Maps.Count);
for (int i = 0; i < Maps.Count; i++)
{
Maps[i].Write(wr);
}
}
public void Write(BinaryReaderWriter wr)
{
wr.Write(Used);
if (Used)
{
wr.WriteString(Name, null, false);
wr.WriteString(Typ, null, false);
wr.Write(Filesize);
wr.Write(Flag);
wr.Write(Part);
wr.Write(Unknown);
if (blocks.Count > 0)
{
for (int i = 0; i < (BlockSize - 32) / 2; i++)
{
if (i < blocks.Count)
{
wr.Write((UInt16)(blocks[i] < 0xffff ? blocks[i] : 0xffff));
}
else
{
wr.Write((UInt16)0xffff);
}
}
}
}
else
{
for (int i = 1; i < BlockSize; i++)
{
wr.Write((byte)0x00);
}
}
}
/// <summary>
/// schreibt das Bitmap als POI in den Stream (falls der Colormode stimmt, sonst Exception)
/// </summary>
/// <param name="bw"></param>
public void WriteAsPoi(BinaryReaderWriter bw)
{
switch (Colormode)
{
case BitmapColorMode.POI_SIMPLE:
case BitmapColorMode.POI_TR:
bw.Write((byte)Width);
bw.Write((byte)Height);
bw.Write((byte)colColorTable.Length);
bw.Write((byte)Colormode);
BinaryColor.WriteColorTable(bw, colColorTable, false);
data.Write(bw);
break;
case BitmapColorMode.POI_ALPHA:
bw.Write((byte)Width);
bw.Write((byte)Height);
bw.Write((byte)colColorTable.Length);
bw.Write((byte)Colormode);
BinaryColor.WriteColorTable(bw, colColorTable, true);
data.Write(bw);
break;
default:
throw new Exception(string.Format("Unerlaubter ColorMode für Bitmap ({0:x2}).", Colormode));
}
}
/// <summary>
/// schreibt den Blockheader und die Blockdaten
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
blh.Length = 20;
blh.Write(wr);
wr.Write(Unknown1);
wr.Write(A);
wr.Write(Unknown2);
wr.Write(Unknown3);
wr.Write(B);
wr.Write(Unknown4);
wr.Write(C);
wr.Write(Unknown5);
wr.Write(D);
wr.Write(Unknown6);
}
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
bw.Write(Unknown_x15);
ContentsBlock.Write(bw);
if (Headerlength > 0x1D) // auch 0x25 gesehen mit 8 zusätzlichen Byte: 00 00 35 00 00 00 10 00
{
bw.Write(Unknown_x1D);
}
}
}
/// <summary>
/// schreibt den Eintrag für eine Drawordertabelle (Typ 0 steht für das Ende eines Levels)
/// </summary>
/// <param name="bw"></param>
/// <param name="length"></param>
public void Write(BinaryReaderWriter bw, int length)
{
bw.Write((byte)(Type & 0xff));
length--;
byte[] b = new byte[length];
if (0xFF < Type) // dann auch Subtypes berücksichtigen
{
for (int i = 0; i < Subtypes.Count; i++)
{
uint bidx = Subtypes[i] / 8; // Byte-Index (0..)
b[bidx] |= (byte)(0x01 << (int)(Subtypes[i] % 8));
}
}
bw.Write(b);
}
/// <summary>
/// schreibt den Multitext in den Stream
/// </summary>
/// <param name="bw"></param>
/// <param name="iCodepage"></param>
public void Write(BinaryReaderWriter bw, int iCodepage)
{
int len = GetIdentificationLength();
if (len <= 0xff)
{
bw.Write((byte)(0xff & len));
}
else
{
bw.Write((UInt16)(0xffff & len));
}
foreach (Text.LanguageCode code in txt.Keys)
{
new Text(txt[code], code).Write(bw, iCodepage);
}
}
public void Write(BinaryReaderWriter bw, int iItemlength)
{
UInt16 type = (UInt16)((Type << 5) | Subtype);
bw.Write(type);
switch (iItemlength)
{
case 3: bw.Write((byte)(Offset & 0xff)); break;
case 4: bw.Write((UInt16)(Offset & 0xffff)); break;
case 5:
bw.Write((UInt16)(Offset & 0xffff));
bw.Write((byte)((Offset >> 16) & 0xff));
break;
}
}
/// <summary>
/// In den Stream werden entsprechend der gespeicherten Position die Daten geschrieben.
/// </summary>
/// <param name="bw"></param>
public void Write(BinaryReaderWriter bw)
{
if (Data != null &&
Data.Length > 0)
{
bw.Seek(Position.Offset);
bw.Write(Data);
}
}
/// <summary>
/// schreibt den Blockheader und die Blockdaten
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
blh.Length = (ushort)(1 + // Unknown1
Text.Length +
1); // 0-Byte
blh.Write(wr);
wr.Write(Unknown1);
wr.WriteString(Text);
}
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
bw.Write(Unknown_0x15);
for (int i = 0; i < SubHeaderOffsets.Length; i++)
{
bw.Write(SubHeaderOffsets[i]);
}
if (Headerlength > 0x35)
{
bw.Write(Unknown_0x35);
}
}
}
/// <summary>
/// schreibt die <see cref="SubtileTableitem"/> und die Höhendaten
/// </summary>
/// <param name="bw"></param>
public void WriteData(BinaryReaderWriter bw)
{
CalculateOffsets();
for (int i = 0; i < Subtiles.Count; i++)
{
Subtiles[i].Tableitem.Write(bw, ZoomlevelItem.Structure_OffsetSize, ZoomlevelItem.Structure_BaseheightSize, ZoomlevelItem.Structure_DiffSize, ZoomlevelItem.Structure_CodingtypeSize);
}
for (int i = 0; i < Subtiles.Count; i++)
{
bw.Write(Subtiles[i].Data);
}
}
/// <summary>
/// schreibt den allgemeinen Header
/// </summary>
/// <param name="wr"></param>
/// <param name="typ">nur angeben wenn der akt. <see cref="GarminTyp"/> überschrieben werden soll</param>
protected void WriteCommonHeader(BinaryReaderWriter wr, string typ = null)
{
wr.Seek(HeaderOffset);
wr.Write(Headerlength);
if (!string.IsNullOrEmpty(typ))
{
GarminTyp = "GARMIN " + typ;
}
wr.WriteString(GarminTyp, null, false);
wr.Write(Unknown_0x0C);
wr.Write(Locked);
wr.Write((Int16)(CreationDate.Year));
wr.Write((byte)(CreationDate.Month));
wr.Write((byte)(CreationDate.Day));
wr.Write((byte)(CreationDate.Hour));
wr.Write((byte)(CreationDate.Minute));
wr.Write((byte)(CreationDate.Second));
}
public override void Write(BinaryReaderWriter bw, uint headeroffset = 0, UInt16 headerlength = 0x29, uint gapoffset = 0, uint dataoffset = 0, bool setsectiondata = true)
{
HeaderOffset = headeroffset;
if (headerlength > 0)
{
Headerlength = headerlength;
}
CreationDate = DateTime.Now;
GapOffset = gapoffset;
DataOffset = dataoffset;
PtrZoomlevel = Headerlength;
for (int z = 0; z < ZoomlevelCount; z++)
{
ZoomLevel[z].CalculateStructureLength();
ZoomLevel[z].ZoomlevelItem.PtrSubtileTable = PtrZoomlevel;
PtrZoomlevel += (uint)ZoomLevel[z].GetTablelength();
ZoomLevel[z].ZoomlevelItem.PtrHeightdata = PtrZoomlevel;
PtrZoomlevel += (uint)ZoomLevel[z].GetDatalength();
}
Encode_Header(bw);
bw.Seek(headerlength);
for (int z = 0; z < ZoomlevelCount; z++)
{
// Subtile-Tabelle schreiben
for (int i = 0; i < ZoomLevel[z].Subtiles.Count; i++)
{
ZoomlevelTableitem zti = ZoomLevel[z].ZoomlevelItem;
ZoomLevel[z].Subtiles[i].Tableitem.Write(bw, zti.Structure_OffsetSize, zti.Structure_BaseheightSize, zti.Structure_DiffSize, zti.Structure_CodingtypeSize);
}
// Subtile-Daten schreiben
for (int i = 0; i < ZoomLevel[z].Subtiles.Count; i++)
{
bw.Write(ZoomLevel[z].Subtiles[i].Data);
}
}
// Zoomleveltabelle schreiben
for (int z = 0; z < ZoomlevelCount; z++)
{
ZoomLevel[z].ZoomlevelItem.Write(bw);
}
bw.Flush();
}
/// <summary>
/// schreibt den Blockheader und die Blockdaten
/// </summary>
/// <param name="wr"></param>
public new void Write(BinaryReaderWriter wr)
{
BinaryReaderWriter wrtmp = new BinaryReaderWriter();
base.Write(wrtmp);
SubCount = (UInt16)DataSize.Count;
//Unknown1 = (UInt16)(SubCount + 1);
wrtmp.Write(Unknown1);
wrtmp.Write(SubCount);
for (int i = 0; i < DataSize.Count; i++)
{
wrtmp.Write(DataSize[i]);
}
wrtmp.Write(HasCopyright);
wrtmp.Write(Unknown2);
wrtmp.Write(Unknown3);
wrtmp.Write(Unknown4);
wrtmp.Write(Unknown5);
wrtmp.Write(Unknown6);
wrtmp.Write(Unknown7);
for (int i = 0; i < Name.Count; i++)
{
wrtmp.WriteString(Name[i]);
}
wrtmp.Write(Unknown8);
wrtmp.Write(Unknown9);
wrtmp.Seek(1);
wrtmp.Write((short)(wrtmp.Length - 3)); // Länge des Datenbereiches schreiben
wrtmp.Seek(0);
wr.Write(wrtmp.ToArray());
wrtmp.Dispose();
}
/// <summary>
/// schreibe die aktuellen Daten als TDB-Datei
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
// alle Daten zunächst nur in einen MemoryStream schreiben und danach mit dessen Daten die CRC berechnen
MemoryStream mem = new MemoryStream();
using (BinaryReaderWriter bw = new BinaryReaderWriter(mem)) {
Head.Write(bw);
Copyright.Write(bw);
if (Head.TDBVersion >= 407)
{
Mapdescription.Write(bw);
}
Overviewmap.Write(bw);
for (int i = 0; i < Tilemap.Count; i++)
{
Tilemap[i].Write(bw);
}
wr.Write(mem.ToArray()); // Ausgabe in den Ziel-Stream
if (Head.TDBVersion >= 407)
{
// CRC32 berechnen
CRC32 crc32 = new CRC32();
mem.Seek(0, SeekOrigin.Begin);
long pos = mem.Length;
for (long i = 0; i < pos; i++)
{
crc32.update((byte)mem.ReadByte());
}
Crc.crc = crc32.Value;
Crc.Write(wr); // Ausgabe in den Ziel-Stream
}
}
}
/// <summary>
/// schreibt die Headerdaten und verwendet die akt. Dateiabschnitte dafür
/// </summary>
/// <param name="bw"></param>
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
ZoomlevelCount = (ushort)ZoomLevel.Count;
ZoomlevelRecordSize = 0x3C;
bw.Write(Flags);
bw.Write(ZoomlevelCount);
bw.Write(Unknown_0x1B);
bw.Write(ZoomlevelRecordSize);
bw.Write(PtrZoomlevel);
bw.Write(Unknown_0x25);
}
}
/// <summary>
/// schreibt den Blockheader und die Blockdaten
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
if (blh.Length == 0)
{
blh.Length = (ushort)(4 + // Mapnumber
4 + // ParentMapnumber
4 + 4 + 4 + 4 + // 4x Koordinaten
Description.Length + 1 // Description + 0-Byte
);
}
blh.Write(wr);
wr.Write(Mapnumber);
wr.Write(ParentMapnumber);
wr.Write(north);
wr.Write(east);
wr.Write(south);
wr.Write(west);
wr.WriteString(Description);
}
/// <summary>
/// schreibt die Daten in den Stream
/// </summary>
/// <param name="bw">Ausgabestream</param>
public void Write(BinaryReaderWriter bw)
{
bw.Write(rawimgdata);
}
protected override void Encode_Header(BinaryReaderWriter bw)
{
if (bw != null)
{
base.Encode_Header(bw);
// Header-Daten schreiben
Nod1Nodes.Write(bw);
bw.Write(Flags);
bw.Write(Unknown_0x1F);
bw.Write(Align);
bw.Write(Mult1);
bw.Write(TableARecordLen);
Nod2RoadData.Write(bw);
bw.Write(Unknown_0x2D);
Nod3BoundaryNodes.Write(bw);
bw.Write(Unknown_0x3B);
Nod4HighClassBoundary.Write(bw);
for (int i = 0; i < ClassBoundaries.Length; i++)
{
bw.Write(ClassBoundaries[i] - (i > 0 ? ClassBoundaries[i - 1] : 0));
}
bw.Write(Unknown_0x5B);
Nod5.Write(bw);
bw.Write(Unknown_0x6F);
Nod6.Write(bw);
bw.Write(Unknown_0x7B);
}
}
/// <summary>
/// schreibt den Header (<see cref="Blocks4Img"/> muss korrekt für die Dateilänge gesetzt sein)
/// </summary>
/// <param name="wr"></param>
public void Write(BinaryReaderWriter wr)
{
CalculateGeometry();
wr.Write(XOR);
wr.Write(Unknown_x01);
wr.Write(UpdateMonth);
wr.Write(_UpdateYear);
wr.Write(Unknown_x0c);
wr.Write(MapsourceFlag);
wr.Write(Checksum);
wr.Write(Encoding.ASCII.GetBytes(SIGNATURE));
wr.Write(Unknown_x16);
wr.Write(SectorsPerTrack);
wr.Write(HeadsPerCylinder);
wr.Write(Cylinders);
wr.Write(Unknown_x1e);
wr.Write((UInt16)CreationDate.Year);
wr.Write((byte)CreationDate.Month);
wr.Write((byte)CreationDate.Day);
wr.Write((byte)CreationDate.Hour);
wr.Write((byte)CreationDate.Minute);
wr.Write((byte)CreationDate.Second);
wr.Write(_HeadSectors);
wr.Write(Encoding.ASCII.GetBytes(MAPFILEIDENTIFIER));
wr.Write(Unknown_x47);
wr.Write(Encoding.ASCII.GetBytes(Description1));
wr.Write(HeadsPerCylinder2);
wr.Write(SectorsPerTrack2);
wr.Write(BlocksizeExp1);
wr.Write(BlocksizeExp2);
wr.Write(Blocks4Img);
wr.Write(Encoding.ASCII.GetBytes(Description2));
wr.Write(Unknown_x83);
wr.Write(StartHeadNumber4Partition);
wr.Write(StartSectorNumber4Partition);
wr.Write(StartCylinderNumber4Partition);
wr.Write(Systemtyp);
wr.Write(LastHeadNumber4Partition);
wr.Write(LastSectorNumber4Partition);
wr.Write(LastCylinderNumber4Partition);
wr.Write(RelativeSectors);
wr.Write(LastSectorNumber4IMG);
wr.Write(Unknown_x1ce);
wr.Write(BOOTSIGNATURE);
Unknown_x200 = new byte[(_HeadSectors - 1) * SECTOR_BLOCKSIZE];
wr.Write(Unknown_x200);
}
public void Write(BinaryReaderWriter wr)
{
wr.Write((byte)Typ);
UInt16 len = 0;
if (Typ == 'L')
{
len = (UInt16)(12 + Name.Count);
foreach (var item in Name)
{
len += (UInt16)item.Length;
}
wr.Write(len);
wr.Write(ProductID);
wr.Write(FamilyID);
wr.Write(MapNumber);
foreach (var item in Name)
{
wr.WriteString(item);
}
wr.Write(Unknown0);
wr.Write(Unknown1);
}
else if (Typ == 'F')
{
len = (UInt16)(8 + Name.Count);
foreach (var item in Name)
{
len += (UInt16)item.Length;
}
wr.Write(len);
wr.Write(ProductID);
wr.Write(FamilyID);
foreach (var item in Name)
{
wr.WriteString(item);
}
}
else if (Typ == 'P')
{
len = (UInt16)14;
wr.Write(len);
wr.Write(ProductID);
wr.Write(FamilyID);
wr.Write(Unknown2);
wr.Write(Unknown3);
wr.Write(Unknown4);
}
else if (Typ == 'V')
{
len = (UInt16)Name.Count;
foreach (var item in Name)
{
len += (UInt16)item.Length;
}
wr.Write(len);
foreach (var item in Name)
{
wr.WriteString(item);
}
}
}
public void Write(BinaryReaderWriter bw, int iCodepage)
{
bw.Write(Options);
switch (Colortype)
{
case ColorType.Day1:
BinaryColor.WriteColor(bw, colDayColor[0]);
break;
case ColorType.Day1_Night1:
BinaryColor.WriteColor(bw, colDayColor[0]);
BinaryColor.WriteColor(bw, colNightColor[0]);
break;
case ColorType.BM_Day2:
XBitmapDay.WriteColorTable(bw);
XBitmapDay.WriteRawdata(bw);
break;
case ColorType.BM_Day2_Night2:
BinaryColor.WriteColorTable(bw, colDayColor);
BinaryColor.WriteColorTable(bw, colNightColor);
XBitmapDay.WriteRawdata(bw);
break;
case ColorType.BM_Day1_Night2:
BinaryColor.WriteColor(bw, colDayColor[0]);
BinaryColor.WriteColorTable(bw, colNightColor);
XBitmapDay.WriteRawdata(bw);
break;
case ColorType.BM_Day2_Night1:
BinaryColor.WriteColorTable(bw, colDayColor);
BinaryColor.WriteColor(bw, colNightColor[0]);
XBitmapDay.WriteRawdata(bw);
break;
case ColorType.BM_Day1:
BinaryColor.WriteColor(bw, colDayColor[0]);
XBitmapDay.WriteRawdata(bw);
break;
case ColorType.BM_Day1_Night1:
BinaryColor.WriteColor(bw, colDayColor[0]);
BinaryColor.WriteColor(bw, colNightColor[0]);
XBitmapDay.WriteRawdata(bw);
break;
}
if (WithString)
{
Text.Write(bw, iCodepage);
}
if (WithExtendedOptions) // es folgen weitere (max. 2) Farben
{
bw.Write(ExtOptions);
switch (FontColType)
{
case FontColours.Day:
BinaryColor.WriteColor(bw, colFontColour[0]);
break;
case FontColours.Night:
BinaryColor.WriteColor(bw, colFontColour[1]);
break;
case FontColours.DayAndNight:
BinaryColor.WriteColorTable(bw, colFontColour);
break;
}
}
}
public void Write(BinaryReaderWriter w)
{
w.Write(SpecType);
w.Write(No);
w.Write(PointsHoriz);
w.Write(PointsVert);
w.Write(LastRowHeight);
w.Write(LastColWidth);
w.Write(Unknown12);
w.Write(MaxIdxHoriz);
w.Write(MaxIdxVert);
w.Write(Structure);
w.Write(SubtileTableitemSize);
w.Write(PtrSubtileTable);
w.Write(PtrHeightdata);
w.Write(west);
w.Write(north);
w.Write(pointDistanceVert);
w.Write(pointDistanceHoriz);
w.Write(MinHeight);
w.Write(MaxHeight);
}
public void Write(BinaryReaderWriter bw, int iCodepage)
{
bw.Write(Options);
bw.Write(Options2);
switch (Polylinetype)
{
case PolylineType.Day2:
BinaryColor.WriteColorTable(bw, colDayColor);
break;
case PolylineType.Day2_Night2:
BinaryColor.WriteColorTable(bw, colDayColor);
BinaryColor.WriteColorTable(bw, colNightColor);
break;
case PolylineType.Day1_Night2:
BinaryColor.WriteColor(bw, colDayColor[0]);
BinaryColor.WriteColorTable(bw, colNightColor);
break;
case PolylineType.NoBorder_Day2_Night1:
BinaryColor.WriteColorTable(bw, colDayColor);
BinaryColor.WriteColor(bw, colNightColor[0]);
break;
case PolylineType.NoBorder_Day1:
BinaryColor.WriteColor(bw, colDayColor[0]);
break;
case PolylineType.NoBorder_Day1_Night1:
BinaryColor.WriteColor(bw, colDayColor[0]);
BinaryColor.WriteColor(bw, colNightColor[0]);
break;
}
if (BitmapHeight == 0) // Linien- und Randbreite ermitteln
{
switch (Polylinetype)
{
case PolylineType.Day2:
case PolylineType.Day2_Night2:
case PolylineType.Day1_Night2:
bw.Write((byte)InnerWidth);
if (InnerWidth > 0)
{
bw.Write((byte)(2 * BorderWidth + InnerWidth));
}
break;
case PolylineType.NoBorder_Day2_Night1:
case PolylineType.NoBorder_Day1:
case PolylineType.NoBorder_Day1_Night1:
bw.Write((byte)InnerWidth);
break;
}
}
else
{
XBitmapDay.WriteRawdata(bw);
}
if (WithString)
{
Text.Write(bw, iCodepage);
}
if (WithExtendedOptions) // es folgen weitere (max. 2) Farben
{
bw.Write(ExtOptions);
switch (FontColType)
{
case FontColours.Day:
BinaryColor.WriteColor(bw, colFontColour[0]);
break;
case FontColours.Night:
BinaryColor.WriteColor(bw, colFontColour[1]);
break;
case FontColours.DayAndNight:
BinaryColor.WriteColorTable(bw, colFontColour);
break;
}
}
}
