Attachment #22573 for bug #59527

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 59527
Collapse All | Expand All




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Point;
import java.awt.Shape;

import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

import java.util.Enumeration;

import java.lang.Math;

/**
 * Implementation of the airbrush tool
 *
 * @author Timothy Boyce
 */
class BitmapAirbrush extends BitmapTool {
    protected GeneralPath brushShape;
    Ellipse2D.Float brushArea;
    protected int brushSize;
    protected int brushSparcity;
    
    public BitmapAirbrush(int xVal, int yVal, Color c, int size, int sparcity){
        super(xVal, yVal, c);
        
        brushSize = size;
        brushSparcity = sparcity;
    }
    
    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(1));
        g.setColor(getFillColor());
        g.setPaintMode();
        
        Enumeration e = pathTrace.elements();
        Point p = null;
        Point l = null;
        Point x = null;
        
        while(e.hasMoreElements()){
            p = (Point)e.nextElement();
            moveBrush(p);
            g.draw(brushShape);
        }
        
        pathTrace.removeAllElements();
        if(p != null)    pathTrace.addElement(p);
    }
    
    private void moveBrush(Point p){
        brushShape = new GeneralPath();
        brushArea = new Ellipse2D.Float(((float)p.x - (brushSize/2)),(float)(p.y - (brushSize/2)), (float)brushSize, (float)brushSize);
        
        /* Choose random pixils in the area */
        int i;
        for(i=0; i<Math.abs(brushSparcity); i++){
            Point randomPoint = new Point((int)(brushArea.getX() + (Math.random() * brushSize)), (int)(brushArea.getY() + (Math.random() * brushSize)));
            while(!brushArea.contains(randomPoint.x, randomPoint.y))
                randomPoint = new Point((int)(brushArea.getX() + (Math.random() * brushSize)), (int)(brushArea.getY() + (Math.random() * brushSize)));
                
            brushShape.moveTo(randomPoint.x, randomPoint.y);
            brushShape.lineTo(randomPoint.x, randomPoint.y);
        }
    }        
}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.awt.Graphics2D;
import java.awt.Point;
import java.util.Stack;
import javax.swing.JOptionPane;

/**
 * Implimentation of the Paint Bucket Edit Tool
 *
 * @author Timothy Boyce
 */
class BitmapFill implements EditTool{
    
    /** The Color of the selected pixel */
    int SrcRGBColor;
    
    /** The color that the pixels will be changed to */
    int DstRGBColor;
    
    /** The image object to edit */
    BufferedImage imageObject;
    
    /** The pixels that are still to be scanned */
    Stack pixelStack;
    
    /** Constructor */
    public BitmapFill(int xVal, int yVal, Color c, BufferedImage b){
        imageObject = b;
        
        SrcRGBColor = imageObject.getRGB(xVal, yVal);
        DstRGBColor = c.getRGB();
        
        pixelStack = new Stack();
        
        seedStack(xVal, yVal);
    }
    
    /** Starts the paint action with the specified point */
    private void seedStack(int xVal, int yVal){
        Point currentPixel;
        imageObject.setRGB(xVal, yVal, DstRGBColor);
        /** Reset the DstRGBColor to account for web optimised images
        with internal colour changes */
        DstRGBColor = imageObject.getRGB(xVal, yVal);
        
        /* If the Src and Destination color are the same, take no action */
        if(SrcRGBColor == DstRGBColor)
            return;
        
        pixelStack.push(new Point(xVal, yVal));
        
        try{
            while(!pixelStack.empty()){
                    currentPixel = (Point)pixelStack.pop();
                    setPixel(currentPixel.x, currentPixel.y);
            }
        } catch (OutOfMemoryError e){
            dumpStack();
        }
    }
    
    /** Sets the passed pixel to the destination color, 
    and checks the surrounding pixels to see if they
    should be added to the stack for colouring */
    private void setPixel(int xVal, int yVal){
        imageObject.setRGB(xVal, yVal, DstRGBColor);

        /** Push any pixils that surround it that are also the same color
        onto the stack to be painted */
        if(isValidPoint(xVal + 1, yVal) && SrcRGBColor == imageObject.getRGB(xVal + 1, yVal))
            pixelStack.push(new Point(xVal + 1, yVal));
        if(isValidPoint(xVal - 1, yVal) && SrcRGBColor == imageObject.getRGB(xVal - 1, yVal))
            pixelStack.push(new Point(xVal - 1, yVal));
        if(isValidPoint(xVal, yVal + 1) && SrcRGBColor == imageObject.getRGB(xVal, yVal + 1))
            pixelStack.push(new Point(xVal, yVal + 1));
        if(isValidPoint(xVal, yVal - 1) && SrcRGBColor == imageObject.getRGB(xVal, yVal - 1))
            pixelStack.push(new Point(xVal, yVal - 1));
    }

    private boolean isValidPoint(int xVal, int yVal){
        return (xVal >= 0 && yVal >= 0 && xVal < imageObject.getWidth() && yVal < imageObject.getHeight());
    }
    
    private void dumpStack(){
        while(!pixelStack.empty()){
            Point p = (Point)pixelStack.pop();
            imageObject.setRGB(p.x, p.y, DstRGBColor);
        }
    }

    public void setDragPoint(int xVal, int yVal){
    }
    
    public void setReleasePoint(int xVal, int yVal){
    }
    
    public void setClickPoint(int xVal, int yVal){
    }
    
    /* Return the tool status */
    public boolean getToolStatus(){
        return true;
    }
    
    public boolean getMemoryless(){
        return false;
    }
    
    public void writeToGraphic(Graphics2D g){
    }
}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Shape;
import java.awt.Rectangle;
import java.awt.BasicStroke;

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;

import java.util.Enumeration;

/**
 * Implementation of the brush tool
 *
 * @author Timothy Boyce
 */
class BitmapFreehandBrush extends BitmapTool {
    protected Shape brushShape;
    protected int brushSize;
    protected int brushSlant;
    protected int brushType;
    
    public static final int BRUSH_BOX = 1;
    public static final int BRUSH_CIRC = 2;
    public static final int BRUSH_LINE_135 = 3;
    public static final int BRUSH_LINE_45 = 4;
    
    private final int BRUSH_LINE = 5;
    private final int SLANT_135 = 1;
    private final int SLANT_45 = 2;
    
    public BitmapFreehandBrush(int xVal, int yVal, Color c, int size){
        super(xVal, yVal, c);
        
        brushSlant = SLANT_45;
        brushSize = size;
        brushType = BRUSH_BOX;
    }

