ContentArea und ToolbarsArea

I have downloaded DockingFrames and I am trying the tutorials to find out how I can use it for my private projects.

Momentarily, I am stuck with the following problem:
How can I Toolbars together with CDockables (i.e. principally a combination of the tutorials common/guide/CommonHelloWorld and ToolbarCommonHelloWorld) ? My status at this moment: if I add a CToolbarContentArea then the CContentArea disappears.

Ich habe DockingFrames heruntergeladen und probiere gerade mit den Tutorials um zu finden, wie ich etwas für meine privaten Projekte nützen kann.

Im Moment hänge ich ganz am Beginn bei folgendem Problem:
Wie kann ich Toolbars und CDockables zusammen nutzen (d.h. im Prinzip eine Kombination der Tutorials common/guide/CommonHelloWorld und ToolbarCommonHelloWorld) ? Mein Status im Moment: wenn ich eine CToolbarContentArea hinzufüge verschwindet die CContentArea.


Die CToolbarContentArea ersetzt die CContentArea, d.h. Du benötigst die „alte“ ContentArea nicht mehr (CToolbarContentArea ist eine Subklasse von CContentArea).

Falls du irgendwo die Methode CControl.getContentArea nutzt: diese Methode liefert dir das „falsche“ Objekt. Du musst dir die neue CToolbarContentArea selbst speichern).

Vielleicht hilft auch dieses Beispiel:

package tutorial.toolbar.common;

import java.awt.Color;

import javax.swing.Icon;
import javax.swing.JButton;

import bibliothek.gui.dock.ExpandableToolbarItemStrategy;
import bibliothek.gui.dock.common.CControl;
import bibliothek.gui.dock.common.CLocation;
import bibliothek.gui.dock.common.DefaultSingleCDockable;
import bibliothek.gui.dock.common.SingleCDockable;
import bibliothek.gui.dock.common.action.CButton;
import bibliothek.gui.dock.toolbar.CToolbarContentArea;
import bibliothek.gui.dock.toolbar.CToolbarItem;
import bibliothek.gui.dock.toolbar.expand.DefaultExpandableToolbarItemStrategy;
import bibliothek.gui.dock.toolbar.expand.ExpandedState;
import bibliothek.gui.dock.toolbar.location.CToolbarAreaLocation;

