Swing ContentPane resettet sich selbst

[bognari]

Huhu, ich habe ein kleines Programm geschrieben in das ich alle meine statischen Methoden die ich im Laufe der Uni bis jetzt geschrieben habe einbinden wollte. Bis jetzt hatte ich immer für die GUI die Standard ContentPane genommen über:

 Container $container = $frame.getContentPane();

Jedoch kann man so kein schönes Wallpaper einbinden wie ich es vor hatte.
Dafür habe ich einen neuen ContentPane gesetzt mit $frame.setContentPane(new DasTEIL());
Es wird auch schön angezeigt jedoch wenn ich auf dem neuen ContentPane etwas mit .add(irgendetwas); ausführe resettet sich der ContentPane irgendwie wieder zu dem Standart Wert. Es wird nicht einmal mehr die paintComponent(Graphics g) Methode des von mir gewählten neuen ContentPane Objekts ausgeführt.

Hier mal der "ganze" Code der GUI und ja ich weiß ist noch nicht viel.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.io.File;

import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

@SuppressWarnings("serial")
public class GUI extends JFrame{

	private final GUI $frame;
	private final Container $container;
	private static final Image $background_image;
	
	public GUI() {
		this.$frame = this;
		$frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		$frame.setMiddleScreen_and_Size(650, 450);
		this.$container = new GUIBackground();
		$frame.setContentPane($container);
		$frame.setGUI(new HelpGUI());		
	}
	
	static{
		File $background_image_file = new File("images/background.jpg");
		$background_image = new ImageIcon($background_image_file.getPath()).getImage();
	}
	
	private void setMiddleScreen_and_Size(int _$x_Axis_int , int _$y_Axis_int) {
		$frame.setSize(_$x_Axis_int, _$y_Axis_int);
		final Dimension $dimension = Toolkit.getDefaultToolkit().getScreenSize();
		$frame.setLocation(($dimension.width - $frame.getSize().width) / 2,
	                 ($dimension.height - $frame.getSize().height) / 2);
	}
	
	private void setGUI(JComponent _$gui_JComponent) { // macht iwie alles kaputt
		$container.removeAll();
		$container.setLayout(new BorderLayout());
		$container.add(BorderLayout.CENTER, _$gui_JComponent); // <--- wenn das weg ist geht es. sonst nicht.
		$frame.validate();
	}
	
	/**
	 * 
	 * gui Classes
	 * 
	 */
	
	protected class GUIBackground extends JComponent  {
		
		@Override
		public void paintComponent(Graphics _$graphic) {
			super.paintComponent(_$graphic);
			_$graphic.drawImage($background_image, 0, 0, Color.WHITE,this); // gucken wie es genau war...
			System.out.println("Bild gemalt");
		}
	}

//	protected class HeaderGUI extends JComponent  {
//		
//		public HeaderGUI(String _$calling_gui_object_string) {
//		
//		}	
//	}
	
	protected class HelpGUI extends JPanel  {
		
		public HelpGUI() {
			this.add(new JLabel("kjfhdsgfrfjlai"));
		}
		
	}	
}