    public BitmapFreehandBrush(int xVal, int yVal, Color c, int size, int type){
        super(xVal, yVal, c);
        
        if(type == BRUSH_LINE_135){
            brushSlant = SLANT_135;
            brushType = BRUSH_LINE;
        }
        else if(type == BRUSH_LINE_45){
            brushSlant = SLANT_45;
            brushType = BRUSH_LINE;
        }
        else{
            brushType = type;
            brushSlant = 0;
        }

        brushSize = size;
    }
    
    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(1));
        g.setColor(getFillColor());
        g.setPaintMode();
        
        Enumeration e = pathTrace.elements();
        Point p = null;
        Point l = null;
        Point x = null;
        
        while(e.hasMoreElements()){
            p = (Point)e.nextElement();
            
            Enumeration subPoints = joinPoints(p, l).elements();
            
            while(subPoints.hasMoreElements()){
                x = (Point)subPoints.nextElement();
                moveBrush(x);
                g.fill(brushShape);
                g.draw(brushShape);
            }
            
            l = new Point(p.x, p.y);
        }
        
        pathTrace.removeAllElements();
        if(p != null)    pathTrace.addElement(p);
    }
    
    private void moveBrush(Point p){
        switch(brushType){
            case BRUSH_BOX:
                brushShape = new Rectangle(p.x - (brushSize/2), p.y - (brushSize/2), brushSize, brushSize);
            return;
            
            case BRUSH_CIRC:
                brushShape = new Ellipse2D.Float(((float)p.x - (brushSize/2)),(float)(p.y - (brushSize/2)), (float)brushSize, (float)brushSize);
            return;
            
            case BRUSH_LINE:
                BasicStroke b = new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
                if(brushSlant == SLANT_135)
                    brushShape = b.createStrokedShape(new Line2D.Float((float)(p.x - brushSize/2), (float)(p.y - brushSize/2), (float)(p.x + brushSize/2), (float)(p.y + brushSize/2)));
                else
                    brushShape = b.createStrokedShape(new Line2D.Float((float)(p.x + brushSize/2), (float)(p.y - brushSize/2), (float)(p.x - brushSize/2), (float)(p.y + brushSize/2)));
            return;
            
            default:
                brushType = BRUSH_BOX;
                brushShape = new Rectangle(p.x - (brushSize/2), p.y - (brushSize/2), brushSize, brushSize);
            return;
        }
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Point;
import java.awt.Color;
import java.awt.geom.GeneralPath;
import java.util.Vector;

/**
 * Implimentation of the Pencil Edit Tool
 *
 * @author Timothy Boyce
 */
class BitmapFreehandLine implements EditTool{

	/** Vector containing the last 3 points of the freehand line */
    protected Vector linePoints = new Vector(){
        public void addElement(Object obj){
            if(this.size() >= 3)
                this.removeElementAt(0);
            super.addElement(obj);
        }
    };
    
    /** General Path used for drawing */
    protected GeneralPath linePath;    
    
    /** Line Color used */
    protected Color lineColor;
    
    /** Tool status boolean */
    protected boolean toolStatus = false;
    
    /** Use the default super class constructior */
    public BitmapFreehandLine(int xVal, int yVal, Color c){
        linePoints.addElement(new Point(xVal, yVal));
        lineColor = c;
    }
    
    public boolean getToolStatus(){
        return toolStatus;
    }
    
    public boolean getMemoryless(){
        return true;
    }
    
    public void setDragPoint(int xVal, int yVal){
        linePoints.addElement(new Point(xVal, yVal));
    }
    
    public void setClickPoint(int xVal, int yVal){
        linePoints.addElement(new Point(xVal, yVal));
    }
    
    public void setReleasePoint(int xVal, int yVal){
        linePoints.addElement(new Point(xVal, yVal));
        toolStatus = true;
    }
    
    
    public void writeToGraphic(Graphics2D g){
        Point p1, p2, p3;
        
        g.setStroke(new BasicStroke(1));
        g.setPaintMode();
        g.setColor(lineColor);
        
        linePath = new GeneralPath();
        
        p1 = (Point)linePoints.firstElement();
        linePath.moveTo(p1.x, p1.y);
        
        if(linePoints.size() == 3)
            p2 = (Point)linePoints.get(1);
        else
            p2 = (Point)linePoints.lastElement();
        
        linePath.lineTo(p2.x, p2.y);
        
        if(linePoints.size()  == 2)
            p3 = (Point)linePoints.firstElement();
        else
            p3 = (Point)linePoints.lastElement();
            
        linePath.lineTo(p3.x, p3.y);
        
        g.draw(linePath);
    }
}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;

import java.util.Vector;

import java.lang.Math;

/**
 * BitmapTool
 *
 * @author Timothy Boyce
 */
abstract class BitmapTool implements EditTool{
    protected Color fillColor;
    protected Vector pathTrace;
    
    protected boolean toolStatus = false;
    
    public BitmapTool(int xVal, int yVal, Color c){
        pathTrace = new Vector();
        pathTrace.addElement(new Point(xVal, yVal));
        
        fillColor = c;
    }
    
    public void setDragPoint(int xVal, int yVal){
        pathTrace.addElement(new Point(xVal, yVal));
    }
    
    /* Default action taken on a release */
    public void setReleasePoint(int xVal, int yVal){
        pathTrace.addElement(new Point(xVal, yVal));
        toolStatus = true;
    }
    
    /* Default action taken on a Click */
    public void setClickPoint(int xVal, int yVal){
    }
    
    /* Return the tool status */
    public boolean getToolStatus(){
        return toolStatus;
    }
    
    protected Color getFillColor(){
        return fillColor;
    }
    
    public boolean getMemoryless(){
        return true;
    }
    
    /* Writes the current tool to the graphis object */
    public abstract void writeToGraphic(Graphics2D g);
    
    protected Vector joinPoints(Point p1, Point p2){
        Point start, end;
        Vector subPath = new Vector();
        float m;
        int b;
        int tx, ty;
        
        if(p1 == null)
            return subPath;
        
        if(p2 == null){
            subPath.addElement(p1);
            return subPath;
        }
        
        if(p1.x - p2.x == 0){
            /* Vertical Line */
            start = (p1.y < p2.y) ? p1 : p2;
            end = (p1.y > p2.y) ? p1 : p2;
            tx = start.x;
            
            for(ty=start.y+1; ty<end.y; ty++){
                subPath.addElement(new Point(tx, ty));
            }
        }
        else{
            /* Calculate Garidient */
            m = (float)(p1.y - p2.y) / (float)(p1.x - p2.x);
            b = (int)(p1.y - m * p1.x); 
            
            if(Math.abs(m) > 1){
                /* Use Y Method */
                start = (p1.y < p2.y) ? p1 : p2;
                end = (p1.y > p2.y) ? p1 : p2;
                
                for(ty=start.y+1; ty<end.y; ty++){
                    tx = (int)((ty - b)/ m );
                    subPath.addElement(new Point(tx, ty));
                }
            }
            else{
                /* Use X Method */
                start = (p1.x < p2.x) ? p1 : p2;
                end = (p1.x > p2.x) ? p1 : p2;
                
                for(tx=start.x+1; tx<end.x; tx++){
                    ty = (int)(m * tx + b);
                    subPath.addElement(new Point(tx, ty));
                }
            }
        }
        return subPath;
    }
}




PROP_ImageLoader_Name=Image Objects
Services/MIMEResolver/org-netbeans-modules-image-mime-resolver.xml=Image Files

# Filenames
Templates/Other/image.image=Image File

# New Image
LBL_ImageProperties=Image Properties

# ImageDataObject.ImageNode
HINT_Thumbnail=Shows thumbnail.
PROP_Thumbnail=Thumbnail

# ImageWizardPanel Labels
LBL_FolderChooser=Target Folder
LBL_FolderChooserBtn=Select
LBL_ColorChooser=Background Color
LBL_FileName=File Name:
LBL_Ext=Ext:
LBL_Folder=Folder:
LBL_BrowseBtn=Browse
LBL_Width=Width:
LBL_Height=Height:
LBL_BackgroundBtn=Background

# Failure to load an image
MSG_CouldNotLoad=Could not load the image
MSG_ErrorWhileLoading=Error while loading the image (corrupted image?)
# Save Image
LBL_CompressionLevel=Compression Level
MSG_CompressionLevel=Select a compression level:
# Convert Image
LBL_Format=Format
MSG_Format=Select a format:
LBL_CouldNotConvert=Convert Error
MSG_CouldNotConvert=Could not convert the image

# Failure to load an image
MSG_UserAbortSave=User aborted saving of file {0}
LBL_NoSaveSupport=No Save Support
MSG_NoSaveSupportConfirm=There is currently no save support for {0} type.\nWould you like to convert to a different format?
MSG_NoSaveSupport=There is currently no save support for {0} type
MSG_CouldNotLoad=Could not load the image
MSG_ErrorWhileLoading=Error while loading the image (corrupted image?)
# External change happened.

LBL_EnlargeFactor_Mnem=E
LBL_DecreaseFactor=Decrease Factor:
LBL_DecreaseFactor_Mnem=D
LBL_ConvertTo=Convert To...

# Tool labels
LBL_Ellipse=Ellipse
LBL_Eraser=Eraser
LBL_Rectangle=Rectangle
LBL_Fill=Fill
LBL_Line=Line
LBL_Select=Select
LBL_Polygon=Polygon
LBL_Pen=Pen
LBL_Brush=Brush
LBL_Arc=Arc
LBL_Spray=Spray
LBL_SetLineColor=Set Line Color
LBL_SetFillColor=Set Fill Color

# ColorChooser Labels
LBL_ForegroundColor=Choose Foreground Color
LBL_BackgroundColor=Choose Background Color

# Show/Hide grid action label
LBL_ShowHideGrid=Toggle grid


ACS_Zoom_BTN=N/A

ACS_Convert_BTN=N/A

ACSD_Toolbar=N/A

ACSN_Toolbar=Zoom Toolbar

ACSN_EditToolbar=Edit Toolbar

ACS_Grid_BTN=N/A





package org.netbeans.modules.image;

import java.io.IOException;

import org.openide.util.actions.CallableSystemAction;
import org.openide.util.HelpCtx;
import org.openide.windows.TopComponent;
import org.openide.util.NbBundle;


/**
 * Action which converts an image to a different format.
 *
 * @author  Jason Solomon
 */
public class ConvertToAction extends CallableSystemAction {

    public void performAction() {
        TopComponent curComponent = TopComponent.getRegistry().getActivated();
        if(curComponent instanceof ImageViewer) {
            ImageViewer currComponent = (ImageViewer) TopComponent.getRegistry().getActivated();
            currComponent.convertTo();
        }
    }

    /** Gets name of action. Implements superclass abstract method. */
    public String getName() {
        return NbBundle.getBundle(ConvertToAction.class).getString("LBL_ConvertTo");
    }

    /** Gets help context for action. Implements superclass abstract method. */
    public org.openide.util.HelpCtx getHelpCtx() {
        return HelpCtx.DEFAULT_HELP;
    }

    /** Overrides superclass method. */
    public boolean isEnabled() {
        TopComponent curComponent = TopComponent.getRegistry().getActivated();
        if(curComponent instanceof ImageViewer)
            return true;
        else
            return false;
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;

/**
 * Interface for all draw tools
 *
 * @author Timothy Boyce
 */
interface EditTool {
    public void setDragPoint(int xVal, int yVal);
    public void setClickPoint(int xVal, int yVal);
    public void setReleasePoint(int xVal, int yVal);
    public boolean getToolStatus();
    public boolean getMemoryless();
    public void writeToGraphic(Graphics2D g);
}

Lines 15-35 Link Here

(-)image/src/org/netbeans/modules/image/ImageDataObject.java (-3 / +186 lines)
15	package org.netbeans.modules.image;	15	package org.netbeans.modules.image;
16		16
17		17
		18	import java.awt.Component;
18	import java.awt.Graphics;	19	import java.awt.Graphics;
19	import java.awt.Image;	20	import java.awt.Image;
		21	import java.awt.image.BufferedImage;
		22	import java.awt.image.RenderedImage;
20	import java.awt.Rectangle;	23	import java.awt.Rectangle;
21	import java.beans.PropertyEditor;	24	import java.beans.PropertyEditor;
22	import java.beans.PropertyEditorSupport;	25	import java.beans.PropertyEditorSupport;
23	import java.io.BufferedInputStream;	26	import java.io.BufferedInputStream;
		27	import java.io.File;
24	import java.io.IOException;	28	import java.io.IOException;
		29	import java.lang.reflect.Array;
25	import java.lang.reflect.InvocationTargetException;	30	import java.lang.reflect.InvocationTargetException;
26	import java.net.URL;	31	import java.net.URL;
		32	import java.util.Iterator;
		33	import java.util.Observable;
		34	import java.util.Observer;
		35	import javax.imageio.ImageIO;
		36	import javax.imageio.ImageWriter;
		37	import javax.imageio.stream.FileImageOutputStream;
27	import javax.swing.Icon;	38	import javax.swing.Icon;
28	import javax.swing.ImageIcon;	39	import javax.swing.ImageIcon;
		40	import javax.swing.JFileChooser;
		41	import javax.swing.JOptionPane;
		42	import javax.swing.SwingUtilities;
29		43
30	import org.openide.actions.OpenAction;	44	import org.openide.actions.OpenAction;
		45	import org.openide.actions.SaveAction;
		46	import org.openide.cookies.OpenCookie;
31	import org.openide.filesystems.FileObject;	47	import org.openide.filesystems.FileObject;
32	import org.openide.filesystems.FileStateInvalidException;	48	import org.openide.filesystems.FileStateInvalidException;
		49	import org.openide.filesystems.FileUtil;
33	import org.openide.loaders.*;	50	import org.openide.loaders.*;
34	import org.openide.nodes.*;	51	import org.openide.nodes.*;
35	import org.openide.ErrorManager;	52	import org.openide.ErrorManager;
Lines 40-49 Link Here
40		57
41	/**	58	/**
42	* Object that represents one file containing an image.	59	* Object that represents one file containing an image.
43	* @author Petr Hamernik, Jaroslav Tulach, Ian Formanek, Michael Wever	60	* @author Petr Hamernik, Jaroslav Tulach, Ian Formanek, Michael Wever, Jason Solomon
44	* @author Marian Petras	61	* @author Marian Petras
45	*/	62	*/
46	public class ImageDataObject extends MultiDataObject implements CookieSet.Factory {	63	public class ImageDataObject extends MultiDataObject implements CookieSet.Factory, Observer {
47		64
48	/** Generated serialized version UID. */	65	/** Generated serialized version UID. */
49	static final long serialVersionUID = -6035788991669336965L;	66	static final long serialVersionUID = -6035788991669336965L;
Lines 51-60 Link Here
51	/** Base for image resource. */	68	/** Base for image resource. */
52	private static final String IMAGE_ICON_BASE = "org/netbeans/modules/image/imageObject"; // NOI18N	69	private static final String IMAGE_ICON_BASE = "org/netbeans/modules/image/imageObject"; // NOI18N
53		70
		71	/ Image held in DataObject /
		72	private Image image;
		73
		74	/** Subclass of java.util.Observable */
		75	private ObservableImage obs = new ObservableImage();
		76
54	/** Open support for this image data object. */	77	/** Open support for this image data object. */
55	private transient ImageOpenSupport openSupport;	78	private transient ImageOpenSupport openSupport;
56	/ Print support for this image data object /	79	/ Print support for this image data object /
57	private transient ImagePrintSupport printSupport;	80	private transient ImagePrintSupport printSupport;
		81	/ Save support for this image data object /
		82	private transient ImageSaveSupport saveSupport;
58		83
59	/** Constructor.	84	/** Constructor.
60	* @param pf primary file object for this data object	85	* @param pf primary file object for this data object
Lines 75-80 Link Here
75	return getOpenSupport();	100	return getOpenSupport();
76	else if( clazz.isAssignableFrom(ImagePrintSupport.class))	101	else if( clazz.isAssignableFrom(ImagePrintSupport.class))
77	return getPrintSupport();	102	return getPrintSupport();
		103	else if( clazz.isAssignableFrom(ImageSaveSupport.class))
		104	return getSaveSupport();
78	else	105	else
79	return null;	106	return null;
80	}	107	}
Lines 101-106 Link Here
101	return printSupport;	128	return printSupport;
102	}	129	}
103		130
		131	/** Gets image save support. */
		132	protected ImageSaveSupport getSaveSupport() {
		133	if(saveSupport == null) {
		134	synchronized(this) {
		135	if(saveSupport == null)
		136	saveSupport = new ImageSaveSupport( this );
		137	}
		138	}
		139	return saveSupport;
		140	}
		141
		142	/** Adds save cookie and sets the modified flag. */
		143	protected void notifyModified() {
		144	String asterisk = new String(" *");
		145
		146	getNodeDelegate().setDisplayName(getPrimaryFile().getNameExt() + asterisk);
		147	addSaveCookie();
		148	setModified(true);
		149	}
		150
		151	/** Removes save cookie and unsets the modified flag. */
		152	protected void notifyUnmodified () {
		153	getNodeDelegate().setDisplayName(getPrimaryFile().getNameExt());
		154	removeSaveCookie();
		155	setModified(false);
		156	obs.setChanged();
		157	obs.notifyObservers();
		158	}
		159
		160	/** Helper method. Adds save cookie to the data object. */
		161	private void addSaveCookie() {
		162	if(getCookie(ImageSaveSupport.class) == null) {
		163	getCookieSet().add(ImageSaveSupport.class, this);
		164	}
		165	}
		166
		167	/** Helper method. Removes save cookie from the data object. */
		168	private void removeSaveCookie() {
		169	if(getCookie(ImageSaveSupport.class) != null) {
		170	getCookieSet().remove(ImageSaveSupport.class, this);
		171	}
		172	}
		173
		174	/** Getter of the full path of the image file. */
		175	public String getPath() {
		176	return getPrimaryFile().getPath();
		177	}
		178
		179	/** Getter of the file extension. */
		180	public String getFormat() {
		181	return getPrimaryFile().getExt().toLowerCase();
		182	}
		183
		184	/** Adds Observer o to ObservableImage obs */
		185	public void addObserver(Observer o) {
		186	obs.addObserver(o);
		187	}
		188
104	/** Help context for this object.	189	/** Help context for this object.
105	* @return the help context	190	* @return the help context
106	*/	191	*/
Lines 135-140 Link Here
135	return new byte[0];	220	return new byte[0];
136	}	221	}
137	}	222	}
		223
		224	/** Clears the stored image and reloads it from the file */
		225	public Image reloadImage() throws IOException {
		226	image = null;
		227	return getImage();
		228	}
138		229
139	// Michael Wever 26/09/2001	230	// Michael Wever 26/09/2001
140	/** Gets image for the image data	231	/** Gets image for the image data
Lines 142-148 Link Here
142	* @return java.io.IOException if an error occurs during reading	233	* @return java.io.IOException if an error occurs during reading
143	*/	234	*/
144	public Image getImage() throws IOException {	235	public Image getImage() throws IOException {
145	return javax.imageio.ImageIO.read(getPrimaryFile().getInputStream());	236	if(image == null) {
		237	image = javax.imageio.ImageIO.read(getPrimaryFile().getInputStream());
		238	}
		239	return image;
146	}	240	}
147		241
148		242
Lines 269-273 Link Here
269	} // End of class ThumbnailPropertyEditor.	363	} // End of class ThumbnailPropertyEditor.
270	} // End of class ThumbnailProperty.	364	} // End of class ThumbnailProperty.
271	} // End of class ImageNode.	365	} // End of class ImageNode.
		366
		367	public void update(Observable o, Object arg) {
		368	notifyModified();
		369	}
272		370
		371	protected void convertTo(final ImageViewer thisViewer) throws IOException {
		372	String bName = getNodeDelegate().getName();
		373	String ext;
		374	String dialogTitle = new String(NbBundle.getMessage(ImageDataObject.class, "LBL_Format"));
		375	String dialogLabel = new String(NbBundle.getMessage(ImageDataObject.class, "MSG_Format"));
		376	String tempWriterTypes[] = ImageIO.getWriterFormatNames();
		377	String writerTypes[] = new String[tempWriterTypes.length];
		378
		379	for(int i = 0; i < writerTypes.length; i++)
		380	writerTypes[i] = new String("");
		381
		382	int z = 0;
		383	boolean found = false;
		384	for(int x = 0; x < tempWriterTypes.length; x++) {
		385	if(x == 0 && !tempWriterTypes[x].toLowerCase().equals(getFormat())) {
		386	writerTypes[z] = tempWriterTypes[x].toLowerCase();
		387	z++;
		388	}
		389	else {
		390	for(int y = 0; y < writerTypes.length; y++) {
		391	if(writerTypes[y].equals(tempWriterTypes[x].toLowerCase()) \|\| tempWriterTypes[x].toLowerCase().equals(getFormat()))
		392	found = true;
		393	}
		394	if(!found) {
		395	writerTypes[z] = tempWriterTypes[x].toLowerCase();
		396	z++;
		397	}
		398	}
		399	found = false;
		400	}
		401
		402	int j = 0;
		403	while(!writerTypes[j].equals("")) {
		404	j++;
		405	}
		406
		407	Class arrayClass = writerTypes.getClass();
		408	Class componentClass = arrayClass.getComponentType();
		409	String finalWriterTypes[] = ((String[])(Array.newInstance(componentClass, j)));
		410
		411	for(int i = 0; i < j; i++)
		412	finalWriterTypes[i] = writerTypes[i];
		413
		414	ext = (String)JOptionPane.showInputDialog((Component)null, dialogLabel,
		415	dialogTitle, JOptionPane.QUESTION_MESSAGE, null, finalWriterTypes, finalWriterTypes[0]);
		416
		417	if(ext != null) {
		418	File newFile = new File(getPrimaryFile().getParent().getPath() + "/" + bName + "." + ext);
		419	BufferedImage newImage = new BufferedImage(((BufferedImage)image).getWidth(), ((BufferedImage)image).getHeight(), BufferedImage.TYPE_INT_RGB);
		420	Graphics g = newImage.getGraphics();
		421	g.drawImage(image, 0, 0, null);
		422	Iterator writers = ImageIO.getImageWritersByFormatName(ext);
		423	ImageWriter writer = (ImageWriter)writers.next();
		424	FileImageOutputStream output = new FileImageOutputStream(newFile);
		425	writer.setOutput(output);
		426	writer.write((RenderedImage)newImage);
		427	FileObject pf = FileUtil.toFileObject(newFile);
		428	ImageDataObject newIDO = (ImageDataObject)DataObject.find(pf);
		429	final OpenCookie openCookie = (OpenCookie)newIDO.getCookie(OpenCookie.class);
		430	if (openCookie == null) {
		431	// cannot open
		432	throw new IOException(NbBundle.getMessage(ImageDataObject.class, "MSG_CouldNotConvert"));
		433	}
		434	else {
435	if(!SwingUtilities.isEventDispatchThread()) {
436	Runnable doOpenClose = new Runnable() {
437	public void run() {
438	openCookie.open();
439	thisViewer.close();
440	}
441	};
442	try {
443	SwingUtilities.invokeAndWait(doOpenClose);
444	} catch(Exception e) {
445	JOptionPane.showMessageDialog(null, NbBundle.getMessage(ImageDataObject.class, "MSG_CouldNotConvert"), NbBundle.getMessage(ImageDataObject.class, "LBL_CouldNotConvert"), JOptionPane.ERROR_MESSAGE);
446	}
447	}
448	else {
449	openCookie.open();
450	thisViewer.close();
451	}
452	}
453	}
454	}
455
273	}	456	}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.AlphaComposite;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseEvent;
import java.util.Observable;
import javax.swing.JPanel;
import javax.swing.ImageIcon;

import javax.swing.JOptionPane;
import org.openide.windows.TopComponent;


/**
 * ImageDisplayEdit
 * Interface between the ImageViewer and the draw tools
 *
 * @author Timothy Boyce
 */
class ImageDisplayEdit extends JPanel{
	
    /** Currently selected editTool object */
    private EditTool currentTool;
    
    /** Offscreen Image Objects */
    protected BufferedImage offScreenImage;
    
    /** Double buffer used for memoryless edit tools */
    protected BufferedImage memOScreenImage;
    
    /** Double buffer user for non-memoryless edit tools */
    protected BufferedImage nonOScreenImage;
    
    /** Primary Image Object */
    private BufferedImage imageObject;
    
    /** Boolean flag to ingore left clicks of the mouse */
    private boolean ignoreButton1 = false;
    
    /** The current scale that the image is being viewed at */
    private double currentScale;
    
    /** On/Off Grid */
    private boolean showGrid = false;
    
    /** Grid color. */
    private final Color gridColor = Color.black;
    
    /** Mouse pointer to be used in the image editor */
    private Cursor editCursor = new Cursor(Cursor.DEFAULT_CURSOR);
    
