Swing JLayeredPane - Wie JScrollPane einbauen?

[redbomber]

Hi zusammen,

wie in anderen Threads bereits besprochen, verwende ich eine JLayered Pane.
Zu dieser JLayeredPane kann ich verschiedene JPanels hinzufügen. Diese werden dann vertikal untereinander in die JLayeredPane hinzugefügt (-> und zwar in den JLayeredPane.DRAG_LAYER).

Wenn ich nun viele Panels hinzufüge landen die ja ausserhalb vom Fenster.
Also habe ich meine JLayeredPane in eine JScrollBar verpackt. Die JScrollBar wiederum ist in einem JPanel (meinem Fenster) verpackt.

Tja, aber die Scrollbar erscheint nicht, auch wenn die JPanels ausserhalb vom Fenster landen.

Wisst ihr wo hier bei mir der Fehler zu suchen ist?

 

[Marco13]

Wenn die Scrolldingens keine Scollbars anzeigt, dann ist der Grund dafür i.a., dass die enhaltenden Component (in diesem Fall, die LayeredPane) eine PreferredSize hat, die kleiner ist, als der Bereich der dargestellt werden kann.
Wie die PreferredSize einer JLayeredPane berechnet wird, weiß ich nicht auswendig - theoretisch könnte man alle darin enthaltenen Panels durchgehen, und von allen zusammen die "Bounding box" bestimmten... vielleicht weiß noch jemand was eleganteres...

 

[Ebenius]

Mach Dir eine eigene Ableitung von JLayeredPane die Scrollable richtig implementiert. Dann solltest Du automatisch (mit Hilfe der API-Doc) zu einem passenden Ergebnis kommen.

Ebenius

 

[redbomber]

ok, vielen Dank!

Aber die reihenfolge bei mit stimmt schon oder?

ALso in meiner Komponente befindet sich die JScrollBar und in dieser wiederum das JLayeredPane?

 

[Ebenius]

Meinst Du tatsächlich JScrollBar oder doch eher JScrollPane?

Ebenius

 

[redbomber]

Ich meinte die JScrollPane

 

[Ebenius]

Ich meinte die JScrollPane

In dem Fall stimmt Deine Reihenfolge, ja.

 

[redbomber]

Ich habe hierzu leider nochmal eine Frage:

Mein JLayeredPane implementiert Scrollable, wodurch ich also mehrere Methoden implementieren muss.

getPreferredScrollableViewportSize();
getScrollableUnitIncrement();
getScrollableBlockIncrement();
getScrollableTracksViewportWidth();
getScrollableTracksViewportHeight();

Wenn ich dieser JLayeredPane zusätzlich Panels hinzufüge, muss ich ja vermutlich irgend eine Größe setzen, wodurch meine JScrollPane mitbekommt, dass die Scrollbar aktiv werden soll.
Aber Aber diese Methoden die ich da oben implementieren kann wie werden diese aufgerufen?
Was muss meine JScrollPane aufrufen, damit sie diese Informationen erhält?

 

[Ebenius]

Ich bin mir nicht richtig sicher, was Deine Frage bedeutet. Deshalb hier mal ein einfaches Quelltext-Beispiel. getScrollableUnitIncrement() und getScrollableBlockIncrement() sollten natürlich noch verhübscht werden.

public class ScrollableLayeredPaneTest {

  static class JScrollableLayeredPane extends JLayeredPane
    implements Scrollable {

    private static int MAX_PREFERRED_SCROLLABLE_HEIGHT = 400;

    @Override
    public Dimension getPreferredSize() {
      final int count = getComponentCount();
      int w = 0;
      int h = 0;
      for (int i = 0; i < count; i++) {
        final Component c = getComponent(i);
        w = Math.max(w, c.getX() + c.getWidth());
        h = Math.max(h, c.getY() + c.getHeight());
      }
      final Insets insets = getInsets();
      return new Dimension(w + insets.right, h + insets.bottom);
    }

    public Dimension getPreferredScrollableViewportSize() {
      final Dimension dim = getPreferredSize();
      dim.height = Math.min(dim.height, MAX_PREFERRED_SCROLLABLE_HEIGHT);
      System.out.println(dim);
      return dim;
    }

    public boolean getScrollableTracksViewportWidth() {
      return true;
    }

    public boolean getScrollableTracksViewportHeight() {
      return false;
    }

    public int getScrollableUnitIncrement(
          Rectangle visibleRect,
          int orientation,
          int direction) {
      return direction < 0 ? -1 : 1;
    }

    public int getScrollableBlockIncrement(
          Rectangle visibleRect,
          int orientation,
          int direction) {
      return direction < 0 ? -10 : 10;
    }
  }

