moeclipse.patch

Index: src/moeclipse/JavaBackgroundModifier.java
===================================================================
--- src/moeclipse/JavaBackgroundModifier.java	(リビジョン 1412)
+++ src/moeclipse/JavaBackgroundModifier.java	(作業コピー)
@@ -1,55 +1,137 @@
 package moeclipse;
 
-import java.net.MalformedURLException;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
 import java.net.URL;
+import java.util.Map;
+import java.util.WeakHashMap;
 
+import javax.imageio.ImageIO;
+
+import moeclipse.ImageConverter.Position;
+
 import org.eclipse.jdt.ui.text.folding.DefaultJavaFoldingStructureProvider;
 import org.eclipse.jdt.ui.text.folding.IJavaFoldingStructureProvider;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
 import org.eclipse.jface.text.source.projection.ProjectionViewer;
+import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyledText;
 import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
 import org.eclipse.ui.texteditor.ITextEditor;
 
 public class JavaBackgroundModifier extends DefaultJavaFoldingStructureProvider
 		implements IJavaFoldingStructureProvider {
 
 	protected StyledText text;
+	protected Point size;
+	protected Listener resizeListener;
+	protected Listener activateListener;
+	protected Image image;
+	static final protected Map<Point, Image> imageCache = new WeakHashMap<Point, Image>();
+	static protected BufferedImage bufferedImage;
 
 	@Override
 	public void install(ITextEditor editor, ProjectionViewer viewer) {
 		super.install(editor, viewer);
+		
 		this.text = viewer.getTextWidget();
-		text.setBackgroundImage(loadImage());
+		setSize (text.getSize());
+
+		loadBufferedImage();
+		reloadImage();
+		text.setBackgroundImage( image );
+		
+		this.resizeListener = new Listener() {
+			@Override
+			public void handleEvent(Event event) {
+				updateBackground();
+			}
+		};
+		this.text.addListener(SWT.Resize ,resizeListener);
+		
+		this.activateListener = new Listener() {
+			@Override
+			public void handleEvent(Event arg0) {
+				updateBackground();
+			}
+		};
+
+		this.text.addListener( SWT.Activate, activateListener);
 	}
+	
+	BufferedImage getBufferedImage(){
+		if( bufferedImage == null ){
+			loadBufferedImage();
+		}
+		return bufferedImage;
+	}
 
-	protected Image loadImage() {
+	void loadBufferedImage() {
 		IPreferenceStore store = Activator.getDefault().getPreferenceStore();
 		String path = store.getString(Constants.PREF_PICTURE_PATH);
-		ImageRegistry ir = Activator.getDefault().getImageRegistry();
-		ImageDescriptor id = ir.getDescriptor(path);
-		if (id == null) {
+		if( path == null ){
+			return;
+		}
+		if( bufferedImage == null ){
 			try {
-				URL url = new URL(path);
-				id = ImageDescriptor.createFromURL(url);
-				ir.put(path, id);
-			} catch (MalformedURLException e) {
+				bufferedImage = ImageIO.read( new URL( path ));
+			} catch (IOException e) {
 				Activator.log(e);
 			}
 		}
-		return ir.get(path);
 	}
+	
+	void reloadImage(){
+		if( size.x == 0 || size.y == 0 ){
+			return;
+		}
+		Image img = imageCache.get( size );
+		if( img == null ){
+			ImageData imgData = ImageConverter.resize(  bufferedImage,  size.x, size.y, text.getBackground() ,Position.BOTTOM_RIGHT);
+			ImageDescriptor id = ImageDescriptor.createFromImageData( imgData );
+			img = id.createImage();
+			imageCache.put( size ,img );
+		}
+		image = img;
+	}
+	
+	void updateBackground(){
+		Point newSize = text.getSize();
+		if( size.equals( newSize ) == false){ 
+			setSize( newSize );
+			reloadImage();
+			text.setBackgroundImage( image );
+			text.setRedraw( true );
+		}
+	}
+	
+	String getPath(){
+		IPreferenceStore store = Activator.getDefault().getPreferenceStore();
+		String path = store.getString(Constants.PREF_PICTURE_PATH);
+		return path;
+	}
+	
+	void setSize( Point p ){
+		this.size = new Point( p.x,p.y );
+	}
 
 	@Override
 	public void uninstall() {
-		this.text.setBackgroundImage(null);
-		IPreferenceStore store = Activator.getDefault().getPreferenceStore();
-		String path = store.getString(Constants.PREF_PICTURE_PATH);
-		ImageRegistry ir = Activator.getDefault().getImageRegistry();
-		ir.remove(path);
+		if( this.text.isDisposed() == false ){
+			if( this.resizeListener != null ){
+				this.text.removeListener( SWT.Resize, resizeListener);
+			}
+			if( this.activateListener != null ){
+				this.text.removeListener( SWT.Activate, activateListener);
+			}
+			this.text.setBackgroundImage(null);
+		}
+
 		super.uninstall();
 	}
-
 }
Index: src/moeclipse/ImageConverter.java
===================================================================
--- src/moeclipse/ImageConverter.java	(リビジョン 0)
+++ src/moeclipse/ImageConverter.java	(リビジョン 0)
@@ -0,0 +1,173 @@
+package moeclipse;
+
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.DirectColorModel;
+import java.awt.image.IndexColorModel;
+import java.awt.image.WritableRaster;
+
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.graphics.PaletteData;
+import org.eclipse.swt.graphics.RGB;
+
+public class ImageConverter {
+	public enum Position{
+		TOP_LEFT,
+		TOP_RIGHT,
+		BOTTOM_LEFT,
+		BOTTOM_RIGHT,
+	}
+	static ImageData resize( BufferedImage bufferedImage ,double width ,double height, Color color ,Position position){
+		double dh = bufferedImage.getHeight();
+		double dw = bufferedImage.getWidth();
+		double scaleX = width / dw;
+		double scaleY = height / dh;
+		
+		int w = (int) ( scaleX < scaleY ?  width : dw * scaleY );
+		int h = (int) ( scaleX < scaleY ?  dh * scaleX : height );
+
+		if( w <= 0 || h <= 0){
+			return convertToSWT( bufferedImage , (int)dw,(int)dh,color, bufferedImage.getColorModel(), position);
+		}
+		Image image =  bufferedImage
+			.getScaledInstance(w, h, Image.SCALE_AREA_AVERAGING);
+ 
+		BufferedImage resizedImage = bufferImage(image, BufferedImage.TYPE_INT_RGB );
+		
+		return convertToSWT( resizedImage , (int)width, (int)height ,color,bufferedImage.getColorModel() , position);
+	}
+	
+	static BufferedImage convertToAWT(ImageData data) {
+		ColorModel colorModel = null;
+		PaletteData palette = data.palette;
+		if (palette.isDirect) {
+			colorModel = new DirectColorModel(data.depth, palette.redMask, palette.greenMask, palette.blueMask);
+			BufferedImage bufferedImage = new BufferedImage(colorModel, colorModel.createCompatibleWritableRaster(data.width, data.height), false, null);
+			for (int y = 0; y < data.height; y++) {
+				for (int x = 0; x < data.width; x++) {
+					int pixel = data.getPixel(x, y);
+					RGB rgb = palette.getRGB(pixel);
+					bufferedImage.setRGB(x, y,  rgb.red << 16 | rgb.green << 8 | rgb.blue);
+				}
+			}
+			return bufferedImage;
+		} else {
+			RGB[] rgbs = palette.getRGBs();
+			byte[] red = new byte[rgbs.length];
+			byte[] green = new byte[rgbs.length];
+			byte[] blue = new byte[rgbs.length];
+			for (int i = 0; i < rgbs.length; i++) {
+				RGB rgb = rgbs[i];
+				red[i] = (byte)rgb.red;
+				green[i] = (byte)rgb.green;
+				blue[i] = (byte)rgb.blue;
+			}
+			if (data.transparentPixel != -1) {
+				colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue, data.transparentPixel);
+			} else {
+				colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue);
+			}		
+			BufferedImage bufferedImage = new BufferedImage(colorModel, colorModel.createCompatibleWritableRaster(data.width, data.height), false, null);
+			WritableRaster raster = bufferedImage.getRaster();
+			int[] pixelArray = new int[1];
+			for (int y = 0; y < data.height; y++) {
+				for (int x = 0; x < data.width; x++) {
+					int pixel = data.getPixel(x, y);
+					pixelArray[0] = pixel;
+					raster.setPixel(x, y, pixelArray);
+				}
+			}
+			return bufferedImage;
+		}
+	}
+
+	static ImageData convertToSWT(BufferedImage bufferedImage ,int width ,int height, Color color, ColorModel orgColorModel, Position position) {
+		int bh = bufferedImage.getHeight();
+		int bw = bufferedImage.getWidth();
+		int offsetY = (position == Position.TOP_LEFT || position == Position.TOP_RIGHT ) ? 0 : height - bh;
+		int offsetX = (position == Position.TOP_LEFT || position == Position.BOTTOM_LEFT ) ? 0 : width - bw;
+		
+		if (bufferedImage.getColorModel() instanceof DirectColorModel) {
+			DirectColorModel colorModel = (DirectColorModel)bufferedImage.getColorModel();
+			
+			PaletteData palette = new PaletteData(colorModel.getRedMask(), colorModel.getGreenMask(), colorModel.getBlueMask());
+			ImageData data = new ImageData(width ,height, colorModel.getPixelSize(), palette);
+			int defaoultPixel = palette.getPixel( color.getRGB() );
+			
+			
+			for (int y = 0; y < data.height; y++) {
+				for (int x = 0; x < data.width; x++) {
+					if( y < offsetY || y >= bh + offsetY || x < offsetX || x >= bw + offsetX ){
+						data.setPixel(x, y, defaoultPixel);
+						if (colorModel.hasAlpha()) {
+							data.setAlpha(x, y, (defaoultPixel >> 24) & 0xFF);
+						}
+						continue;
+					}
+					
+					int rgb = bufferedImage.getRGB(x - offsetX, y - offsetY);
+					
+					int pixel = palette.getPixel(new RGB((rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF)); 
+					data.setPixel(x, y, pixel);
+					if (colorModel.hasAlpha()) {
+						data.setAlpha(x , y , (rgb >> 24) & 0xFF);
+					}
+					else if( orgColorModel.hasAlpha() ){
+						if( orgColorModel instanceof DirectColorModel ){
+							int alpha = ((DirectColorModel)orgColorModel).getAlphaMask();
+							data.setAlpha(x, y, (rgb >> 24) & alpha);
+						}
+					}
+				}
+			}
+			return data;		
+		} else if (bufferedImage.getColorModel() instanceof IndexColorModel) {
+			IndexColorModel colorModel = (IndexColorModel)bufferedImage.getColorModel();
+			int size = colorModel.getMapSize();
+			byte[] reds = new byte[size];
+			byte[] greens = new byte[size];
+			byte[] blues = new byte[size];
+			colorModel.getReds(reds);
+			colorModel.getGreens(greens);
+			colorModel.getBlues(blues);
+			RGB[] rgbs = new RGB[size];
+			for (int i = 0; i < rgbs.length; i++) {
+				rgbs[i] = new RGB(reds[i] & 0xFF, greens[i] & 0xFF, blues[i] & 0xFF);
+			}
+			PaletteData palette = new PaletteData(rgbs);
+			ImageData data = new ImageData(width, height, colorModel.getPixelSize(), palette);
+			data.transparentPixel = colorModel.getTransparentPixel();
+			WritableRaster raster = bufferedImage.getRaster();
+			int[] pixelArray = new int[1];
+			int defaoultPixel = palette.getPixel( color.getRGB() );
+			for (int y = 0; y < data.height; y++) {
+				for (int x = 0; x < data.width; x++) {
+					if( y < offsetY || y >= bh + offsetY || x < offsetX || x >= bw + offsetX ){
+						data.setPixel(x, y, defaoultPixel);
+						continue;
+					}
+					raster.getPixel(x - offsetX, y - offsetY, pixelArray);
+					data.setPixel(x, y , pixelArray[0]);
+				}
+			}
+			return data;
+		}
+		return null;
+	}
+	
+	private static final int DEFAULT_IMAGE_TYPE = BufferedImage.TYPE_INT_RGB;
+
+    public static BufferedImage bufferImage(Image image) {
+        return bufferImage(image, DEFAULT_IMAGE_TYPE);
+    }
+
+    public static BufferedImage bufferImage(Image image, int type) {
+        BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
+        Graphics2D g = bufferedImage.createGraphics();
+        g.drawImage(image, null, null);
+        return bufferedImage;
+    }
+}