Falls sich evtl jemand die anderen Methoden ansehen mag Poste ich diese auch mal:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Task {
	public static int checksum(long _$number_long) {
		String $number_string = String.valueOf(_$number_long);
		int $result_int = 0;
		for(int $counter_int = 0; $counter_int < $number_string.length(); $counter_int++){
			$result_int += Integer.valueOf($number_string.charAt($counter_int));
		}
		return $result_int;
	}

	public static double circular_area(double _$full_circle_double) {
		return (Math.pow(_$full_circle_double, 2) / ( 4 * Math.PI)); // A = u^2/4pi
	}

	public static List<Integer> divide_the_amount(int _$anmount_int) {
		List<Integer> $result = new ArrayList<Integer>();
		Double[] $cash_array = {500.00, 200.00, 100.00, 50.00, 20.00, 10.00, 5.00, 2.00, 1.00, 0.50, 0.20, 0.10, 0.05, 0.02, 0.01};
		for(final double $cash : $cash_array){
			int $elements_int = (int) (_$anmount_int / $cash);
			_$anmount_int %= $cash;
			$result.add($elements_int);
		}
		return $result;
	}

	public static int euclid(int _$number_1_int, int _$number_2_int) {
		if( _$number_2_int == 0) {
			return _$number_1_int;
		}else{
			return euclid(_$number_2_int, _$number_1_int % _$number_2_int);
		}
	}

	public static BigDecimal euler_iteravis(long _$steps_long) { // bigdecimal fuer genaure berechnungen
		BigDecimal $euler_bigD = new BigDecimal(1);
		for(long $counter_long = 1; $counter_long <= _$steps_long; $counter_long++){
			BigDecimal $fak_division_bigD = new BigDecimal(1).divide(new BigDecimal(fak_iteravis($counter_long)));
			$euler_bigD.add($fak_division_bigD);
		}
		return $euler_bigD;
	}

	public static BigDecimal euler_recursively(long _$steps_long) { // bigdecimal fuer genaure berechnungen
		BigDecimal $euler_bigD = new BigDecimal(1);
		for(long $counter_long = 1; $counter_long <= _$steps_long; $counter_long++){
			BigDecimal $fak_division_bigD = new BigDecimal(1).divide(new BigDecimal(fak_recursively($counter_long)));
			$euler_bigD.add($fak_division_bigD);
		}
		return $euler_bigD;
	}

	public static BigInteger fak_iteravis(long _$number_long) {
		BigInteger $return_bigI = BigInteger.ONE;
		for(long $counter_long = 1; $counter_long <= _$number_long; $counter_long++){
			$return_bigI = $return_bigI.multiply(BigInteger.valueOf($counter_long));
		}
		return $return_bigI;
	}

	public static BigInteger fak_recursively(long _$number_long) {
		if (_$number_long <= 1) {
			return BigInteger.ONE;
		}else{
			return BigInteger.valueOf(_$number_long).multiply(fak_recursively(--_$number_long));
		}
	}

	public static double fall_stretch(double _$seconds_double) {
		double $g_double = 9.80665;
		return (($g_double * Math.pow(_$seconds_double, 2)) / (2));
	}

	public static long fibonacci(long _$number_long) {
		if (_$number_long > 1) {
			return fibonacci(--_$number_long) + fibonacci(--_$number_long);
		}else{
			if (_$number_long == 1) {
				return 1;
			}else{
				return 0;
			}
		}
	}

	public static long lcm(int _$number_1_int, int _$number_2_int) {
		List<Integer> $number_1_prime_array = primeFactorization(new ArrayList<Integer>(), _$number_1_int);
		List<Integer> $number_2_prime_array = primeFactorization(new ArrayList<Integer>(), _$number_2_int);
		List<Integer> $prime_factors_array = new ArrayList<Integer>();
		long $result_long = 1;
		for(final int $prime_factor : $number_1_prime_array) {
			if (!($prime_factors_array.contains($prime_factor))) {
				$prime_factors_array.add($prime_factor);
			}
		}
		for(final int $prime_factor : $number_2_prime_array) {
			if (!($prime_factors_array.contains($prime_factor))) {
				$prime_factors_array.add($prime_factor);
			}
		}
		for(final int $prime_factor_int : $prime_factors_array) {
			$result_long *= (long) Math.pow($prime_factor_int, primeFactor($prime_factor_int, $number_1_prime_array, $number_2_prime_array));
		}
		return $result_long;
	}

	public static int maximum(List<Integer> _$numbers_array) {
		int $temp_int = _$numbers_array.get(0);
		for(final int $number_int : _$numbers_array){
			if($temp_int < $number_int){
				$temp_int = $number_int;
			}
		}
		return $temp_int;
	}

	public static int minimum(List<Integer> _$numbers_array) {
		int $temp_int = _$numbers_array.get(0);
		for(final int $number_int : _$numbers_array){
			if($temp_int > $number_int){
				$temp_int = $number_int;
			}
		}
		return $temp_int;
	}

	public static int nullcheck(int _$number) throws Exception { // public damit die gui es auch benutzen kann
		if (_$number < 1) {
			throw new Exception("NICHT kleiner als 1 !");
		}
		return _$number;
	}

	private static int numberOfTheItem(List<Integer> _$number_array, int _$item) {
		int $number_item_int = 0;
		while(_$number_array.indexOf(_$item) > -1) {
			$number_item_int++;
			_$number_array.remove(_$number_array.indexOf(_$item));
		}
		return $number_item_int;
	}

	public static BigDecimal pi(long _$steps_long) {
		BigDecimal $pi_bigD = new BigDecimal(1);
		for(long $counter_long = 2; $counter_long <= _$steps_long; $counter_long = $counter_long + 2){
			$pi_bigD.multiply(new BigDecimal($counter_long).divide(new BigDecimal($counter_long - 1)).multiply(new BigDecimal($counter_long).divide(new BigDecimal($counter_long + 1))));
		}
		return $pi_bigD.multiply(new BigDecimal(2));
	}

	private static int primeFactor(int _$factors_int, List<Integer> _$number_1_array, List<Integer> _$number_2_array) {
		return Math.max(numberOfTheItem(_$number_1_array, _$factors_int),numberOfTheItem(_$number_2_array, _$factors_int));
	}

	private static List<Integer> primeFactorization(List<Integer> _$divisor_array, int _$number_int) {
		if ( _$number_int == 1) {
			return _$divisor_array;
		}else{
			for (int $divisor = 2; $divisor < _$number_int; $divisor++) {
				if ((_$number_int % $divisor) == 0) {
					_$divisor_array.add($divisor);
					return primeFactorization(_$divisor_array, _$number_int / $divisor);
				}
			}
			_$divisor_array.add(_$number_int); // dummer boolean return...
			return _$divisor_array;
		}
	}

	public static boolean primes_check_iteratively(int _$number_int){ // 3561 ms fuer 100.000 tests
		for(int $counter_int = 2; $counter_int < _$number_int; $counter_int++){
			if((_$number_int % $counter_int) == 0){
				return false;
			}
		}
		return true;
	}

	public static boolean primes_check_java(int _$number_int) { // 2821 ms fuer 100.000 tests
		BigInteger $number_biginteger = BigInteger.valueOf(_$number_int); // falls man den einfachen test verwenden darf.
		return $number_biginteger.isProbablePrime(100);
	}

	public static boolean primes_check_recursively(int _$possible_prime_int, int _$number_int){
		if (_$number_int <= 1) {
			return true;
		}else{
			if(_$possible_prime_int % _$number_int == 0) {
				return false;
			}else{
				return primes_check_recursively(_$possible_prime_int, --_$number_int);
			}
		}
	}

	public static List<Integer> primes_iteratively(int _$number_int, byte _$method_byte) {
		List<Integer> $result_array = new ArrayList<Integer>();
		for(int $counter_int = 2; $counter_int <= _$number_int; $counter_int++){
			switch (_$method_byte){
			case 1	:	{
							if(primes_check_iteratively($counter_int)){
								$result_array.add($counter_int);
							}
							break;
						}
			case 2	: 	{
							if(primes_check_recursively($counter_int, $counter_int - 1)){ // kein -- weil sonst sich $counter_int wieder verringert !
								$result_array.add($counter_int);
							}
							break;
						}
			case 3 	: 	{
							if(primes_check_java($counter_int)){
								$result_array.add($counter_int);
							}
							break;
						}
			}
		}
		return $result_array;
	}

	public static long square(int _$number_int) {
		if (_$number_int > 1){
			return (2 * _$number_int - 1) + square(--_$number_int);
		}else{
			if ( _$number_int == 1 ) {
				return 1;
			}else{
				return 0;
			}
		}
	}

	public static String string_filter(String _$input_string, List<Character> _$filter_array) { // geht evtl nicht da es warper objekte sind und nicht primitive datentypen !
		String $result_string = "";
		for(int $counter_int = 0; $counter_int < _$input_string.length(); $counter_int++) {
			if (_$filter_array.contains(_$input_string.charAt($counter_int))) {
				$result_string += String.valueOf(_$input_string.charAt($counter_int));
			}
		}
		return $result_string;
	}

	public static List<List<Integer>> table(int _$x_int, int _$y_int) {
		List<List<Integer>> $result_array = new ArrayList<List<Integer>>();
		for(int $y_axis_int = 1; $y_axis_int <= _$y_int; $y_axis_int++) {
			List<Integer> $line_array = new ArrayList<Integer>();
			for(int $x_axis_int = 1; $x_axis_int <= _$x_int; $x_axis_int++) {
				$line_array.add($y_axis_int * $x_axis_int);
			}
			$result_array.add($line_array);
		}
		return $result_array;
	}
	
	public static void file_writer(String _$line_string, String _$file_string) throws SecurityException, IOException {
		FileWriter $fileWriter = new FileWriter(_$file_string);
		BufferedWriter $bufferedWriter = new BufferedWriter($fileWriter);
		Scanner $line_scanner = new Scanner(_$line_string);
		String $line_string = "";		
		while($line_scanner.hasNextLine()) {
			$line_string = $line_scanner.nextLine();
//			while($line_string.indexOf("\\n") > -1) { // brauch man theoretisch nicht da man enter benutzen darf 
//				$bufferedWriter.write($line_string.substring(0, $line_string.indexOf("\\n")));
//				$bufferedWriter.newLine();
//				$line_string = $line_string.substring($line_string.indexOf("\\n") + 2);
//			} 
			$bufferedWriter.write($line_string);
			$bufferedWriter.newLine();
		}
		$bufferedWriter.close();
	}
	
	public static int word_counter(String _$word_string, String _$file_string) throws IOException, URISyntaxException {

		BufferedReader $bufferedReader = new BufferedReader(getFile(_$file_string));
		String $line_string = $bufferedReader.readLine();
		int $result_int = 0;

		while($line_string != null) {
			if($line_string.indexOf(_$word_string) > -1) {
				$result_int++;
//				System.out.println($line_string);
			}
			$line_string = $bufferedReader.readLine();
		}
		$bufferedReader.close();

		return $result_int;
	}
	
	private static InputStreamReader getFile(String _$file_string) throws IOException, URISyntaxException {
		URL $file_url = new URI(_$file_string).toURL();
		InputStream $inputStream = $file_url.openStream();
		InputStreamReader $inputStreamReader = new InputStreamReader($inputStream);
		return $inputStreamReader;
	}
}

 