  /**
   * Test main method.
   * 
   * @param args ignore
   */
  public static void main(String[] args) {
    final JScrollableLayeredPane layeredPane = new JScrollableLayeredPane();

    final JPanel contentPane = new JPanel(new BorderLayout(6, 6));
    contentPane.add(new JScrollPane(layeredPane));
    final AbstractAction acn = new AbstractAction("Add Child Panel") {

      public void actionPerformed(ActionEvent e) {
        final JPanel child = new JPanel(new BorderLayout(6, 6));
        final int childCount = layeredPane.getComponentCount();
        final JLabel headLabel = new JLabel("Child " + (childCount + 1));
        child.add(headLabel, BorderLayout.PAGE_START);
        headLabel.setOpaque(true);
        headLabel.setBackground(Color.BLUE.darker());
        headLabel.setForeground(Color.WHITE);

        child.setSize(new Dimension(200, 150));
        child.setLocation(childCount * 30, childCount * 120);
        child.setBackground(Color.WHITE);
        child.setBorder(BorderFactory.createEtchedBorder());

        layeredPane.add(child, new Integer(childCount + 1));
        layeredPane.revalidate();
      }
    };
    contentPane.add(new JButton(acn), BorderLayout.PAGE_END);

    final JFrame f = new JFrame("Test Frame: ScrollableLayeredPaneTest");
    f.setContentPane(contentPane);
    f.pack();
    f.setSize(800, 400);
    f.setLocationRelativeTo(null);
    f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    f.setVisible(true);
  }
}

Ebenius

 

[redbomber]

Also erst einmal vielen Dank!
hat alles funktioniert. Jetzt hätte ich dazu aber noch eine weitere Frage:

Um die preferrefSize meiner JLayeredPane zu berechnen, führe ich die folgende Methode von dir aus. Nun würde ich gerne, dass meine JLayeredPane, MINIMAL so groß ist wie mein Fenster.
Zur Erinnerung: Meine JLayeredPane befindet sich in einer JScrollPane und diese wiederum in einem JPanel.

Indem ich unten in der Methode auf die JScrollPane zugreife fange ich mehr oder weniger die Größe des fensters ab und lege dadurch die Minimalgröße meiner JScrollPane fest. Aber irgendwie erscheint mir das als sehr unschön. Bzw, welche Größe von welcher Componente muss ich erfragen damit das stimmt?

public Dimension getPreferredSize() {
	final int count = getComponentCount();
	int w = 0;
	int h = 0;
	for (int i = 0; i < count; i++) {
		final Component c = getComponent(i);
		w = Math.max(w, c.getX() + c.getWidth());
		h = Math.max(h, c.getY() + c.getHeight());
	}
		
	final Insets insets = getInsets();

	PlotScrollPane scrollPane = chromeModel.getScrollPane();
		
	if(scrollPane != null){
		if(h < scrollPane.getVisibleRect().height){
			h = scrollPane.getVisibleRect().height - (scrollPane.getHorizontalScrollBar().getHeight()+1);
		}
			
		if(w < scrollPane.getVisibleRect().width){
			w = scrollPane.getVisibleRect().width-(scrollPane.getVerticalScrollBar().getWidth()+1);
		}
	}
		
	return new Dimension(w + insets.right, h + insets.bottom);
}

 

[Ebenius]

Vielleicht liegt es an dem Wein den ich im Laufe des Abends trank... Aber ich verstehe Dich nicht.

1. Wieso soll die JScrollPane MINIMAL so groß sein wie das Fenster? Sie kann doch gar nicht größer werden.
2. Die Berechnung ab Zeile 17 Deines letzten Quelltext-Ausschnitts basiert auf dem VisibleRect der JScrollPane warum? Das VisibleRect ist der angezeigte Bereich einer Komponente; in diesem Fall also die gesamte Komponente. Also wäre doch getBounds() das gleiche. Nicht, dass ich verstanden hätte, was Du genau bezweckst. Aber der Umstand an sich legt den Verdacht nahe, dass Du es auch nicht ganz verstanden hast...