    /** Image Observer Object */
    private ObservableImage obs = new ObservableImage();
    
    /** The primary or foreground color, defaulted to black */
    private Color primary = getDefaultPrimaryColor();
    
    /** The secondary, background, or fill colour, defaulted to white */
    private Color secondary = getDefaultSecondaryColor();
       
    /** Line width for vector tools */
    private int lineWidth; 
           
    /** Static Tool Values */
    public static final int TOOL_DEFAULT = 1;
    public static final int TOOL_POLYGON = 2;
    public static final int TOOL_PEN = 3;
    public static final int TOOL_BRUSH = 4;
    public static final int TOOL_ARC = 5;
    public static final int TOOL_LINE = 6;
    public static final int TOOL_RECTANGLE = 7;
    public static final int TOOL_ELLIPSE = 8;
    public static final int TOOL_FILL = 9;
    public static final int TOOL_SPRAY = 10;
    public static final int TOOL_ERASER = 11;
    
    /** Tool selected */
    private int toolSelected = TOOL_DEFAULT;
    
    /** Static subtools for the TOOL_RECTANGLE tool
    and the TOOL_ELLIPSE */
    public static final int SUB_LINEONLY = 1;
    public static final int SUB_BOTH = 2;
    public static final int SUB_FILLONLY = 3;
    
    /** Subtool selection. Actual meaning changes depending upon
    the tool being used. */
    private int subTool = SUB_LINEONLY;
        
    /** The brush shape used */
    private int brushShape = BitmapFreehandBrush.BRUSH_BOX;
    
    /** The brush size */
    private int brushSize = 1;
        
    /** Corner rounding factor for the rectangle */
    private int roundingFactor;
    
    /** Class constructor
        sets current scale, gets acces to storedImage, and adds various
        action listeners */
    public ImageDisplayEdit(NBImageIcon storedImage, double imageScale){
        currentScale = imageScale;
        
        imageObject = (BufferedImage)storedImage.getImage();
        
        nonOScreenImage = new BufferedImage(imageObject.getColorModel(), (WritableRaster)imageObject.getData(), false, null);
        memOScreenImage = new BufferedImage(imageObject.getWidth(), imageObject.getHeight(), BufferedImage.TYPE_INT_ARGB);
        
        
        this.addMouseListener(new MouseAdapter(){
            public void mouseEntered(MouseEvent thisEvent){
                setCursor(editCursor);
            }
        
            /** Set the mouse pressed event to create a new edit tool object
            and setup correct imag buffers */
            public void mousePressed(MouseEvent thisEvent){
                if(currentTool == null 
                && thisEvent.getButton() == MouseEvent.BUTTON1
                && getScaledValue(thisEvent.getX(), currentScale) < imageObject.getWidth()
                && getScaledValue(thisEvent.getY(), currentScale) < imageObject.getHeight()
                )
                {
                    int sx = getScaledValue(thisEvent.getX(), currentScale);
                    int sy = getScaledValue(thisEvent.getY(), currentScale);
                    ignoreButton1 = false;

                                             
                    /* Switch Here */ 
                    switch (toolSelected){
                        case TOOL_DEFAULT: currentTool = null; break;
                        case TOOL_POLYGON: currentTool = new VectorPolygon(sx, sy, primary, lineWidth, VectorPolygon.FREEHAND_POLY); break;
                        case TOOL_PEN: currentTool = new BitmapFreehandLine(sx, sy, primary); break;
                        case TOOL_BRUSH: currentTool = new BitmapFreehandBrush(sx, sy, primary, lineWidth, brushShape); break;
                        case TOOL_ARC: currentTool = new VectorArc(sx, sy, primary, lineWidth); break;
                        case TOOL_LINE: currentTool = new VectorLine(sx, sy, primary, lineWidth); break;
                        case TOOL_RECTANGLE:
                          if(subTool == SUB_FILLONLY)
                            currentTool = new VectorRectangle(sx, sy, secondary, secondary, lineWidth, roundingFactor);
                          else if(subTool == SUB_BOTH)
                            currentTool = new VectorRectangle(sx, sy, primary, secondary, lineWidth, roundingFactor);
                          else
                            currentTool = new VectorRectangle(sx, sy, primary, lineWidth, roundingFactor);
                          break;
                        case TOOL_ELLIPSE: 
                          if(subTool == SUB_FILLONLY)
                            currentTool = new VectorEllipse(sx, sy, secondary, secondary, lineWidth);
                          else if(subTool == SUB_BOTH)
                            currentTool = new VectorEllipse(sx, sy, primary, secondary, lineWidth); 
                          else
                            currentTool = new VectorEllipse(sx, sy, primary, lineWidth);
                          break;
                        case TOOL_FILL: currentTool = new BitmapFill(sx, sy, primary, imageObject); break;
                        case TOOL_SPRAY: currentTool = new BitmapAirbrush(sx, sy, primary, lineWidth + 10, 40); break;
                        case TOOL_ERASER: currentTool = new BitmapFreehandBrush(sx, sy, secondary, lineWidth, BitmapFreehandBrush.BRUSH_BOX); break;
                        default: currentTool = null;
                    }
                    /* End Switch */

                    /* Setup memoryless or non-memoryless buffer */
                    offScreenImage = (currentTool != null && currentTool.getMemoryless())  ? nonOScreenImage : memOScreenImage;
                    repaint(0, 0, getWidth(), getHeight());
                }
                else if(currentTool != null && thisEvent.getButton() == MouseEvent.BUTTON3){
                    nonOScreenImage.setData(imageObject.getData());
                }
            }
            
            /** If an edit tool is in use, send it the mouse released event, and let it
            take actions, as are appropriate for it */
            public void mouseReleased(MouseEvent thisEvent){
                if(currentTool != null && thisEvent.getButton() == MouseEvent.BUTTON1){
                    int sx = getScaledValue(thisEvent.getX(), currentScale);
                    int sy = getScaledValue(thisEvent.getY(), currentScale);
                    
                    currentTool.setReleasePoint(sx, sy);
     
                    repaint(0, 0, getWidth(), getHeight());
                }
                if(thisEvent.getButton() == MouseEvent.BUTTON3){
                    currentTool = null;
                    repaint(0, 0, getWidth(), getHeight());
                }
            }
            
            public void mouseClicked(MouseEvent thisEvent){
                if(currentTool != null && thisEvent.getButton() == MouseEvent.BUTTON1){
                    int sx = getScaledValue(thisEvent.getX(), currentScale);
                    int sy = getScaledValue(thisEvent.getY(), currentScale);
                    
                    currentTool.setClickPoint(sx, sy);
                    
                    repaint(0, 0, getWidth(), getHeight());
                }
            }
        });
            
        this.addMouseMotionListener(new MouseMotionAdapter(){
            public void mouseDragged(MouseEvent thisEvent){
                if(currentTool != null && (thisEvent.getButton() == MouseEvent.BUTTON1 || thisEvent.getButton() == MouseEvent.NOBUTTON)){
                    int sx = getScaledValue(thisEvent.getX(), currentScale);
                    int sy = getScaledValue(thisEvent.getY(), currentScale);
                    
                    currentTool.setDragPoint(sx, sy);
                    repaint(0, 0, getWidth(), getHeight());
                }
            }
        });

        obs.addObserver(storedImage.getIDO());
    }
    
    /** Toggle the grid on and off */
    public void toggleGrid(){
        showGrid = !showGrid;
    }
    
    public void setPrimaryColor(Color newColor){
        primary = newColor;
    }
    
    public void setSecondayColor(Color newColor){
        secondary = newColor;
    };
    
    public static Color getDefaultPrimaryColor(){
        return new Color(0, 0, 0);
    };
    
    public static Color getDefaultSecondaryColor(){
        return new Color(255, 255, 255);
    };
    
    public void setToolType(int newTool){
      if(newTool < 1 || newTool > 11)
        toolSelected = TOOL_DEFAULT;
      else
        toolSelected = newTool;
    };
    
    public int getToolType(){
      return toolSelected; 
    }
    
    public void setRoundingFactor(int newFactor){
      if(newFactor < 0 || newFactor > 100)
        roundingFactor = 0;
      else
        roundingFactor = newFactor;
    }
    
    public int getRoundingFactor(){
        return roundingFactor;   
    }
    
    public void setSubTool(int newSubTool){
      if(newSubTool < 1 || newSubTool > 3)
        subTool = SUB_LINEONLY;
      else
        subTool = newSubTool; 
    }
    
    public int getSubTool(){
        return subTool;   
    }
    
    public void setLineWidth(int newWidth){
     lineWidth = newWidth; 
    }
    
    public int getLineWidth(){
        return lineWidth;   
    }
    
    public void setBrushType(int newType){
        if(newType < 1 || newType > 4)
            brushShape = BitmapFreehandBrush.BRUSH_BOX;
        else
            brushShape = newType;
    }
    
    public int getBrushType(){
        return brushShape;
    }
    
    public void setCustomCursor(Cursor newCursor){
        editCursor = newCursor;
        setCursor(editCursor);
    };
    
    /** Set the scaling factor of the image */
    public void setScale(double newScale){
        this.currentScale = newScale;
        repaint(0, 0, getHeight(), getWidth());
    };
    
    public double getScale(){
        return currentScale;    
    }
    
    /* Return the pixel value after applying the current
    zoom scale */
    protected int getScaledValue(int value, double scale){
        return (int)(value/scale);
    }

    public void paint(Graphics g){
        /** Paint the component before anything else occurs */
        this.paintComponent(g);
        
        Graphics2D g2D = (Graphics2D)g;
        
        if (getSize().width <= 0 || getSize().height <= 0) 
        return; 

        /** Draw this edit tool if the is one in use */     
      if(currentTool != null){
           Graphics2D offScreenGraphics = (Graphics2D)offScreenImage.getGraphics();
           AffineTransform oldTransform = g2D.getTransform();
           g2D.transform(AffineTransform.getScaleInstance(currentScale, currentScale));
           
           /** Drawing method for non-memoryless tools */
        if(!currentTool.getMemoryless()){    
            currentTool.writeToGraphic(offScreenGraphics);
            
            g2D.drawImage(offScreenImage, 0, 0, null);
            
            offScreenGraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0));
            offScreenGraphics.fillRect(0, 0, offScreenImage.getWidth(), offScreenImage.getHeight());
            
            if(currentTool.getToolStatus()){
                    currentTool.writeToGraphic((Graphics2D)imageObject.getGraphics());
                    nonOScreenImage.setData(imageObject.getData());
                    currentTool = null;
                    obs.setChanged();
                    obs.notifyObservers();
                    g2D.setTransform(oldTransform);
                    this.paintComponent(g);
                }
        }
        else{
        /** Drawing method for memoryless tools */
            currentTool.writeToGraphic(offScreenGraphics);
            
            g2D.drawImage(offScreenImage,
              0,
              0,
              (int)(imageObject.getWidth()),
              (int)(imageObject.getHeight()),
              0,
              0,
              imageObject.getWidth(),
              imageObject.getHeight(),
              this
            );
            
            if(currentTool.getToolStatus()){
                imageObject.setData(offScreenImage.getData());
                currentTool = null;
                obs.setChanged();
                obs.notifyObservers();
            }     
        }    
        g2D.setTransform(oldTransform);
    }
    
    /* Draw the grid onto the screen, if it is visable */
    if(showGrid)
        drawGrid(g, imageObject.getWidth(), imageObject.getHeight());    
     }
     
     /** Paint the currently visable, unedited image to the component */
     protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      g.drawImage(
          imageObject,
          0,
          0,
          (int)(getScale() * imageObject.getWidth()),
          (int)(getScale() *imageObject.getHeight()),
          0,
          0,
          imageObject.getWidth(),
          imageObject.getHeight(),
          this
      );
    }
    
    /** Attempt to draw a grid to the graphics object */
    private void drawGrid(Graphics g, int iconWidth, int iconHeight){
      int x = (int)(getScale () * iconWidth);
      int y = (int)(getScale () * iconHeight);

      double gridDistance = getScale();

      if(gridDistance < 2) 
        // Disable painting of grid if no image pixels would be visible.
        return;

      g.setColor(gridColor);

      double actualDistance = gridDistance;
      for(int i = (int)actualDistance; i < x ;actualDistance += gridDistance, i = (int)actualDistance) {
          g.drawLine(i,0,i,(y-1));
      }

      actualDistance = gridDistance;
      for(int j = (int)actualDistance; j < y; actualDistance += gridDistance, j = (int)actualDistance) {
        g.drawLine(0,j,(x-1),j);
      }
   }
  
  /** Replace the Image object in the image display editor, with a new image object */
  public void reload(NBImageIcon newImage){
        this.imageObject = (BufferedImage)newImage.getImage();
        repaint(0, 0, getWidth(), getHeight());
    }
}




<!--
                Sun Public License Notice

The contents of this file are subject to the Sun Public License
Version 1.0 (the "License"). You may not use this file except in
compliance with the License. A copy of the License is available at
http://www.sun.com/

The Original Code is NetBeans. The Initial Developer of the Original
Code is Sun Microsystems, Inc. Portions Copyright 1997-2005 Sun
Microsystems, Inc. All Rights Reserved.
-->

<HTML><BODY>
Creates a new image file. You can edit the file in the IDE's Image Editor.
</BODY></HTML>

Lines 172-175 Link Here

(-)image/src/org/netbeans/modules/image/ImageOpenSupport.java (-1 lines)
172	}	172	}
173	} // End of nested Environment class.	173	} // End of nested Environment class.
174	}	174	}
175




package org.netbeans.modules.image;

import java.awt.Component;
import java.awt.Image;
import java.awt.image.RenderedImage;
import java.io.IOException;
import java.io.File;
import java.util.Iterator;
import java.util.List;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.FileImageOutputStream;
import javax.swing.JOptionPane;

import org.openide.cookies.SaveCookie;
import org.openide.util.NbBundle;
import org.openide.windows.TopComponent;


/**
 * Support for saving images
 *
 * @author Jason Solomon
 */
public class ImageSaveSupport implements SaveCookie {
    
    private ImageDataObject imageDataObject;
    
    private Image image;

    private String format;
    
    /** Creates a new instance of ImageSaveSupport */
    public ImageSaveSupport(ImageDataObject ido) {
        imageDataObject = ido;
    }
    
    /** Invoke the save operation.
     * @throws IOException if the object could not be saved
     */
    public void save () throws java.io.IOException {
        format = imageDataObject.getFormat();
        image = imageDataObject.getImage();

        if(saveFile()) {
            imageDataObject.reloadImage();
            imageDataObject.notifyUnmodified();
        }
        else {
            IOException ex = new IOException(NbBundle.getMessage(ImageSaveSupport.class, "MSG_UserAbortSave", imageDataObject.getPath()));
            throw ex;
        }
    }
    
