LittleWindow.java :  » Image » jdebye » gui » Java Open Source

Java Open Source » Image » jdebye 
jdebye » gui » LittleWindow.java
package gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Transparency;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.RenderedImage;
import java.awt.image.SampleModel;
import java.awt.image.renderable.ParameterBlock;
import java.io.File;
import java.io.IOException;
import java.util.Vector;

import javax.media.jai.Interpolation;
import javax.media.jai.JAI;
import javax.media.jai.PlanarImage;
import javax.media.jai.operator.TransposeDescriptor;
import javax.swing.BoxLayout;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import javax.swing.filechooser.FileFilter;

import save.ExampleFileFilter;
import save.SaveStrategy;

import com.sun.media.jai.widget.DisplayJAI;

import dcartes.analysis.PrintData;
import dcartes.draw.DebyeDrawPoints;
import dcartes.draw.DrawOval;
import dcartes.draw.DrawOvalPanel;
import dcartes.image.AffineFrame;
import dcartes.image.Convert;
import dcartes.image.SplitBandHSBI;
import dcartes.image.Transpose;
import dcartes.math.DrawGraphics;
import dcartes.util.CountVectorAction;
import dcartes.util.Sources;


/**
 * Essa classe  a clase bsica para a construo da interface grfica da janela interna da aplicao.
 * Est baseada no padro de projeto Command (Erich Gamma et. Al) para executar as requisies feitas
 * pelo usurio via interface grfica.
 */
