Pessoal boa tarde. como eu faço pra um usuario selecionar um componente da minha aplicação e ele mesmo redimensionar. assim como fazemos com componentes swing do java que inserimos num frame e aumentamos ou diminuimos o …

Redimensionar components em tempo de execução

Axo q n existe uma forma simple de fazer isso o codigo abaixo possui DragnDrop e deve ser inserido no MouseListener e MouseMotionListener no component(Feito p/ um projeto antigo meu) o ideal é inserir em todos os components interno do container;

package db;

import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dialog;
import java.awt.Frame;
import java.awt.Window;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

public class DND implements MouseListener, MouseMotionListener {

    private int mx;
    private int my;
    private int cx;
    private int cy;
    private int w;
    private int h;
    private Component c;
    public static final int ONLY_MOVE = 1;
    public static final int ONLY_RESIZE = 2;
    private int acao;
    private int resize;

    public DND(int acao) {//parametros "ONLY_MOVE", "ONLY_RESIZE" ou "ONLY_RESIZE | ONLY_MOVE"
        this.acao = acao;
        resize = Cursor.DEFAULT_CURSOR;
    }

    @Override
    public void mouseClicked(MouseEvent e) {
    }

    @Override
    public void mousePressed(MouseEvent e) {
        if (e.getButton() == MouseEvent.BUTTON1) {
            if (ONLY_MOVE == (acao & ONLY_MOVE)) {

                mx = e.getXOnScreen();
                my = e.getYOnScreen();

//init Aki seleciona o componente q será arrastado ou redimensionado, neste caso
                Component aux = (Component) e.getSource();
                while (aux != null && !(c instanceof Window)) {
                    c = aux;
                    aux = c.getParent();
                }
//fim
                if (c != null) {
                    cx = c.getLocationOnScreen().x;
                    cy = c.getLocationOnScreen().y;
                    w = c.getWidth();
                    h = c.getHeight();
                }
            }
        }
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if (e.getButton() == MouseEvent.BUTTON1) {
            c = null;
        }
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        if (resize != Cursor.DEFAULT_CURSOR) {
            if (ONLY_RESIZE == (acao & ONLY_RESIZE)) {
                int nsx, nsy, npx, npy;
                npx = cx;
                npy = cy;
                nsx = w;
                nsy = h;
                if (resize == Cursor.NW_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int y = e.getYOnScreen();
                    int dx = x - mx;
                    int dy = y - my;

                    npx = cx + dx;
                    npy = cy + dy;
                    nsx = w - dx;
                    nsy = h - dy;
                } else if (resize == Cursor.NE_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int y = e.getYOnScreen();
                    int dx = x - mx;
                    int dy = y - my;

                    npx = cx;
                    npy = cy + dy;
                    nsx = w + dx;
                    nsy = h - dy;
                } else if (resize == Cursor.SW_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int y = e.getYOnScreen();
                    int dx = x - mx;
                    int dy = y - my;

                    npx = cx + dx;
                    npy = cy;
                    nsx = w - dx;
                    nsy = h + dy;
                } else if (resize == Cursor.SE_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int y = e.getYOnScreen();
                    int dx = x - mx;
                    int dy = y - my;

                    npx = cx;
                    npy = cy;
                    nsx = w + dx;
                    nsy = h + dy;
                } else if (resize == Cursor.N_RESIZE_CURSOR) {
                    int y = e.getYOnScreen();
                    int dy = y - my;

                    npx = cx;
                    npy = cy + dy;
                    nsx = w;
                    nsy = h - dy;
                } else if (resize == Cursor.S_RESIZE_CURSOR) {
                    int y = e.getYOnScreen();
                    int dy = y - my;

                    npx = cx;
                    npy = cy;
                    nsx = w;
                    nsy = h + dy;
                } else if (resize == Cursor.W_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int dx = x - mx;

                    npx = cx + dx;
                    npy = cy;
                    nsx = w - dx;
                    nsy = h;
                } else if (resize == Cursor.E_RESIZE_CURSOR) {
                    int x = e.getXOnScreen();
                    int dx = x - mx;

                    npx = cx;
                    npy = cy;
                    nsx = w + dx;
                    nsy = h;
                }
                synchronized (c.getTreeLock()) {
                    if (nsx < c.getMinimumSize().width) {
                        if (npx != cx) {
                            npx = npx - (c.getMinimumSize().width - nsx);
                        } else {
                            nsx = c.getMinimumSize().width;
                        }
                    }
                    if (nsy < c.getMinimumSize().height) {
                        if (npy != cy) {
                            npy = npy - (c.getMinimumSize().height - nsy);
                        } else {
                            nsy = c.getMinimumSize().height;
                        }
                    }
                    c.setBounds(npx, npy, nsx, nsy);
                }
            }
        } else if (c != null) {
            int x = e.getXOnScreen();
            int y = e.getYOnScreen();
            int dx = x - mx;
            int dy = y - my;
            c.setLocation(cx + dx, cy + dy);
        }
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        if (ONLY_RESIZE == (acao & ONLY_RESIZE) && c == null) {
            Component com = (Component) e.getSource();
            Component par = null;
            Component aux = com;

            while (aux != null && !(par instanceof Window)) {
                par = aux;
                aux = par.getParent();
            }

            int dx0 = Math.abs(e.getXOnScreen() - par.getLocationOnScreen().x);
            int dy0 = Math.abs(e.getYOnScreen() - par.getLocationOnScreen().y);
            int dx1 = Math.abs(e.getXOnScreen() - par.getLocationOnScreen().x - par.getWidth());
            int dy1 = Math.abs(e.getYOnScreen() - par.getLocationOnScreen().y - par.getHeight());

            int d = 3;
//init verifica se o component é redimensionavel, no meu projeto eram os dialogs e frames
            boolean r = false;
            if (par instanceof Dialog) {
                r = ((Dialog) par).isResizable();
            }
            if (par instanceof Frame) {
                r = ((Frame) par).isResizable();
            }
//fim

            if (r) {
                if (dx0 >= 0 && dx0 <= d) {
                    if (dy0 >= 0 && dy0 <= d) {
                        com.setCursor(new Cursor(Cursor.NW_RESIZE_CURSOR));
                        resize = Cursor.NW_RESIZE_CURSOR;
                    } else if (dy1 >= 0 && dy1 <= d) {
                        com.setCursor(new Cursor(Cursor.SW_RESIZE_CURSOR));
                        resize = Cursor.SW_RESIZE_CURSOR;
                    } else {
                        com.setCursor(new Cursor(Cursor.W_RESIZE_CURSOR));
                        resize = Cursor.W_RESIZE_CURSOR;
                    }
                } else if (dx1 >= 0 && dx1 <= d) {
                    if (dy0 >= 0 && dy0 <= d) {
                        resize = Cursor.NE_RESIZE_CURSOR;
                    } else if (dy1 >= 0 && dy1 <= d) {
                        resize = Cursor.SE_RESIZE_CURSOR;
                    } else {
                        resize = Cursor.E_RESIZE_CURSOR;
                    }
                } else if (dy0 >= 0 && dy0 <= d) {
                    resize = Cursor.N_RESIZE_CURSOR;
                } else if (dy1 >= 0 && dy1 <= d) {
                    resize = Cursor.S_RESIZE_CURSOR;
                } else {
                    resize = Cursor.DEFAULT_CURSOR;
                }
            } else {
                resize = Cursor.DEFAULT_CURSOR;
            }
            com.setCursor(new Cursor(resize));
        }
    }
}