[SlaterB]

schau dir folgendes Programm an, beachte die verwendeten Background-Farben statt Bilder

public class Test {
    public static void main(String[] args)     {
        new GUI();
    }
}

class GUI    extends JFrame {
    private final Container $container;

    public GUI()    {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(300, 300);
        this.$container = new JPanel();
        this.$container.setBackground(Color.BLUE);

        setContentPane($container);
        setGUI(new HelpGUI());
        setVisible(true);
    }

    private void setGUI(JComponent _$gui_JComponent)    {
        $container.removeAll();
        $container.setLayout(new BorderLayout());
        $container.add(BorderLayout.CENTER, _$gui_JComponent);
        validate();
    }

    protected class HelpGUI        extends JPanel    {
        public HelpGUI()     {
            setBackground(Color.GREEN);
            this.add(new JLabel("kjfhdsgfrfjlai"));
        }
    }
}

kommentiere testweise Zeile 24 aus und starte das Programm nochmal


vielleicht möchtest du
setOpaque(false);
im HelpGUI-Panel verwenden

 

[bognari]

Ah ok danke.
Hatte nicht mit gerechnet das er es einfach nur überlagert da ja nicht mal eine simple Ausgabe in der paintContent() ging.

Nun geht es aber wie es sollte mit der Transparenz.