public class LittleWindow extends JInternalFrame
                         implements  ActionListener, InternalFrameListener, MouseListener,MouseMotionListener
{





//diego ...............................................................................................................
    private Vector vectorZoomOut = new Vector();//controle do zoom
    private Vector vectorZoomIn = new Vector();//controle do zoom
    /**
     * Propriedade referente a classe PrintPanel.
     */
    private DrawOvalPanel drawOvalPanel;


    private int i = 0;//controle de contagem
    float zoomFactor = 1.0f;//controle do zoom
    float rotateFactor = 0.0f;//controle do zoom
    float xTrans = 0.0f;//controle de translao
    float yTrans = 0.0f;//controle de translao
    float xReleased = 0.0f;//controle de evento de mouse
    float yReleased = 0.0f;//controle de evento de mouse
    float xPressed = 0.0f;//controle de evento de mouse
    float yPressed = 0.0f;//controle de evento de mouse

    private String message;//controle para fins gerais de mensagens ao usuario

    public static int srcHeight;
    public static int srcWidth;



    /**
     * Variveis de instncia para manipulao dos arquivos no processo de save
     */
    public File filename, savefilename;

    /**
     * Variveis manipulao dos arquivos no processo de  abrir uma nova littleWindow com uma ROI
     */
    public JFileChooser jfilechooser;

    /**
     *  O vetor storePath guarda o path dos arquivo que foram abertos
     */
    public Vector storePath = new Vector();

    /**
     *O vetor storeImageProcessed guarda a imagem aberta\processada
     */
    public Vector storeImageProcessed = new Vector();

    /**
     * Esse atributo armazena uma regio de interesse que foi selecionada na imagem original
     */
    public PlanarImage roi;

    /**
     * Armazena o nome da regio da interesse. Esse nome ser exibido na janela interna quando o usurio
     * clicar requisitar a ao de colar a regio de interesse
     */
    public String nomeRoi;

    /**
     * openNumberInterno  utilizado para criar uma nova littleWindow, entretanto, a mesma ser instanciada
     * por meio de um objeto do tipo littlewindow
     */
    public int openNumberIntern = 0;

    /**
     * desktopInterno  utilizado para armazenar o Desktop que  utilizado pela aplicao para exibir as
     * janelas internas. Esse atributo foi criado para evitar que, quando uma littlewindow instanciar outra
     * littlewindow, ambas as janelas internas estejam no mesmo desktop.
     */
    JDesktopPane desktopIntern = new JDesktopPane();

    /**
     * Armazena o path no qual foi aberta a imagem
     */
    public String pathGlobal;

    public static int result;


    /**
     * Varivel para seleo do mouse. Representa a posio inicial (quando clica) do cursor do mouse no eixo x
     */
    float x0=0;
    /**
     * Varivel para seleo do mouse. Representa a posio inicial do cursor do mouse no eixo y
     */
    float y0=0;

    /**
     * Varivel para seleo do mouse. Representa a posio final(quando solta o boto) do cursor do mouse no eixo x
     */
    float xFim=0;

    /**
     * Varivel para seleo do mouse. Representa a posio final do cursor do mouse no eixo y
     */
    float yFim=0;

    /**
     * Variveis auxiliares para selecionar uma regio de interesse na imagem.
     */
    int x1=0;

    /**
     * Variveis auxiliares para selecionar uma regio de interesse na imagem.
     */
    int x2=0;

    /**
     * Variveis auxiliares para selecionar uma regio de interesse na imagem.
     */
    int y1=0;

    /**
     * Variveis auxiliares para selecionar uma regio de interesse na imagem.
     */
    int y2=0;

    /**
     * Largura da regio de interesse selecionada na imagem
     */
    int wSelect=0;

    /**
     * Altura da regio de interesse selecionada na imagem
     */
    int hSelect=0;

    /**
     * Coordenada x (canto superior esquerdo) do ponto de inicio da seleo da regio de interesse
     */
    int xSelect=0;

    /**
     * Coordenada y (canto superior esquerdo) do ponto de inicio da seleo da regio de interesse
     */
    int ySelect=0;

    /**
     * Varivel utilizada para acessar o vetor storeImageProcessed, que armazena as imagens abertas e processadas
     */
    public int posProcessed = 0;

    /**
     *Instancias das classes dos pacotes criados
     */
    private SaveStrategy strategy = new SaveStrategy();

    /**
     * show  um atributo do tipo DisplayJAI que exibe a imagem na janela interna da aplicao
     */
    public DisplayJAI show;

    /**
     * src  a varivel que sempre armazena a imagem que est sendo processada
     */
    public PlanarImage src;
    /**
     *  utilizado para exibir as barras de rolagens quando a imagem aberta apresentar uma dimenso muito grande
     * (maior que 600x750)
     */
    public JScrollPane scrollPane;

    public Sources sourcesVector = new Sources() ;

    public DrawOval drawOval;
    //JMenus
    private JMenuBar bar = new JMenuBar();

    //Toolbar
    private JToolBar toolbar = new JToolBar();

    //Barra de menus - Arquivo
    private ListenFile listenFile = new ListenFile( "File" );
        private ListenSaveFile listenSaveFile = new ListenSaveFile( "Save" );
        private ListenSaveAsFile listenSaveAsFile = new ListenSaveAsFile( "Save As..." );
        private ListenExit listenExit = new ListenExit( "Exit" );

    //Barra de menus - Edit
    private ListenEdit listenEdit = new ListenEdit( "Edit" );
        private ListenUndo listenUndo = new ListenUndo("Undo");
        private ListenRedo listenRedo = new ListenRedo("Redo");
        private ListenDuplicar listenDuplicar = new ListenDuplicar("Duplicate");
        private ListenZoomOut listenZoomOut = new ListenZoomOut("Zoom -");
        private ListenZoomIn listenZoomIn = new ListenZoomIn("Zoom +");
        private ListenNoZoom listenNoZoom = new ListenNoZoom("View 100%");//Diego - Imagem do tamanho original
        private ListenPersonalZoom listenPersonalZoom = new ListenPersonalZoom( "Zoom..." );



    //Barra de menus - Operaes de Imagem
    private ListenImage listenImage = new ListenImage( "Image" );
         private ListenInfoImage listenInfoImage = new ListenInfoImage( "Image Info" );
         private ListenConvertToGrey listenConvertToGrey = new ListenConvertToGrey( "Convert to Grey" );
         private ListenConvertToColor listenConvertToColor = new ListenConvertToColor( "Convert to Color");
         private ListenInvert listenInvert = new ListenInvert( "Invert Image" );
         private ListenSplitRGB listenSplitRGB = new ListenSplitRGB( "Split RGB" );
         private ListenConvertGreyToBlackWhite listenConvertGreyToBlackWhite = new ListenConvertGreyToBlackWhite( "Black and White");
         private ListenCombineChannels listenCombineChannels = new ListenCombineChannels( "Merge RGB" );

    //Barra de menus - Operaes Geomtricas
    private ListenGeometric listenGeometric = new ListenGeometric("Geometric Operations");
        private ListenAffine listenAffine = new ListenAffine ("Affine Transform");
        private ListenTranspose listenTranspose = new ListenTranspose( "Traspose Operations" );
            private ListenFlipVertical listenFlipVertical = new ListenFlipVertical( "FLIP VERTICAL" );
            private ListenFlipHorizontal listenFlipHorizontal = new ListenFlipHorizontal( "FLIP HORIZONTAL" );
            private ListenFlipDiagonal listenFlipDiagonal = new ListenFlipDiagonal( "FLIP DIAGONAL" );
            private ListenFlipAntidiagonal listenFlipAntidiagonal = new ListenFlipAntidiagonal( "FLIP ANTIDIAGONAL" );
            private ListenRot90 listenRot90 = new ListenRot90( "ROTATE 90" );
            private ListenRot180 listenRot180 = new ListenRot180( "ROTATE 180" );
            private ListenRot270 listenRot270 = new ListenRot270( "ROTATE 270" );


 
       
    //Barra de menus - Analysis........................................................................................

    private ListenAnalysis listenAnalysis = new ListenAnalysis( "Analysis" );
        private ListenDebyeAnalysis listenDebyeAnalysis = new ListenDebyeAnalysis( "Debye-Scherrer" );
            private ListenPrintValues listenPrintValues = new ListenPrintValues( "Print Values" );
            private ListenDrawGraphics listenDrawGraphics = new ListenDrawGraphics( "Draw Graphics" );
            private ListenDrawOval listenDrawOval = new ListenDrawOval( "Set Image" );
            private ListenDebyeAnalyzer listenDebyeAnalyze = new ListenDebyeAnalyzer( "Analyze" );
            private ListenDebyeDrawPoints listenDebyeDrawPoints = new ListenDebyeDrawPoints( "Draw Points" );
        


    //...........................................................................................Diego Menu End ......
    //cones
    //primeiro icone
    //private ImageIcon Icone = new ImageIcon("images/icones/salvar20.jpg");
    //private ListenSaveIcone button1 = new ListenSaveIcone("Salvar imagem",Icone);

    
    
    public boolean setOn = false;



    private JLabel positionLabel = new JLabel( "Position: ") ;




    /**
     * Mtodo vazio servindo apenas para referncia
     */
    public LittleWindow()
    {
    }

    /**
     * Mtodo construtor da classe LittleWindow. Define todos os componentes grficos que sero necessrios para
     * a classe.
     * @param path - caminho onde encontra-se o arquivo grfico aberto (imagem)
     * @param src - arquivo grfico aberto
     * @param desktopMain - JDesktopPane onde ser alocado a LittleWindow
     */
    public LittleWindow(String path, PlanarImage src, JDesktopPane desktopMain)
    {

        super("",true,true,true,true);

        //para criar uma nova littlewindow

        desktopIntern = desktopMain;



        //referentes a barra de menus - Arquivo
        setJMenuBar(bar);
        bar.setBackground( Color.white );

        listenFile.add(listenSaveFile);   listenSaveFile.addActionListener(this);
        listenSaveFile.setBackground( Color.white );
        listenFile.add(listenSaveAsFile); listenSaveAsFile.addActionListener(this);
        listenSaveAsFile.setBackground( Color.white );

        listenFile.add(listenExit); listenExit.addActionListener(this);
        listenExit.setBackground( Color.white );

        bar.add(listenFile);

        //referentes a barra de menus - Editar
        listenEdit.add(listenUndo); listenUndo.addActionListener(this);
        listenUndo.setBackground( Color.white );
        listenEdit.add(listenRedo); listenRedo.addActionListener(this);
        listenRedo.setBackground( Color.white );
        listenEdit.add(listenDuplicar); listenDuplicar.addActionListener(this);
        listenDuplicar.setBackground( Color.white );
        listenEdit.add( listenZoomIn ); listenZoomIn.addActionListener( this );
        listenZoomIn.setBackground( Color.white );
        listenEdit.add( listenZoomOut ); listenZoomOut.addActionListener( this );
        listenZoomOut.setBackground( Color.white );
        listenEdit.add( listenNoZoom ); listenNoZoom.addActionListener( this );
        listenNoZoom.setBackground( Color.white );
        listenEdit.add( listenPersonalZoom ); listenPersonalZoom.addActionListener( this );
        listenPersonalZoom.setBackground( Color.white );
        listenEdit.setBackground( Color.white );
        bar.add(listenEdit);

        //referentes a barra de menu Operaes de Imagem
        listenImage.add( listenInfoImage ); listenInfoImage.addActionListener( this );
        listenImage.add( listenConvertToGrey ); listenConvertToGrey.addActionListener( this );
        listenImage.add( listenConvertToColor ); listenConvertToColor.addActionListener( this );
        listenImage.add( listenInvert ); listenInvert.addActionListener( this );
        listenImage.add( listenSplitRGB ); listenSplitRGB.addActionListener( this );
        listenImage.add( listenConvertGreyToBlackWhite ); listenConvertGreyToBlackWhite.addActionListener( this );
        listenImage.add( listenCombineChannels ); listenCombineChannels.addActionListener( this );
        listenInfoImage.setBackground( Color.white );
        bar.add(listenImage);
        //referentes a barra de menu Operaes Geomtricas

        listenGeometric.add(listenAffine); listenAffine.addActionListener(this);
        listenAffine.setBackground( Color.white );
        listenTranspose.setBackground( Color.white );
        listenTranspose.isBackgroundSet();
        listenTranspose.add( listenFlipVertical ); listenFlipVertical.addActionListener( this );
        listenFlipVertical.setBackground( Color.white );
        listenTranspose.add( listenFlipHorizontal ); listenFlipHorizontal.addActionListener( this );
        listenFlipHorizontal.setBackground( Color.white );
        listenTranspose.add( listenFlipDiagonal ); listenFlipDiagonal.addActionListener( this );
        listenFlipDiagonal.setBackground( Color.white );
        listenTranspose.add( listenFlipAntidiagonal ); listenFlipAntidiagonal.addActionListener( this );
        listenFlipAntidiagonal.setBackground( Color.white );
        listenTranspose.addSeparator();
        listenTranspose.add( listenRot90 ); listenRot90.addActionListener( this );
        listenRot90.setBackground( Color.white );
        listenTranspose.add( listenRot180 ); listenRot180.addActionListener( this );
        listenRot180.setBackground( Color.white );
        listenTranspose.add( listenRot270 ); listenRot270.addActionListener( this );
        listenRot270.setBackground( Color.white );

        listenGeometric.add( listenTranspose );

        bar.add(listenGeometric);

       
        ///Menu Analysis*************************************************************************************
        listenDebyeAnalysis.add( listenPrintValues );  listenPrintValues.addActionListener( this );
            listenPrintValues.setBackground( Color.white );
        listenDebyeAnalysis.add( listenDrawGraphics ); listenDrawGraphics.addActionListener( this );
            listenDrawGraphics.setBackground( Color.white );
        listenDebyeAnalysis.add( listenDrawOval ); listenDrawOval.addActionListener( this );
            listenDrawOval.setBackground( Color.white );
        listenDebyeAnalysis.add( listenDebyeAnalyze );  listenDebyeAnalyze.addActionListener( this );
            listenDebyeAnalyze.setBackground( Color.white );
            listenDebyeAnalysis.setBackground( Color.white );
        //listenDebyeAnalysis.add( listenDebyeDrawPoints ); listenDebyeDrawPoints.addActionListener( this );
        listenAnalysis.add( listenDebyeAnalysis );
        
        bar.add( listenAnalysis );


        toolbar.setPreferredSize(new Dimension(30,25));
        toolbar.setCursor(Cursor.getDefaultCursor());

        setCursor(Cursor.getDefaultCursor());


        //button1.addActionListener(this);
        //toolbar.add(button1);

    


        toolbar.add( positionLabel );

        storePath.add(path);
        pathGlobal = path;


        this.src = src;
        setImageProcessed( src );
        show = new DisplayJAI(src);
        show.addMouseListener(this);
        show.addMouseMotionListener(this);

        scrollPane = new JScrollPane();

        scrollPane.setViewportView(show);
        scrollPane.addMouseListener(this);
        scrollPane.addMouseMotionListener(this);

        getContentPane().add(scrollPane);
        getContentPane().repaint();

        setTitle( pathGlobal );

        addInternalFrameListener(this);
        getContentPane().add(toolbar, BorderLayout.NORTH);
        setSize( src.getWidth(), src.getHeight() );
        setVisible(true);

        pack();
        //O try-catch serve para colocar sempre a ultima imagem aberta no focus corrente
        try {

            setSelected(true);

        } catch (java.beans.PropertyVetoException e2){

            System.out.println( e2 );

        }


    }



    /**
     * Essa funo descobre qual foi o ltimo diretrio onde foi aberta uma imagem.
      @return - o diretrio de onde foi aberta a ltima imagem.
     */
    public String lastPath()
    {
        String lastPath =(String) storePath.lastElement();
        System.out.println("Ultimo Caminho" + lastPath);
        return lastPath;
    }


    /**
     * Esse mtodo  usado para atualizar a imagem que est sendo mostrada no focus corrente.
     * @param src - nova imagem a ser exibida
     */
    public void updateImage( PlanarImage src )
    {

        posProcessed++;
        show = new DisplayJAI(src);
        scrollPane.add(show);
        scrollPane.setViewportView(show);
        getContentPane().repaint();
        setImageProcessed( src );
        setSize( src.getWidth(), src.getHeight() );
        setVisible(true);
        pack();

    }


    public PlanarImage getImageProcessed(){
        return (PlanarImage) storeImageProcessed.elementAt( posProcessed );

    }

    public void setImageProcessed( PlanarImage src ){

        try{
            this.src = src;
            storeImageProcessed.add( (PlanarImage)src );
        }catch( Exception e ){
            JOptionPane.showMessageDialog( null, e.getMessage() );
        }
    }
    public String getMessage(){
        return message;
    }
    public void setMessage( String text ){
        message = text;
    }
    /**
     * Funo que implementa a lgica para salvar uma imagem.
     * @param src imagem a ser salva
     */
    /**
     * Funo que implementa a lgica para salvar uma imagem.
     * @param src: imagem a ser salva
     * @param caminho:  uma string que gurda o diretrio onde a imagem deve ser salva.
     */
    public void save(PlanarImage src, String path)
    {

            JFileChooser salvaArquivo = new JFileChooser();

            String extension;
            int i = path.indexOf(".");
            extension = path.substring(i+1).trim();

            ExampleFileFilter filterSave = new ExampleFileFilter();
            filterSave.addExtension(extension);

            salvaArquivo.setFileFilter(filterSave);

            salvaArquivo.setDialogType(JFileChooser.SAVE_DIALOG);
            extension="."+extension;
                if (  (extension.equals(".gif")) || (extension.equals(".GIF")) )
                {
                    System.out.println("To save gif format is not avaliable");
                }



                if (  (extension.equals(".jpg"))||(extension.equals(".JPG"))||(extension.equals(".jpeg"))||(extension.equals(".JPEG") )  )
                {
                    strategy.choice(1,src, path);
                }
                if (  (extension.equals(".bmp")) || (extension.equals(".BMP")) )
                {
                    strategy.choice(2,src, path);
                }
                if ((extension.equals(".png")) || (extension.equals(".PNG")))
                {
                    strategy.choice(3,src,path);
                }
                if ((extension.equals(".tiff")) || (extension.equals(".TIFF")))
                {
                    strategy.choice(4,src, path);
                }
                if ((extension.equals(".pnm")) || (extension.equals(".PNM")))
                {
                    strategy.choice(5,src, path);
                }
        }




    /**
     * A funo saveAs  responsvel por salvar um arquivo grfico (imagem) no diretrio escolhido pelo usurio.
     * Os formatos disponveis para salvar uma imagem so: PNG, BMP, JPEG, JPG E TIFF.
     * @param src -  o arquivo grafico (imagem) que deve ser armazenado em um diretrio escolhido pelo usurio.
     */
    public void saveAs(PlanarImage src)
    {
        String  saveName;

        JFileChooser salvaArquivoAs = new JFileChooser();

        String extension;



        //nome=(String)storePath.elementAt(0);

        int i = pathGlobal.indexOf(".");
        extension = pathGlobal.substring(i+1).trim();

        ExampleFileFilter filterSaveAsPNM = new ExampleFileFilter();
        filterSaveAsPNM.addExtension("PNM");
        salvaArquivoAs.setFileFilter(filterSaveAsPNM);

        ExampleFileFilter filterSaveAsJPG = new ExampleFileFilter();
        filterSaveAsJPG.addExtension("JPG");
        salvaArquivoAs.setFileFilter(filterSaveAsJPG);

        ExampleFileFilter filterSaveAsBMP = new ExampleFileFilter();
        filterSaveAsBMP.addExtension("BMP");
        salvaArquivoAs.setFileFilter(filterSaveAsBMP);

        ExampleFileFilter filterSaveAsPNG = new ExampleFileFilter();
        filterSaveAsPNG.addExtension("PNG");
        salvaArquivoAs.setFileFilter(filterSaveAsPNG);

        ExampleFileFilter filterSaveAsTIFF = new ExampleFileFilter();
        filterSaveAsTIFF.addExtension("TIFF");
        salvaArquivoAs.setFileFilter(filterSaveAsTIFF);

        salvaArquivoAs.setDialogType(JFileChooser.SAVE_DIALOG);
        //Referente a mensagem de alerta
        JFrame frameMensSalvar = new JFrame();
                  Dialogo caixaDialogo= new Dialogo(frameMensSalvar);
                  caixaDialogo.CaixaDialogoOK("Tipo do Arquivo","No  necessrio digitar a extenso do arquivo junto" +
                          " com o nome do mesmo!");
        int result = salvaArquivoAs.showSaveDialog(this);

        if (result == JFileChooser.APPROVE_OPTION)
        {
            //savefilename carrega o caminho e arquivo completo
            savefilename = salvaArquivoAs.getSelectedFile();
            System.out.println("Gravando imagem em: " + savefilename+"."+extension);

            //pegando o filtro utilizado
            FileFilter returnFilter;
            returnFilter = salvaArquivoAs.getFileFilter();
            System.out.println("Arquivo escolhido pelo usuario"+returnFilter.getDescription());

            //tratando o (.JPG)
            pathGlobal = returnFilter.getDescription();
            //se livra do primeiro (
            i = pathGlobal.indexOf("(");
            extension = pathGlobal.substring(i+1).trim();
            //se livra do segundo )
            int size=extension.length();
            extension = extension.substring(0, size-1);
            saveName = savefilename+extension;

            System.out.println("saveNome "+saveName);


            if (  (extension.equals(".gif")) || (extension.equals(".GIF")) )
            {

                System.out.println("O formato gif no est disponvel para salvar o arquivo.");
            }

            if (  (extension.equals(".jpg"))||(extension.equals(".JPG"))||(extension.equals(".jpeg"))||(extension.equals(".JPEG") )  )
            {
                strategy.choice(1,src, saveName);
            }
            if (  (extension.equals(".bmp")) || (extension.equals(".BMP")) )
            {
                strategy.choice(2,src, saveName);
            }
            if ((extension.equals(".png")) || (extension.equals(".PNG")))
            {
                strategy.choice(3,src, saveName);
            }
            if ((extension.equals(".tiff")) || (extension.equals(".TIFF")))
            {
                strategy.choice(4,src, saveName);
            }
            if ((extension.equals(".pnm")) || (extension.equals(".PNM")))
            {
                strategy.choice(5,src, saveName);
            }
        }//do if



    }

    /**
     * Implementa o mtodo actionPerformed da interface ActionListener
     * @param e - evento que gerou a ativao do mtodo
     */
    public void actionPerformed(ActionEvent e)
    {
        CommandInterface obj = (CommandInterface)e.getSource();
        obj.ExecuteAction();
    }


/****************** Esses mtodos so necessrios quando implementa-se a inteface internalFrame ***********************/

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameActivated(InternalFrameEvent e){


        System.out.println("***************************************************");
        System.out.println("Titulo "+getTitle());
        nomeRoi = getTitle();

        System.out.println("posProcessed "+ posProcessed);
        System.out.println("storeImageProcessed "+ storeImageProcessed.size());
        System.out.println("Varivel pathGlobal: " + pathGlobal);
        System.out.println("Varivel nomeRoi: " + nomeRoi);
    }

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameOpened(InternalFrameEvent e){}

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameIconified(InternalFrameEvent e){}

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameDeiconified(InternalFrameEvent e){}

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameDeactivated(InternalFrameEvent e){}

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameClosing(InternalFrameEvent e){}

    /**
     * Essa funo  a implementao do mtodo internalFrameActivated da interface InternalFrameListener
     * O mtodo varre o titulo da imagem e captura o seu ID, aps, imprime na tela algumas informaes.
     * @param e - evento que ativou esse mtodo
     */
    public void internalFrameClosed(InternalFrameEvent e){

        sourcesVector.removeSources( src );

    }

/**********************************************************************************************************************/

/*************** Esses mtodos so necessrios quando implementa-se a interface MouseListener *************************/
    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mousePressed(MouseEvent e)
    {

        //diego......................................................................................................
        xPressed = e.getX();    //diego-para o crop
        yPressed = e.getY();   //diego-para o crop
        //-------------------------------------------



       //diego........................................................................................................

        x0=e.getX();
        y0=e.getY();

        
        
        Graphics g=getGraphics();


         if(x1<x2 && y1<y2) //x e y padro (ponto inicial menor que o final)
         {
             if(e.getX()<x1 || e.getX()>x2 || e.getY()<y1 || e.getY()>y2)
                update(g);
         }
         else if(x1<x2 && y1>y2)  //x padro y no-padro (x inicial maior que o final mas y inicial maior que o final)
         {
             if(e.getX()<x1 || e.getX()>x2 || e.getY()>y1 || e.getY()<y2)
                 update(g);

         }else if(x1>x2 && y1<y2) //x no-padro y padro
         {
             if(e.getX()>x1 || e.getX()<x2 || e.getY()<y1 || e.getY()>y2)
                 update(g);

         }else if(x1>x2 && y1>y2)//x e y no-padro
         {
             if(e.getX()>x1 || e.getX()<x2 || e.getY()>y1 || e.getY()<y2)
                                 update(g);
         }


    }

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseReleased(MouseEvent e) {

         xReleased = e.getX();  //diego
         yReleased = e.getY();  //diego


         if(x1<x2 && y1<y2) //x e y padro (ponto inicial menor que o final)
         {
             xSelect=x1;
             ySelect=y1;
             hSelect=y2-y1;
             wSelect=x2-x1;
         }
         else if(x1<x2 && y1>y2)  //x padro y no-padro (x inicial maior que o final mas y inicial maior que o final)
         {
             xSelect=x1;
             ySelect=y2;
             hSelect=y1-y2;
             wSelect=x2-x1;

         }else if(x1>x2 && y1<y2) //x no-padro y padro
         {
             xSelect=x2;
             ySelect=y2;
             hSelect=y2-y1;//aqui tava o erro
             wSelect=x1-x2;

         }else if(x1>x2 && y1>y2)//x e y no-padro
         {
             xSelect=x2;
             ySelect=y2;
             hSelect=y1-y2;
             wSelect=x1-x2;
         }

    }

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseMoved(MouseEvent e) {
        double x=e.getPoint().getX();
        double y=e.getPoint().getY();
        //altera a forma do cursor
        positionLabel.setText( "  " + " X = " + ( x ) + " ;  " + " Y = " + (  y ) );//diego
        if(x<src.getWidth() && y<src.getHeight())
        {
            setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

        }
        else
        {
            setCursor(Cursor.getDefaultCursor());
        }

    }

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseDragged(MouseEvent e) {
        //diego.......................................................................................................





        //diego......................................................................................................
        xFim=e.getX();
        yFim=e.getY();
        int xAux=(int)x0;
        int yAux=(int)y0;
        //faz a seleo com o mouse
        if(setOn)
        {
            Graphics g=getGraphics();
            update(g);


            float w= xFim-x0;
            float h= yFim-y0;


            if(w<0)
            {
                w=-1*w;
                xAux=(int)xFim;
            }
            if(h<0)
            {
                h=-1*h;
                yAux=(int)yFim;

            }
            g.setColor(Color.CYAN);
            g.drawRect(xAux+5, yAux+80,(int)w,(int)h);
            x1=(int)x0;
            x2=(int)xFim;
            y1=(int)y0;
            y2=(int)yFim;
            positionLabel.setText( "  " + " x = " + ( x1 ) + " ;  " + " y = " + (  y1 ) + "      " +
                    " "+ " w = " + w + "  " + " h = " + h    );//diego
            /*hSelect=(int)h;
            wSelect=(int)w;
            xSelect=xAux;
            ySelect=yAux;*/

        }
    }

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseEntered(MouseEvent e){}

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseExited(MouseEvent e){}

    /**
    * Implementao do mtodo mousePressed da interface MouseListener
    * @param e - evento que ativou o mtodo
    */
    public void mouseClicked(MouseEvent e){}




    /******************************** Classes correspondentes aos componentes graficos ************************************/
//Classes para o Menu Arquivo
class ListenFile extends JMenu implements CommandInterface
        {
            /**
             * Mtodo construtor da classe ListenFile.
             * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Arquivo
             * @param caption - texto que  utilizado para nomear o menu.
             */
            public ListenFile(String caption)
            {
                super(caption);
                setMnemonic(KeyEvent.VK_A);
            }

            public void ExecuteAction()
            {


            }
        }

class ListenSaveFile extends JMenuItem implements CommandInterface
    {
            /**
             * Mtodo construtor da classe ListenSaveAsFile.
             * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
             * Salvar do Menu Arquivo.
             * @param caption texto que  utilizado para nomear o item do Menu.
             */
            public ListenSaveFile(String caption)
            {
                super(caption);
                setMnemonic(KeyEvent.VK_S);
                setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK));

            }
            /**
             * Ao a ser executada quando o item Salvar do menu Arquivo  selecionado.
             */
            public void ExecuteAction()
            {

                PlanarImage src;
                src = getImageProcessed();
                save(src, pathGlobal);
            }
        }

