зеркало из https://github.com/mono/ikvm-fork.git
684 строки
22 KiB
C#
684 строки
22 KiB
C#
/*
|
|
Copyright (C) 2012 Volker Berlin (i-net software)
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
|
|
Jeroen Frijters
|
|
jeroen@frijters.net
|
|
|
|
*/
|
|
|
|
namespace ikvm.awt
|
|
{
|
|
|
|
using java.awt.image;
|
|
using System.IO;
|
|
using System.Drawing;
|
|
|
|
/// <summary>
|
|
/// Encodes images in ICO format.
|
|
/// </summary>
|
|
internal class IconFactory
|
|
{
|
|
|
|
/// <summary>
|
|
/// Indicates that ICO data represents an icon (.ICO).
|
|
/// </summary>
|
|
private const int TYPE_ICON = 1;
|
|
|
|
private BinaryWriter writer;
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of IconFactory </summary>
|
|
internal IconFactory()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a Icon from the given list of images
|
|
/// </summary>
|
|
/// <param name="images">list of images</param>
|
|
/// <returns></returns>
|
|
internal Icon CreateIcon(java.util.List images, Size size)
|
|
{
|
|
MemoryStream stream = new MemoryStream();
|
|
Write(images, stream);
|
|
stream.Position = 0;
|
|
return new Icon(stream, size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes multiple images without colour depth conversion.
|
|
/// </summary>
|
|
/// <param name="images">
|
|
/// the list of source images to be encoded </param>
|
|
/// <param name="stream">
|
|
/// the output to which the encoded image will be written </param>
|
|
internal void Write(java.util.List images, System.IO.Stream stream)
|
|
{
|
|
writer = new BinaryWriter(stream);
|
|
|
|
int count = images.size();
|
|
|
|
// file header 6
|
|
WriteFileHeader(count, TYPE_ICON);
|
|
|
|
// file offset where images start
|
|
int fileOffset = 6 + count * 16;
|
|
|
|
// icon entries 16 * count
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
BufferedImage imgc = (BufferedImage)images.get(i);
|
|
fileOffset += WriteIconEntry(imgc, fileOffset);
|
|
}
|
|
|
|
// images
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
BufferedImage imgc = (BufferedImage)images.get(i);
|
|
|
|
// info header
|
|
WriteInfoHeader(imgc);
|
|
// color map
|
|
if (imgc.getColorModel().getPixelSize() <= 8)
|
|
{
|
|
IndexColorModel icm = (IndexColorModel)imgc.getColorModel();
|
|
WriteColorMap(icm);
|
|
}
|
|
// xor bitmap
|
|
WriteXorBitmap(imgc);
|
|
// and bitmap
|
|
WriteAndBitmap(imgc);
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the ICO file header for an ICO containing the given number of
|
|
/// images.
|
|
/// </summary>
|
|
/// <param name="count">
|
|
/// the number of images in the ICO </param>
|
|
/// <param name="type">
|
|
/// TYPE_ICON
|
|
private void WriteFileHeader(int count, int type)
|
|
{
|
|
// reserved 2
|
|
writer.Write((short)0);
|
|
// type 2
|
|
writer.Write((short)type);
|
|
// count 2
|
|
writer.Write((short)count);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes the <em>AND</em> bitmap for the given image according the its
|
|
/// alpha channel (transparency) and writes it to the given output.
|
|
/// </summary>
|
|
/// <param name="img">
|
|
/// the image to encode as the <em>AND</em> bitmap. </param>
|
|
private void WriteAndBitmap(BufferedImage img)
|
|
{
|
|
WritableRaster alpha = img.getAlphaRaster();
|
|
|
|
// indexed transparency (eg. GIF files)
|
|
if (img.getColorModel() is IndexColorModel && img.getColorModel().hasAlpha())
|
|
{
|
|
int w = img.getWidth();
|
|
int h = img.getHeight();
|
|
|
|
int bytesPerLine = GetBytesPerLine1(w);
|
|
|
|
byte[] line = new byte[bytesPerLine];
|
|
|
|
IndexColorModel icm = (IndexColorModel)img.getColorModel();
|
|
Raster raster = img.getRaster();
|
|
|
|
for (int y = h - 1; y >= 0; y--)
|
|
{
|
|
for (int x = 0; x < w; x++)
|
|
{
|
|
int bi = x / 8;
|
|
int i = x % 8;
|
|
// int a = alpha.getSample(x, y, 0);
|
|
int p = raster.getSample(x, y, 0);
|
|
int a = icm.getAlpha(p);
|
|
// invert bit since and mask is applied to xor mask
|
|
int b = ~a & 1;
|
|
line[bi] = SetBit(line[bi], i, b);
|
|
}
|
|
|
|
writer.Write(line);
|
|
}
|
|
}
|
|
// no transparency
|
|
else if (alpha == null)
|
|
{
|
|
int h = img.getHeight();
|
|
int w = img.getWidth();
|
|
// calculate number of bytes per line, including 32-bit padding
|
|
int bytesPerLine = GetBytesPerLine1(w);
|
|
|
|
byte[] line = new byte[bytesPerLine];
|
|
for (int i = 0; i < bytesPerLine; i++)
|
|
{
|
|
line[i] = (byte)0;
|
|
}
|
|
|
|
for (int y = h - 1; y >= 0; y--)
|
|
{
|
|
writer.Write(line);
|
|
}
|
|
}
|
|
// transparency (ARGB, etc. eg. PNG)
|
|
else
|
|
{
|
|
int w = img.getWidth();
|
|
int h = img.getHeight();
|
|
|
|
int bytesPerLine = GetBytesPerLine1(w);
|
|
|
|
byte[] line = new byte[bytesPerLine];
|
|
|
|
for (int y = h - 1; y >= 0; y--)
|
|
{
|
|
for (int x = 0; x < w; x++)
|
|
{
|
|
int bi = x / 8;
|
|
int i = x % 8;
|
|
int a = alpha.getSample(x, y, 0);
|
|
// invert bit since and mask is applied to xor mask
|
|
int b = ~a & 1;
|
|
line[bi] = SetBit(line[bi], i, b);
|
|
}
|
|
|
|
writer.Write(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void WriteXorBitmap(BufferedImage img)
|
|
{
|
|
Raster raster = img.getRaster();
|
|
switch (img.getColorModel().getPixelSize())
|
|
{
|
|
case 1:
|
|
Write1(raster);
|
|
break;
|
|
case 4:
|
|
Write4(raster);
|
|
break;
|
|
case 8:
|
|
Write8(raster);
|
|
break;
|
|
case 24:
|
|
Write24(raster);
|
|
break;
|
|
case 32:
|
|
Raster alpha = img.getAlphaRaster();
|
|
Write32(raster, alpha);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the <tt>InfoHeader</tt> structure to output
|
|
///
|
|
/// </summary>
|
|
private void WriteInfoHeader(BufferedImage img)
|
|
{
|
|
// Size of InfoHeader structure = 40
|
|
writer.Write(40);
|
|
// Width
|
|
writer.Write(img.getWidth());
|
|
// Height
|
|
writer.Write(img.getHeight() * 2);
|
|
// Planes (=1)
|
|
writer.Write((short)1);
|
|
// Bit count
|
|
writer.Write((short)img.getColorModel().getPixelSize());
|
|
// Compression
|
|
writer.Write(0);
|
|
// Image size - compressed size of image or 0 if Compression = 0
|
|
writer.Write(0);
|
|
// horizontal resolution pixels/meter
|
|
writer.Write(0);
|
|
// vertical resolution pixels/meter
|
|
writer.Write(0);
|
|
// Colors used - number of colors actually used
|
|
writer.Write(0);
|
|
// Colors important - number of important colors 0 = all
|
|
writer.Write(0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the <tt>IconEntry</tt> structure to output
|
|
/// </summary>
|
|
private int WriteIconEntry(BufferedImage img, int fileOffset)
|
|
{
|
|
// Width 1 byte Cursor Width (16, 32 or 64)
|
|
int width = img.getWidth();
|
|
writer.Write((byte)(width == 256 ? 0 : width));
|
|
// Height 1 byte Cursor Height (16, 32 or 64 , most commonly = Width)
|
|
int height = img.getHeight();
|
|
writer.Write((byte)(height == 256 ? 0 : height));
|
|
// ColorCount 1 byte Number of Colors (2,16, 0=256)
|
|
short BitCount = (short)img.getColorModel().getPixelSize();
|
|
int NumColors = 1 << (BitCount == 32 ? 24 : (int)BitCount);
|
|
byte ColorCount = (byte)(NumColors >= 256 ? 0 : NumColors);
|
|
writer.Write((byte)ColorCount);
|
|
// Reserved 1 byte =0
|
|
writer.Write((byte)0);
|
|
// Planes 2 byte =1
|
|
writer.Write((short)1);
|
|
// BitCount 2 byte bits per pixel (1, 4, 8)
|
|
writer.Write((short)BitCount);
|
|
// SizeInBytes 4 byte Size of (InfoHeader + ANDbitmap + XORbitmap)
|
|
int cmapSize = GetColorMapSize(BitCount);
|
|
int xorSize = GetBitmapSize(width, height, BitCount);
|
|
int andSize = GetBitmapSize(width, height, 1);
|
|
int size = 40 + cmapSize + xorSize + andSize;
|
|
writer.Write(size);
|
|
// FileOffset 4 byte FilePos, where InfoHeader starts
|
|
writer.Write(fileOffset);
|
|
return size;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the colour map resulting from the source <tt>IndexColorModel</tt>.
|
|
/// </summary>
|
|
/// <param name="icm">
|
|
/// the source <tt>IndexColorModel</tt> </param>
|
|
private void WriteColorMap(IndexColorModel icm)
|
|
{
|
|
int mapSize = icm.getMapSize();
|
|
for (int i = 0; i < mapSize; i++)
|
|
{
|
|
int rgb = icm.getRGB(i);
|
|
byte r = (byte)(rgb >> 16);
|
|
byte g = (byte)(rgb >> 8);
|
|
byte b = (byte)(rgb);
|
|
writer.Write(b);
|
|
writer.Write(g);
|
|
writer.Write(r);
|
|
writer.Write((byte)0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the number of bytes per line required for the given width in
|
|
/// pixels, for a 1-bit bitmap. Lines are always padded to the next 4-byte
|
|
/// boundary.
|
|
/// </summary>
|
|
/// <param name="width">
|
|
/// the width in pixels </param>
|
|
/// <returns> the number of bytes per line </returns>
|
|
private int GetBytesPerLine1(int width)
|
|
{
|
|
int ret = (int)width / 8;
|
|
if (ret % 4 != 0)
|
|
{
|
|
ret = (ret / 4 + 1) * 4;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the number of bytes per line required for the given with in
|
|
/// pixels, for a 4-bit bitmap. Lines are always padded to the next 4-byte
|
|
/// boundary.
|
|
/// </summary>
|
|
/// <param name="width">
|
|
/// the width in pixels </param>
|
|
/// <returns> the number of bytes per line </returns>
|
|
private int GetBytesPerLine4(int width)
|
|
{
|
|
int ret = (int)width / 2;
|
|
if (ret % 4 != 0)
|
|
{
|
|
ret = (ret / 4 + 1) * 4;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the number of bytes per line required for the given with in
|
|
/// pixels, for a 8-bit bitmap. Lines are always padded to the next 4-byte
|
|
/// boundary.
|
|
/// </summary>
|
|
/// <param name="width">
|
|
/// the width in pixels </param>
|
|
/// <returns> the number of bytes per line </returns>
|
|
private int GetBytesPerLine8(int width)
|
|
{
|
|
int ret = width;
|
|
if (ret % 4 != 0)
|
|
{
|
|
ret = (ret / 4 + 1) * 4;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the number of bytes per line required for the given with in
|
|
/// pixels, for a 24-bit bitmap. Lines are always padded to the next 4-byte
|
|
/// boundary.
|
|
/// </summary>
|
|
/// <param name="width">
|
|
/// the width in pixels </param>
|
|
/// <returns> the number of bytes per line </returns>
|
|
private int GetBytesPerLine24(int width)
|
|
{
|
|
int ret = width * 3;
|
|
if (ret % 4 != 0)
|
|
{
|
|
ret = (ret / 4 + 1) * 4;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the size in bytes of a bitmap with the specified size and
|
|
/// colour depth.
|
|
/// </summary>
|
|
/// <param name="w">
|
|
/// the width in pixels </param>
|
|
/// <param name="h">
|
|
/// the height in pixels </param>
|
|
/// <param name="bpp">
|
|
/// the colour depth (bits per pixel) </param>
|
|
/// <returns> the size of the bitmap in bytes </returns>
|
|
private int GetBitmapSize(int w, int h, int bpp)
|
|
{
|
|
int bytesPerLine = 0;
|
|
switch (bpp)
|
|
{
|
|
case 1:
|
|
bytesPerLine = GetBytesPerLine1(w);
|
|
break;
|
|
case 4:
|
|
bytesPerLine = GetBytesPerLine4(w);
|
|
break;
|
|
case 8:
|
|
bytesPerLine = GetBytesPerLine8(w);
|
|
break;
|
|
case 24:
|
|
bytesPerLine = GetBytesPerLine24(w);
|
|
break;
|
|
case 32:
|
|
bytesPerLine = w * 4;
|
|
break;
|
|
}
|
|
int ret = bytesPerLine * h;
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes raster data as a 1-bit bitmap.
|
|
/// </summary>
|
|
/// <param name="raster">
|
|
/// the source raster data </param>
|
|
private void Write1(Raster raster)
|
|
{
|
|
int bytesPerLine = GetBytesPerLine1(raster.getWidth());
|
|
|
|
byte[] line = new byte[bytesPerLine];
|
|
|
|
for (int y = raster.getHeight() - 1; y >= 0; y--)
|
|
{
|
|
for (int i = 0; i < bytesPerLine; i++)
|
|
{
|
|
line[i] = 0;
|
|
}
|
|
|
|
for (int x = 0; x < raster.getWidth(); x++)
|
|
{
|
|
int bi = x / 8;
|
|
int i = x % 8;
|
|
int index = raster.getSample(x, y, 0);
|
|
line[bi] = SetBit(line[bi], i, index);
|
|
}
|
|
|
|
writer.Write(line);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes raster data as a 4-bit bitmap.
|
|
/// </summary>
|
|
/// <param name="raster">
|
|
/// the source raster data </param>
|
|
private void Write4(Raster raster)
|
|
{
|
|
int width = raster.getWidth();
|
|
int height = raster.getHeight();
|
|
|
|
// calculate bytes per line
|
|
int bytesPerLine = GetBytesPerLine4(width);
|
|
|
|
// line buffer
|
|
byte[] line = new byte[bytesPerLine];
|
|
|
|
// encode and write lines
|
|
for (int y = height - 1; y >= 0; y--)
|
|
{
|
|
|
|
// clear line buffer
|
|
for (int i = 0; i < bytesPerLine; i++)
|
|
{
|
|
line[i] = 0;
|
|
}
|
|
|
|
// encode raster data for line
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
|
|
// calculate buffer index
|
|
int bi = x / 2;
|
|
|
|
// calculate nibble index (high order or low order)
|
|
int i = x % 2;
|
|
|
|
// get color index
|
|
int index = raster.getSample(x, y, 0);
|
|
// set color index in buffer
|
|
line[bi] = SetNibble(line[bi], i, index);
|
|
}
|
|
|
|
// write line data (padding bytes included)
|
|
writer.Write(line);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes raster data as an 8-bit bitmap.
|
|
/// </summary>
|
|
/// <param name="raster">
|
|
/// the source raster data </param>
|
|
private void Write8(Raster raster)
|
|
{
|
|
int width = raster.getWidth();
|
|
int height = raster.getHeight();
|
|
|
|
// calculate bytes per line
|
|
int bytesPerLine = GetBytesPerLine8(width);
|
|
|
|
// write lines
|
|
for (int y = height - 1; y >= 0; y--)
|
|
{
|
|
|
|
// write raster data for each line
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
|
|
// get color index for pixel
|
|
byte index = (byte)raster.getSample(x, y, 0);
|
|
|
|
// write color index
|
|
writer.Write(index);
|
|
}
|
|
|
|
// write padding bytes at end of line
|
|
for (int i = width; i < bytesPerLine; i++)
|
|
{
|
|
writer.Write((byte)0);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes raster data as a 24-bit bitmap.
|
|
/// </summary>
|
|
/// <param name="raster">
|
|
/// the source raster data </param>
|
|
private void Write24(Raster raster)
|
|
{
|
|
int width = raster.getWidth();
|
|
int height = raster.getHeight();
|
|
|
|
// calculate bytes per line
|
|
int bytesPerLine = GetBytesPerLine24(width);
|
|
|
|
// write lines
|
|
for (int y = height - 1; y >= 0; y--)
|
|
{
|
|
|
|
// write pixel data for each line
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
|
|
// get RGB values for pixel
|
|
byte r = (byte)raster.getSample(x, y, 0);
|
|
byte g = (byte)raster.getSample(x, y, 1);
|
|
byte b = (byte)raster.getSample(x, y, 2);
|
|
|
|
// write RGB values
|
|
writer.Write(b);
|
|
writer.Write(g);
|
|
writer.Write(r);
|
|
}
|
|
|
|
// write padding bytes at end of line
|
|
for (int i = width * 3; i < bytesPerLine; i++)
|
|
{
|
|
writer.Write((byte)0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes and writes raster data, together with alpha (transparency) data,
|
|
/// as a 32-bit bitmap.
|
|
/// </summary>
|
|
/// <param name="raster">
|
|
/// the source raster data </param>
|
|
/// <param name="alpha">
|
|
/// the source alpha data </param>
|
|
private void Write32(Raster raster, Raster alpha)
|
|
{
|
|
int width = raster.getWidth();
|
|
int height = raster.getHeight();
|
|
|
|
// write lines
|
|
for (int y = height - 1; y >= 0; y--)
|
|
{
|
|
|
|
// write pixel data for each line
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
|
|
// get RGBA values
|
|
byte r = (byte)raster.getSample(x, y, 0);
|
|
byte g = (byte)raster.getSample(x, y, 1);
|
|
byte b = (byte)raster.getSample(x, y, 2);
|
|
byte a = (byte)alpha.getSample(x, y, 0);
|
|
|
|
// write RGBA values
|
|
writer.Write(b);
|
|
writer.Write(g);
|
|
writer.Write(r);
|
|
writer.Write(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a particular bit in a byte.
|
|
/// </summary>
|
|
/// <param name="bits">
|
|
/// the source byte </param>
|
|
/// <param name="index">
|
|
/// the index of the bit to set </param>
|
|
/// <param name="bit">
|
|
/// the value for the bit, which should be either <tt>0</tt> or
|
|
/// <tt>1</tt>. </param>
|
|
/// <param name="the">
|
|
/// resultant byte </param>
|
|
private byte SetBit(byte bits, int index, int bit)
|
|
{
|
|
if (bit == 0)
|
|
{
|
|
bits &= (byte)~(1 << (7 - index));
|
|
}
|
|
else
|
|
{
|
|
bits |= (byte)(1 << (7 - index));
|
|
}
|
|
return bits;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets a particular nibble (4 bits) in a byte.
|
|
/// </summary>
|
|
/// <param name="nibbles">
|
|
/// the source byte </param>
|
|
/// <param name="index">
|
|
/// the index of the nibble to set </param>
|
|
/// <param name="the">
|
|
/// value for the nibble, which should be in the range
|
|
/// <tt>0x0..0xF</tt>. </param>
|
|
private byte SetNibble(byte nibbles, int index, int nibble)
|
|
{
|
|
nibbles |= (byte)(nibble << ((1 - index) * 4));
|
|
|
|
return nibbles;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the size in bytes for a colour map with the specified bit
|
|
/// count.
|
|
/// </summary>
|
|
/// <param name="sBitCount">
|
|
/// the bit count, which represents the colour depth </param>
|
|
/// <returns> the size of the colour map, in bytes if <tt>sBitCount</tt> is
|
|
/// less than or equal to 8, otherwise <tt>0</tt> as colour maps are
|
|
/// only used for bitmaps with a colour depth of 8 bits or less. </returns>
|
|
private int GetColorMapSize(short sBitCount)
|
|
{
|
|
int ret = 0;
|
|
if (sBitCount <= 8)
|
|
{
|
|
ret = (1 << sBitCount) * 4;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
}
|
|
}
|