Grüße,
Ebenius

 

[redbomber]

ja ich hab das auch nicht verstanden
Jetzt denke ich es aber verstanden zu haben, was ja auch logisch ist.
Klar meine ScrollPane ist so groß wie mein Fenster. Also bringts nichts davon die Größe abzufragen.

Ich möchte folgendes:
Meine JLayeredPane, soll im kleinsten Zustand (also ich kann meine Panels in der Breite zoomen) genau das Fenster ausfüllen, also es sollen keine ScrollBalken oder so angezeigt werden. Es soll einfach genau reinpassen.


Ich habe von allen Komponenten die Größen abgefragt und gesetzt, bin aber nie auf ein sauberes Ergebnis gekommen.

 

[Ebenius]

Meine JLayeredPane, soll im kleinsten Zustand (also ich kann meine Panels in der Breite zoomen) genau das Fenster ausfüllen, also es sollen keine ScrollBalken oder so angezeigt werden. Es soll einfach genau reinpassen.

Ich habe von allen Komponenten die Größen abgefragt und gesetzt, bin aber nie auf ein sauberes Ergebnis gekommen.

Jetzt habe ich eine Ahnung. Aber Dein Problem kann ich noch immer nicht richtig greifen.

Du hast eine JScrollPane. Auf dieser liegt ein JLayeredPane. Jetzt möchtest Du, die Größe des JLayeredPane verkleinern, damit es exakt die Größe des sichtbaren Bereichs der JScrollPane hat. Habe ich das richtig verstanden?

Ebenius

 

[redbomber]

Genau, also stell die vor in der JScrollPane ist meine JLayered Pane.
Jetzt kann ich mit der Maus zoomen, wodurch die JLayered Pane von der Breite her immer kleiner wird.
Theoretisch könnte ich die dann ja winzig machen.

Gerne hätte ich es aber so, daß diese JLayeredPane maximal so klein wird, dass sie komplett ins Fenster passt.

Um das zu erreichen habe ich einfach die Größe des Fensters abgefragt, in der sich die JScrollPane befindet.
Trotzdem war dann die JLayeredPane immer noch einen tick zu groß, so daß die ScrollPane ihren ScrollBalken anzeigen musste.

Das konnte ich dann auch beheben, aber dazu musste ich z.b. von der Höhe -10 Pixel abziehen.
Das fand ich unschön und wollte daher wissen ob dies die richtige Lösung sein kann?

 

[Ebenius]

Trotzdem war dann die JLayeredPane immer noch einen tick zu groß, so daß die ScrollPane ihren ScrollBalken anzeigen musste.

Das konnte ich dann auch beheben, aber dazu musste ich z.b. von der Höhe -10 Pixel abziehen.

Ah jetzt wird's klar. Natürlich muss der Wert kleiner sein als die Fenstergröße. Ein Fenster hat einen Rahmen und eine Titelzeile. Außerdem liegt die JLayeredPane ja nicht direkt auf dem Fenster. Sondern auf dem JViewport eines JScrollPane. Die JScrollPane braucht auch nochmal ein bisschen Platz für ihren Rahmen. Und -- je nach Look and Feel -- gibt's auch noch einen Rahmen auf dem JViewport. Du solltest also nicht die Größe des Fensters abfragen, sondern die Größe des Sichtfensters in der JScrollPane.

final Dimension minimumLayeredPaneSize = scrollPane.getViewport().getExtentSize();

Siehe JViewport.getExtentSize().

Hilft Dir das weiter? Auf jeden Fall kann ich Dir das Sun Java™ Tutorial: How to Use Scroll Panes ans Herz legen. Der Aufwand lohnt!

Ebenius

 

[redbomber]

ja vielen Dank!
Das hat mir weiter geholfen.
Und das Tutorial werde ich mir jetzt mal durchlesen...hatte gerade wieder etwas womit ich mich mit der JScrollPane herum geärgert habe.

 

[redbomber]

Ich habe hierzu leider nochmal ein paar Fragen:

1.
was bewirkt denn dieses private static int MAX_PREFERRED_SCROLLABLE_HEIGHT = 400; ?
Wenn ich die Werte verändere dann gibt es keine Änderung die ich bemerke.