class ListenSaveAsFile extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenSaveAsFile.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Salvar Como do Menu Arquivo.
         * @param caption - texto que  utilizado para nomear o item do Menu.
        */
        public ListenSaveAsFile(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_B);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_B, ActionEvent.CTRL_MASK));

        }
        /**
         * Ao a ser executada quando o item Salvar Como do menu Arquivo  selecionado.
         */
        public void ExecuteAction()
        {

            PlanarImage src;
            src = getImageProcessed();
            saveAs(src);
        }
    }



class ListenExit extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenExit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Fechar do Menu Arquivo.
         * @param caption - texto que  utilizado para nomear o item do Menu
         */
        public ListenExit(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_F);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F, ActionEvent.CTRL_MASK));

        }
        /**
         * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
         */
        public void ExecuteAction()
        {
            dispose();
        }
    }

//Classes para o Menu Editar
class ListenEdit extends JMenu implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenEdit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Editar
         * @param caption - texto que  utilizado para nomear o menu.
         */
        public ListenEdit(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_E);
        }

        public void ExecuteAction()
        {

        }
    }

    class ListenUndo extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenUndo.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Desfazer do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenUndo(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_D);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Desfazer do menu Editar for selecionado
         */
        public void ExecuteAction()
        {
               if( posProcessed > 0 ){

                   posProcessed--;
                   show = new DisplayJAI( getImageProcessed() );
                   scrollPane.add(show);
                   scrollPane.setViewportView(show);
                   getContentPane().repaint();
                   setSize( getImageProcessed().getWidth(), getImageProcessed().getHeight() );
                   setVisible(true);
                   pack();



               }else
               JOptionPane.showMessageDialog( this,
                                              "Undo process < Store image process...",
                                              "Oooppps!",
                                              JOptionPane.INFORMATION_MESSAGE
                                             );

        }
    }

    class ListenRedo extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenRedo.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Refazer do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
         */
        public ListenRedo(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_R);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Refazer do menu Editar for selecionado
         */
        public void ExecuteAction()
        {
            posProcessed++;

            if( posProcessed >= storeImageProcessed.size() ){

                JOptionPane.showMessageDialog( this,
                                               "Redo process > Store image process...",
                                               "Oooppps!",
                                               JOptionPane.INFORMATION_MESSAGE
                                              );
                posProcessed--;

            }

            if ( posProcessed >= 0  && posProcessed < storeImageProcessed.size() ){

                 show = new DisplayJAI( getImageProcessed() );
                 scrollPane.add(show);
                 scrollPane.setViewportView(show);
                 getContentPane().repaint();
                 setSize( getImageProcessed().getWidth(), getImageProcessed().getHeight() );
                 setVisible(true);
                 pack();

            }

        }
    }

    class ListenDuplicar extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe Duplicar.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Duplicar imagem do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenDuplicar(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_P);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Duplicar imagem do menu Editar for selecionado
         */
        public void ExecuteAction()
        {
            //Aqui vai o cdigo para duplicar uma imagem. Responsveis Gabrielle, Grasiela e Luciana
            //PlanarImage duplicada =
            storeImageProcessed.addElement(storeImageProcessed.elementAt(posProcessed));
            new ShowImage((PlanarImage)storeImageProcessed.lastElement(), nomeRoi, desktopIntern );
        }
    }

    class ListenZoomIn extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenZoomIn.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Zoom + do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenZoomIn(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_I);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Zoom + do menu Editar for selecionado
         */
        public void ExecuteAction()
        {



                      ActionListener actionZoom = new CountVectorAction(i++);
                      vectorZoomIn.add(actionZoom);
                      this.addActionListener(actionZoom);

                      if( vectorZoomOut.size() == 0 ){

                          vectorZoomOut.removeAllElements();

                      }

                      if( vectorZoomOut.size() == vectorZoomIn.size() ){

                           if( zoomFactor < 1.0f ){

                                zoomFactor = zoomFactor + 0.1f;

                                if( zoomFactor >= 0.6f ){

                                    zoomFactor = 1.0f;
                                    vectorZoomIn.removeAllElements();
                                    vectorZoomOut.removeAllElements();

                                }
                           }

                           if( zoomFactor > 1.0f ){

                               zoomFactor = (float)vectorZoomOut.size() + 1.0f;

                           }

                           if( zoomFactor == 1.0f ){
                               zoomFactor = 1.0f;

                               //vectorZoomOut.removeAllElements();
                               //vectorZoomIn.removeAllElements();

                           }

                      }

                      if( vectorZoomOut.size() > vectorZoomIn.size()  ){

                             if( zoomFactor < 1.0f ){

                                 zoomFactor = zoomFactor + 0.1f;

                             }
                             if(zoomFactor > 1.0f ) {

                                 zoomFactor = zoomFactor + 1.0f;

                             }

                             if( zoomFactor == 1.0f ){

                                 zoomFactor = 1.0f;

                             }

                      }


                      if( vectorZoomIn.size() >= 6 ){

                            System.out.println( "Zoom Mximo!" );
                            vectorZoomIn.remove( actionZoom );
                            //System.out.println("zoomIn " +  vectorZoomOut.size() + "\n");
                      }

                      if( vectorZoomIn.size() > vectorZoomOut.size() && vectorZoomOut.size() != 0 ) {

                            if( zoomFactor < 1.0f ){

                                zoomFactor = zoomFactor + 0.1f;

                                if( zoomFactor >= 0.6f ){

                                   zoomFactor = 1.0f;
                                   vectorZoomIn.removeAllElements();
                                   vectorZoomOut.removeAllElements();

                                }
                            }

                            if( zoomFactor > 1.0f ){

                                zoomFactor = zoomFactor + 1.0f;

                            }
                      }

                      if( vectorZoomIn.size() > 0 && vectorZoomOut.size() == 0 ){

                        switch( vectorZoomIn.size() ){

                           case 0:
                             zoomFactor = 1.0f;
                             //zoomPercent = "100%";
                           break;

                           case 1:
                              zoomFactor = 2.0f;
                              //zoomPercent = "200%";
                           break;

                           case 2:
                              zoomFactor = 3.0f;
                              //zoomPercent = "300%";
                           break;

                           case 3:
                              zoomFactor = 4.0f;
                              //zoomPercent = "400%";
                           break;

                           case 4:
                               zoomFactor = 5.0f;
                              //zoomPercent = "500%";
                           break;

                           case 5:
                               zoomFactor = 6.0f;
                              //zoomPercent = "600%";
                           break;

                       }

                      }

                      if( vectorZoomOut.size() > 0 ){

                          int end = vectorZoomOut.size()-1;
                          vectorZoomOut.removeElementAt( end );

                      }

                      if( zoomFactor == 1.0f ){

                          vectorZoomIn.removeAllElements();

                      }

                      if( zoomFactor > 6.0f ){

                          zoomFactor = 6.0f;

                      }

                      if( zoomFactor < 0.1f ){

                          zoomFactor = 0.1f;

                      }


                       Interpolation interpolationNearest = Interpolation.getInstance( Interpolation.INTERP_BILINEAR );
                       AffineTransform scale = AffineTransform.getScaleInstance( zoomFactor, zoomFactor);
                       //AffineTransform affineZoom = new AffineTransform(  zoomFactor , //escala em x
                       //                                                      0.0F, //corte em y
                       //                                                      0.0F, //corte em x
                       //                                                      zoomFactor , //escala em y
                       //                                                      0.0F, //translaao em x
                        //                                                     0.0F);//translaao em y
                       //

                       PlanarImage src = getImageProcessed();
                       PlanarImage dst = JAI.create( "affine", src, scale, interpolationNearest );


                       show= new DisplayJAI(dst);

                       scrollPane.add(show);

                       scrollPane.setViewportView(show);
                       System.out.println( "vectorZoomIn Clicked = " + vectorZoomIn.size() + "\n");
                       System.out.println("vectorZoomOut Received = " +  vectorZoomOut.size() + "\n");
                       System.out.println("zoomFactor IN = " +  zoomFactor + "\n");



        }
    }

    class ListenZoomOut extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenZoomOut.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Zoom - do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenZoomOut(String caption)    //zoom menos
        {
            super(caption);
            setMnemonic(KeyEvent.VK_O);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Zoom - do menu Editar for selecionado
         */
        public void ExecuteAction()
        {






           ActionListener actionZoom = new CountVectorAction(i++);
           vectorZoomOut.add(actionZoom);
           this.addActionListener(actionZoom);


           if( vectorZoomIn.size() == 0 ){

               vectorZoomIn.removeAllElements();

           }

           if( ( vectorZoomOut.size() > vectorZoomIn.size() ) && vectorZoomIn.size() != 0 ){

                if( vectorZoomOut.size() > 4 && vectorZoomIn.size() > 0){

                    zoomFactor = 1.0f;
                    vectorZoomOut.removeAllElements();
                    vectorZoomIn.removeAllElements();

                }

                if( zoomFactor > 1.0f ){


                    zoomFactor = zoomFactor - 1.0f;

                    if( zoomFactor == 0 ){

                        zoomFactor = 1.0f;
                        vectorZoomOut.removeAllElements();
                        vectorZoomIn.removeAllElements();

                    }

                }

                if( zoomFactor < 1.0f ){

                    zoomFactor = ( zoomFactor - 0.1f );
                    if( zoomFactor < 0.3f ){

                        zoomFactor = 0.2f;

                    }
                    if( zoomFactor >= 0.6f ){

                        zoomFactor = 1.0f;
                        vectorZoomOut.removeAllElements();
                        vectorZoomIn.removeAllElements();
                    }
                }

            }

           if( vectorZoomOut.size() == vectorZoomIn.size() ){

                      if( zoomFactor > 1.0f ){

                          zoomFactor = zoomFactor - 1.0f;

                      }

                      if( zoomFactor < 1.0f ){

                          zoomFactor = zoomFactor + 0.1f;

                          if( zoomFactor >= 0.5f ){

                              zoomFactor = 1.0f;
                              vectorZoomIn.removeAllElements();
                              vectorZoomOut.removeAllElements();
                         }
                      }

           }

           if( vectorZoomOut.size() < vectorZoomIn.size() && vectorZoomOut.size() != 0 ){

               zoomFactor = (float)Math.abs( vectorZoomIn.size() - vectorZoomOut.size() ) + (float)vectorZoomOut.size();

           }

           if( vectorZoomOut.size() >= 5 && vectorZoomIn.size() == 0){

               System.out.println("Zoom Mnimo!");
               vectorZoomOut.remove( actionZoom );
               //System.out.println("zoomOut " +  vectorZoomOut.size() + "\n");

           }

           if( vectorZoomOut.size() >= 0 && vectorZoomIn.size() == 0){

             switch(  vectorZoomOut.size()  ){

                case 0:
                  zoomFactor = 1.0f;
                  //zoomPercent = "100%";
                break;

                case 1:
                   zoomFactor = 0.5f;
                   //zoomPercent = "50%";
                break;

                case 2:
                   zoomFactor = 0.4f;
                   //zoomPercent = "40%";
                break;

                case 3:
                   zoomFactor = 0.3f;
                   //zoomPercent = "30%";
                break;

                case 4:
                    zoomFactor = 0.2f;
                    //zoomPercent = "20%";
                break;

                case 5:
                    zoomFactor = 0.1f;
                    //zoomPercent = "10%";
                break;


            }

           }

           if( vectorZoomIn.size() > 0 ){

               int end = vectorZoomIn.size()-1;
               vectorZoomIn.removeElementAt( end );

           }

           if( zoomFactor == 1.0f ){

               vectorZoomOut.removeAllElements();

           }

           if( zoomFactor > 6.0f ){

               zoomFactor = 6.0f;

           }

           if( zoomFactor < 0.1f ){

               zoomFactor = 0.1f;

           }

           Interpolation interpolationNearest = Interpolation.getInstance( Interpolation.INTERP_NEAREST );
           AffineTransform scale = AffineTransform.getScaleInstance( zoomFactor, zoomFactor );
             /*AffineTransform affineZoom = new AffineTransform( zoomFactor, //escala em x
                                                               0.0F, //corte em y
                                                               0.0F, //corte em x
                                                               zoomFactor, //escala em y
                                                               0.0F, //translaao em x
                                                               0.0F);//translaao em y
             */

            PlanarImage src = getImageProcessed();

            PlanarImage dst = JAI.create( "affine", src, scale, interpolationNearest );


            show= new DisplayJAI(dst);

            scrollPane.add(show);

            scrollPane.setViewportView(show);


        }



    }

    class ListenNoZoom extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenNoZoom.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * View 100% - do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenNoZoom(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_Z);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item View 100% do menu Editar for selecionado
         */
        public void ExecuteAction()
        {

           vectorZoomOut.removeAllElements();
           vectorZoomIn.removeAllElements();
           zoomFactor = 1.0f;
           Interpolation interpolationNearest = Interpolation.getInstance( Interpolation.INTERP_NEAREST );
           AffineTransform scale = AffineTransform.getScaleInstance( zoomFactor, zoomFactor );
             /*AffineTransform affineZoom = new AffineTransform( zoomFactor/2, //escala em x
                                                               0.0F, //corte em y
                                                               0.0F, //corte em x
                                                               zoomFactor/2, //escala em y
                                                               0.0F, //translaao em x
                                                               0.0F);//translaao em y
             */
            PlanarImage src = getImageProcessed();
            PlanarImage dst = JAI.create( "affine", src, scale, interpolationNearest );


            show= new DisplayJAI(dst);

            scrollPane.add(show);

            scrollPane.setViewportView(show);


        }



    }

    class ListenPersonalZoom extends JMenuItem implements CommandInterface
    {
            /**
             * Mtodo construtor da classe ListenNoZoom.
             * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
             * View 100% - do Menu Editar.
             * @param caption - texto que  utilizado para nomear o item do Menu*
            */
            public ListenPersonalZoom(String caption)
            {
                super(caption);
                setMnemonic(KeyEvent.VK_P);
                setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, ActionEvent.CTRL_MASK));
            }

            /**
             * Ao a ser executada quando o item View 100% do menu Editar for selecionado
             */
            public void ExecuteAction()
            {

               //new SelectZoom( src  );


            }



        }