    private boolean saveFile() throws IOException {
        boolean compressionSupported;
        Iterator writers = ImageIO.getImageWritersByFormatName(format);
        if(!writers.hasNext()) {
            if(JOptionPane.showConfirmDialog(null, NbBundle.getMessage(ImageSaveSupport.class, "MSG_NoSaveSupportConfirm", format), NbBundle.getMessage(ImageSaveSupport.class, "LBL_NoSaveSupport"), JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
                TopComponent curComponent = TopComponent.getRegistry().getActivated();
                if(curComponent instanceof ImageViewer) {
                    ImageViewer currComponent = (ImageViewer) TopComponent.getRegistry().getActivated();
                    imageDataObject.convertTo(currComponent);
                }
            }
            IOException ex = new IOException(NbBundle.getMessage(ImageSaveSupport.class, "MSG_NoSaveSupport", format));
            throw ex;
        }
        ImageWriter writer = (ImageWriter)writers.next();
        ImageWriteParam iwp = writer.getDefaultWriteParam();

        try {
            compressionSupported = true;
            iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        } catch (UnsupportedOperationException e) {
            compressionSupported = false;
            iwp = writer.getDefaultWriteParam();
        }

        if(compressionSupported) {
            return getCompression(writer, iwp);
        }
        else {
            return writeFile(writer, iwp, (float)0.00);
        }
    }

    private boolean getCompression(ImageWriter writer, ImageWriteParam iwp) throws IOException {
        String compressionStr;
        float compression;
        String dialogTitle = new String(NbBundle.getMessage(ImageSaveSupport.class, "LBL_CompressionLevel"));
        String dialogLabel = new String(NbBundle.getMessage(ImageSaveSupport.class, "MSG_CompressionLevel"));
        int i;

        String[] qualityDescTemp = iwp.getCompressionQualityDescriptions();
        float qualityValsTemp[] = iwp.getCompressionQualityValues();
        String[] qualityDesc = new String[qualityDescTemp.length + 1];
        float qualityVals[] = new float[qualityValsTemp.length + 1];
        for(i = 0; i < qualityDescTemp.length; i++) {
            qualityDesc[i] = qualityDescTemp[i];
            qualityVals[i] = qualityValsTemp[i];
        }
        qualityDesc[qualityDesc.length - 1] = "Default";
        qualityVals[qualityVals.length - 1] = (float)0.00;

        compressionStr = (String)JOptionPane.showInputDialog((Component)null, dialogLabel,
            dialogTitle, JOptionPane.QUESTION_MESSAGE, null, qualityDesc, qualityDesc[qualityDesc.length - 1]);

        if(compressionStr != null) {
            for(i = 0; i < qualityDesc.length; i++) {
                if(compressionStr.equals(qualityDesc[i]))
                    break;
            }

            compression = qualityVals[i];

            return writeFile(writer, iwp, compression);
        }
        return false;
    }

    private boolean writeFile(ImageWriter writer, ImageWriteParam iwp, float compression) throws IOException {
        String filePath = imageDataObject.getPath();
        IIOImage iioImage;
        FileImageOutputStream output;

        if(compression != (float)0.00) {
            iwp.setCompressionQuality(compression);
        }
        iioImage = new IIOImage((RenderedImage)image, (List)null, (IIOMetadata)null);
        output = new FileImageOutputStream(new File(filePath));
        writer.setOutput(output);
        writer.write((IIOMetadata)null, iioImage, iwp);
        return true;
    }
}

Lines 13-27 Link Here

(-)image/src/org/netbeans/modules/image/ImageViewer.java (-52 / +723 lines)
13		13
14	package org.netbeans.modules.image;	14	package org.netbeans.modules.image;
15		15
		16	import java.awt.AlphaComposite;
		17	import java.awt.BasicStroke;
16	import java.awt.BorderLayout;	18	import java.awt.BorderLayout;
17	import java.awt.Color;	19	import java.awt.Color;
18	import java.awt.Component;	20	import java.awt.Component;
		21	import java.awt.Cursor;
19	import java.awt.Dimension;	22	import java.awt.Dimension;
		23	import java.awt.FlowLayout;
		24	import java.awt.Font;
20	import java.awt.Graphics;	25	import java.awt.Graphics;
		26	import java.awt.Graphics2D;
		27	import java.awt.Point;
		28	import java.awt.GridLayout;
21	import java.awt.Image;	29	import java.awt.Image;
22	import java.awt.Toolkit;	30	import java.awt.Toolkit;
23	import java.awt.event.ActionListener;	31	import java.awt.event.ActionListener;
24	import java.awt.event.ActionEvent;	32	import java.awt.event.ActionEvent;
		33	import java.awt.geom.Line2D;
		34	import java.awt.geom.Ellipse2D;
25	import java.beans.PropertyChangeEvent;	35	import java.beans.PropertyChangeEvent;
26	import java.beans.PropertyChangeListener;	36	import java.beans.PropertyChangeListener;
27	import java.io.IOException;	37	import java.io.IOException;
Lines 32-46 Link Here
32	import java.util.HashSet;	42	import java.util.HashSet;
33	import java.util.Iterator;	43	import java.util.Iterator;
34	import java.util.Set;	44	import java.util.Set;
		45	import java.util.Observer;
		46	import java.util.Observable;
35	import javax.swing.Action;	47	import javax.swing.Action;
		48	import javax.swing.ButtonGroup;
		49	import javax.swing.event.ChangeEvent;
		50	import javax.swing.event.ChangeListener;
36	import javax.swing.Icon;	51	import javax.swing.Icon;
37	import javax.swing.ImageIcon;	52	import javax.swing.ImageIcon;
38	import javax.swing.JButton;	53	import javax.swing.JButton;
		54	import javax.swing.JColorChooser;
		55	import javax.swing.JFormattedTextField;
39	import javax.swing.JLabel;	56	import javax.swing.JLabel;
		57	import javax.swing.JOptionPane;
40	import javax.swing.JPanel;	58	import javax.swing.JPanel;
41	import javax.swing.JScrollPane;	59	import javax.swing.JScrollPane;
		60	import javax.swing.JSpinner;
		61	import javax.swing.JTextField;
42	import javax.swing.JToggleButton;	62	import javax.swing.JToggleButton;
43	import javax.swing.JToolBar;	63	import javax.swing.JToolBar;
		64	import javax.swing.SpinnerModel;
		65	import javax.swing.SpinnerNumberModel;
44		66
45	import org.openide.filesystems.FileObject;	67	import org.openide.filesystems.FileObject;
46	import org.openide.filesystems.FileUtil;	68	import org.openide.filesystems.FileUtil;
Lines 57-66 Link Here
57		79
58	/**	80	/**
59	* Top component providing a viewer for images.	81	* Top component providing a viewer for images.
60	* @author Petr Hamernik, Ian Formanek, Lukas Tadial	82	* @author Petr Hamernik, Ian Formanek, Lukas Tadial, Dragan Mandic, Jason Solomon
61	* @author Marian Petras	83	* @author Marian Petras
62	*/	84	*/
63	public class ImageViewer extends CloneableTopComponent {	85	public class ImageViewer extends CloneableTopComponent implements Observer {
64		86
65	/** Serialized version UID. */	87	/** Serialized version UID. */
66	static final long serialVersionUID =6960127954234034486L;	88	static final long serialVersionUID =6960127954234034486L;
Lines 72-99 Link Here
72	private NBImageIcon storedImage;	94	private NBImageIcon storedImage;
73		95
74	/** Component showing image. */	96	/** Component showing image. */
75	private JPanel panel;	97	private ImageDisplayEdit panel;
76		98
77	/** Scale of image. */	99	/** Scale of image. */
78	private double scale = 1.0D;	100	private double scale = 1.0D;
79		101
80	/** On/off grid. */
81	private boolean showGrid = false;
82
83	/** Increase/decrease factor. */	102	/** Increase/decrease factor. */
84	private final double changeFactor = Math.sqrt(2.0D);	103	private final double changeFactor = Math.sqrt(2.0D);
85		104
86	/** Grid color. */
87	private final Color gridColor = Color.black;
88
89	/** Listens for name changes. */	105	/** Listens for name changes. */
90	private PropertyChangeListener nameChangeL;	106	private PropertyChangeListener nameChangeL;
91		107
92	/** collection of all buttons in the toolbar */	108	/** collection of all buttons in the toolbar */
93	private final Collection/<JButton>/ toolbarButtons	109	private final Collection/<JButton>/ toolbarButtons
94	= new ArrayList/<JButton>/(11);	110	= new ArrayList/<JButton>/(11);
		111	/** All the custom cursors used in the ImageViewer */
		112	private Cursor sprayCursor;
		113	private Cursor penCursor;
		114	private Cursor fillCursor;
		115	private Cursor brushCursor;
		116
		117
		118	private JToggleButton noFillRect;
		119	private JToggleButton fillRect;
		120	private JToggleButton noLineRect;
		121
		122	private JToggleButton noFillEllipse;
		123	private JToggleButton fillEllipse;
		124	private JToggleButton noLineEllipse;
		125
		126	private JToggleButton brushCircle;
		127	private JToggleButton brushSquare;
		128	private JToggleButton brushLeft;
		129	private JToggleButton brushRight;
		130
		131	private JSpinner cornerRounding;
		132	private JSpinner toolSize;
95		133
		134	private JPanel cornerRoundingPanel;
		135	private JPanel linePanel;
96		136
		137	private JColorChooser fgColor = new JColorChooser();
		138	private JColorChooser bgColor = new JColorChooser();
		139
97	/** Default constructor. Must be here, used during de-externalization */	140	/** Default constructor. Must be here, used during de-externalization */
98	public ImageViewer () {	141	public ImageViewer () {
99	super();	142	super();
Lines 123-128 Link Here
123	TopComponent.NodeName.connect (this, obj.getNodeDelegate ());	166	TopComponent.NodeName.connect (this, obj.getNodeDelegate ());
124		167
125	storedObject = obj;	168	storedObject = obj;
		169
		170	/* Add an observer */
		171	storedObject.addObserver(this);
126		172
127	// force closing panes in all workspaces, default is in current only	173	// force closing panes in all workspaces, default is in current only
128	setCloseOperation(TopComponent.CLOSE_EACH);	174	setCloseOperation(TopComponent.CLOSE_EACH);
Lines 132-137 Link Here
132		178
133	/* compose the whole panel: */	179	/* compose the whole panel: */
134	JToolBar toolbar = createToolBar();	180	JToolBar toolbar = createToolBar();
		181	JToolBar edittoolbar = createEditToolBar();
135	Component view;	182	Component view;
136	if (storedImage != null) {	183	if (storedImage != null) {
137	view = createImageView();	184	view = createImageView();
Lines 142-147 Link Here
142	setLayout(new BorderLayout());	189	setLayout(new BorderLayout());
143	add(view, BorderLayout.CENTER);	190	add(view, BorderLayout.CENTER);
144	add(toolbar, BorderLayout.NORTH);	191	add(toolbar, BorderLayout.NORTH);
		192	add(edittoolbar, BorderLayout.WEST);
145		193
146	getAccessibleContext().setAccessibleDescription(NbBundle.getBundle(ImageViewer.class).getString("ACS_ImageViewer"));	194	getAccessibleContext().setAccessibleDescription(NbBundle.getBundle(ImageViewer.class).getString("ACS_ImageViewer"));
147		195
Lines 155-207 Link Here
155	};	203	};
156		204
157	obj.addPropertyChangeListener(WeakListeners.propertyChange(nameChangeL, obj));	205	obj.addPropertyChangeListener(WeakListeners.propertyChange(nameChangeL, obj));
		206
		207	initialiseCustomCursors();
		208	}
		209
		210	/** Laods all the custom cursors */
		211	private void initialiseCustomCursors(){
		212	Toolkit tk = Toolkit.getDefaultToolkit();
		213	sprayCursor = tk.createCustomCursor(new ImageIcon(getClass().getResource("/org/netbeans/modules/image/sprayCursor.gif")).getImage(), new Point(0, 13), "Airbrush"); // Local
		214	penCursor = tk.createCustomCursor(new ImageIcon(getClass().getResource("/org/netbeans/modules/image/penCursor.gif")).getImage(), new Point(1, 14), "Pencil"); // Local
		215	fillCursor = tk.createCustomCursor(new ImageIcon(getClass().getResource("/org/netbeans/modules/image/fillCursor.gif")).getImage(), new Point(1, 12), "Paint Bucket"); // Local
		216	brushCursor = tk.createCustomCursor(new ImageIcon(getClass().getResource("/org/netbeans/modules/image/brushCursor.gif")).getImage(), new Point(0, 14), "Brush"); // Local
158	}	217	}
159		218
160	/**	219	/**
161	*/	220	*/
162	private Component createImageView() {	221	private Component createImageView() {
163	panel = new JPanel() {	222	panel = new ImageDisplayEdit(storedImage, getScale());
164	protected void paintComponent(Graphics g) {
165	super.paintComponent(g);
166	g.drawImage(
167	storedImage.getImage(),
168	0,
169	0,
170	(int)(getScale () * storedImage.getIconWidth ()),
171	(int)(getScale () * storedImage.getIconHeight ()),
172	0,
173	0,
174	storedImage.getIconWidth(),
175	storedImage.getIconHeight(),
176	this
177	);
178
179	if(showGrid) {
180	int x = (int)(getScale () * storedImage.getIconWidth ());
181	int y = (int)(getScale () * storedImage.getIconHeight ());
182
183	double gridDistance = getScale();
184
185	if(gridDistance < 2)
186	// Disable painting of grid if no image pixels would be visible.
187	return;
188
189	g.setColor(gridColor);
190
191	double actualDistance = gridDistance;
192	for(int i = (int)actualDistance; i < x ;actualDistance += gridDistance, i = (int)actualDistance) {
193	g.drawLine(i,0,i,(y-1));
194	}
195
196	actualDistance = gridDistance;
197	for(int j = (int)actualDistance; j < y; actualDistance += gridDistance, j = (int)actualDistance) {
198	g.drawLine(0,j,(x-1),j);
199	}
200	}
201
202	}
203
204	};
205	storedImage.setImageObserver(panel);	223	storedImage.setImageObserver(panel);
206	panel.setPreferredSize(new Dimension(storedImage.getIconWidth(), storedImage.getIconHeight() ));	224	panel.setPreferredSize(new Dimension(storedImage.getIconWidth(), storedImage.getIconHeight() ));
207	JScrollPane scroll = new JScrollPane(panel);	225	JScrollPane scroll = new JScrollPane(panel);
Lines 344-353 Link Here
344	toolBar.addSeparator(new Dimension(11,2));	362	toolBar.addSeparator(new Dimension(11,2));
345	toolBar.add(button = getGridButton());	363	toolBar.add(button = getGridButton());
346	toolbarButtons.add(button);	364	toolbarButtons.add(button);
		365	toolBar.addSeparator(new Dimension(11,2));
		366	toolBar.add(button = getConvertButton());
		367	toolbarButtons.add(button);
347		368
348	return toolBar;	369	return toolBar;
349	}	370	}
350		371
		372	//** Creates edittoolbar. */
		373	private JToolBar createEditToolBar()
		374	{
		375	ButtonGroup bgGroup = new javax.swing.ButtonGroup();
		376	ButtonGroup bgLineWidth = new javax.swing.ButtonGroup();
		377	ButtonGroup bgRect = new javax.swing.ButtonGroup();
		378	ButtonGroup bgEllipse = new javax.swing.ButtonGroup();
		379	ButtonGroup bgBrush = new javax.swing.ButtonGroup();
		380	JToolBar editToolBar = new javax.swing.JToolBar();
		381	editToolBar.setName (NbBundle.getBundle(ImageViewer.class).getString("ACSN_EditToolbar"));
		382	editToolBar.setOrientation(1);
		383
		384	setLayout(null);
		385
		386	editToolBar.setFloatable (false);
		387
		388	JToggleButton selectTButton = new JToggleButton();
		389	editToolBar.add(selectTButton = getSelectTButton());
		390	selectTButton.setSelected(true);
		391	selectTButton.setSize(32,17);
		392	bgGroup.add(selectTButton);
		393
		394	JToggleButton polygonTButton = new JToggleButton();
		395	editToolBar.add(polygonTButton = getPolygonTButton());
		396	bgGroup.add(polygonTButton);
		397
		398	JToggleButton penTButton = new JToggleButton();
		399	editToolBar.add(penTButton = getPenTButton());
		400	bgGroup.add(penTButton);
		401
		402	JToggleButton brushTButton = new JToggleButton();
		403	editToolBar.add(brushTButton = getBrushTButton());
		404	bgGroup.add(brushTButton);
		405
		406	JToggleButton eraserTButton = new JToggleButton();
		407	editToolBar.add(eraserTButton = getEraserTButton());
		408	bgGroup.add(eraserTButton);
		409
		410	JToggleButton arcTButton = new JToggleButton();
		411	editToolBar.add(arcTButton = getArcTButton());
		412	bgGroup.add(arcTButton);
		413
		414	JToggleButton lineTButton = new JToggleButton();
		415	editToolBar.add(lineTButton = getLineTButton());
		416	bgGroup.add(lineTButton);
		417
		418	JToggleButton rectangleTButton = new JToggleButton();
		419	editToolBar.add(rectangleTButton = getRectangleTButton());
		420	bgGroup.add(rectangleTButton);
		421
		422	JToggleButton ovalTButton = new JToggleButton();
		423	editToolBar.add(ovalTButton = getEllipseTButton());
		424	bgGroup.add(ovalTButton);
		425
		426	JToggleButton fillTButton = new JToggleButton();
		427	editToolBar.add(fillTButton = getFillTButton());
		428	bgGroup.add(fillTButton);
		429
		430	JToggleButton sprayTButton = new JToggleButton();
		431	editToolBar.add(sprayTButton = getSprayTButton());
		432	bgGroup.add(sprayTButton);
		433
		434	editToolBar.addSeparator(new Dimension(2,4));
		435
436	JButton foregroundButton = new JButton();
437	editToolBar.add(foregroundButton = getForegroundButton());
438
439	editToolBar.addSeparator(new Dimension(2,2));
440
441	JButton backgroundButton = new JButton();
442	editToolBar.add(backgroundButton = getBackgroundButton());
443
444	editToolBar.addSeparator(new Dimension(2,4));
445
446	brushSquare = new JToggleButton();
447	editToolBar.add(brushSquare = getBrushSquareTButton());
448	brushSquare.setSelected(true);
449	bgBrush.add(brushSquare);
450	brushSquare.setVisible(false);
451
452	brushCircle = new JToggleButton();
453	editToolBar.add(brushCircle = getBrushCircleTButton());
454	bgBrush.add(brushCircle);
455	brushCircle.setVisible(false);
456
457	brushRight = new JToggleButton();
458	editToolBar.add(brushRight = getBrushRightTButton());
459	bgBrush.add(brushRight);
460	brushRight.setVisible(false);
461
462	brushLeft = new JToggleButton();
463	editToolBar.add(brushLeft = getBrushLeftTButton());
464	bgBrush.add(brushLeft);
465	brushLeft.setVisible(false);
466
467	noFillRect = new JToggleButton();
468	editToolBar.add(noFillRect = getNoFillRectTButton());
469	bgRect.add(noFillRect);
470	noFillRect.setSelected(true);
471	noFillRect.setVisible(false);
472
473	fillRect = new JToggleButton();
474	editToolBar.add(fillRect = getFillRectTButton());
475	bgRect.add(fillRect);
476	fillRect.setVisible(false);
477
478	noLineRect = new JToggleButton();
479	editToolBar.add(noLineRect = getNoLineRectTButton());
480	bgRect.add(noLineRect);
481	noLineRect.setVisible(false);
482
483	noFillEllipse = new JToggleButton();
484	editToolBar.add(noFillEllipse = getNoFillEllipseTButton());
485	bgEllipse.add(noFillEllipse);
486	noFillEllipse.setSelected(true);
487	noFillEllipse.setVisible(false);
488
489	fillEllipse = new JToggleButton();
490	editToolBar.add(fillEllipse = getFillEllipseTButton());
491	bgEllipse.add(fillEllipse);
492	fillEllipse.setVisible(false);
493
494	noLineEllipse = new JToggleButton();
495	editToolBar.add(noLineEllipse = getNoLineEllipseTButton());
496	bgEllipse.add(noLineEllipse);
497	noLineEllipse.setVisible(false);
498
499	editToolBar.addSeparator(new Dimension(2,2));
500
501	linePanel = new JPanel();
502	linePanel.setLayout(null);
503
504	SpinnerModel lineWidthModel = new SpinnerNumberModel(1, 1, 40, 1);
505	toolSize = new JSpinner(lineWidthModel);
506
507	toolSize.addChangeListener(new ChangeListener() {
508	public void stateChanged(javax.swing.event.ChangeEvent evt) {
509	panel.setLineWidth(((Integer)(toolSize.getValue())).intValue());
510	changeLine();
511	}
512	});
513	toolSize.setSize(32,17);
514
515	JFormattedTextField bs = ((JSpinner.DefaultEditor)toolSize.getEditor()).getTextField();
516	bs.setEditable(false);
517	bs.setFont(new Font("Arial Narrow", 0, 10));
518	bs.setBackground(Color.white);
519
520	linePanel.add(toolSize);
521	linePanel.setVisible(false);
522
523	cornerRoundingPanel = new JPanel();
524	cornerRoundingPanel.setLayout(null);
525
526	SpinnerModel cornerRoundingModel = new SpinnerNumberModel(0, 0, 100, 5);
527	cornerRounding = new JSpinner(cornerRoundingModel);
528	cornerRounding.addChangeListener(new ChangeListener() {
529	public void stateChanged(javax.swing.event.ChangeEvent evt) {
530	panel.setRoundingFactor(((Integer)(cornerRounding.getValue())).intValue());
531	}
532	});
533	cornerRounding.setSize(32,17);
534
535	JFormattedTextField tf = ((JSpinner.DefaultEditor)cornerRounding.getEditor()).getTextField();
536	tf.setEditable(false);
537	tf.setFont(new Font("Arial Narrow", 0, 10));
538	tf.setBackground(Color.white);
539
540	cornerRoundingPanel.add(cornerRounding);
541	cornerRoundingPanel.setVisible(false);
542
543	editToolBar.add(linePanel);
544	editToolBar.addSeparator(new Dimension(2,2));
545	editToolBar.add(cornerRoundingPanel);
546	add(editToolBar);
547
548	return editToolBar;
549	}
550
351	/** Updates the name and tooltip of this top component according to associated data object. */	551	/** Updates the name and tooltip of this top component according to associated data object. */
352	private void updateName () {	552	private void updateName () {
353	// update name	553	// update name
Lines 541-546 Link Here
541	SystemAction.get(ZoomInAction.class),	741	SystemAction.get(ZoomInAction.class),
542	SystemAction.get(ZoomOutAction.class),	742	SystemAction.get(ZoomOutAction.class),
543	SystemAction.get(CustomZoomAction.class),	743	SystemAction.get(CustomZoomAction.class),
		744	SystemAction.get(ConvertToAction.class),
544	null},	745	null},
545	oldValue);	746	oldValue);
546	}	747	}
Lines 609-614 Link Here
609		810
610	resizePanel();	811	resizePanel();
611	panel.repaint(0, 0, panel.getWidth(), panel.getHeight());	812	panel.repaint(0, 0, panel.getWidth(), panel.getHeight());
		813	panel.setScale(scale);