n esqueça q o PARENT do component tem q ser Container com layout NULL ou com layout q n manipule o container, se n toda vez q mudar o tamanho, pode bagunçar os components aki um teste pra brinca

public class Teste {

    public static void main(String[] args) {
        JLabel jLabelDefault = new JLabel("Hello");
        
        DND dndLabel = new DND(DND.ONLY_MOVE | DND.ONLY_RESIZE);
        jLabelDefault.addMouseListener(dndLabel);
        jLabelDefault.addMouseMotionListener(dndLabel);
        
        jLabelDefault.setBorder(BorderFactory.createCompoundBorder(
            BorderFactory.createLineBorder(Color.BLACK),
            BorderFactory.createEmptyBorder(10, 20, 10, 20)));
        
        JDialog jDialogDefault = new JDialog();
        
        DND dndDialog = new DND(DND.ONLY_MOVE | DND.ONLY_RESIZE);
        jDialogDefault.addMouseListener(dndDialog);
        jDialogDefault.addMouseMotionListener(dndDialog);
        
        jDialogDefault.setModal(true);
        jDialogDefault.setUndecorated(true);
        jDialogDefault.getContentPane().add(jLabelDefault);
        jDialogDefault.pack();
        jDialogDefault.setMinimumSize(jDialogDefault.getSize());//obrigatorio setar o tamanho minimo
        jDialogDefault.setDefaultCloseOperation(JDialogDefault.DISPOSE_ON_CLOSE);
        jDialogDefault.setLocationRelativeTo(null);
        jDialogDefault.setVisible(true);
    }
}

2 Respostas

Topicos relacionados