class ListenImage extends JMenu implements CommandInterface
{
        /**
         * Mtodo construtor da classe ListenEdit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Editar
         * @param caption - texto que  utilizado para nomear o menu.
         */
        public ListenImage(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_I);
        }

        public void ExecuteAction()
        {

        }
    }
    class ListenInfoImage extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenExit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Fechar do Menu Arquivo.
         * @param caption - texto que  utilizado para nomear o item do Menu
         */
        public ListenInfoImage(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_I);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

        }
        /**
         * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
         */
        public void ExecuteAction()
        {

            PlanarImage img = getImageProcessed();
            String output = " ";
            File image = new File(pathGlobal);

            output += ( "\n" + "Image file size: " + image.length() + " bytes");

            output += ( "\n" + "Dimensions: "+ img.getWidth() + "x" + img.getHeight() + " pixels" );

             output += ( " (from " + img.getMinX() + "," + img.getMinY() + " to " +
                (img.getMaxX() - 1 ) + "," + ( img.getMaxY() - 1 ) + ")" );

                if ( ( img.getNumXTiles() != 1 ) || ( img.getNumYTiles() != 1) ){


                output += ( "\n" +"Tiles: " +  img.getTileWidth() + "x" + img.getTileHeight() + " pixels" +
                " (" + img.getNumXTiles() + "x" + img.getNumYTiles() + " tiles)" );


                output += ( "\n" + " (from "+ img.getMinTileX() + "," + img.getMinTileY() +
                " to " + img.getMaxTileX() + "," + img.getMaxTileY() + ")" + " offset: " + img.getTileGridXOffset() +
                        "," + img.getTileGridXOffset() );

                }

            SampleModel sampleModel = img.getSampleModel();

            output += ( "\n" + "Number of bands: " + sampleModel.getNumBands() );

            output += ( "\n" + "Data type: " );
            switch( sampleModel.getDataType() )
            {
                case DataBuffer.TYPE_BYTE:  output += "byte"; break;
                case DataBuffer.TYPE_SHORT:  output += "short"; break;
                case DataBuffer.TYPE_USHORT:  output += "ushort"; break;
                case DataBuffer.TYPE_INT: output += "int"; break;
                case DataBuffer.TYPE_FLOAT:  output += "float"; break;
                case DataBuffer.TYPE_DOUBLE:  output += "double"; break;
                case DataBuffer.TYPE_UNDEFINED:  output += "undefined"; break;
            }

            ColorModel colorModel = img.getColorModel();
            if ( colorModel != null ){


               output += ( "\n" + "Number of color components: "+
               colorModel.getNumComponents() );


               output += ( "\n" +"Bits per pixel: " + colorModel.getPixelSize() );

               output += ( "\n" +"Transparency: ");
               switch( colorModel.getTransparency() )
               {

                   case Transparency.OPAQUE: output += "opaque"; break;
                   case Transparency.BITMASK: output += "bitmask"; break;
                   case Transparency.TRANSLUCENT: output += "translucent"; break;

               }
            }

            else  output += "No color model.";

            JOptionPane.showMessageDialog( null, "Image Information :  " +
                    output, "ImageInfo" , JOptionPane.INFORMATION_MESSAGE );

         }



    }

    class ListenConvertToGrey extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenConvertToGrey(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {
          
         
         
         PlanarImage dst = null;
           double brightness = 0;

           double[][] matrix = {    //R     , G     ,   B
                                   { 0.2126D, 0.7152D, 0.0722D, brightness }
                 
                               };
           if ( src != null ) {
               ParameterBlock pb = new ParameterBlock();
               pb.addSource(src);
               pb.add(matrix);
               try {
                   dst = JAI.create( "bandcombine", pb, null );
               } catch(  Exception e ) {
                   JOptionPane.showMessageDialog(null, e.getMessage());
               }
           }
           new ShowImage( dst, "grey",  desktopIntern );
         /*
         try {
                        
               SplitBandHSBI splitBandHSBI = new SplitBandHSBI( src );
               PlanarImage dstH = (PlanarImage) splitBandHSBI.getHue();
               PlanarImage dstS = (PlanarImage) splitBandHSBI.getSaturation();
               PlanarImage dstB = (PlanarImage) splitBandHSBI.getBrightness();
               PlanarImage dstI = (PlanarImage) splitBandHSBI.getIntensity();

               new ShowImage( dstH, "Image H", desktopIntern );
               new ShowImage( dstS, "Image S", desktopIntern );
               new ShowImage( dstB, "Image B", desktopIntern );
               new ShowImage( dstI, "Image I", desktopIntern );

           } catch (Exception e) {
               e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
           }

    */



       }

    }

    class ListenConvertToColor extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenConvertToColor(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {

              PlanarImage dst = Convert.convertGrayToColor(src, 0);
              //showImage( dst, "imageGrey" );
              new ShowImage( dst, "grey",  desktopIntern );

       }

    }

    class ListenSplitRGB extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenSplitRGB(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {

           try {
               SplitBandHSBI splitBandHSBI = new SplitBandHSBI( src );
               PlanarImage dstH = (PlanarImage) splitBandHSBI.getHue();
               PlanarImage dstS = (PlanarImage) splitBandHSBI.getSaturation();
               PlanarImage dstB = (PlanarImage) splitBandHSBI.getBrightness();
               PlanarImage dstI = (PlanarImage) splitBandHSBI.getIntensity();


               new ShowImage( dstH, "Image H", desktopIntern );
               new ShowImage( dstS, "Image S", desktopIntern );
               new ShowImage( dstB, "Image B", desktopIntern );
               new ShowImage( dstI, "Image I", desktopIntern );
             

           } catch (Exception e) {
               e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
           }
           /*
           Vector rgbVector = Convert.splitRGB( src, 0 );
           PlanarImage dstR = (PlanarImage)rgbVector.elementAt( 0 );
           PlanarImage dstG = (PlanarImage)rgbVector.elementAt( 1 );
           PlanarImage dstB = (PlanarImage)rgbVector.elementAt( 2 );

           new ShowImage( dstR, "Image R", desktopIntern );
           new ShowImage( dstG, "Image G", desktopIntern );
           new ShowImage( dstB, "Image B", desktopIntern );
           */
       }

    }


    class ListenInvert extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenInvert(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {

              PlanarImage dst = Convert.convertImageToInvert(src);
              new ShowImage( dst, "imageGrey", desktopIntern );



       }

    }

    class ListenConvertGreyToBlackWhite extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenConvertGreyToBlackWhite(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {

              PlanarImage dst = Convert.convertGrayToBlackWhite(src);
              new ShowImage( dst, "binary", desktopIntern );



       }

    }

    class ListenCombineChannels extends JMenuItem implements CommandInterface
    {
       /**
                 * Mtodo construtor da classe ListenExit.
                 * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
                 * Fechar do Menu Arquivo.
                 * @param caption - texto que  utilizado para nomear o item do Menu
                 */
       public ListenCombineChannels(String caption)
       {
          super(caption);
          setMnemonic(KeyEvent.VK_I);
          setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, ActionEvent.CTRL_MASK));

       }
       /**
                 * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
                 */
       public void ExecuteAction()
       {


           //System.out.println( " teste " + sourceVector.getSources().size() );
           PlanarImage dst = Convert.mergeRGB(sourcesVector.getVSources());
           new ShowImage( dst, "channels", desktopIntern );

       }

    }

    class ListenRotateIcon extends JButton implements CommandInterface
    {
        /**
          * Mtodo construtor da classe ListenRotateIcon, que produz o cone "Rotate".
          * Essa funo tambm  utilizada para configurar o texto que ser exibido quando o usurio
          * passa com o apontador do mouse em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Rotate".
          */
         public ListenRotateIcon(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

        /**
         * Ao a ser executada quando o cone "Rotate" for selecionado.
         * Cada click rotaciona a imagem em 90.
         *
         */
         public void ExecuteAction()
         {



            RenderedImage image = getImageProcessed();

            ParameterBlock pb = new ParameterBlock();
            pb.addSource( image );

            pb.add( TransposeDescriptor.ROTATE_90 );

            PlanarImage dst =  JAI.create( "transpose", pb );

            show= new DisplayJAI( dst );

            scrollPane.add(show);

            scrollPane.setViewportView(show);

            setImageProcessed( dst );





         }
    }



class ListenAnalysis extends JMenu implements CommandInterface
 {

        /**
         * Mtodo construtor da classe ListenDcartes.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Dcartes
         * @param caption - texto que  utilizado para nomear o menu.
         */
        public ListenAnalysis(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_A);
        }

        public void ExecuteAction()
        {


        }
    }

 class ListenDebyeAnalysis extends JMenu implements CommandInterface
 {

        public ListenDebyeAnalysis(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_D);
        }

        public void ExecuteAction()
        {


        }

    }

    class ListenPrintValues extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenExit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Fechar do Menu Arquivo.
         * @param caption - texto que  utilizado para nomear o item do Menu
         */
        public ListenPrintValues(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_P);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, ActionEvent.CTRL_MASK));

        }
        /**
         * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
         */
        public void ExecuteAction()
        {


           PrintData printData = new PrintData(  src.getWidth(), "Debye-Scherrer", "ngulo", "intensidade" );
            try {
                printData.calcDebyeScherrer(src);
            } catch (IOException e) {
                e.printStackTrace();
            }
           printData.setSize(300,400);
           printData.setLocation( 200, 300 );
           printData.setVisible( true );
           //System.out.print( printData.getXValues() );

        }



    }

    class ListenDrawGraphics extends JMenuItem implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenExit.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Fechar do Menu Arquivo.
         * @param caption - texto que  utilizado para nomear o item do Menu
         */
        public ListenDrawGraphics(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_D);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D, ActionEvent.CTRL_MASK));

        }
        /**
         * Ao a ser executada quando o item Sair do menu Arquivo for selecionado
         */
        public void ExecuteAction()
        {
            try{

                DrawGraphics drawFrame = new DrawGraphics( src );
                drawFrame.setSize( 700, 400  );
                drawFrame.setLocation( 300, 300  );
                drawFrame.setVisible(true);

            }catch( Exception e ){

                   JOptionPane.showMessageDialog( null, e.getMessage(), "Try Again!", JOptionPane.ERROR_MESSAGE );

            }



        }



    }

    class ListenDrawOval extends JMenuItem implements CommandInterface
    {

         public ListenDrawOval(String caption)
         {
            super(caption);
            setMnemonic(KeyEvent.VK_S);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK));

         }



         public void ExecuteAction()
        {
            try{
                if ( src.getNumBands() != 1 ){
                   PlanarImage dst = Convert.convertColorToGrey( src, 0 );
                   updateImage( dst );
                   JOptionPane.showMessageDialog( null,
                           "A imagem foi convertida para 8 bits " , 
                           "Informao",
                           JOptionPane.INFORMATION_MESSAGE );
                }


                DrawOval drawOval = new DrawOval( src );
                scrollPane.add(drawOval);
                scrollPane.setViewportView(drawOval);

                drawOvalPanel = new DrawOvalPanel(  );


                final JFrame frame  = new JFrame();
                frame.add(drawOvalPanel);
                frame.setSize( 330,73);
                frame.setLocation( 150, 10  );
                 
                frame.setVisible(true);
                //frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
                frame.setAlwaysOnTop(true);
                frame.setResizable(false);
                //frame.setUndecorated(true);
                frame.addWindowListener( new WindowAdapter(){
                  
                  public void windowClosing( WindowEvent event){
                    updateImage(src);
                    
                  }
                });

                JButton sim = drawOvalPanel.getOkButton();
                sim.setEnabled(true);
                //sim.setText( "Sim" );
                sim.addActionListener( new ActionListener() {
                    public void actionPerformed( ActionEvent e ){
                      PlanarImage dst = DrawOval.Crop2Theta( src );
                        new ShowImage( dst, "Configured Image", desktopIntern );

                        updateImage( src );
                        frame.dispose();
                    }
                });

                JButton cancel = drawOvalPanel.getCancelButton();
                cancel.setEnabled(true);
                //sim.setText( "Sim" );
                cancel.addActionListener( new ActionListener() {
                    public void actionPerformed( ActionEvent e ){
                      updateImage( src );
                      frame.dispose();
                    }
                });
                
                
              
               
                
                
            }catch( Exception e ){

                  JOptionPane.showMessageDialog( null, e.getMessage(), "Try Again!", JOptionPane.ERROR_MESSAGE );

            }
        }



    }

    class ListenDebyeAnalyzer extends JMenuItem implements CommandInterface
    {


         public ListenDebyeAnalyzer(String caption)
         {
            super(caption);
            setMnemonic(KeyEvent.VK_A);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, ActionEvent.CTRL_MASK));
         }


         public void ExecuteAction()
         {

                

                 DrawGraphics drawFrame = new DrawGraphics( src );
                 drawFrame.setSize( 700, 400  );
                 drawFrame.setLocation( 300, 300  );
                 drawFrame.setVisible(true);

             PrintData printData = new PrintData(  src.getWidth(), "Debye-Scherrer", "ngulo", "intensidade" );

             try {

                  printData.calcDebyeScherrer(src);

             } catch (IOException e) {

                     e.printStackTrace();

             }

             printData.setSize(300,400);
             printData.setLocation( 200, 300 );
             printData.setVisible( true );

         }

    }

    class ListenDebyeDrawPoints extends JMenuItem implements CommandInterface
    {


         public ListenDebyeDrawPoints(String caption)
         {
            super(caption);
            setMnemonic(KeyEvent.VK_N);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, ActionEvent.CTRL_MASK));
         }


         public void ExecuteAction()
         {

             try{

                DebyeDrawPoints debyeDrawPoints = new DebyeDrawPoints( src );
                scrollPane.add(debyeDrawPoints);
                scrollPane.setViewportView(debyeDrawPoints);

            }catch( Exception e ){

                  JOptionPane.showMessageDialog( null, e.getMessage(), "Try Again!", JOptionPane.ERROR_MESSAGE );

            }


         }

    }


    // Classes para o Menu Operaes Geomtricas