612	}	814	}
613		815
614	/** Return zooming factor.*/	816	/** Return zooming factor.*/
Lines 619-624 Link Here
619	/** Change proportion "out"*/	821	/** Change proportion "out"*/
620	private void scaleOut() {	822	private void scaleOut() {
621	scale = scale / changeFactor;	823	scale = scale / changeFactor;
		824	panel.setScale(scale);
622	}	825	}
623		826
624	/** Change proportion "in"*/	827	/** Change proportion "in"*/
Lines 632-637 Link Here
632	if (newComputedScale == oldComputedScale)	835	if (newComputedScale == oldComputedScale)
633	// Has to increase.	836	// Has to increase.
634	scale = newComputedScale + 1.0D;	837	scale = newComputedScale + 1.0D;
		838
		839	panel.setScale(scale);
		840	}
		841
		842	public void convertTo() {
		843	try {
		844	storedObject.convertTo(this);
		845	} catch(IOException e) {
		846	JOptionPane.showMessageDialog(null, NbBundle.getMessage(ImageViewer.class, "MSG_CouldNotConvert"), NbBundle.getMessage(ImageViewer.class, "LBL_CouldNotConvert"), JOptionPane.ERROR_MESSAGE);
		847	}
		848	}
		849
		850	public void update(Observable o, Object arg){
		851	updateView(storedObject);
		852	panel.reload(storedImage);
635	}	853	}
636		854
637	/** Gets zoom button. */	855	/** Gets zoom button. */
Lines 676-687 Link Here
676	button.setMnemonic(NbBundle.getBundle(ImageViewer.class).getString("ACS_Grid_BTN_Mnem").charAt(0));	894	button.setMnemonic(NbBundle.getBundle(ImageViewer.class).getString("ACS_Grid_BTN_Mnem").charAt(0));
677	button.addActionListener(new ActionListener() {	895	button.addActionListener(new ActionListener() {
678	public void actionPerformed(ActionEvent evt) {	896	public void actionPerformed(ActionEvent evt) {
679	showGrid = !showGrid;	897	panel.toggleGrid();
680	panel.repaint(0, 0, panel.getWidth(), panel.getHeight());	898	panel.repaint(0, 0, panel.getWidth(), panel.getHeight());
681	}	899	}
682	});	900	});
683		901
684	return button;	902	return button;
		903	}
		904
		905	private JButton getConvertButton() {
		906	// PENDING buttons should have their own icons.
		907	JButton button = new JButton(NbBundle.getMessage(CustomZoomAction.class, "LBL_ConvertTo"));
		908	button.getAccessibleContext().setAccessibleDescription(NbBundle.getBundle(ImageViewer.class).getString("ACS_Convert_BTN"));
		909	button.addActionListener(new ActionListener() {
		910	public void actionPerformed(ActionEvent evt) {
		911	ConvertToAction sa = (ConvertToAction) SystemAction.get(ConvertToAction.class);
		912	sa.performAction();
		913	}
		914	});
		915
		916	return button;
		917	}
		918
		919	/** Gets ellipse button.*/
		920	private JToggleButton getEllipseTButton() {
		921	JToggleButton ellipseTButton = new JToggleButton();
		922	ellipseTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Ellipse"));
		923	ellipseTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/oval.gif")));
		924
		925	ellipseTButton.addActionListener(new ActionListener() {
		926	public void actionPerformed(ActionEvent evt) {
		927	panel.setToolType(ImageDisplayEdit.TOOL_ELLIPSE);
		928	panel.setCustomCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
		929	setSubtoolsVisible();
		930	}
		931	});
		932
		933	return ellipseTButton;
		934	}
		935
		936	/** Gets rectangle button.*/
		937	private JToggleButton getRectangleTButton(){
		938	JToggleButton rectangleTButton = new JToggleButton();
		939	rectangleTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Rectangle"));
		940	rectangleTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/rect.gif")));
		941
		942	rectangleTButton.addActionListener(new ActionListener() {
		943	public void actionPerformed(ActionEvent evt) {
		944	panel.setToolType(ImageDisplayEdit.TOOL_RECTANGLE);
		945	panel.setCustomCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
		946	setSubtoolsVisible();
		947	}
		948	});
		949
		950	return rectangleTButton;
		951	}
		952
		953	/** Gets fill button.*/
		954	private JToggleButton getFillTButton(){
		955	JToggleButton fillTButton = new JToggleButton();
		956	fillTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Fill"));
		957	fillTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/fill.gif")));
		958
		959	fillTButton.addActionListener(new ActionListener() {
		960	public void actionPerformed(ActionEvent evt) {
		961	panel.setToolType(ImageDisplayEdit.TOOL_FILL);
		962	panel.setCustomCursor(fillCursor);
		963	setSubtoolsVisible();
		964	}
		965	});
		966
967	return fillTButton;
968	}
969
970	/** Gets line button.*/
971	private JToggleButton getLineTButton(){
972	JToggleButton lineTButton = new JToggleButton();
973	lineTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Line"));
974	lineTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/line.gif")));
975
976	lineTButton.addActionListener(new ActionListener() {
977	public void actionPerformed(ActionEvent evt) {
978	panel.setToolType(ImageDisplayEdit.TOOL_LINE);
979	panel.setCustomCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
980	setSubtoolsVisible();
981	}
982	});
983
984	return lineTButton;
985	}
986
987	/** Gets select button.*/
988	private JToggleButton getSelectTButton(){
989	JToggleButton selectTButton = new JToggleButton();
990	selectTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Select"));
991	selectTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/arrow.gif")));
992
993	selectTButton.addActionListener(new ActionListener() {
994	public void actionPerformed(ActionEvent evt) {
995	panel.setToolType(ImageDisplayEdit.TOOL_DEFAULT);
996	panel.setCustomCursor(new Cursor(Cursor.DEFAULT_CURSOR));
997	setSubtoolsVisible();
998	}
999	});
1000
1001	return selectTButton;
1002	}
1003
1004	/** Gets polygon button.*/
1005	private JToggleButton getPolygonTButton(){
1006	JToggleButton polygonTButton = new JToggleButton();
1007	polygonTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Polygon"));
1008	polygonTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/polygon.gif")));
1009
1010	polygonTButton.addActionListener(new ActionListener() {
1011	public void actionPerformed(ActionEvent evt) {
1012	panel.setToolType(ImageDisplayEdit.TOOL_POLYGON);
1013	panel.setCustomCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
1014	setSubtoolsVisible();
1015	}
1016	});
1017
1018	return polygonTButton;
1019	}
1020
1021	/** Gets pen button.*/
1022	private JToggleButton getPenTButton(){
1023	JToggleButton penTButton = new JToggleButton();
1024	penTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Pen"));
1025	penTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/pen.gif")));
1026
1027	penTButton.addActionListener(new ActionListener() {
1028	public void actionPerformed(ActionEvent evt) {
1029	panel.setToolType(ImageDisplayEdit.TOOL_PEN);
1030	panel.setCustomCursor(penCursor);
1031	setSubtoolsVisible();
1032	}
1033	});
1034
1035	return penTButton;
1036	}
1037
1038	/** Gets eraser button.*/
1039	private JToggleButton getEraserTButton(){
1040	JToggleButton eraserTButton = new JToggleButton();
1041	eraserTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Eraser"));
1042	eraserTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/eraser.gif")));
1043
1044	eraserTButton.addActionListener(new ActionListener() {
1045	public void actionPerformed(ActionEvent evt) {
1046	panel.setToolType(ImageDisplayEdit.TOOL_ERASER);
1047	panel.setCustomCursor (new Cursor(Cursor.CROSSHAIR_CURSOR));
1048	setSubtoolsVisible();
1049	}
1050	});
1051
1052	return eraserTButton;
1053	}
1054
1055	/** Gets brush button.*/
1056	private JToggleButton getBrushTButton(){
1057	JToggleButton brushTButton = new JToggleButton();
1058	brushTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Brush"));
1059	brushTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/brush.gif")));
1060
1061	brushTButton.addActionListener(new ActionListener() {
1062	public void actionPerformed(ActionEvent evt) {
1063	panel.setToolType(ImageDisplayEdit.TOOL_BRUSH);
1064	panel.setCustomCursor(brushCursor);
1065	setSubtoolsVisible();
1066	}
1067	});
1068
1069	return brushTButton;
1070	}
1071
1072	/** Gets arc button.*/
1073	private JToggleButton getArcTButton(){
1074	JToggleButton arcTButton = new JToggleButton();
1075	arcTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Arc"));
1076	arcTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/arc.gif")));
1077
1078	arcTButton.addActionListener(new ActionListener() {
1079	public void actionPerformed(ActionEvent evt) {
1080	panel.setToolType(ImageDisplayEdit.TOOL_ARC);
1081	panel.setCustomCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
1082	setSubtoolsVisible();
1083	}
1084	});
1085
1086	return arcTButton;
685	}	1087	}
686		1088
		1089	/** Gets spray button.*/
		1090	private JToggleButton getSprayTButton(){
		1091	JToggleButton sprayTButton = new JToggleButton();
		1092	sprayTButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_Spray"));
		1093	sprayTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/spray.gif")));
		1094
		1095	sprayTButton.addActionListener(new ActionListener() {
		1096	public void actionPerformed(ActionEvent evt) {
		1097	panel.setToolType(ImageDisplayEdit.TOOL_SPRAY);
		1098	panel.setCustomCursor(sprayCursor);
		1099	setSubtoolsVisible();
		1100	}
		1101	});
		1102
		1103	return sprayTButton;
		1104	}
		1105
		1106	/** Gets foreground button.*/
		1107	private JButton getForegroundButton(){
		1108	final JButton foregroundButton = new JButton(" ");
		1109	foregroundButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_SetLineColor"));
		1110	foregroundButton.setBackground(panel.getDefaultPrimaryColor());
		1111	foregroundButton.addActionListener(new ActionListener()
		1112	{
		1113	public void actionPerformed(ActionEvent evt)
		1114	{
		1115	Color newColor = fgColor.showDialog(null,"Choose Foreground Color", foregroundButton.getForeground());
		1116	foregroundButton.setBackground(newColor);
		1117
		1118	panel.setPrimaryColor(newColor);
		1119	}
		1120	});
		1121
		1122	return foregroundButton;
		1123	}
		1124
		1125	/** Gets background button.*/
		1126	private JButton getBackgroundButton(){
		1127	final JButton backgroundButton = new JButton(" ");
		1128	backgroundButton.setBackground(panel.getDefaultSecondaryColor());
		1129	backgroundButton.setToolTipText (NbBundle.getBundle(ImageViewer.class).getString("LBL_SetFillColor"));
		1130	backgroundButton.addActionListener(new ActionListener()
		1131	{
		1132	public void actionPerformed(ActionEvent evt)
		1133	{
		1134	Color newColor = bgColor.showDialog(null,"Choose Background Color", backgroundButton.getBackground());
		1135	backgroundButton.setBackground(newColor);
		1136
		1137	panel.setSecondayColor(newColor);
		1138	}
		1139	});
		1140
		1141	return backgroundButton;
		1142	}
		1143
		1144
		1145	/** Gets noFillRect button */
		1146	private JToggleButton getNoFillRectTButton(){
		1147	JToggleButton noFillRectTButton = new JToggleButton();
		1148	noFillRectTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/noFillRect.gif")));
		1149
		1150	noFillRectTButton.addActionListener(new ActionListener() {
		1151	public void actionPerformed(ActionEvent evt) {
		1152	panel.setSubTool(ImageDisplayEdit.SUB_LINEONLY);
1153	}
1154	});
1155
1156	return noFillRectTButton;
1157	}
1158
1159	/** Gets fillRect button */
1160	private JToggleButton getFillRectTButton(){
1161	JToggleButton fillRectTButton = new JToggleButton();
1162	fillRectTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/fillRect.gif")));
1163
1164	fillRectTButton.addActionListener(new ActionListener() {
1165	public void actionPerformed(ActionEvent evt) {
1166	panel.setSubTool(ImageDisplayEdit.SUB_BOTH);
1167	}
1168	});
1169
1170	return fillRectTButton;
1171	}
1172
1173	/** Gets noLineRect button */
1174	private JToggleButton getNoLineRectTButton(){
1175	JToggleButton noLineRectTButton = new JToggleButton();
1176	noLineRectTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/noLineRect.gif")));
1177
1178	noLineRectTButton.addActionListener(new ActionListener() {
1179	public void actionPerformed(ActionEvent evt) {
1180	panel.setSubTool(ImageDisplayEdit.SUB_FILLONLY);
1181	}
1182	});
1183
1184	return noLineRectTButton;
1185	}
1186
1187	/** Gets noFillEllipse button */
1188	private JToggleButton getNoFillEllipseTButton(){
1189	JToggleButton noFillEllipseTButton = new JToggleButton();
1190	noFillEllipseTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/noFillEllipse.gif")));
1191
1192	noFillEllipseTButton.addActionListener(new ActionListener() {
1193	public void actionPerformed(ActionEvent evt) {
1194	panel.setSubTool(ImageDisplayEdit.SUB_LINEONLY);
1195	}
1196	});
1197
1198	return noFillEllipseTButton;
1199	}
1200
1201	/** Gets fillEllipse button */
1202	private JToggleButton getFillEllipseTButton(){
1203	JToggleButton fillEllipseTButton = new JToggleButton();
1204	fillEllipseTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/fillEllipse.gif")));
1205
1206	fillEllipseTButton.addActionListener(new ActionListener() {
1207	public void actionPerformed(ActionEvent evt) {
1208	panel.setSubTool(ImageDisplayEdit.SUB_BOTH);
1209	}
1210	});
1211
1212	return fillEllipseTButton;
1213	}
1214
1215	/** Gets noLineEllipse button */
1216	private JToggleButton getNoLineEllipseTButton(){
1217	JToggleButton noLineEllipseTButton = new JToggleButton();
1218	noLineEllipseTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/noLineEllipse.gif")));
1219
1220	noLineEllipseTButton.addActionListener(new ActionListener() {
1221	public void actionPerformed(ActionEvent evt) {
1222	panel.setSubTool(ImageDisplayEdit.SUB_FILLONLY);
1223	}
1224	});
1225
1226	return noLineEllipseTButton;
1227	}
1228
1229	/** Gets brushSquare button */
1230	private JToggleButton getBrushSquareTButton(){
1231	JToggleButton brushSquareTButton = new JToggleButton();
1232	brushSquareTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/brushSquare.gif")));
1233
1234	brushSquareTButton.addActionListener(new ActionListener() {
1235	public void actionPerformed(ActionEvent evt) {
1236	panel.setBrushType(BitmapFreehandBrush.BRUSH_BOX);
1237	}
1238	});
1239
1240	return brushSquareTButton;
1241	}
1242
1243	/** Gets brushCircle button */
1244	private JToggleButton getBrushCircleTButton(){
1245	JToggleButton brushCircleTButton = new JToggleButton();
1246	brushCircleTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/brushCircle.gif")));
1247
1248	brushCircleTButton.addActionListener(new ActionListener() {
1249	public void actionPerformed(ActionEvent evt) {
1250	panel.setBrushType(BitmapFreehandBrush.BRUSH_CIRC);
1251	}
1252	});
1253
1254	return brushCircleTButton;
1255	}
1256
1257	/** Gets brushLongLeftTButton button */
1258	private JToggleButton getBrushLeftTButton(){
1259	JToggleButton brushLeftTButton = new JToggleButton();
1260	brushLeftTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/brushLeft.gif")));
1261
1262	brushLeftTButton.addActionListener(new ActionListener() {
1263	public void actionPerformed(ActionEvent evt) {
1264	panel.setBrushType(BitmapFreehandBrush.BRUSH_LINE_135);
1265	}
1266	});
1267
1268	return brushLeftTButton;
1269	}
1270
1271	/** Gets brushLongRightTButton button */
1272	private JToggleButton getBrushRightTButton(){
1273	JToggleButton brushRightTButton = new JToggleButton();
1274	brushRightTButton.setIcon(new javax.swing.ImageIcon(getClass().getResource("/org/netbeans/modules/image/brushRight.gif")));
1275
1276	brushRightTButton.addActionListener(new ActionListener() {
1277	public void actionPerformed(ActionEvent evt) {
1278	panel.setBrushType(BitmapFreehandBrush.BRUSH_LINE_45);
1279	}
1280	});
1281
1282	return brushRightTButton;
1283	}
1284
1285	/** changes the line width display */
1286	private void changeLine() {
1287	Graphics2D g = (Graphics2D)linePanel.getGraphics();
1288
1289	g.setColor(Color.WHITE);
1290	g.fillRect(0, 20, 32, 40);
1291	g.setClip(0, 20, 32, 40);
1292
1293	if (panel.getToolType() == ImageDisplayEdit.TOOL_SPRAY){
1294	g.setColor(Color.BLACK);
1295	Ellipse2D testEllipse = new Ellipse2D.Float(10 - (panel.getLineWidth() / 2), 34 - (panel.getLineWidth() / 2), (float)panel.getLineWidth() + 10, (float)panel.getLineWidth() + 10);
1296	g.draw(testEllipse);
1297	}else{
1298	g.setColor(Color.BLACK);
1299	Line2D testLine = new Line2D.Float(new Point(0, 40), new Point(32, 40));
1300	g.setStroke(new BasicStroke(panel.getLineWidth()));
1301	g.draw(testLine);
1302	}
1303	}
1304
1305	/** set the lines widths visible */
1306	private void setSubtoolsVisible(){
1307	if (panel.getToolType() == ImageDisplayEdit.TOOL_RECTANGLE){
1308	noFillRect.setVisible(true);
1309	fillRect.setVisible(true);
1310	noLineRect.setVisible(true);
1311	cornerRoundingPanel.setVisible(true);
1312	}else{
1313	noFillRect.setVisible(false);
1314	fillRect.setVisible(false);
1315	noLineRect.setVisible(false);
1316	cornerRoundingPanel.setVisible(false);
1317	}
1318
1319	if (panel.getToolType() == ImageDisplayEdit.TOOL_ELLIPSE){
1320	noFillEllipse.setVisible(true);
1321	fillEllipse.setVisible(true);
1322	noLineEllipse.setVisible(true);
1323	}else{
1324	noFillEllipse.setVisible(false);
1325	fillEllipse.setVisible(false);
1326	noLineEllipse.setVisible(false);
1327	}
1328
1329	if (panel.getToolType() == ImageDisplayEdit.TOOL_BRUSH){
1330	brushCircle.setVisible(true);
1331	brushSquare.setVisible(true);;
1332	brushLeft.setVisible(true);
1333	brushRight.setVisible(true);
1334	}else{
1335	brushCircle.setVisible(false);
1336	brushSquare.setVisible(false);;
1337	brushLeft.setVisible(false);
1338	brushRight.setVisible(false);
1339	}
1340
1341	switch (panel.getToolType()){
1342	case ImageDisplayEdit.TOOL_POLYGON:
1343	case ImageDisplayEdit.TOOL_BRUSH:
1344	case ImageDisplayEdit.TOOL_ARC:
1345	case ImageDisplayEdit.TOOL_LINE:
1346	case ImageDisplayEdit.TOOL_RECTANGLE:
1347	case ImageDisplayEdit.TOOL_ELLIPSE:
1348	case ImageDisplayEdit.TOOL_ERASER:
1349	case ImageDisplayEdit.TOOL_SPRAY:
1350	linePanel.setVisible(true);
1351	changeLine();
1352	break;
1353	default:
1354	linePanel.setVisible(false);
1355	break;
1356	}
1357	}
687	}	1358	}




