/**
* Builds an image data that is based on the released image but has the pressed/enter key area
* painted with data from the pressed/enter image
*
* @param key The pressed key
* @param isEnter Whether the image being retrieved will be used for enter or pressed
* @return An image data built the way described at method description
*/
private ImageData getKeyImageData(IAndroidKey key, boolean isEnter) {
ImageData resultingImage;
ImageData releasedImage = getImageData(false, false);
ImageData keyImage = isEnter ? getImageData(false, true) : getImageData(true, false);
resultingImage = (ImageData) releasedImage.clone();
Rectangle keyArea = key.getKeyArea();
int resultingImageSize = resultingImage.width * keyArea.height;
int[] keyPixelBuffer = new int[resultingImageSize];
int startY = keyArea.y < 0 ? 0 : keyArea.y;
keyImage.getPixels(0, startY, resultingImageSize, keyPixelBuffer, 0);
for (int line = 0; line < keyArea.height; line++) {
int pos = (line * resultingImage.width) + Math.abs(keyArea.x);
int startX = Math.abs(keyArea.x);
startY = (keyArea.y < 0 ? 0 : keyArea.y) + line;
if (startY < 0) {
continue;
}
int putWidth = keyArea.x < 0 ? keyArea.width - startX : keyArea.width;
resultingImage.setPixels(startX, startY, putWidth, keyPixelBuffer, pos);
}
return resultingImage;
}
private ImageData createHilbertHeapImage(byte pixData[]) {
int w, h;
// Pick an image size that the largest of heaps will fit into.
w = (int) Math.sqrt(((16 * 1024 * 1024) / 8));
// Space-filling curves require a power-of-2 width.
w = nextPow2(w);
h = w;
// Create the heap image.
ImageData id = new ImageData(w, h, 8, mMapPalette);
// Copy the data into the image
// int maxX = zOrderData(id, pixData);
Point maxP = hilbertOrderData(id, pixData);
// update the max size to make it a round number once the zoom is applied
int factor = 100 / ZOOMS[mZoom.getSelectionIndex()];
if (factor != 1) {
int tmp = maxP.x % factor;
if (tmp != 0) {
maxP.x += factor - tmp;
}
tmp = maxP.y % factor;
if (tmp != 0) {
maxP.y += factor - tmp;
}
}
if (maxP.y < id.height) {
// Crop the image down to the interesting part.
id = new ImageData(id.width, maxP.y, id.depth, id.palette, id.scanlinePad, id.data);
}
if (maxP.x < id.width) {
// crop the image again. A bit trickier this time.
ImageData croppedId = new ImageData(maxP.x, id.height, id.depth, id.palette);
int[] buffer = new int[maxP.x];
for (int l = 0; l < id.height; l++) {
id.getPixels(0, l, maxP.x, buffer, 0);
croppedId.setPixels(0, l, maxP.x, buffer, 0);
}
id = croppedId;
}
// apply the zoom
if (factor != 1) {
id = id.scaledTo(id.width / factor, id.height / factor);
}
return id;
}
){kind=link}
/**
* Converts an AWT based buffered image into an SWT <code>Image</code>. This will always return an
* <code>Image</code> that has 24 bit depth regardless of the type of AWT buffered image that is
* passed into the method.
*
* @param awtImage the {@link java.awt.image.BufferedImage} to be converted to an <code>Image
* </code>
* @return an <code>Image</code> that represents the same image data as the AWT <code>
* BufferedImage</code> type.
*/
private static org.eclipse.swt.graphics.Image toSWT(Device device, BufferedImage awtImage) {
// We can force bitdepth to be 24 bit because BufferedImage getRGB
// allows us to always retrieve 24 bit data regardless of source color depth.
PaletteData palette = new PaletteData(0xFF0000, 0xFF00, 0xFF);
ImageData swtImageData = new ImageData(awtImage.getWidth(), awtImage.getHeight(), 24, palette);
// Ensure scansize is aligned on 32 bit.
int scansize = (((awtImage.getWidth() * 3) + 3) * 4) / 4;
WritableRaster alphaRaster = awtImage.getAlphaRaster();
byte[] alphaBytes = new byte[awtImage.getWidth()];
for (int y = 0; y < awtImage.getHeight(); y++) {
int[] buff = awtImage.getRGB(0, y, awtImage.getWidth(), 1, null, 0, scansize);
swtImageData.setPixels(0, y, awtImage.getWidth(), buff, 0);
if (alphaRaster != null) {
int[] alpha = alphaRaster.getPixels(0, y, awtImage.getWidth(), 1, (int[]) null);
for (int i = 0; i < awtImage.getWidth(); i++) {
alphaBytes[i] = (byte) alpha[i];
}
swtImageData.setAlphas(0, y, awtImage.getWidth(), alphaBytes, 0);
}
}
return new org.eclipse.swt.graphics.Image(device, swtImageData);
}
public void setPixels(
final int xmin,
final int ymin,
final int width,
final int height,
final int[] pixels32,
final int pixeloffset,
final int pixelscan) {
logger.debug("Actualizando imagen de pantalla");
// Zona actual e imagen de fondo
if (loaded) {
SVGNode root = raster.document.root;
// Zona actual
TinyMatrix inverse = root.getGlobalTransform().inverse();
TinyPoint p1 = new TinyPoint(0, 0);
inverse.transform(p1);
TinyPoint p2 = new TinyPoint(width << TinyUtil.FIX_BITS, height << TinyUtil.FIX_BITS);
inverse.transform(p2);
if (currentZone.isEmpty()
|| currentZone.xmin != p1.x
|| currentZone.ymin != p1.y
|| currentZone.xmax != p2.x
|| currentZone.ymax != p2.y) {
currentZone.xmin = p1.x;
currentZone.ymin = p1.y;
currentZone.xmax = p2.x;
currentZone.ymax = p2.y;
// Nueva imagen de fondo
if (backImage != null && !backImage.isDisposed()) {
backImage.dispose();
backImage = null;
}
backImage = getBackImage();
}
}
// Imagen del SVG
int totalHeight = 0;
try {
totalHeight = pixels32.length / pixelscan;
// Establecer los pixeles y los alphas
ImageData imData =
new ImageData(pixelscan, totalHeight, 32, new PaletteData(0xFF0000, 0xFF00, 0xFF));
byte[] alphaData = new byte[pixels32.length];
for (int i = 0; i < pixels32.length; i++) {
alphaData[i] = (byte) (pixels32[i] >> 24);
}
imData.setPixels(0, 0, pixels32.length, pixels32, 0);
imData.setAlphas(0, 0, pixels32.length, alphaData, 0);
if (svgImage != null && !svgImage.isDisposed()) svgImage.dispose();
// logger.debug("Antes de generar la imagen1:");
// logger.debug("Antes de generar la imagen2:"+imData.height);
svgImage = new Image(Display.getDefault(), imData);
logger.debug("Imagen generada");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.debug("ERROR");
}
logger.debug("Verificando clipping");
// Clipping
if (width < pixelscan || height < totalHeight) {
logger.debug("Hay clipping");
GC gc = new GC(svgImage);
int rasterBackground = raster.getBackground();
Color rasterBackgroundColor =
new Color(
Display.getDefault(),
(rasterBackground & 0x00FF0000) >> 16,
(rasterBackground & 0x0000FF00) >> 8,
(rasterBackground & 0x000000FF));
gc.setBackground(rasterBackgroundColor);
if (xmin > 0) {
gc.fillRectangle(0, 0, xmin, totalHeight);
}
if (xmin + width < pixelscan) {
gc.fillRectangle(xmin + width, 0, pixelscan - xmin - width, totalHeight);
}
if (ymin > 0) {
gc.fillRectangle(0, 0, pixelscan, ymin);
}
if (ymin + height < totalHeight) {
gc.fillRectangle(0, ymin + height, pixelscan, totalHeight - ymin - height);
}
rasterBackgroundColor.dispose();
gc.dispose();
}
// logger.debug("Arrancando thread de display");
if (synchPaint) {
getDisplay().syncExec(new redrawThread());
} else {
getDisplay().asyncExec(new redrawThread());
}
logger.debug("Imagen de pantalla actualizada");
}