class ListenGeometric extends JMenu implements CommandInterface
    {
        /**
         * Mtodo construtor da classe ListenGeometrica.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Geometrica
         * @param caption - texto que  utilizado para nomear o menu.
         */
        public ListenGeometric(String caption)
        {
            super(caption);
            //setMnemonic(KeyEvent.VK_H);
        }

        public void ExecuteAction()
        {

        }
    }
  class ListenTranspose extends JMenu implements CommandInterface
  {
        /**
         * Mtodo construtor da classe ListenGeometrica.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o Menu Geometrica
         * @param caption - texto que  utilizado para nomear o menu.
         */
        public ListenTranspose(String caption)
        {
            super(caption);
            //setMnemonic(KeyEvent.VK_O);
        }

        public void ExecuteAction()
        {


        }
    }

    class ListenFlipVertical extends JMenuItem implements CommandInterface
    {

        public ListenFlipVertical(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_V);
        }

        public void ExecuteAction()
        {

             PlanarImage dst = Transpose.FlipVertical(src);
             updateImage( dst );

        }

    }

    class ListenFlipHorizontal extends JMenuItem implements CommandInterface
    {

        public ListenFlipHorizontal(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_H);
        }

        public void ExecuteAction()
        {
            PlanarImage dst = Transpose.FlipHorizontal(src);
            updateImage( dst );

        }

    }

    class ListenFlipDiagonal extends JMenuItem implements CommandInterface
    {

        public ListenFlipDiagonal(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_D);
        }

        public void ExecuteAction()
        {

            PlanarImage dst = Transpose.FlipDiagonal(src);
            updateImage( dst );

        }

    }

    class ListenFlipAntidiagonal extends JMenuItem implements CommandInterface
    {

        public ListenFlipAntidiagonal(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_A);
        }

        public void ExecuteAction()
        {

            PlanarImage dst = Transpose.FlipAntidiagonal(src);
            updateImage( dst );

        }

    }

    class ListenRot90 extends JMenuItem implements CommandInterface
    {

        public ListenRot90(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_9);
        }

        public void ExecuteAction()
        {

             PlanarImage dst = Transpose.Rot90(src);
             updateImage( dst );
        }

    }

    class ListenRot180 extends JMenuItem implements CommandInterface
    {

        public ListenRot180(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_1);
        }

        public void ExecuteAction()
        {

             PlanarImage dst = Transpose.Rot180(src);
             updateImage( dst );
        }

    }

    class ListenRot270 extends JMenuItem implements CommandInterface
    {

        public ListenRot270(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_2);
        }

        public void ExecuteAction()
        {

             PlanarImage dst = Transpose.Rot270(src);
             updateImage( dst );
        }

    }