package org.netbeans.modules.image;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.imageio.ImageIO;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.LineBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;

import org.openide.WizardDescriptor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.HelpCtx;
import org.openide.util.NbBundle;

/**
 * JPanel used by the NewImageFileWizardIterator
 * 
 * @author Jason Solomon
 */
final public class ImageWizardPanel extends JPanel implements WizardDescriptor.FinishablePanel, DocumentListener {
    
    private transient Set listeners = new HashSet(1);
    
    private Color bgColor = Color.white;
    
    // Swing Components
    private JButton btnBrowse;
    private JButton btnBackground;
    private JColorChooser chBackground;
    private JComboBox cmbExt;
    private JFileChooser chFolder;
    private JLabel lblFileName;
    private JLabel lblExt;
    private JLabel lblFolder;
    private JLabel lblWidth;
    private JLabel lblHeight;
    private JPanel pnlTop;
    private JPanel pnlMid;
    private JPanel pnlBottom;
    private JPanel pnlBackground;
    private JTextField jtfFileName;
    private JTextField jtfFolder;
    private JTextField jtfWidth;
    private JTextField jtfHeight;
    
    public ImageWizardPanel() {
        setName(NbBundle.getMessage(ImageWizardPanel.class, "LBL_ImageProperties"));
        initComponents();
    }
    
    public Component getComponent() {
        return this;
    }
    
    public boolean isFinishPanel() {
        return true;
    }
    
    public boolean isValid() {
        try {
            if(jtfFileName.getText().equals(""))
                return false;
            
            File tempFile = new File(jtfFolder.getText());
            if (!tempFile.isDirectory())
                return false;
            
            int testWidth = Integer.parseInt(jtfWidth.getText());
            int testHeight = Integer.parseInt(jtfHeight.getText());
            if(testWidth <= 0 || testHeight <= 0)
                return false;
            
            return true;
        } catch(IllegalArgumentException e) {
            return false;
        }
    }
    
    public HelpCtx getHelp() {
        return null;
    }
    
    public void addChangeListener(ChangeListener l) {
        synchronized(listeners) {
            listeners.add(l);
        }
    }
    
    public void removeChangeListener(ChangeListener l) {
        synchronized(listeners) {
            listeners.remove(l);
        }
    }
    
    public void storeSettings(Object settings) {
    }
    
    public void readSettings(Object settings) {
    }
    
    public String getFileName() {
        return jtfFileName.getText();
    }
    
    public String getExt() {
        return (String)cmbExt.getSelectedItem();
    }
    
    public File getFolder() {
        return new File(jtfFolder.getText());
    }
    
    public int getImageWidth() {
        return Integer.parseInt(jtfWidth.getText());
    }
    
    public int getImageHeight() {
        return Integer.parseInt(jtfHeight.getText());
    }
    
    public Color getBackground() {
        return bgColor;
    }
    
