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;
}
}
}
/// <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));
}
}
public void Read(BinaryReaderWriter br)
{
try {
Options = br.ReadByte();
uint iWidth = br.ReadByte();
uint iHeight = br.ReadByte();
colsday = br.ReadByte();
ColormodeDay = (BitmapColorMode)br.ReadByte();
this.XBitmapDay = new PixMap(iWidth, iHeight, colsday, ColormodeDay, br);
if (WithNightXpm)
{
colsnight = br.ReadByte();
ColormodeNight = (BitmapColorMode)br.ReadByte();
if (!NightXpmHasData)
{
Color[] col = BinaryColor.ReadColorTable(br, colsnight);
XBitmapNight = new PixMap(XBitmapDay);
XBitmapNight.SetNewColors(col);
}
else
{
XBitmapNight = new PixMap(Width, Height, colsnight, ColormodeNight, br);
}
}
if (WithString)
{
Text = new MultiText(br);
}
if (WithExtendedOptions)
{
ExtOptions = br.ReadByte();
switch (FontColType)
{
case FontColours.Day:
colFontColour[0] = BinaryColor.ReadColor(br);
break;
case FontColours.Night:
colFontColour[1] = BinaryColor.ReadColor(br);
break;
case FontColours.DayAndNight:
colFontColour = BinaryColor.ReadColorTable(br, 2);
break;
}
}
} catch (Exception ex) {
throw new Exception(string.Format("Fehler beim Lesen des Punktes 0x{0:x} 0x{1:x}: {2}", Type, Subtype, ex.Message));
}
}
/// <summary>
/// schreibt nur die Farbtabelle (für Polygon/Polyline)
/// </summary>
/// <param name="bw"></param>
/// <param name="bWithAlpha"></param>
public void WriteColorTable(BinaryReaderWriter bw)
{
BinaryColor.WriteColorTable(bw, colColorTable, false);
}
/// <summary>
/// erzeugt ein Bild mit max. 256 Farben (auch 0 Farben); transparent ist die "Dummy"-Farbe; liest die Farbtabelle und die Daten ev. aus dem Stream
/// </summary>
/// <param name="iWidth"></param>
/// <param name="iHeight"></param>
/// <param name="iColors">Anzahl der einzulesenden Farben</param>
/// <param name="cm"></param>
/// <param name="br"></param>
public PixMap(uint iWidth, uint iHeight, int iColors, BitmapColorMode cm, BinaryReaderWriter br = null)
{
data = new PixData(iWidth, iHeight, BitsPerPixel4BitmapColorMode(cm, iColors));
Colormode = cm;
colColorTable = new Color[iColors];
for (int i = 0; i < iColors; i++) // Init. der Farbtabelle
{
colColorTable[i] = TransparentColor;
}
if (cm == BitmapColorMode.POLY1TR) // in diesem Spezialfall alle Pixel/Bits auf 1 setzen
{
data.SetAllBits();
}
if (br != null)
{
if (iColors == 0) // keine Farbtabelle, d.h. Pixel sind direkt durch ihre Farben definiert
{
colColorTable = new Color[0];
switch (Colormode)
{
case BitmapColorMode.POI_SIMPLE:
data = new PixData(iWidth, iHeight, BpP, br);
break;
case BitmapColorMode.POI_TR:
/* Keine Ahnung warum. Eigentlich wären überhaupt keine Daten nötig.
* Mit dem 1 Bit könnten 2 Farben gemeint sein:
* 0 --> transparent
* 1 --> ???
* In der Praxis scheint aber immer 0 darin zu stehen.
*/
data = new PixData(iWidth, iHeight, BpP, br);
//for(int i=0;i<rawimgdata.Length;i++)
// if (rawimgdata[i] != 0) {
// Debug.WriteLine("Bitmap mit iColors==0 und NICHT alle Daten=0");
// break;
// }
break;
case BitmapColorMode.POI_ALPHA:
data = new PixData(iWidth, iHeight, BpP, br);
break;
case BitmapColorMode.POLY1TR:
case BitmapColorMode.POLY2:
throw new Exception(string.Format("Für den ColorMode {0} muß eine Farbtabelle mit eingelesen werden.", Colormode));
default:
throw new Exception(string.Format("Unbekannter ColorMode für Bitmap ({0:x2}).", Colormode));
}
}
else
{
switch (Colormode)
{
case BitmapColorMode.POI_SIMPLE:
case BitmapColorMode.POI_TR:
colColorTable = BinaryColor.ReadColorTable(br, iColors, false);
break;
case BitmapColorMode.POI_ALPHA:
colColorTable = BinaryColor.ReadColorTable(br, iColors, true);
break;
case BitmapColorMode.POLY1TR:
if (iColors != 1)
{
throw new Exception(string.Format("Für den ColorMode {0} kann nur 1 Farbe (nicht {1}) eingelesen werden.",
Colormode, iColors));
}
colColorTable = BinaryColor.ReadColorTable(br, 1, false);
break;
case BitmapColorMode.POLY2:
if (iColors != 2)
{
throw new Exception(string.Format("Für den ColorMode {0} können nur 2 Farben (nicht {1}) eingelesen werden.",
Colormode, iColors));
}
colColorTable = BinaryColor.ReadColorTable(br, 2, false);
break;
default:
throw new Exception(string.Format("Unbekannter ColorMode für Bitmap ({0:x2}).", Colormode));
}
data = new PixData(iWidth, iHeight, BpP, br);
}
}
}
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;
}
}
}
public void Read(BinaryReaderWriter br)
{
long startpos = br.BaseStream.Position;
try {
Options = br.ReadByte();
Options2 = br.ReadByte();
// Farben einlesen (1 bis max. 4)
switch (Polylinetype)
{
case PolylineType.Day2:
colDayColor = BinaryColor.ReadColorTable(br, 2);
break;
case PolylineType.Day2_Night2:
colDayColor = BinaryColor.ReadColorTable(br, 2);
colNightColor = BinaryColor.ReadColorTable(br, 2);
break;
case PolylineType.Day1_Night2:
colDayColor[0] = BinaryColor.ReadColor(br);
colNightColor = BinaryColor.ReadColorTable(br, 2);
break;
case PolylineType.NoBorder_Day2_Night1:
colDayColor = BinaryColor.ReadColorTable(br, 2);
colNightColor[0] = BinaryColor.ReadColor(br);
break;
case PolylineType.NoBorder_Day1:
colDayColor[0] = BinaryColor.ReadColor(br);
break;
case PolylineType.NoBorder_Day1_Night1:
colDayColor[0] = BinaryColor.ReadColor(br);
colNightColor[0] = BinaryColor.ReadColor(br);
break;
}
if (BitmapHeight == 0) // Linien- und Randbreite ermitteln
{
switch (Polylinetype)
{
case PolylineType.Day2:
case PolylineType.Day2_Night2:
case PolylineType.Day1_Night2:
InnerWidth = br.ReadByte();
if (InnerWidth > 0) // sonst Bitmap, also KEINE BorderWidth
{
BorderWidth = (br.ReadByte() - InnerWidth) / 2;
}
break;
case PolylineType.NoBorder_Day2_Night1:
case PolylineType.NoBorder_Day1:
case PolylineType.NoBorder_Day1_Night1:
InnerWidth = br.ReadByte(); // es folgt KEINE BorderWidth
break;
}
}
else // Bitmap einlesen (Höhe ist Thickness Pixel, Breite 32 Pixel, Dummyfarbe!)
{
XBitmapDay = new PixMap(32, BitmapHeight, new Color[1] {
Color.White
}, BitmapColorMode.POLY1TR, br);
}
if (WithString)
{
Text = new MultiText(br);
}
if (WithExtendedOptions)
{
ExtOptions = br.ReadByte();
switch (FontColType)
{
case FontColours.Day:
colFontColour[0] = BinaryColor.ReadColor(br);
break;
case FontColours.Night:
colFontColour[1] = BinaryColor.ReadColor(br);
break;
case FontColours.DayAndNight:
colFontColour = BinaryColor.ReadColorTable(br, 2);
break;
}
}
} catch (Exception ex) {
throw new Exception(string.Format("Fehler beim Lesen der Linie 0x{0:x} 0x{1:x}: {2}", Type, Subtype, ex.Message));
}
}
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 Read(BinaryReaderWriter br)
{
try {
Options = br.ReadByte();
// es folgen 1 bis max. 4 Farben und ev. 1 Bitmap
switch (Colortype) // hier muss sicher noch überprüft werden, ob die Typen wirklich richtig interpretiert werden
{
case ColorType.Day1:
colDayColor[0] = BinaryColor.ReadColor(br);
break;
case ColorType.Day1_Night1:
colDayColor[0] = BinaryColor.ReadColor(br);
colNightColor[0] = BinaryColor.ReadColor(br);
break;
case ColorType.BM_Day2: // 2 Farben + 1x Pixeldaten
colDayColor = BinaryColor.ReadColorTable(br, 2);
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY2, br);
break;
case ColorType.BM_Day2_Night2: // 4 Farben + 1x Pixeldaten
colDayColor = BinaryColor.ReadColorTable(br, 2);
colNightColor = BinaryColor.ReadColorTable(br, 2);
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY2, br);
XBitmapNight = new PixMap(XBitmapDay);
XBitmapNight.SetNewColors(colNightColor);
break;
case ColorType.BM_Day1_Night2: // 3 Farben + 1x Pixeldaten
colDayColor[0] = BinaryColor.ReadColor(br);
colDayColor[1] = PixMap.TransparentColor;
colNightColor = BinaryColor.ReadColorTable(br, 2);
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY2, br);
XBitmapNight = new PixMap(XBitmapDay);
XBitmapNight.ChangeColorMode(BitmapColorMode.POLY2);
XBitmapNight.SetNewColors(colNightColor);
break;
case ColorType.BM_Day2_Night1: // 3 Farben + 1x Pixeldaten
colDayColor = BinaryColor.ReadColorTable(br, 2);
colNightColor[0] = BinaryColor.ReadColor(br);
colNightColor[1] = PixMap.TransparentColor;
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY2, br);
XBitmapNight = new PixMap(XBitmapDay);
XBitmapNight.ChangeColorMode(BitmapColorMode.POLY1TR);
XBitmapNight.SetNewColors(colNightColor);
break;
case ColorType.BM_Day1: // 1 Farbe + 1x Pixeldaten
colDayColor[0] = colNightColor[0] = BinaryColor.ReadColor(br);
colDayColor[1] = colNightColor[1] = PixMap.TransparentColor;
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY1TR, br);
break;
case ColorType.BM_Day1_Night1: // 2 Farben + 1x Pixeldaten
colDayColor[0] = BinaryColor.ReadColor(br);
colDayColor[1] = PixMap.TransparentColor;
colNightColor[0] = BinaryColor.ReadColor(br);
colNightColor[1] = PixMap.TransparentColor;
XBitmapDay = new PixMap(32, 32, colDayColor, BitmapColorMode.POLY1TR, br);
XBitmapNight = new PixMap(XBitmapDay);
XBitmapNight.SetNewColors(colNightColor);
break;
}
if (WithDayBitmap)
{
// sicherheitshalber nochmal die Bitmapfarben übernehmen
DayColor1 = XBitmapDay.GetColor(0);
if (XBitmapDay.Colors > 1)
{
DayColor2 = XBitmapDay.GetColor(1);
}
if (XBitmapNight != null)
{
NightColor1 = XBitmapNight.GetColor(0);
if (XBitmapNight.Colors > 1)
{
NightColor2 = XBitmapNight.GetColor(1);
}
}
}
if (WithString)
{
Text = new MultiText(br);
}
if (WithExtendedOptions) // es folgen weitere (max. 2) Farben
{
ExtOptions = br.ReadByte();
switch (FontColType)
{
case FontColours.Day:
colFontColour[0] = BinaryColor.ReadColor(br);
break;
case FontColours.Night:
colFontColour[1] = BinaryColor.ReadColor(br);
break;
case FontColours.DayAndNight:
colFontColour = BinaryColor.ReadColorTable(br, 2);
break;
}
}
} catch (Exception ex) {
throw new Exception(string.Format("Fehler beim Lesen des Polygons 0x{0:x} 0x{1:x}: {2}", Type, Subtype, ex.Message));
}
}