class ListenAffine extends JMenuItem implements CommandInterface
{
        /**
         * Mtodo construtor da classe Rotacionar.
         * Esse mtodo configura as teclas de atalho para a funo bem como cria um "ouvinte" para o item
         * Rotacionar imagem do Menu Editar.
         * @param caption - texto que  utilizado para nomear o item do Menu*
        */
        public ListenAffine(String caption)
        {
            super(caption);
            setMnemonic(KeyEvent.VK_T);
            setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T, ActionEvent.CTRL_MASK));
        }

        /**
         * Ao a ser executada quando o item Rotacionar imagem do menu Editar for selecionado
         */
        public void ExecuteAction()
        {

            setImageProcessed( (PlanarImage)storeImageProcessed.elementAt( posProcessed ) );
            AffineFrame affineFrame = new AffineFrame(src, desktopIntern);

            affineFrame.setSize( 300, 300  );
            affineFrame.setLocation( 500, 200  );
            affineFrame.setVisible(true);
            /*
            JButton ok = affineFrame.getAffineButtonOk();

            ok.addActionListener( new ActionListener(){
            public void actionPerformed( ActionEvent e ){


                try{
                     PlanarImage src = getImageProcessed();
                     PlanarImage dst = JAI.create( "affine",
                                                      src,
                                                      affineFrame.getAffineTransform(),
                                                      affineFrame.getInterpolationFrame()
                                                    );

                     new ShowImage( dst , "AffineImage", desktopIntern );

                    affineFrame.dispose();
                    }catch( Exception nfe ){

                           JOptionPane.showMessageDialog(null, "Number of the type float!", "Ooops!", JOptionPane.ERROR_MESSAGE );
                           affineFrame.dispose();
                    }




            }
        } );


            */


         }

      }

  

    



