bibliothek.gui.dock.common.perspective.CControlPerspectiveBlop Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of docking-frames-common Show documentation
Docking Frames Common legacy version used in openTCS
The newest version!
/*
 * Bibliothek - DockingFrames
 * Library built on Java/Swing, allows the user to "drag and drop"
 * panels containing any Swing-Component the developer likes to add.
 * 
 * Copyright (C) 2012 Benjamin Sigg
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Benjamin Sigg
 * [email protected]
 * CH - Switzerland
 */
package bibliothek.gui.dock.common.perspective;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import bibliothek.gui.dock.DockElement;
import bibliothek.gui.dock.common.CControl;
import bibliothek.gui.dock.common.intern.CSetting;
import bibliothek.gui.dock.common.intern.layout.CControlPerspectiveResource;
import bibliothek.gui.dock.frontend.SettingsBlop;
import bibliothek.gui.dock.support.util.ApplicationResourceManager;
import bibliothek.util.xml.XElement;
import bibliothek.util.xml.XException;

/**
 * A {@link CControlPerspectiveBlop} stores all the data a file contains that was writting
 * with {@link CControl#write(java.io.DataOutputStream)} or {@link CControl#writeXML(java.io.File)}. This
 * class allows clients to read and modify the layout files without actually loading any {@link DockElement}s.
 * @author Benjamin Sigg
 */
public class CControlPerspectiveBlop {
	/** offers factories necessary to read and write perspectives */
	private CControlPerspective control;
	
	/** stores data that cannot be interpreted by the perspective API  */
	private ApplicationResourceManager resourceManager = new ApplicationResourceManager();
	
	/** reads and writes the actual layout data */
	private CControlPerspectiveResource resource;
	
	public CControlPerspectiveBlop( CControlPerspective control ){
		if( control == null ){
			throw new IllegalArgumentException( "control must not be null" );
		}
		this.control = control;
		resource = new CControlPerspectiveResource( control );
		try {
			resourceManager.put( "ccontrol.frontend", resource );
		}
		catch( IOException e ) {
			throw new IllegalStateException( "This cannot happen", e );
		}
	}

	/**
	 * Gets the names of all {@link #getPerspective(String) perspectives} that are
	 * available.
	 * @return the name of the perspectives
	 */
	public String[] getPerspectiveNames(){
		return resource.getSettings().getNames();
	}
	
	/**
	 * Gets the raw data about the layout that is stored using name as key.
	 * @param name the key of the layout
	 * @return the raw data or null if name was not found
	 * @see #getPerspective(String)
	 */
	public CSetting getSetting( String name ){
		return (CSetting)resource.getSettings().getSetting( name );
	}
	
	/**
	 * Gets the perspective which was stored using name as key.
	 * @param name the key of the layout
	 * @return the perspective or null if name was not found
	 */
	public CPerspective getPerspective( String name ){
		CSetting setting = getSetting( name ); 
		if( setting == null ){
			return null;
		}
		return control.read( setting, false );
	}
	
	/**
	 * Stores a new layout for name.
	 * @param name the name of the layout, not null
	 * @param perspective the new layout, not null
	 */
	public void putPerspective( String name, CPerspective perspective ){
		if( name == null ){
			throw new IllegalArgumentException( "name must not be null" );
		}
		if( perspective == null ){
			throw new IllegalArgumentException( "perspective must not be null" );
		}
		CSetting setting = control.write( perspective, false );
		putSetting( name, setting );
	}
	
	/**
	 * Stores raw data of a layout with name name.
	 * @param name the name of the layout, not null
	 * @param setting the new layout, not null
	 * @see #putPerspective(String, CPerspective)
	 */
	public void putSetting( String name, CSetting setting ){
		resource.getSettings().put( name, setting );
	}
	
	/**
	 * Removes a layout from this blop.
	 * @param name the name of the layout to remove
	 */
	public void removePerspective( String name ){
		resource.getSettings().remove( name );
	}

	/**
	 * Gets the name of the layout that is currently shown.
	 * @return the name of the current layout, can be null
	 */
	public String getPerspectiveName(){
		return resource.getSettings().getCurrentName();
	}
	
	/**
	 * Sets the name of the current layout.
	 * @param name the name of the current layout, can be null
	 */
	public void setPerspectiveName( String name ){
		SettingsBlop blop = resource.getSettings();
		blop.setCurrent( name, blop.getCurrentSetting() );
	}
	
	/**
	 * Gets the current layout.
	 * @return the currently applied layout, may be null
	 */
	public CPerspective getPerspective(){
		CSetting setting = getSetting();
		if( setting == null ){
			return null;
		}
		return control.read( setting, true );
	}
	
	/**
	 * Gets the raw data of the current layout.
	 * @return the raw data
	 */
	public CSetting getSetting(){
		return (CSetting)resource.getSettings().getCurrentSetting();
	}
	
	/**
	 * Sets the layout that should be loaded.
	 * @param perspective the new layout, not null
	 */
	public void setPerspective( CPerspective perspective ){
		CSetting setting = control.write( perspective, true );
		setSetting( setting );
	}
	
	/**
	 * Sets the raw data of the layout that should be loaded.
	 * @param setting the new layout, not null
	 */
	public void setSetting( CSetting setting ){
		SettingsBlop blop = resource.getSettings();
		blop.setCurrent( blop.getCurrentName(), setting );
	}

    /**
     * Performs the same actions as {@link CControl#readXML(XElement)}, this method extracts all layouts of
     * an xml file.
     * @param root the root xml element in the file
     * @throws XException if the structure of root is not as expected
     */
    public void readXML( XElement root ) throws XException{
    	resourceManager.readXML( root );
    }

    /**
     * Performs the same actions as {@link CControl#read(DataInputStream)}, this method extracts all layouts of
     * a byte file.
     * @param in the stream to read from
     * @throws if the stream cannot be read
     */    
    public void read( DataInputStream in ) throws IOException{
    	resourceManager.readStream( in );
    }
    
    /**
     * Performs the same actions as {@link CControl#writeXML(java.io.File)}.
     * @param root the xml element to write into
     */
    public void writeXML( XElement root ){
    	resource.writeXML( root );
    }
    
    /**
     * Performs the same actions as {@link CControl#write(DataOutputStream)}
     * @param out the stream to write into
     * @throws IOException if the stream is not writeable
     */
    public void write( DataOutputStream out ) throws IOException{
    	resource.write( out );
    }
}