# schönes Resize bei eigenem JFrame



## The_S (19. Dez 2006)

Hi,

ich brauche in einem Fenster eine eigene Titelleiste. Dazu habe ich mir eine eigene Klasse geschrieben die ein JFrame verwendet (sie erbt nicht davon, da ich keine Lust habe alle Methoden zu überschreiben. Stattdessen implementiere ich nur die, die ich wirklich benötige).

Um meine eigene Titelleiste implementieren zu können muss ich das JFrame ja undecorated true setzen. Das hat zur Folge, dass ich es nicht mehr verschieben und vergrößern/verkleinern kann. Diese Funktionen habe ich händisch programmiert, aber jetzt muss ich leider feststellen, dass das resizen sehr hässlich ist. Und zwar hab ich folgende Möglichkeiten:

1. Beim Resizen keine bestimmten Parameter setzen => die GUI flackert und die Componenten werden erst später an die richtige Position gesetzt
2. Zusätzlich nach jedem mouseDragged(MouseEvent evt) Aufruf validate ausführen => GUI flackert immernoch, aber die Componenten werden sofort angepasst
3. Das JFrame vor dem Resizen anweisen, dass es repaint ignorieren soll und anschließend wieder erlauben => GUI flackert nicht, aber alle Componenten werden während des Resize-Vorgangs ausgeblendet. Man sieht lediglich die Hintergrundfarbe des JFrames.

Der dazugehörige MouseListener:


```
private MouseAdapter click = new MouseAdapter() {
		
		public void mousePressed(MouseEvent mou) {
			
			startX = mou.getX();
			startY = mou.getY();
			startX2 = (int)MouseInfo.getPointerInfo().getLocation().getX();
			startY2 = (int)MouseInfo.getPointerInfo().getLocation().getY();
			if (rand != NONE) {
				frame.setIgnoreRepaint(true);
			}
		}
		
		public void mouseReleased(MouseEvent mou) {
			
			frame.setIgnoreRepaint(false);
			frame.validate();
			initial();
		}
	};
```

und hier der MouseListener:


```
private MouseMotionAdapter drag = new MouseMotionAdapter() {
		
		public void mouseDragged(MouseEvent mou) {
			
			if (mou.getSource() == contentPane && dragContent == false) {
				return;
			}
			int x = (int)MouseInfo.getPointerInfo().getLocation().getX();
			int y = (int)MouseInfo.getPointerInfo().getLocation().getY();
			int width = frame.getWidth() - (x - startX2);
			int height = frame.getHeight() - (y - startY2);
			if (rand == NONE) {
				frame.setLocation(x - startX,
									y - startY);
			}
			else {
				if (rand == EAST) {
					setSize(frame.getWidth() + (x - startX2),
							frame.getHeight());
				}
				else if (rand == WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos,
								width,
								frame.getHeight());
				}
				else if (rand == SOUTH) {
					setSize(frame.getWidth(),
							frame.getHeight() + (y - startY2));
				}
				else if (rand == NORTH) {
					setBounds(xPos,
								yPos + (y2Pos - yPos) - height,
								frame.getWidth(),
								height);
				}
				else if (rand == SOUTH_EAST) {
					setSize(frame.getWidth() + (x - startX2),
							frame.getHeight() + (y - startY2));
				}
				else if (rand == SOUTH_WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos,
								width,
								frame.getHeight() + (y - startY2));
				}
				else if (rand == NORTH_WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos + (y2Pos - yPos) - height,
								width,
								height);
				}
				else if (rand == NORTH_EAST) {
					setBounds(xPos,
								yPos + (y2Pos - yPos) - height,
								frame.getWidth() + (x - startX2),
								height);
				}
	//			frame.invalidate();
				startX2 = x;
				startY2 = y;
			}
		}
		
		public void mouseMoved(MouseEvent mou) {
			
			Point p = MouseInfo.getPointerInfo().getLocation();
			int x = (int)p.getX();
			int y = (int)p.getY();
			if (xPos - 5 < x && xPos + 5 > x) {
				if (yPos - 5 < y && yPos + 5 > y) {
					setRand(NORTH_WEST);
				}
				else if (y2Pos - 5 < y && y2Pos + 5 > y) {
					setRand(SOUTH_WEST);
				}
				else {
					setRand(WEST);
				}
			}
			else if (x2Pos - 5 < x && x2Pos + 5 > x) {
				if (yPos - 5 < y && yPos + 5 > y) {
					setRand(NORTH_EAST);
				}
				else if (y2Pos - 5 < y && y2Pos + 5 > y) {
					setRand(SOUTH_EAST);
				}
				else {
					setRand(EAST);
				}
			}
			else if (yPos - 5 < y && yPos + 5 > y) {
				setRand(NORTH);
			}
			else if (y2Pos - 5 < y && y2Pos + 5 > y) {
				setRand(SOUTH);
			}
			else {
				setRand(NONE);
			}
		}
	};
```