/***************************************** Classes para os cones *****************************************************/
class ListenSaveIcone extends JButton implements CommandInterface
    {
         /**
          * Metdo construtor da classe ListenSaveIcone, que produz o cone "Salvar Como". Essa funo tambm
          *  utilizada para configurar o texto que ser exibido quando o usurio passa com o apontador do mouse
          * em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Salvar Como".
          */
         public ListenSaveIcone(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

           /**
            * Ao a ser executada quando o cone Salvar (Figura de um disquete) for selecionado
            */
           public void ExecuteAction()
           {
                PlanarImage src;
                src = getImageProcessed();
                save(src, pathGlobal);

           }
       }

    class ListenUndoIcone extends JButton implements CommandInterface
    {
         /**
          * Mtodo construtor da classe ListenUndoIcone, que produz o cone "Desfazer Operao". Essa funo tambm
          *  utilizada para configurar o texto que ser exibido quando o usurio passa com o apontador do mouse
          * em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Desfazer Operao".
          */
         public ListenUndoIcone(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

         /**
          * Ao a ser executada quando o cone Desfazer (uma seta para a esquerda) for selecionado
          */
         public void ExecuteAction()
         {
               if( posProcessed > 0 ){

                   posProcessed--;
                   show = new DisplayJAI( getImageProcessed() );
                   scrollPane.add(show);
                   scrollPane.setViewportView(show);
                   getContentPane().repaint();
                   setSize( getImageProcessed().getWidth(), getImageProcessed().getHeight() );
                   setVisible(true);
                   pack();



               }else
               JOptionPane.showMessageDialog( this,
                                              "Undo process < Store image process...",
                                              "Oooppps!",
                                              JOptionPane.INFORMATION_MESSAGE
                                             );
         }
    }

    class ListenRedoIcone extends JButton implements CommandInterface
    {
         /**
          * Mtodo construtor da classe ListenRedoIcone, que produz o cone "Refazer Operao". Essa funo tambm
          *  utilizada para configurar o texto que ser exibido quando o usurio passa com o apontador do mouse
          * em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Refazer Operao".
          */
         public ListenRedoIcone(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

         /**
          * Ao a ser executada quando o cone Refazer (uma seta para a direita) for selecionado
          */
         public void ExecuteAction()
         {
            posProcessed++;

            if( posProcessed >= storeImageProcessed.size() ){

                JOptionPane.showMessageDialog( this,
                                               "Redo process > Store image process...",
                                               "Oooppps!",
                                               JOptionPane.INFORMATION_MESSAGE
                                              );
                posProcessed--;

            }

            if ( posProcessed >= 0  && posProcessed < storeImageProcessed.size() ){

                 show = new DisplayJAI( getImageProcessed() );
                 scrollPane.add(show);
                 scrollPane.setViewportView(show);
                 getContentPane().repaint();
                 setSize( getImageProcessed().getWidth(), getImageProcessed().getHeight() );
                 setVisible(true);
                 pack();

            }

         }
    }

    

    class ListenSelecionarIcone extends JButton implements CommandInterface
    {
         /**
          * Mtodo construtor da classe ListenSelecionarIcone, que produz o cone "Selecionar Imagem".
          * Essa funo tambm  utilizada para configurar o texto que ser exibido quando o usurio
          * passa com o apontador do mouse em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Selecionar Imagem".
          */
         public ListenSelecionarIcone(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

        /**
         * Ao a ser executada quando o cone Selecionar (figura com desenhos geomtricos) for selecionado
         */
         public void ExecuteAction()
         {
             if( !(setOn) )
             {
                 setOn=true;
                 this.setIcon(null);
             }
             else
             {
                 setOn=false;
                 setIcon(null);
             }
         }
    }

    class ListenCopiarIcone extends JButton implements CommandInterface
    {
         /**
          * Mtodo construtor da classe ListenCopiarIcone, que produz o cone "Copiar Imagem".
          * Essa funo tambm  utilizada para configurar o texto que ser exibido quando o usurio
          * passa com o apontador do mouse em cima do cone.
          * @param text - Texto que  exibido quando o usurio passar com o apontador do mouse por sobre o cone.
          * @param icon - cone que ser utilizado para construir o boto "Copiar Imagem".
          */
         public ListenCopiarIcone(String text,Icon icon)
         {
             super(icon);
             this.setToolTipText(text); //texto que aparece quando passa com o mouse por cima do cone
             this.setBorderPainted(false);
         }

        /**
         * Ao a ser executada quando o cone Copiar for selecionado
         */
         public void ExecuteAction()
         {


//diego...........a classe deve se chamar crop!!!.....................................................................


            if( xReleased > xPressed && yReleased > yPressed ){//4

                xTrans = -xPressed;
                yTrans = -yPressed;

            }
            if(  xReleased < xPressed && yReleased < yPressed ){//1

                xTrans = -xReleased;
                yTrans = -yReleased;

            }

            if( xReleased < xPressed && yReleased > yPressed ){//3

                xTrans = -xReleased;
                yTrans = -yPressed;

            }

            if( xReleased > xPressed && yReleased < yPressed ){//2
                xTrans = -xPressed;
                yTrans = -yReleased;


            }

            float widthDiego = Math.abs( xPressed - xReleased );
            float heightDiego = Math.abs( yPressed - yReleased );
            //gurias
            ParameterBlock pb = new ParameterBlock();
            pb.addSource(src);
            System.out.println("chegou aqui 1");
            Vector parametros = new Vector();
            Float x = new Float(-xTrans);//era xselect
            Float y = new Float(-yTrans);
            Float width = new Float(widthDiego);   //era width
            Float height = new Float(heightDiego);
            System.out.println("xSelect" + xSelect);
            System.out.println("ySelect" + ySelect);
            System.out.println("width" + width);
            System.out.println("height" + height);
            parametros.add(x);
            parametros.add(y);
            parametros.add(width);
            parametros.add(height);
            pb.setParameters(parametros);
            System.out.println("chegou aqui 2");
            //guriasEnd
            src = getImageProcessed();
            AffineTransform trans = AffineTransform.getTranslateInstance( xTrans , yTrans );
            roi = JAI.create("crop", pb,  null);
            PlanarImage src = JAI.create( "affine", roi, trans );
            //areaTransferencia.add((PlanarImage)roi); //Gabi
            new ShowImage(src, nomeRoi, desktopIntern ); //aqui tudo certo, a parte de baixo que tava dando erro

            //DisplayJAI show= new DisplayJAI(src);

            //scrollPane.add(show);

           // scrollPane.setViewportView(show);
//diego...........................................................................................................End.
           /*PlanarImage roi = JAI.create("crop", pb,  null);
           areaTransferencia.add((PlanarImage)roi); //Gabi
           DisplayJAI show= new DisplayJAI(roi);
       scrollPane.add(show);
       scrollPane.setViewportView(show);
           */
         }
    }



/**********************************************************************************************************************/








//..............................................................................................Diego Schmaedech..End
/**********************************************************************************************************************/






/*************************************** Classe para as caixas de dilogos ********************************************/
public class Dialogo extends JPanel
{
      JFrame frame;
       /**
        * Mtodo construtor da classe Dialogo
        * @param frame
        */
       public Dialogo(JFrame frame)
       {
            this.frame = frame;
       }

    /**
     * Funo para exibir uma mensagem de alerta.
      * @param titulo - Ttulo da mensagem
     * @param texto - Texto da mensagem
     * @return a caixa de mensagem
     */
    public JPanel CaixaDialogoOK(String titulo, String texto)
    {
                JOptionPane.showMessageDialog(frame,texto,titulo, JOptionPane.WARNING_MESSAGE);
                JButton button = new JButton();
                return criarPane(titulo, button);
    }

    /**
     * Funo para exibir uma mensagem de erro
     * @param titulo - Ttulo da mensagem
     * @param texto - Texto da mensagem
     * @return a caixa de mensagem
     */
    public JPanel CaixaDialogo(String titulo, String texto)
    {
        JOptionPane.showMessageDialog(frame, texto, titulo, JOptionPane.ERROR_MESSAGE);
        JButton button = new JButton();
        return criarPane(titulo, button);
    }

    /**
    *  Essa funo serve para criar uma caixa de dilogo com botes SIM e NO.
    * @param titulo - Ser o ttulo da Caixa de Mensagem
    * @param pergunta - Ser a pergunta mostrada ao usurio
    * @return escolha - Se o valor da escolha for true,  porque pressionou o boto sim
    *                   Se o valor da escolha for false,  porque pressionou o boto no
    */
    public boolean CaixaDialogoSN(String titulo, String pergunta)
    {
          boolean escolha=false;
          int n = JOptionPane.showConfirmDialog(frame,titulo,pergunta,JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE);
          if(n==JOptionPane.YES_OPTION)
          {
            escolha=true;
            return escolha;
          }
          return escolha;
      }

    /**
    * Essa funo  responsvel por montar um caixa de texto apartir de uma descrio de um boto.
    *  aqui que defini-se a posio e as bordas dos elementos dentro de uma caixa de texto.
    * @param descricao - Texto da caixa de mensagem
    * @param botao - Boto da caixa de mensagem
    * @return  caixa de mensagem montada
    */
    public JPanel criarPane(String descricao, JButton botao)
    {

        JPanel caixaDialogo = new JPanel();
        JLabel label = new JLabel(descricao);

        caixaDialogo.setLayout(new BoxLayout(caixaDialogo, BoxLayout.Y_AXIS));
        caixaDialogo.add(label);

        JPanel painel = new JPanel();
        painel.setLayout(new BorderLayout());
        painel.add(caixaDialogo, BorderLayout.NORTH);
        painel.add(botao, BorderLayout.SOUTH);
        return painel;
    }

 }




}//fim de LitleWindow
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.