    private void initComponents() {
        GridBagConstraints gridBagConstraints;
        
        String tempWriterTypes[] = ImageIO.getWriterFormatNames();
        String writerTypes[] = new String[tempWriterTypes.length];
        
        for(int i = 0; i < writerTypes.length; i++)
            writerTypes[i] = new String("");
        
        int z = 0;
        boolean found = false;
        for(int x = 0; x < tempWriterTypes.length; x++) {
            if(x == 0) {
                writerTypes[z] = tempWriterTypes[x].toLowerCase();
                z++;
            }
            else {
                for(int y = 0; y < writerTypes.length; y++) {
                    if(writerTypes[y].equals(tempWriterTypes[x].toLowerCase()))
                        found = true;
                }
                if(!found) {
                    writerTypes[z] = tempWriterTypes[x].toLowerCase();
                    z++;
                }
            }
        }
        
        chBackground = new JColorChooser();
        
        chFolder = new JFileChooser();
        chFolder.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
        chFolder.setDialogTitle(NbBundle.getMessage(ImageWizardPanel.class, "LBL_FolderChooser"));
        
        DefaultComboBoxModel cmbModel = new DefaultComboBoxModel();
        
        int j = 0;
        while(!writerTypes[j].equals("")) {
            cmbModel.addElement(writerTypes[j]);
            j++;
        }
        
        pnlTop = new JPanel();
        lblFileName = new JLabel();
        jtfFileName = new JTextField();
        lblExt = new JLabel();
        cmbExt = new JComboBox(cmbModel);
        lblFolder = new JLabel();
        jtfFolder = new JTextField();
        btnBrowse = new JButton();
        pnlMid = new JPanel();
        lblWidth = new JLabel();
        jtfWidth = new JTextField();
        lblHeight = new JLabel();
        jtfHeight = new JTextField();
        pnlBottom = new JPanel();
        btnBackground = new JButton();
        pnlBackground = new JPanel();
        
        jtfFileName.getDocument().addDocumentListener(this);
        jtfFolder.getDocument().addDocumentListener(this);
        jtfWidth.getDocument().addDocumentListener(this);
        jtfHeight.getDocument().addDocumentListener(this);
        
        btnBackground.addActionListener(
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    Color newBGColor = chBackground.showDialog(null, NbBundle.getMessage(ImageWizardPanel.class, "LBL_ColorChooser"), Color.white);
                    if(newBGColor != null) {
                        bgColor = newBGColor;
                    }
                    pnlBackground.setBackground(bgColor);
                }
            }
        );
        
        btnBrowse.addActionListener(
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(chFolder.showDialog(null, NbBundle.getMessage(ImageWizardPanel.class, "LBL_FolderChooserBtn")) == JFileChooser.APPROVE_OPTION) {
                        File tempFolder = chFolder.getSelectedFile();
                        jtfFolder.setText(tempFolder.getPath());
                    }
                }
            }
        );
        
        setLayout(new BorderLayout());
        
        pnlTop.setLayout(new GridBagLayout());

        lblFileName.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_FileName"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.anchor = GridBagConstraints.WEST;
        gridBagConstraints.insets = new Insets(30, 12, 0, 0);
        pnlTop.add(lblFileName, gridBagConstraints);

        jtfFileName.setText("newImage");
        jtfFileName.setPreferredSize(new Dimension(200, 23));
        jtfFileName.setMinimumSize(new Dimension(200, 23));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
        gridBagConstraints.weightx = 1.0;
        gridBagConstraints.insets = new Insets(29, 11, 0, 11);
        pnlTop.add(jtfFileName, gridBagConstraints);

        lblExt.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_Ext"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(30, 12, 0, 0);
        pnlTop.add(lblExt, gridBagConstraints);

        cmbExt.setPreferredSize(new Dimension(60, 22));
        cmbExt.setMinimumSize(new Dimension(60, 22));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(29, 11, 0, 11);
        pnlTop.add(cmbExt, gridBagConstraints);

        lblFolder.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_Folder"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.gridx = 0;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.anchor = GridBagConstraints.WEST;
        gridBagConstraints.insets = new Insets(12, 12, 0, 0);
        pnlTop.add(lblFolder, gridBagConstraints);

        jtfFolder.setPreferredSize(new Dimension(250, 23));
        jtfFolder.setMinimumSize(new Dimension(250, 23));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.gridx = 1;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.gridwidth = 2;
        gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
        gridBagConstraints.weightx = 2.0;
        gridBagConstraints.insets = new Insets(12, 11, 0, 11);
        pnlTop.add(jtfFolder, gridBagConstraints);

        btnBrowse.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_BrowseBtn"));
        btnBrowse.setPreferredSize(new Dimension(75, 27));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.gridx = 3;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.insets = new Insets(12, 11, 0, 11);
        pnlTop.add(btnBrowse, gridBagConstraints);

        add(pnlTop, BorderLayout.NORTH);
        
        pnlMid.setLayout(new GridBagLayout());

        lblWidth.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_Width"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.anchor = GridBagConstraints.WEST;
        gridBagConstraints.insets = new Insets(20, 100, 0, 0);
        pnlMid.add(lblWidth, gridBagConstraints);

        jtfWidth.setText("200");
        jtfWidth.setPreferredSize(new Dimension(60, 23));
        jtfWidth.setMinimumSize(new Dimension(60, 23));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(19, 11, 0, 11);
        pnlMid.add(jtfWidth, gridBagConstraints);

        lblHeight.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_Height"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(20, 12, 0, 0);
        pnlMid.add(lblHeight, gridBagConstraints);

        jtfHeight.setText("200");
        jtfHeight.setPreferredSize(new Dimension(60, 23));
        jtfHeight.setMinimumSize(new Dimension(60, 23));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(19, 11, 0, 100);
        pnlMid.add(jtfHeight, gridBagConstraints);

        add(pnlMid, BorderLayout.CENTER);
        
        pnlBottom.setLayout(new GridBagLayout());

        btnBackground.setText(NbBundle.getMessage(ImageWizardPanel.class, "LBL_BackgroundBtn"));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(30, 11, 30, 11);
        pnlBottom.add(btnBackground, gridBagConstraints);

        pnlBackground.setLayout(null);

        pnlBackground.setBackground(Color.white);
        pnlBackground.setBorder(new LineBorder(Color.black));
        pnlBackground.setPreferredSize(new Dimension(40, 40));
        gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.insets = new Insets(0, 0, 2, 0);
        pnlBottom.add(pnlBackground, gridBagConstraints);

        add(pnlBottom, BorderLayout.SOUTH);
    }
    
    public void insertUpdate(DocumentEvent e) {
        ChangeEvent ce = new ChangeEvent(this);
        Iterator it = listeners.iterator();
        while (it.hasNext()) {
            ((ChangeListener)it.next()).stateChanged(ce);
        }
    }
    
    public void removeUpdate(DocumentEvent e) {
        ChangeEvent ce = new ChangeEvent(this);
        Iterator it = listeners.iterator();
        while (it.hasNext()) {
            ((ChangeListener)it.next()).stateChanged(ce);
        }
    }
    
    public void changedUpdate(DocumentEvent e) {
        ChangeEvent ce = new ChangeEvent(this);
        Iterator it = listeners.iterator();
        while (it.hasNext()) {
            ((ChangeListener)it.next()).stateChanged(ce);
        }
    }
    
}




        <folder name="View">
            <file name="org.netbeans.modules.image.ZoomInAction.instance" />
            <file name="org.netbeans.modules.image.ZoomOutAction.instance" />
            <file name="org.netbeans.modules.image.CustomZoomAction.instance"/>
            <file name="org.netbeans.modules.image.ConvertToAction.instance" />
        </folder>
    </folder>
    
    <folder name="Services">
        <folder name="MIMEResolver">
            <file name="org-netbeans-modules-image-mime-resolver.xml" url="mime-resolver.xml">
                <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.image.Bundle"/>
                <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/modules/image/imageObject.gif"/>
            </file>
        </folder>
    </folder>
    
    <folder name="Templates">
        <attr name="API_Support/Other" boolvalue="true"/>
        <folder name="Other">
            <file name="image.image" url="image.image">
                <attr name="template" boolvalue="true" />
                <attr name="templateWizardURL" urlvalue="nbresloc:/org/netbeans/modules/image/ImageHelp.html" />
                <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.image.Bundle" />
                <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/modules/image/imageObject.gif"/>
                <attr name="instantiatingIterator" methodValue="org.netbeans.modules.image.NewImageFileWizardIterator.createImageTemplateIterator" />
                <attr name="templateCategory" stringvalue="simple-files"/>
            </file>
        </folder>
    </folder>

Lines 24-30 Link Here

(-)image/src/org/netbeans/modules/image/NBImageIcon.java (-1 / +6 lines)
24	/**	24	/**
25	* ImageIcon with serialization.	25	* ImageIcon with serialization.
26	*	26	*
27	* @author Petr Hamernik, Michael Wever	27	* @author Petr Hamernik, Michael Wever, Jason Solomon
28	* @author Marian Petras	28	* @author Marian Petras
29	*/	29	*/
30	class NBImageIcon extends ImageIcon implements Serializable {	30	class NBImageIcon extends ImageIcon implements Serializable {
Lines 96-99 Link Here
96	(image != null) ? image : new ImageIcon().getImage());	96	(image != null) ? image : new ImageIcon().getImage());
97	}	97	}
98	} // End of nested class ResolvableHelper.	98	} // End of nested class ResolvableHelper.
		99
		100	protected ImageDataObject getIDO() {
		101	return obj;
		102	}
		103
99	}	104	}




package org.netbeans.modules.image;

import java.awt.Component;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.stream.FileImageOutputStream;
import javax.swing.JComponent;
import javax.swing.event.ChangeListener;

import org.openide.WizardDescriptor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;

/**
 * Wizard to create a new Image file.
 * 
 * @author Jason Solomon
 */
public class NewImageFileWizardIterator implements WizardDescriptor.InstantiatingIterator {
    
    private transient WizardDescriptor wizard;
    
    private transient WizardDescriptor.Panel[] panels;
    
    private transient int index;
    
    private transient Set listeners = new HashSet(1);
    
    /** Create a new wizard iterator. */
    public NewImageFileWizardIterator() {
    }
    
    public void initialize(WizardDescriptor wizard) {        
        this.wizard = wizard;
        index = 0;
        
        panels = new ImageWizardPanel[1];
        panels[0] = new ImageWizardPanel();
        
        // Make sure list of steps is accurate.
        String[] beforeSteps = null;
        Object prop = wizard.getProperty ("WizardPanel_contentData");
        if (prop != null && prop instanceof String[]) {
            beforeSteps = (String[])prop;
        }
        
        assert panels != null;
        
        int diff = 0;
        if (beforeSteps == null) {
            beforeSteps = new String[0];
        } else if (beforeSteps.length > 0) {
            diff = ("...".equals(beforeSteps[beforeSteps.length - 1])) ? 1 : 0;
        }
        String[] steps = new String[(beforeSteps.length - diff) + panels.length];
        for (int i = 0; i < steps.length; i++) {
            if (i < (beforeSteps.length - diff)) {
                steps[i] = beforeSteps[i];
            } else {
                steps[i] = panels[i - beforeSteps.length + diff].getComponent().getName();
            }
        }
        for (int i = 0; i < panels.length; i++) {
            Component c = panels[i].getComponent();
            if (steps[i] == null) {
                steps[i] = c.getName();
            }
            if (c instanceof JComponent) {
                JComponent jc = (JComponent)c;
                jc.putClientProperty("WizardPanel_contentSelectedIndex", new Integer(i));
                jc.putClientProperty("WizardPanel_contentData", steps);
            }
        }
    }
    
    public Set instantiate() throws IOException {
        String fileName = ((ImageWizardPanel)(panels[index])).getFileName();
        String ext = ((ImageWizardPanel)(panels[index])).getExt();
        File folder = ((ImageWizardPanel)(panels[index])).getFolder();
        int width = ((ImageWizardPanel)(panels[index])).getImageWidth();
        int height = ((ImageWizardPanel)(panels[index])).getImageHeight();
        Color bgColor = ((ImageWizardPanel)(panels[index])).getBackground();
        
        File newFile =  new File(folder, fileName + "." + ext);
        BufferedImage newImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics g = newImage.getGraphics();
        g.setColor(bgColor);
        g.fillRect(0, 0, width, height);
        Iterator writers = ImageIO.getImageWritersByFormatName(ext);
        ImageWriter writer = (ImageWriter)writers.next();
        FileImageOutputStream output = new FileImageOutputStream(newFile);
        writer.setOutput(output);
        writer.write((RenderedImage)newImage);
        FileObject pf = FileUtil.toFileObject(newFile);
        
        return Collections.singleton(pf);
    }
    
    public void uninitialize(WizardDescriptor wizard) {
        this.wizard = null;
    }
    
    public String name() {
        return "";
    }
    
    public final void addChangeListener(ChangeListener l) {
        synchronized(listeners) {
            listeners.add(l);
        }
    }
    
    public final void removeChangeListener(ChangeListener l) {
        synchronized(listeners) {
            listeners.remove(l);
        }
    }
    
    public boolean hasNext() {
        return index < panels.length - 1;
    }
    
    public boolean hasPrevious() {
        return index > 0;
    }
    
    public void nextPanel() {
        if (!hasNext()) throw new NoSuchElementException();
        index++;
    }
    
    public void previousPanel() {
        if (!hasPrevious()) throw new NoSuchElementException();
        index--;
    }
    
    public WizardDescriptor.Panel current() {
        return panels[index];
    }
    
    public static WizardDescriptor.InstantiatingIterator createImageTemplateIterator() {
        return new NewImageFileWizardIterator ();
    }
    
}




package org.netbeans.modules.image;

import java.util.Observable;

/**
 * Allows a public call to the setChanged() method of Observable
 * 
 * @author Jason Solomon
 */
public class ObservableImage extends Observable {
    public void setChanged() {
        super.setChanged();
    }
}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Point;
import java.awt.Dimension;
import java.awt.Shape;
import java.awt.Rectangle;
import java.awt.geom.Arc2D;
import java.lang.Math;

/**
 * Implimentation of the Vector Arc tool.  Draws a
 * 90 degree line joining both points
 *
 * @author Timothy Boyce
 */
class VectorArc extends VectorTool{

    /** Simply use the supercalss default constructor */
    public VectorArc(int xVal, int yVal, Color c, int w){
        super(xVal, yVal, c, w);
    }
    
    /** Draw an arc on the graphics context
    between the start and end clicks */
    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(getLineWidth()));
        g.setPaintMode();
        g.setColor(getLineColor());
        
        Arc2D.Float thisArc = new Arc2D.Float();
        
        /* Calculate the bounding rectangle */
        double top, left, direction;
        top = (getStart().getY() < getEnd().getY()) ? getTopLeft().getY() - getDimension().getHeight() : getTopLeft().getY();
        left = (getStart().getX() > getEnd().getX()) ? getTopLeft().getX() - getDimension().getWidth() : getTopLeft().getX();
        direction = (getStart().getX() - getEnd().getX()) * (getStart().getY() - getEnd().getY());
        direction = -(Math.abs(direction) / direction);
        
        Point topLeft = new Point((int)left, (int)top);
        Dimension rectDim = new Dimension((int)(2 * getDimension().getWidth()),(int)(2 * getDimension().getHeight()));
        
        /* Sets the arcs bounds */
        thisArc.setFrame(new Rectangle(topLeft, rectDim));
        
        /* Set the angle extent and start */
        thisArc.setAngleStart((getEnd().getY() < getStart().getY()) ? 90 : 270);
        thisArc.setAngleExtent(direction * 90);
    
        g.draw(thisArc);
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Shape;
import java.awt.geom.Ellipse2D;

/**
 * Implimentation of the Ellipse Edit Tool
 *
 * @author Timothy Boyce
 */
class VectorEllipse extends VectorTool{
    /** The fill color of the Ellipse */
    private Color fillColor;

    /** Constructor for a line ellipse */
    public VectorEllipse(int xVal, int yVal, Color c, int w){
        super(xVal, yVal, c, w);
        fillColor = null;
    }
    
    /** Constructor for a filled ellipse */
    public VectorEllipse(int xVal, int yVal, Color line, Color fill, int w){
        super(xVal, yVal, line, w);
        fillColor = fill;
    }

    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(getLineWidth()));
        g.setPaintMode();
            
        Ellipse2D.Float thisEllipse = new Ellipse2D.Float((float)getTopLeft().getX(), (float)getTopLeft().getY(), (float)getDimension().getWidth(), (float)getDimension().getHeight());
            
        if(fillColor != null){
            g.setColor(fillColor);
            g.fill(thisEllipse);
        }
        
        g.setColor(getLineColor());
        g.draw(thisEllipse);
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.geom.Line2D;
import java.awt.Color;

/** Implimentation of the Line tool.
 *
 * @author Timothy Boyce
 */
class VectorLine extends VectorTool{

    /** Use the superclass constructor */
    public VectorLine(int xVal, int yVal, Color c, int w){
        super(xVal, yVal, c, w);
    }

    /** Draw a line between the start and end points, 
    to the specified graphics object */
    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(getLineWidth()));
        g.setPaintMode();
        g.setColor(getLineColor());
        g.draw(new Line2D.Float(getStart(), getEnd()));
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Point;
import java.awt.Color;
import java.awt.geom.GeneralPath;
import java.util.Vector;

/**
 * Implimentation of the Polygon Edit Tool
 *
 * @author Timothy Boyce
 */
class VectorPolygon implements EditTool{

    /** The start point of the polygon */
    protected Point startPoint;
    
    /** The end point of the polygon */
    protected Point lastPoint;
    
    /** Vector containing the last 3 polygon points */
    protected Vector polygonSegPoints = new Vector(){
        public void addElement(Object obj){
            if(this.size() >= 3)
                this.removeElementAt(0);
            super.addElement(obj);
        }
    };
    
    /** General path used for drawing polygon segments */
    protected GeneralPath polygonSegPath;    
    