Es soll aufjedenfall der Container "titlePane", welchen ich "frame" als BorderLayout.NORTH geadded habe beim Resizen mitaktualisiert werden (größe). Dafür nehme ich ein flackern dieses Containers in Kauf. Außerdem soll noch der Container contentPane seinen Inhalt behalten und nicht flackern. Eine sofortige Anpassung an die neue Größe ist nicht erforderlich.

Ich hoffe es ist soweit alles klar was ich möchte. Danke!


----------



## Wildcard (19. Dez 2006)

Schau dir mal das an:
http://www-128.ibm.com/developerworks/java/library/j-iframe/


----------



## The_S (19. Dez 2006)

Hi, danke für den Link  .

Hast du damit schon etwas gemacht?

Hab mir das mal durchgelesen und gedacht "WOW, sowas gibt es?". Hab weiter gelesen und mir gedacht "Unglaublich, da muss es einen Haken geben" (natürlich in der Annahme, dass es keinen gibt). Dann hab ich das alles mal runtergeladen und ausprobiert. Und schon zeigte sich der Haken:

1. Verschieben von den Frames ist verdammt langsam und hinterlässt schlieren
2. Resizen ist noch viel langsamer
3. Die (von der Seite) hoch gelobte Transparenz erwies sich nach 30 Sekunden test bereits als fehlerhaft

Da allein beim 2-Minuten-Test von den 4 mitgelieferten Beispielen solche Mängel auftraten, kann ich beim besten Willen kein großes Vertrauen in diese Lib setzen. 

Aber trotzdem Danke für deine Mühe. Evtl. weiß ja noch jemand eine Lösung, wie ich schön resizen kann  .


----------



## Wildcard (19. Dez 2006)

Nein, versucht hab ich's nicht, ich dachte nur: 'hey, das sieht nett aus'  :lol:


----------



## The_S (20. Dez 2006)

Weiß evtl. jemand wie das in einem Frame realisiert wird? Da funktionierts ja auch. Oder wird das resizen von dem OS gesteuert?

Ich durchsuch jetzt schon seit 3 Stunden die Source von Java und kann nichtmal den Hauch eines Hinweises finden, wie das realisiert ist :cry: .


----------



## The_S (29. Jan 2008)

Nachdem mein Azubi letztens diesen Thread wieder gefunden hat, habe ich mich nochmal drüber gesetzt und eine recht simple Lösung für das Problem gefunden. Beim Resizen wird einfach nicht direkt gezeichnet, sondern zuerst einmal auf ein Image und anschließend dieses Image anstelle des eigentlichen Contents.

Es verhält sich zwar noch nicht  zu 100% wie ein normales Window, aber auf jedenfall schonmal besser als vorher. Aus diesem Anlass veröffentliche ich hier auch mal diese Klasse.

Den Code habe ich mir ansonsten nicht mehr angeschaut, ich weiß auch nicht mehr was ich noch alles auf meiner Todo/Bug-Liste hatte. Von daher kann es gut sein, dass noch der eine oder andere Fehler auftritt. Bei einem kurzen Test ist mir aber keiner mehr aufgefallen. Die Klasse kann direkt compiliert und (dank der Beispiel-Main) auch ausgeführt werden.