public class CommonHelloWorld {
	public static void newCodeForHlein( CControl control, CToolbarContentArea area ) {
		// using "base(area)" to create a location pointing to "area" ...
		SingleCDockable dockableLeft = new DefaultSingleCDockable( "left", "Hello World (left)" );
		control.addDockable( dockableLeft );
		dockableLeft.setLocation( CLocation.base(area).normal().west( 0.5 ) );
		dockableLeft.setVisible( true );

		// .. but we can use "base()" as well, because in our case the unique-id of "area" is equal to the default id "base".
		SingleCDockable dockableRight = new DefaultSingleCDockable( "right", "Hello World (right)" );
		control.addDockable( dockableRight );
		dockableRight.setLocation( CLocation.base().normal().east( 0.5 ) );
		dockableRight.setVisible( true );
		// without any location, new dockables appear at the top
		SingleCDockable dockableTop = new DefaultSingleCDockable( "top", "Hello World (top)" );
		control.addDockable( dockableTop );
		dockableTop.setVisible( true );
	public static void main( String[] args ){
		/* The toolbar extension can be used together with the Common project. The extension adds some new 
		 * CStations and CDockables to the framework. This example will show how to use them. */
		/* But before we start we need a frame and a CControl */
		JTutorialFrame frame = new JTutorialFrame( CommonHelloWorld.class );
		CControl control = new CControl( frame );
		frame.destroyOnClose( control );
		/* We are going to allow our toolbars to expand to different sizes. This feature needsd to be enabled
		 * by replacing the default ExpandableToolbarItemStrategz  */
		control.putProperty( ExpandableToolbarItemStrategy.STRATEGY, new DefaultExpandableToolbarItemStrategy() );

		/* Instead of a CContentArea we create a CToolbarContentArea. This class adds four CToolbarAreas around
		 * the five CStations that are usually shown by the CContentArea. */
		CToolbarContentArea area = new CToolbarContentArea( control, "base" );
		/* The new area needs to be registered at the CControl... */
		control.addStationContainer( area );
		/* ... and added to the frame */
		frame.add( area );

		/* We are going to add several buttons to toolbar, we'll use these icons to make the more visible. */
		Icon red = new ColorIcon( Color.RED );
		Icon green = new ColorIcon( Color.GREEN );
		Icon blue = new ColorIcon( Color.BLUE );
		Icon yellow = new ColorIcon( Color.YELLOW );

		/* In this example we add all our toolbars to the eastern side of the frame. To build up the layout
		 * we are going to use the "CDockable.setLocation" method, which requires an object of type CLocation.
		 * The CToolbarAreaLocation offers methods to build such a CLocation, we can obtain such a builder by
		 * just asking the eastern toolbar for it. */
		CToolbarAreaLocation location = area.getEastToolbar().getStationLocation();
		/* The toolbars build a tree, in order to place an item we need to traverse the tree and point to a leaf.
		 * 1. In our case there are four trees, one on each side of the frame. "location" represents the
		 *    root of the tree to the east.
		 * 2. Below the root is the group. A group usually has a black title, and orders its children
		 *    in several columns.
		 * 3. The group is built of actual toolbars.
		 * 4. And finally each toolbar is a set of items. */
		/* The first location points to the first group -> the first toolbar of the first column -> the first item.
		 * The next two locations point to the same toolbar but to the next items. */
		add( control, "A", red, 0 ).toolbar( 0, 0 ).item( 0 ) );
		add( control, "B", red, 0 ).toolbar( 0, 0 ).item( 1 ) );
		add( control, "C", red, 0 ).toolbar( 0, 0 ).item( 2 ) );
		/* The next three locations point to a new toolbar below the first one we added */
		add( control, "D", green, 0 ).toolbar( 0, 1 ).item( 0 ) );
		add( control, "E", green, 0 ).toolbar( 0, 1 ).item( 1 ) );
		add( control, "F", green, 0 ).toolbar( 0, 1 ).item( 2 ) );
		/* This location points to a toolbar that is above the first toolbar */
		add( control, "G", blue, 0 ).toolbar( 0, -1 ).item( 0 ) );
		/* The next three locations all point to the same toolbar as well. The first location points to 
		 * a toolbar that is left of all the existing toolbars. Since this action adds a new toolbar
		 * at position "0", the next two locations need to point to the first toolbar of the group. */
		add( control, "H", red, 0 ).toolbar( -1, 0 ).item( 0 ) );
		add( control, "I", red, 0 ).toolbar( 0, 0 ).item( 0 ) );
		add( control, "J", red, 0 ).toolbar( 0, 0 ).item( 0 ) );
		/* It is ok to create a location pointing to some strange places. While the framework cannot
		 * place the item at the desired location, it tries to place it as near as possible. */
		add( control, "K", green, 0 ).toolbar( 15, 16 ).item( 18 ) );
		/* Of course we can also point to another group, in this case we add a group before the
		 * one that contains all the other toolbars. */
		add( control, "L", blue, -1 ).toolbar( 0, 0 ).item( 0 ) );

		/* If we want to place an item near another item, we can make use of the "aside" method
		 * offered by CLocation. This method creates a new location "near" itself. */
		add( control, "M", yellow, get( control, "L" ).aside() );
		add( control, "N", yellow, get( control, "M" ).aside() );
		newCodeForHlein( control, area );
		frame.setBounds( 20, 20, 400, 400 );
		frame.setVisible( true );

	/* This method creates and adds a dockable to the application. */
	private static void add( CControl control, String id, Icon icon, CLocation location ){
		/* We need some text for the buttons */
		String text = id + id.toLowerCase() + id.toLowerCase() + id.toLowerCase(); 
		/* Creating the Dockable, and accessing its internal representation to make it look nicer. */
		CToolbarItem item = new CToolbarItem( id );
		item.intern().setTitleText( text );
		/* The content of the Dockable can be any CAction, in this case the action is the default content. */
		item.setItem( new CButton( null, icon ) );
		/* We can also show a normal Component, in this case the Component is only shown if the 
		 * expanded-state of the dockable is changed to "STRECHED" */
		item.setItem( new JButton( text, icon ), ExpandedState.STRETCHED );
		/* These are standard functions not related to the extension. */
		item.setLocation( location );
		control.addDockable( item );
		item.setVisible( true );
	/* This method gets the current location of the dockable with identifier "id" */
	private static CLocation get( CControl control, String id ){
		SingleCDockable dockable = control.getSingleDockable( id );
		return dockable.getBaseLocation();

Vielen Dank für die Antwort.

Ich habe mittlerweile auch CToolbarContentArea.getCenterArea() gefunden, was auch weiterhilft.

1 Like