    /** The line color */
    protected Color lineColor;
    
    /** The width of the line */
    protected float lineWidth;
    
    /** The status of the tool, true = complete, false = incomplete */
    protected boolean toolStatus = false;
    
    /** The type of the polgon, points only, or freehand and points */
    protected boolean polyType;
    
    /** Static polygon type varibles used in the constructor */
    public static final boolean FREEHAND_POLY = true;
    public static final boolean POINT_POLY = false;

    /** Constructor, set the start point of the polygon, and other various 
    variables. */
    public VectorPolygon(int xVal, int yVal, Color c, int w, boolean f){
        startPoint = new Point(xVal, yVal);
        polygonSegPoints.addElement(startPoint);
        lastPoint = new Point(-1, -1);
        lineColor = c;
        lineWidth = (float)w;
        polyType = false;
    }
    
    public boolean getToolStatus(){
        return toolStatus;
    }
    
    public boolean getMemoryless(){
        return true;
    }
    
    /** When the image display editor invokes the setDragPoint
    command, only set a new polygone point if the user has selected a
    freehand polygon type */
    public void setDragPoint(int xVal, int yVal){
        if(polyType == VectorPolygon.FREEHAND_POLY){
            polygonSegPoints.addElement(new Point(xVal, yVal));
            lastPoint.setLocation(xVal, yVal);
        }
    }
    
    public void setClickPoint(int xVal, int yVal){
        lastPoint.setLocation(xVal, yVal);    
        polygonSegPoints.addElement(new Point(xVal, yVal));
    }
    
    public void setReleasePoint(int xVal, int yVal){
        /** Finish the polygon if the user clicks in the same spot twice */
        if((xVal == lastPoint.x) && (yVal == lastPoint.y)){
            toolStatus = true;
        }
        
        lastPoint.setLocation(xVal, yVal);    
        polygonSegPoints.addElement(new Point(xVal, yVal));
    }
    
    
    /** Write the last 2 polgon segments to the graphics context:
    Since this is a non-memoryless tool, all preceding points will
    still be held in the buffer.  Only the last 2 segments need to
    be drawn in order to get the new line, and the proper segment
    joining at the newly created corner. */
    public void writeToGraphic(Graphics2D g){
        Point p1, p2, p3;
        
        g.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g.setPaintMode();
        g.setColor(lineColor);
        
        polygonSegPath = new GeneralPath();
        
        p1 = (Point)polygonSegPoints.firstElement();
        polygonSegPath.moveTo(p1.x, p1.y);
        
        if(polygonSegPoints.size() == 3)
            p2 = (Point)polygonSegPoints.get(1);
        else
            p2 = (Point)polygonSegPoints.lastElement();
        
        polygonSegPath.lineTo(p2.x, p2.y);
        
        if(polygonSegPoints.size()  == 2)
            p3 = (Point)polygonSegPoints.firstElement();
        else
            p3 = (Point)polygonSegPoints.lastElement();
            
        polygonSegPath.lineTo(p3.x, p3.y);
        
        if(getToolStatus()){
            polygonSegPath.lineTo(startPoint.x, startPoint.y);
        }
        
        g.draw(polygonSegPath);
    }
}




package org.netbeans.modules.image;

import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.Rectangle;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.GradientPaint;

import java.awt.geom.RoundRectangle2D;

/**
 * VectorRectangle
 *
 * @author Timothy Boyce
 */
class VectorRectangle extends VectorTool{
    private Color fillColor;
    private float roundingFactor;

    public VectorRectangle(int xVal, int yVal, Color c, int w){
        super(xVal, yVal, c, w);
        
        /* Set the fill colour to null,
        and corner rounding to 0 */
        fillColor = null;
        roundingFactor = 0;
    }
    
    public VectorRectangle(int xVal, int yVal, Color c, int w, float r){
        super(xVal, yVal, c, w);
        
        /* Set the fill to null */
        fillColor = null;
        
        /* Set CornerRounding */
        roundingFactor = r;
    }
    
    public VectorRectangle(int xVal, int yVal, Color line, Color fill, int w){
        super(xVal, yVal, line, w);
        
        /* Set the fill colour to null */
        fillColor = fill;
        roundingFactor = 0;
    }
    
    public VectorRectangle(int xVal, int yVal, Color line, Color fill, int w, float r){
        super(xVal, yVal, line, w);
        
        /* Set the fill colour to null */
        fillColor = fill;
        roundingFactor = r;
    }

    /* Returns null if there is no fill, the
    color if the tool is complete, or the XOR
    mode color if the tool is not yet complete */
    protected Color getFillColor(){
            return fillColor;
    }

    public void writeToGraphic(Graphics2D g){
        g.setStroke(new BasicStroke(getLineWidth(), BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER));
        g.setPaintMode();
        
        Shape thisRectangle;
        
        if(roundingFactor == 0)
            thisRectangle = new Rectangle(getTopLeft(), getDimension());
        else
            thisRectangle = new RoundRectangle2D.Float((float)getTopLeft().getX(), (float)getTopLeft().getY(), (float)getDimension().getWidth(), (float)getDimension().getHeight(), roundingFactor, roundingFactor);
            
        /* Fill it if the user chose a filled variation */
        if(fillColor != null){
            g.setColor(getFillColor());
            g.fill(thisRectangle);
        }
        
        /* Paint the line */
        g.setColor(getLineColor());
        g.draw(thisRectangle);
        
    }
    
}




package org.netbeans.modules.image;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;

/**
 * VectorTool
 *
 * @author Timothy Boyce
 */
abstract class VectorTool implements EditTool{
    protected Point startPoint;
    protected Point endPoint;
    private Color lineColor;
    private float lineWidth;
    private Rectangle BoundingRectangle;
    private Rectangle OldBoundingRectangle;
    
    protected boolean toolStatus = false;
    
    public VectorTool(int xVal, int yVal, Color c, int w){
        /* Set the start points */
        startPoint = new Point(xVal, yVal);
        
        /* Default the end points to the start points */
        endPoint = new Point(xVal, yVal);
        
        /* Set the Line Colour */
        lineColor = c;
        
        /* Sets the Line Width */
        lineWidth = (float)w;
    }
    
    /* Default Action to be performed on a drag */
    public void setDragPoint(int xVal, int yVal){
        endPoint.setLocation(xVal, yVal);
    }
    
    /* Default action taken on a release */
    public void setReleasePoint(int xVal, int yVal){
        endPoint.setLocation(xVal, yVal);
        
        /* Most Edit tools are complete when the user releases
        the mouse */
        toolStatus = true;
    }
    
    /* Default action taken on a Click */
    public void setClickPoint(int xVal, int yVal){
    }
    
    /* Return the tool status */
    public boolean getToolStatus(){
        return toolStatus;
    }
    
    /* Return the shape height */
    private int getHeight(){
        return Math.abs((int)startPoint.getY() - (int)endPoint.getY());
    }
    
    /* Return the shape width */
    private int getWidth(){
        return Math.abs((int)startPoint.getX() - (int)endPoint.getX());
    }
    
    /* Retern the top-left point */
    protected Point getTopLeft(){
        double left = (startPoint.getX() < endPoint.getX()) ? startPoint.getX() : endPoint.getX();
        double top = (startPoint.getY() < endPoint.getY()) ? startPoint.getY() : endPoint.getY();
        
        return new Point((int)left, (int)top);
    }
    
    /* Return the bottom-right point */
    protected Point getBottomRight(){
        double right = (startPoint.getX() > endPoint.getX()) ? startPoint.getX() : endPoint.getX();
        double bottom = (startPoint.getY() > endPoint.getY()) ? startPoint.getY() : endPoint.getY();
        
        return new Point((int)right, (int)bottom);
    }
    
    /* Return the start point object */
    protected Point getStart(){
        return startPoint;
    }
    
    /*Return the end point object */
    protected Point getEnd(){
        return endPoint;
    }
    
    /* Return the width and height as a dimension object */
    protected Dimension getDimension(){
        return new Dimension(getWidth(), getHeight());
    }
    
    /* Returns a rectangle that bounds this object */
    public Rectangle getBounds(){
        return new Rectangle(getTopLeft(), getDimension());
    }
    
    /* Returns the line colour if the tool
    is complete, otherwise it returns the colour
    black to be used in XOR mode */
    protected  Color getLineColor(){
            return lineColor;
    }
    
    protected float getLineWidth(){
        return lineWidth;
    }
    
    public boolean getMemoryless(){
        return false;
    };
    
    /* Writes the current tool to the graphis object */
    public abstract void writeToGraphic(Graphics2D g);
}

Return to bug 59527

Lines 13-23 Link Here

(-)image/src/org/netbeans/modules/image/Bundle.properties (+58 lines)
13	PROP_ImageLoader_Name=Image Objects	13	PROP_ImageLoader_Name=Image Objects
14	Services/MIMEResolver/org-netbeans-modules-image-mime-resolver.xml=Image Files	14	Services/MIMEResolver/org-netbeans-modules-image-mime-resolver.xml=Image Files
15		15
		16	# Filenames
		17	Templates/Other/image.image=Image File
		18
		19	# New Image
		20	LBL_ImageProperties=Image Properties
		21
16	# ImageDataObject.ImageNode	22	# ImageDataObject.ImageNode
17	HINT_Thumbnail=Shows thumbnail.	23	HINT_Thumbnail=Shows thumbnail.
18	PROP_Thumbnail=Thumbnail	24	PROP_Thumbnail=Thumbnail
19		25
		26	# ImageWizardPanel Labels
		27	LBL_FolderChooser=Target Folder
		28	LBL_FolderChooserBtn=Select
		29	LBL_ColorChooser=Background Color
		30	LBL_FileName=File Name:
		31	LBL_Ext=Ext:
		32	LBL_Folder=Folder:
		33	LBL_BrowseBtn=Browse
		34	LBL_Width=Width:
		35	LBL_Height=Height:
		36	LBL_BackgroundBtn=Background
		37
		38	# Failure to load an image
		39	MSG_CouldNotLoad=Could not load the image
		40	MSG_ErrorWhileLoading=Error while loading the image (corrupted image?)
		41	# Save Image
		42	LBL_CompressionLevel=Compression Level
		43	MSG_CompressionLevel=Select a compression level:
		44	# Convert Image
		45	LBL_Format=Format
		46	MSG_Format=Select a format:
		47	LBL_CouldNotConvert=Convert Error
		48	MSG_CouldNotConvert=Could not convert the image
		49
20	# Failure to load an image	50	# Failure to load an image
		51	MSG_UserAbortSave=User aborted saving of file {0}
		52	LBL_NoSaveSupport=No Save Support
		53	MSG_NoSaveSupportConfirm=There is currently no save support for {0} type.\nWould you like to convert to a different format?
		54	MSG_NoSaveSupport=There is currently no save support for {0} type
21	MSG_CouldNotLoad=Could not load the image	55	MSG_CouldNotLoad=Could not load the image
22	MSG_ErrorWhileLoading=Error while loading the image (corrupted image?)	56	MSG_ErrorWhileLoading=Error while loading the image (corrupted image?)
23	# External change happened.	57	# External change happened.
Lines 31-36 Link Here
31	LBL_EnlargeFactor_Mnem=E	65	LBL_EnlargeFactor_Mnem=E
32	LBL_DecreaseFactor=Decrease Factor:	66	LBL_DecreaseFactor=Decrease Factor:
33	LBL_DecreaseFactor_Mnem=D	67	LBL_DecreaseFactor_Mnem=D
		68	LBL_ConvertTo=Convert To...
		69
		70	# Tool labels
		71	LBL_Ellipse=Ellipse
		72	LBL_Eraser=Eraser
		73	LBL_Rectangle=Rectangle
		74	LBL_Fill=Fill
		75	LBL_Line=Line
		76	LBL_Select=Select
		77	LBL_Polygon=Polygon
		78	LBL_Pen=Pen
		79	LBL_Brush=Brush
		80	LBL_Arc=Arc
		81	LBL_Spray=Spray
		82	LBL_SetLineColor=Set Line Color
		83	LBL_SetFillColor=Set Fill Color
		84
		85	# ColorChooser Labels
		86	LBL_ForegroundColor=Choose Foreground Color
		87	LBL_BackgroundColor=Choose Background Color
34		88
35	# Show/Hide grid action label	89	# Show/Hide grid action label
36	LBL_ShowHideGrid=Toggle grid	90	LBL_ShowHideGrid=Toggle grid
Lines 51-59 Link Here
51		105
52	ACS_Zoom_BTN=N/A	106	ACS_Zoom_BTN=N/A
53		107
		108	ACS_Convert_BTN=N/A
		109
54	ACSD_Toolbar=N/A	110	ACSD_Toolbar=N/A
55		111
56	ACSN_Toolbar=Zoom Toolbar	112	ACSN_Toolbar=Zoom Toolbar
		113
		114	ACSN_EditToolbar=Edit Toolbar
57		115
58	ACS_Grid_BTN=N/A	116	ACS_Grid_BTN=N/A
59		117

Added Link Here

(-)image/src/org/netbeans/modules/image/ImageHelp.html (+16 lines)
1	<!--
2	Sun Public License Notice
3
4	The contents of this file are subject to the Sun Public License
5	Version 1.0 (the "License"). You may not use this file except in
6	compliance with the License. A copy of the License is available at
7	http://www.sun.com/
8
9	The Original Code is NetBeans. The Initial Developer of the Original
10	Code is Sun Microsystems, Inc. Portions Copyright 1997-2005 Sun
11	Microsystems, Inc. All Rights Reserved.
12	-->
13
14	<HTML><BODY>
15	Creates a new image file. You can edit the file in the IDE's Image Editor.
16	</BODY></HTML>

Lines 19-33 Link Here

(-)image/src/org/netbeans/modules/image/Layer.xml (-2 / +17 lines)
19	<folder name="View">	19	<folder name="View">
20	<file name="org.netbeans.modules.image.ZoomInAction.instance" />	20	<file name="org.netbeans.modules.image.ZoomInAction.instance" />
21	<file name="org.netbeans.modules.image.ZoomOutAction.instance" />	21	<file name="org.netbeans.modules.image.ZoomOutAction.instance" />
22	<file name="org.netbeans.modules.image.CustomZoomAction.instance"/>	22	<file name="org.netbeans.modules.image.CustomZoomAction.instance"/>
		23	<file name="org.netbeans.modules.image.ConvertToAction.instance" />
23	</folder>	24	</folder>
24	</folder>	25	</folder>
25		26
26	<folder name="Services">	27	<folder name="Services">
27	<folder name="MIMEResolver">	28	<folder name="MIMEResolver">
28	<file name="org-netbeans-modules-image-mime-resolver.xml" url="mime-resolver.xml">	29	<file name="org-netbeans-modules-image-mime-resolver.xml" url="mime-resolver.xml">
29	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.image.Bundle"/>	30	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.image.Bundle"/>
30	<attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/modules/image/imageObject.gif"/>	31	<attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/modules/image/imageObject.gif"/>
		32	</file>
		33	</folder>
		34	</folder>
		35
		36	<folder name="Templates">
		37	<attr name="API_Support/Other" boolvalue="true"/>
		38	<folder name="Other">
		39	<file name="image.image" url="image.image">
		40	<attr name="template" boolvalue="true" />
		41	<attr name="templateWizardURL" urlvalue="nbresloc:/org/netbeans/modules/image/ImageHelp.html" />
		42	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.image.Bundle" />
		43	<attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/modules/image/imageObject.gif"/>
		44	<attr name="instantiatingIterator" methodValue="org.netbeans.modules.image.NewImageFileWizardIterator.createImageTemplateIterator" />
		45	<attr name="templateCategory" stringvalue="simple-files"/>
31	</file>	46	</file>
32	</folder>	47	</folder>
33	</folder>	48	</folder>