```
package de.egui.frames;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JPanel;

public class PaneTitleFrame {

	private static final long serialVersionUID = 1L;
	
	private static final int NONE = 0;
	private static final int WEST = 1;
	private static final int SOUTH_WEST = 2;
	private static final int SOUTH = 3;
	private static final int SOUTH_EAST = 4;
	private static final int EAST = 5;
	private static final int NORTH_EAST = 6;
	private static final int NORTH = 7;
	private static final int NORTH_WEST = 8;
	private static final int WIDTH = 1;
	private static final int HEIGHT = 2;
	private static final int BOTH = 3;
	
	private int startX = 0;
	private int startY = 0;
	private int startX2 = 0;
	private int startY2 = 0;
	private int rand = NONE;
	private int xPos = 0;
	private int yPos = 0;
	private int x2Pos = 0;
	private int y2Pos = 0;
	
	private boolean dragContent = false;
	private boolean resizable = true;
	private boolean resize = false;
	private boolean press = false;
	
	private BufferedImage temp = null;
	
	private Container contentPane = null;
	private Container titlePane = null;
	private Container northPane = null;
	private Container menuPane = null;
	
	private JComponent leftPane = null;
	private JComponent rightPane = null;
	private JComponent southPane = null;
	private JComponent northrightPane = null;
	private JComponent northleftPane = null;
	private JComponent northnorthPane = null;
	private JComponent menuleftPane = null;
	private JComponent menurightPane = null;
	
	private Dimension minimumSize = null;
	private Dimension maximumSize = null;
	
	private JMenuBar jMenuBar = null;
	
	private JFrame frame = null;
	
	public PaneTitleFrame() {
		
		temp = new BufferedImage((int)Toolkit.getDefaultToolkit().getScreenSize().getWidth(), 
								(int)Toolkit.getDefaultToolkit().getScreenSize().getHeight(), 
								BufferedImage.TYPE_INT_RGB);
		
		frame = new JFrame() {
			
			private static final long serialVersionUID = 1L;
			
			public void paint(Graphics g) {
				
				if (resize) {
					resize = false;
					super.paint(temp.getGraphics());
					g.drawImage(temp, 0, 0, this);
				}
				else {
					super.paint(g);
				}
			}
		};
		
		contentPane = new JPanel();
		northPane = new JPanel();
		menuPane = new JPanel();
		titlePane = new JPanel();

		leftPane = new JLabel();
		rightPane = new JLabel();
		southPane = new JLabel();
		northleftPane = new JLabel();
		northrightPane = new JLabel();
		northnorthPane = new JLabel();
		menuleftPane = new JLabel();
		menurightPane = new JLabel();
		
		frame.setLayout(new BorderLayout());
		northPane.setLayout(new BorderLayout());
		menuPane.setLayout(new BorderLayout());
		
		menuPane.add(menuleftPane, BorderLayout.WEST);
		menuPane.add(menurightPane, BorderLayout.EAST);
		
		northPane.add(northleftPane, BorderLayout.WEST);
		northPane.add(northrightPane, BorderLayout.EAST);
		northPane.add(northnorthPane, BorderLayout.NORTH);
		northPane.add(menuPane, BorderLayout.SOUTH);
		
		frame.getContentPane().add(contentPane);
		frame.getContentPane().add(leftPane, BorderLayout.WEST);
		frame.getContentPane().add(rightPane, BorderLayout.EAST);
		frame.getContentPane().add(southPane, BorderLayout.SOUTH);
		frame.getContentPane().add(northPane, BorderLayout.NORTH);

		leftPane.setPreferredSize(new Dimension(2, 0));
		rightPane.setPreferredSize(new Dimension(2, 0));
		southPane.setPreferredSize(new Dimension(0, 2));
		northleftPane.setPreferredSize(new Dimension(2, 0));
		northrightPane.setPreferredSize(new Dimension(2, 0));
		menuleftPane.setPreferredSize(new Dimension(2, 0));
		menurightPane.setPreferredSize(new Dimension(2, 0));
		northnorthPane.setPreferredSize(new Dimension(0, 2));
		titlePane.setPreferredSize(new Dimension(0, 30));

		leftPane.setOpaque(true);
		rightPane.setOpaque(true);
		southPane.setOpaque(true);
		northleftPane.setOpaque(true);
		northrightPane.setOpaque(true);
		menuleftPane.setOpaque(true);
		menurightPane.setOpaque(true);
		northnorthPane.setOpaque(true);
		
		titlePane.setBackground(Color.blue);

		leftPane.addMouseListener(click);
		leftPane.addMouseMotionListener(drag);
		rightPane.addMouseListener(click);
		rightPane.addMouseMotionListener(drag);
		southPane.addMouseListener(click);
		southPane.addMouseMotionListener(drag);
		northleftPane.addMouseListener(click);
		northleftPane.addMouseMotionListener(drag);
		northrightPane.addMouseListener(click);
		northrightPane.addMouseMotionListener(drag);
		menuleftPane.addMouseListener(click);
		menuleftPane.addMouseMotionListener(drag);
		menurightPane.addMouseListener(click);
		menurightPane.addMouseMotionListener(drag);
		northnorthPane.addMouseListener(click);
		northnorthPane.addMouseMotionListener(drag);
		titlePane.addMouseListener(click);
		titlePane.addMouseMotionListener(drag);
		northPane.addMouseListener(click);
		northPane.addMouseMotionListener(drag);
		contentPane.addMouseListener(click);
		contentPane.addMouseMotionListener(drag);
		
		frame.setUndecorated(true);
		frame.setResizable(false);
		
		setTitlePane(titlePane);
		
		validate();
	}
	
	public void initial() {
		
		if (frame.isVisible()) {
			xPos = (int)frame.getLocationOnScreen().getX();
			yPos = (int)frame.getLocationOnScreen().getY();
			x2Pos = xPos + frame.getWidth();
			y2Pos = yPos + frame.getHeight();
			validate();
		}
	}
	
	public void setComponentDragable(Component comp, boolean dragable) {

		comp.removeMouseListener(click);
		comp.removeMouseMotionListener(drag);
		if (dragable) {
			comp.addMouseListener(click);
			comp.addMouseMotionListener(drag);
		}
	}
	
	private void setRand(int rand) {
		
		if (!resizable) {
			frame.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
			rand = NONE;
			return;
		}
		this.rand = rand;
		if (rand == EAST || rand == WEST) {
			frame.setCursor(new Cursor(Cursor.E_RESIZE_CURSOR));
		}
		else if (rand == SOUTH_EAST || rand == NORTH_WEST) {
			frame.setCursor(new Cursor(Cursor.SE_RESIZE_CURSOR));
		}
		else if (rand == NORTH_EAST || rand == SOUTH_WEST) {
			frame.setCursor(new Cursor(Cursor.NE_RESIZE_CURSOR));
		}
		else if (rand == NORTH || rand == SOUTH) {
			frame.setCursor(new Cursor(Cursor.N_RESIZE_CURSOR));
		}
		else {
			frame.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
		}
	}
	
	private void checkContainer(Container cont) {
		
		boolean temp = true;
		for (MouseListener ml : cont.getMouseListeners()) {
			if (ml.equals(click)) {
				temp = false;
				break;
			}
		}
		if (temp) {
			cont.addMouseListener(click);
		}
		temp = true;
		for (MouseMotionListener mml : cont.getMouseMotionListeners()) {
			if (mml.equals(drag)) {
				temp = false;
				break;
			}
		}
		if (temp) {
			cont.addMouseMotionListener(drag);
		}
	}
	
	private int possibleSize(int width, int height) {
		
		boolean widthB = true;
		boolean heightB = true;
		if (minimumSize != null) {
			if (minimumSize.getWidth() > width) {
				widthB = false;
			}
			if (minimumSize.getHeight() > height) {
				heightB = false;
			}
		}
		if (maximumSize != null) {
			if (maximumSize.getWidth() < width) {
				widthB = false;
			}
			if (maximumSize.getHeight() < height) {
				heightB = false;
			}
		}
		if (widthB && heightB) {
			return BOTH;
		}
		if (widthB) {
			return WIDTH;
		}
		if (heightB) {
			return HEIGHT;
		}
		return NONE;
	}
	
	private MouseAdapter click = new MouseAdapter() {
		
		public void mousePressed(MouseEvent mou) {
			
			press = true;
			startX = (int)(mou.getComponent().getLocationOnScreen().getX() + mou.getX()) -
						(int)frame.getLocationOnScreen().getX();
			startY = (int)(mou.getComponent().getLocationOnScreen().getY() + mou.getY()) -
						(int)frame.getLocationOnScreen().getY();
			startX2 = (int)MouseInfo.getPointerInfo().getLocation().getX();
			startY2 = (int)MouseInfo.getPointerInfo().getLocation().getY();
		}
		
		public void mouseReleased(MouseEvent mou) {
			
			press = false;
			frame.validate();
			initial();
		}
		
		public void mouseExited(MouseEvent mou) {
			
			if (!press) {
				setRand(NONE);
			}
		}
	};
	
	private MouseMotionAdapter drag = new MouseMotionAdapter() {
		
		public void mouseDragged(MouseEvent mou) {
			
			resize = false;
			if (mou.getSource() == contentPane && dragContent == false) {
				return;
			}
			int x = (int)MouseInfo.getPointerInfo().getLocation().getX();
			int y = (int)MouseInfo.getPointerInfo().getLocation().getY();
			int width = frame.getWidth() - (x - startX2);
			int height = frame.getHeight() - (y - startY2);
			if (rand == NONE) {
				frame.setLocation(x - startX,
									y  - startY);
			}
			else {
				if (rand == EAST) {
					setSize(frame.getWidth() + (x - startX2),
							frame.getHeight());
				}
				else if (rand == WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos,
								width,
								frame.getHeight());
				}
				else if (rand == SOUTH) {
					setSize(frame.getWidth(),
							frame.getHeight() + (y - startY2));
				}
				else if (rand == NORTH) {
					setBounds(xPos,
								yPos + (y2Pos - yPos) - height,
								frame.getWidth(),
								height);
				}
				else if (rand == SOUTH_EAST) {
					setSize(frame.getWidth() + (x - startX2),
							frame.getHeight() + (y - startY2));
				}
				else if (rand == SOUTH_WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos,
								width,
								frame.getHeight() + (y - startY2));
				}
				else if (rand == NORTH_WEST) {
					setBounds(xPos + (x2Pos - xPos) - width,
								yPos + (y2Pos - yPos) - height,
								width,
								height);
				}
				else if (rand == NORTH_EAST) {
					setBounds(xPos,
								yPos + (y2Pos - yPos) - height,
								frame.getWidth() + (x - startX2),
								height);
				}
				startX2 = x;
				startY2 = y;
			}
		}
		
		public void mouseMoved(MouseEvent mou) {
			
			Point p = MouseInfo.getPointerInfo().getLocation();
			int x = (int)p.getX();
			int y = (int)p.getY();
			if (xPos - 5 < x && xPos + 5 > x) {
				if (yPos - 5 < y && yPos + 5 > y) {
					setRand(NORTH_WEST);
				}
				else if (y2Pos - 5 < y && y2Pos + 5 > y) {
					setRand(SOUTH_WEST);
				}
				else {
					setRand(WEST);
				}
			}
			else if (x2Pos - 5 < x && x2Pos + 5 > x) {
				if (yPos - 5 < y && yPos + 5 > y) {
					setRand(NORTH_EAST);
				}
				else if (y2Pos - 5 < y && y2Pos + 5 > y) {
					setRand(SOUTH_EAST);
				}
				else {
					setRand(EAST);
				}
			}
			else if (yPos - 5 < y && yPos + 5 > y) {
				setRand(NORTH);
			}
			else if (y2Pos - 5 < y && y2Pos + 5 > y) {
				setRand(SOUTH);
			}
			else {
				setRand(NONE);
			}
		}
	};

	public Container getContentPane() {
		return contentPane;
	}

	public void setContentPane(Container contentPane) {
		
		frame.getContentPane().remove(this.contentPane);
		this.contentPane = contentPane;
		frame.getContentPane().add(contentPane);
		setBackground(contentPane.getBackground());
		setForeground(contentPane.getForeground());
		frame.validate();
		checkContainer(contentPane);
	}

	public boolean isDragContent() {
		return dragContent;
	}

	public void setDragContent(boolean dragContent) {
		this.dragContent = dragContent;
	}

	public Container getTitlePane() {
		return titlePane;
	}

	public void setTitlePane(Container titlePane) {
		
		if (titlePane == null) {
			titlePane = new Container();
			titlePane.setPreferredSize(new Dimension(0, 0));
		}
		northPane.remove(this.titlePane);
		this.titlePane = titlePane;
		northPane.add(titlePane, BorderLayout.CENTER);
		northPane.validate();
		checkContainer(titlePane);
	}
	
	public void setSize(int width, int height) {
		
		int i = possibleSize(width, height);
		if (i == BOTH) {
			frame.setSize(width, height);
		}
		else if (i == WIDTH) {
			frame.setSize(width, frame.getHeight());
		}
		else if (i == HEIGHT) {
			frame.setSize(frame.getWidth(), height);
		}
		initial();
	}
	
	public void setBounds(int x, int y, int width, int height) {
		
		int i = possibleSize(width, height);
		if (i != NONE) {
			resize = true;
			if (i == BOTH) {
				temp = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
				frame.setBounds(x, y, width, height);
			}
			else if (i == WIDTH) {
				temp = new BufferedImage(width, frame.getHeight(), BufferedImage.TYPE_INT_RGB);
				frame.setBounds(x, (int)frame.getBounds().getY(), width, (int)frame.getBounds().getHeight());
			}
			else if (i == HEIGHT) {
				temp = new BufferedImage(frame.getWidth(), height, BufferedImage.TYPE_INT_RGB);
				frame.setBounds((int)frame.getBounds().getX(), y, (int)frame.getBounds().getWidth(), height);
			}
			validate();
		}
	}
	
	public void setVisible(boolean visible) {
		
		frame.setVisible(visible);
		if (visible) {
			initial();
		}
	}
	
	public void setBackground(Color background) {
		
		frame.setBackground(background);
		contentPane.setBackground(background);
		leftPane.setBackground(background);
		rightPane.setBackground(background);
		southPane.setBackground(background);
	}
	
	public Color getBackground() {
		return frame.getBackground();
	}
	
	public void setForeground(Color foreground) {

		frame.setForeground(foreground);
		contentPane.setForeground(foreground);
	}
	
	public Color getForeground() {
		return frame.getForeground();
	}

	public Dimension getMaximumSize() {
		return maximumSize;
	}

	public void setMaximumSize(Dimension maximumSize) {
		this.maximumSize = maximumSize;
	}

	public Dimension getMinimumSize() {
		return minimumSize;
	}

	public void setMinimumSize(Dimension minimumSize) {
		this.minimumSize = minimumSize;
	}
	
	public void setAlwaysOnTop(boolean bool) {
		frame.setAlwaysOnTop(bool);
	}
	
	public boolean isAlwaysOnTop() {
		return frame.isAlwaysOnTop();
	}
	
	public void setUndecorated(boolean undecorated) {
		frame.setUndecorated(undecorated);
	}
	
	public boolean isUndeocrated() {
		return frame.isUndecorated();
	}
	
	public void setDefaultCloseOperation(int operation) {
		frame.setDefaultCloseOperation(operation);
	}
	
	public int getDefaultCloseOperation() {
		return frame.getDefaultCloseOperation();
	}
	
	public void validate() {
		frame.validate();
	}
	
	public void repaint() {
		frame.repaint();
	}
	
	public void addComponentListener(ComponentListener cl) {
		frame.addComponentListener(cl);
	}
	
	public void removeComponentListener(ComponentListener cl) {
		frame.removeComponentListener(cl);
	}
	
	public void dispose() {
		frame.dispose();
	}
	
	public int getExtendedState() {
		return frame.getExtendedState();
	}
	
	public void setExtendedState(int state) {
		frame.setExtendedState(state);
	}

	protected JFrame getFrame() {
		return frame;
	}

	protected void setFrame(JFrame frame) {
		this.frame = frame;
	}

	public boolean isResizable() {
		return resizable;
	}

	public void setResizable(boolean resizable) {
		this.resizable = resizable;
	}

	public JMenuBar getJMenuBar() {
		return jMenuBar;
	}

	public void setBorderColor(Color col) {
		
		northleftPane.setBackground(col);
		northnorthPane.setBackground(col);
		northrightPane.setBackground(col);
		southPane.setBackground(col);
		leftPane.setBackground(col);
		rightPane.setBackground(col);
		menuleftPane.setBackground(col);
		menurightPane.setBackground(col);
	}
	
	public void setJMenuBar(JMenuBar menuBar) {
		jMenuBar = menuBar;
		if (jMenuBar != null) {
			menuPane.add(jMenuBar, BorderLayout.CENTER);
		}
		else {
			menuPane.add(new Container(), BorderLayout.CENTER);
		}
		validate();
	}
	
	public static void main(String[] args) {
		
		final PaneTitleFrame ptf = new PaneTitleFrame();
		JMenuBar menu = new JMenuBar();
		JPanel title = new JPanel();
		JPanel content = new JPanel();
		JButton minimieren = new JButton("_");
		JButton close = new JButton("X");
		JLabel text = new JLabel("Test Anwendung");
		title.setLayout(new BorderLayout());
		title.add(minimieren, BorderLayout.WEST);
		title.add(text);
		title.add(close, BorderLayout.EAST);
		title.setBackground(new Color(200, 150, 150));
		content.add(new JLabel("Test Label"));
		content.add(new JButton("Test Button"));
		close.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				System.exit(0);
			}
		});
		minimieren.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent evt) {
				ptf.setExtendedState(JFrame.ICONIFIED);
			}
		});
		menu.add(new JMenu("Datei"));
		
		ptf.setComponentDragable(minimieren, false);
		ptf.setComponentDragable(close, false);
		ptf.setContentPane(content);
		ptf.setBorderColor(Color.black);
		ptf.setTitlePane(title);
		ptf.setJMenuBar(menu);
		ptf.setSize(400, 400);
		ptf.setDragContent(true);
		ptf.setMinimumSize(new Dimension(50, 50));
		ptf.setResizable(true);
		ptf.setVisible(true);
	}
}
```


----------