2.
Ich habe das gleiche auch für den vertikalen Scrollbalken realisiert:

private static int MAX_PREFERRED_SCROLLABLE_HEIGHT = 0;
private static int MAX_PREFERRED_SCROLLABLE_WIDTH = 0;

public Dimension getPreferredScrollableViewportSize() {
		final Dimension dim = getPreferredSize();
		dim.height = Math.min(dim.height, MAX_PREFERRED_SCROLLABLE_HEIGHT);
		dim.width = Math.min(dim.width, MAX_PREFERRED_SCROLLABLE_WIDTH);
		return dim;
	}

	public boolean getScrollableTracksViewportWidth() {
		return false;
	}

	public boolean getScrollableTracksViewportHeight() {
		return false;
	}

	public int getScrollableUnitIncrement(Rectangle visibleRect,
			int orientation, int direction) {
		System.out.println(direction);
		return direction < 0 ? -1 : 1;
	}

	public int getScrollableBlockIncrement(Rectangle visibleRect,
			int orientation, int direction) {
		System.out.println(direction);
		return direction < 0 ? -10 : 10;
	}

Jetzt gibt es bei mir allerdings das Problem, wenn ich auf dem Scrollbalken nach OBEN oder nach LINKS klicke, dann bewegt sich der Scrollbalken trotzdem nach UNTEN bzw. nach RECHTS. getScrollableUnitIncrement() liefert mir aber je nachdem wohin ich klicke -1 bzw +1

 

[Ebenius]

1. was bewirkt denn dieses [...]?

private static int MAX_PREFERRED_SCROLLABLE_HEIGHT = 400;

Wenn ich die Werte verändere dann gibt es keine Änderung die ich bemerke.

Das hängt davon ab, wie Deine JScrollPane in der Kontainer-Hierarchie hängt. Wenn Du die Größenangaben über setPreferredSize(...) fest machst, dann hat das ganze keinen Einfluss. Anderenfalls würde

1. ein etwaiger LayoutManager des Kontainers auf dem die JScrollPane liegt die JScrollPane nach deren PreferredSize fragen,
2. diese würde feststellen, dass sie selbst keine eigene PreferredSize hat,
3. würde den Viewport nach dessen PreferredSize fragen,
4. dieser würde wiederum feststellen, dass er keine eigene PreferredSize hat,
5. der würde sich deshalb die View angucken und festellen: Die View implementiert Scrollable,
6. dann würde der Viewport die entsprechenden getPreferredScrollableViewportXXX()-Methoden aufrufen, um festzustellen, wie groß sich die View den Viewport wünscht,
7. die View wiederum würde zuerst nachsehen, wie groß sie eigentlich sein will und dann die gewünschte Größe beschränken auf die oben erwähnten Maximalwerte.

All das passiert aber nicht so, wenn

• die JScrollPane auf einem Kontainer liegt der nicht mit einem LayoutManager ausgelegt wird, oder
• die JScrollPane auf einem Kontainer liegt der einen LayoutManager hat, der sich für die PreferredSize der JScrollPane nicht interessiert, oder
• entsprechendes auf einem Elternkontainer des eben erwähnten Kontainers passiert, oder
• die JScrollPane eine eigene PreferredSize hat, oder
• der Viewport eine eigene PreferredSize hat.

Irgendwas davon trifft bestimmt bei Dir zu.

2. [...] wenn ich auf dem Scrollbalken nach OBEN oder nach LINKS klicke, dann bewegt sich der Scrollbalken trotzdem nach UNTEN bzw. nach RECHTS.

Sorry, das hab ich verwechselt. Das increment sollte für beide Richtungen positiv sein; die direction benötigt man für komplexere Berechnungen, wenn man zum Beispiel zum nächsten/vorhergehenden Kind, zur nächsten/vorhergehenden Zeile, etc. springen will. Hättest Du allerdings mal probieren können, wenn's Dir schon auffällt. :bae:

public int getScrollableUnitIncrement(
      Rectangle visibleRect,
      int orientation,
      int direction) {
  return 1;
}

public int getScrollableBlockIncrement(
      Rectangle visibleRect,
      int orientation,
      int direction) {
  return 10;
}

Ebenius