* Don't forget that this dockable MUST ALSO BE in the DOCKED state (added to the desktop
* in a split, tab or compound node) otherwise the missing restore information will cause
* unwanted behaviour, or exceptions.
*/
public void setMaximizedDockable(WSDockKey max){
this.maximizedDockable = max;
}
private SingleDockableNode getNode(WSDockKey key){
return (SingleDockableNode) nodesByKey.get(key);
}
/** Splits a dockable (with a given split location)
*
* @param base the dockable to be splitted
* @param newDockable the new dockable
* @param split the orientation of split
* @param splitLocation where the split divisor is (always relative from the top/left dockable, so
* split(a, b, SPLIT_TOP, 0.1f) and split(a, b, SPLIT_BOTTOM, 0.1f) have the same dividor location (somewhere near
* the top of the split).
*/
public void split(WSDockKey base, WSDockKey newDockable, DockingConstants.Split split, double splitLocation){
Node baseNode = getNode(base);
if (baseNode == null){
throw new IllegalArgumentException("base dockable not found " + base);
}
SplitNode splitNode = new SplitNode();
replaceChild(baseNode.parent, baseNode, splitNode);
switch(split.value()){
case DockingConstants.INT_SPLIT_TOP:
splitNode.setTop(new SingleDockableNode(newDockable));
splitNode.setBottom(baseNode);
splitNode.isHorizontal = false;
break;
case DockingConstants.INT_SPLIT_LEFT:
splitNode.setLeft(new SingleDockableNode(newDockable));
splitNode.setRight(baseNode);
splitNode.isHorizontal = true;
break;
case DockingConstants.INT_SPLIT_BOTTOM:
splitNode.setBottom(new SingleDockableNode(newDockable));
splitNode.setTop(baseNode);
splitNode.isHorizontal = false;
break;
case DockingConstants.INT_SPLIT_RIGHT:
splitNode.setRight(new SingleDockableNode(newDockable));
splitNode.setLeft(baseNode);
splitNode.isHorizontal = true;
break;
}
splitNode.location = splitLocation;
}
/** Creates a tab containing baseTab and newTab (if baseTab is already into a Tab, then
* newTab will just be added at the "order" position.
*/
public void createTab(WSDockKey baseTab, WSDockKey newTab, int order){
SingleDockableNode baseTabNode = getNode(baseTab);
if (baseTabNode == null){
throw new IllegalArgumentException("base dockable not found " + baseTab);
}
if (baseTabNode.parent instanceof TabNode){ // already in a tab
TabNode parent = (TabNode) baseTabNode.parent;
parent.addTab(order, new SingleDockableNode(newTab));
} else {
// replace parent by a tab
TabNode gParent = new TabNode();
replaceChild(baseTabNode.parent, baseTabNode, gParent);
gParent.addTab(0, baseTabNode);
gParent.addTab(order, new SingleDockableNode(newTab));
}
}
/** Adds a dockable into a compound dockable */
public void addDockable(WSDockKey compoundDockable, WSDockKey childDockable){
SingleDockableNode node = getNode(compoundDockable);
Node parent = node.parent;
CompoundDockableNode cnode = new CompoundDockableNode(compoundDockable);
replaceChild(parent, node, cnode);
cnode.setNestedNode(new SingleDockableNode(childDockable));
}
/** Adds a new dockable (and stores its return-to-docked position) */
public void addHiddenDockable(WSDockKey dockable, RelativeDockablePosition dockedPosition){
int zone;
if (dockable.getAutoHideBorder() == null) {
zone = AutoHidePolicy.getPolicy().getDefaultHideBorder().value();
} else {
zone = dockable.getAutoHideBorder().value();
}
ArrayList border = borders[zone];
border.add(new HiddenNode(new SingleDockableNode(dockable), dockedPosition));
}
/** Adds a new floating dockable
*
* @param dockable the dockable to add as floating
* @param windowRect rectangle defining the window (relative to screen) of the floating dockable
* @param returnPosition where to put the dockable when returning to the desktop
*
*/
public void setFloating(WSDockKey dockable, Rectangle windowRect, RelativeDockablePosition returnPosition){
FloatingNode f = new FloatingNode(new SingleDockableNode(dockable), windowRect, returnPosition);
floatingNodes.add(f);
}
/** Returns the name of this desktop (which must match the name of a real desktop if more than one desktops are used ) */
public String getDesktopName() {
return desktopName;
}
/** Updates the name of this workspace desktop */
public void setDesktopName(String name) {
this.desktopName = name;
}
/** Package method : used to encode this desktop into an XML stream */
void writeDesktopNode(PrintWriter out) {
out.println(" It is used to have a memory of grouped (tabbed) dockables in order to keep the
* group together when dockable are restored from auto-hide mode.
* This method is generally called by the tabbed container management, and not directly
* by the developper.
*
* However, there is a case where calling this method can be usefull :
* when, at startup, a desktop is built with multiple hidden dockables, and the developper wants
* them to be grouped in a tab container when they are restored to the desktop.
*
* @param base an already tabbed dockable
* @param newTab a dockable to add to the tab group
*
*@since 1.1.2
*/
public void addToTabbedGroup(WSDockKey base, WSDockKey newTab){
/* this method is called when a dockable is added to a dockableTabbedContainer */
LinkedList group = (LinkedList) tabbedGroups.get(base);
if (group == null){
group = new LinkedList();
group.add(base);
tabbedGroups.put(base, group);
}
group.add(newTab);
tabbedGroups.put(newTab, group);
}
// ------- inner classes used to handle dockable layout
/** abstract node into the layout */
private abstract class Node {
Node parent;
}
/** a node describing a tab */
private class TabNode extends Node {
ArrayList tabs = new ArrayList();
SingleDockableNode getTab(int index){
return (SingleDockableNode) tabs.get(index);
}
void addTab(int index, SingleDockableNode tab){
tabs.add(index, tab);
tab.parent = this;
}
private void replaceTab(int index, SingleDockableNode node) {
tabs.set(index, node);
node.parent = this;
}
}
/** a node containing a single dockable */
private class SingleDockableNode extends Node {
WSDockKey key;
SingleDockableNode(WSDockKey key){
this.key = key;
nodesByKey.put(key, this);
}
}
/** a single node that contains a whole dockable hierarchy */
private class CompoundDockableNode extends SingleDockableNode {
Node nestedNode;
CompoundDockableNode(WSDockKey key){
super(key);
}
void setNestedNode(Node nested){
nested.parent = this;
nestedNode = nested;
}
}
/** a node that represents a split */
private class SplitNode extends Node{
void setTop(Node node) {
this.left = node;
node.parent = this;
}
void setBottom(Node node) {
this.right = node;
node.parent = this;
}
void setLeft(Node node) {
this.left = node;
node.parent = this;
}
void setRight(Node node) {
this.right = node;
node.parent = this;
}
Node getTop(){
return left;
}
Node getBottom(){
return right;
}
Node getLeft(){
return left;
}
Node getRight(){
return right;
}
Node left, right;
private double location; // proportional location (0-1)
boolean isHorizontal;
}
/** a node describing a auto-hide dockable */
private class HiddenNode extends Node {
private SingleDockableNode node;
private RelativeDockablePosition position;
HiddenNode(SingleDockableNode node, RelativeDockablePosition position){
this.node = node;
node.parent = this;
this.position = position;
}
void setChild(SingleDockableNode child){
child.parent = this;
this.node = child;
}
}
/** used as root node for main and hidden hierarchies */
private class TopLevelNode extends Node {
Node child;
void setChild(Node child){
this.child = child;
child.parent = this;
}
}
/** top container for floating dockables */
private class FloatingNode extends Node {
private Node child;
private Rectangle windowRect;
private RelativeDockablePosition returnPosition;
FloatingNode(Node child, Rectangle windowRect, RelativeDockablePosition returnPosition){
this.windowRect = windowRect;
this.returnPosition = returnPosition;
setChild(child);
}
void setChild(Node child){
this.child = child;
child.parent = this;
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/ws/WSDockKey.java 0000644 0001750 0001750 00000013442 10573516350 025341 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking.ws;
import com.vlsolutions.swing.docking.DockingConstants;
/** Defines a key associated to a dockable in a workspace.
*
* The internal "key" will have to match the one of a DockKey when the
* worspace is applied to a DockingContext.
*
* example :
* if your application uses a dockable with DockKey k = new DockKey("testDockable");
* Design note : We use this class insted of DockKey because sometimes dockkeys are lazily
* created (at dockable creation) and thus aren't already available when specifying a
* workspace.
*
* @author Lilian Chamontin, VLSolutions
*/
public class WSDockKey {
private String key; // must match DockKey#key
private DockingConstants.Hide autoHideBorder;
public WSDockKey(String key) {
this.key = key;
}
public String toString(){
return key;
}
/** returns this object's hashcode */
public int hashCode(){
return key.hashCode();
}
public boolean equals(Object o){
if (o instanceof WSDockKey){
return key.equals(((WSDockKey)o).key);
}
return false;
}
/** returns the inner key of this object (which must match a DockKey's 'key' instance variable) */
public String getKey() {
return key;
}
/** Returns the autohide border of this dockable, or null if not set*/
public DockingConstants.Hide getAutoHideBorder(){
return autoHideBorder;
}
/** Updates the autohide border property */
public void setAutoHideBorder(DockingConstants.Hide border){
this.autoHideBorder = border;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/ws/Workspace.java 0000644 0001750 0001750 00000024637 10573516350 025504 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking.ws;
import com.vlsolutions.swing.docking.DockingContext;
import com.vlsolutions.swing.docking.DockingDesktop;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/** A logical organization of dockables. Used to define and save desktop layouts (xml loading in not supported yet).
*
* A Workspace is composed of WSDesktop elements (one per involved desktop).
*
* Each WSDesktop supports an API similar to the DockingDesktop (addDockable, split, createTab), where
* arguments are simple DockKeys (and not Dockables).
*
* Currently this version doesn't support dockable removal : you can create a workspace, but shouldn't alter its
* layout by moving already positionned dockables elsewhere (e.g. workspace will fail if you install a dockable
* on an auto-hide border, then add is as a docked tab later).
*
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1.2
*/
public class Workspace {
private ArrayList desktops = new ArrayList();
/** Creates a workspace with a single default WSDesktop */
public Workspace() {
desktops.add(new WSDesktop());
}
/** Removes the contained desktops */
public void clear(){
desktops.clear();
}
/** Adds a new desktop to this workspace */
public void addDesktop(WSDesktop desktop){
desktops.add(desktop);
}
/** Return the number of desktops contained in this workspace (default is 1 ) */
public int getDesktopCount(){
return desktops.size();
}
/** Returns the index-th desktop contained */
public WSDesktop getDesktop(int index){
return (WSDesktop) desktops.get(index);
}
/** Returns a desktop identified by its name or null if not found */
public WSDesktop getDesktop(String desktopName){
if (desktops.size() == 1){
return (WSDesktop) desktops.get(0);
}
for (int i=0; i < desktops.size(); i++){
WSDesktop d = (WSDesktop) desktops.get(i);
if (d.getDesktopName().equals(desktopName) ){
return d;
}
}
return null;
}
/** Applies this workspace to the given docking context (this is equivalent as loading a
* workspace file from DockingContext.readXML() : it removes every dockable from the context and
* associated desktops, and clears their dockable states, then it reloads the dockables as specified
* by this workspace layout.
*/
public void apply(DockingContext dockingContext) throws WorkspaceException {
ByteArrayOutputStream outb = new ByteArrayOutputStream();
PrintWriter out = new PrintWriter(outb);
out.println("");
out.println("
* The workspace is then ready to be applied or saved as a stream.
* @since 2.1.3
* @see #apply(DockingContext)
*/
public void loadFrom(DockingContext context) throws WorkspaceException{
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
context.writeXML(out);
out.close();
byte [] bytes = out.toByteArray();
//System.out.println(new String(bytes));
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
readXML(is);
is.close();
} catch (Exception e){
throw new WorkspaceException(e);
}
}
/** Saves the workspace layout into an XML stream.
*
* The workspace is composed of every desktop layouts associated
* with this workspace (desktops are identified by their 'desktopName' property).
*
*
* The stream is not closed at the end of the operation.
*
* @see #readXML(InputStream)
* */
public void writeXML(OutputStream stream) throws IOException {
PrintWriter out = new PrintWriter(stream);
out.println("");
out.println("
* Anchor is expressed as a bitwise OR between ANCHOR_ fields (for example ANCHOR_TOP|ANCHOR_LEFT)
*/
public int getAnchor() {
return anchor;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AnchorManager.java 0000644 0001750 0001750 00000043032 10573516346 025615 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockingActionAddDockableEvent;
import com.vlsolutions.swing.docking.event.DockingActionCreateTabEvent;
import com.vlsolutions.swing.docking.event.DockingActionEvent;
import com.vlsolutions.swing.docking.event.DockingActionListener;
import com.vlsolutions.swing.docking.event.DockingActionSplitComponentEvent;
import com.vlsolutions.swing.docking.event.DockingActionSplitDockableContainerEvent;
import com.vlsolutions.swing.docking.event.DockingActionSplitDockableEvent;
import java.awt.Component;
import java.awt.Container;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import javax.swing.JSplitPane;
/** A helper class used to specify and enforce constraints within a container
* (DockingPanel or CompoundDockingPanel).
*
* Constraints are currently defined as anchors (AnchorConstraints objects associated to Dockables).
*
* @author Lilian Chamontin, VLSolutions
* @see AnchorConstraints
* @since 2.1
*/
public class AnchorManager {
/** Top most ancestor container */
private Container container;
/** Map of AnchorConstraints (value) associated to Dockables (key) */
private HashMap constraintsByDockable = new HashMap();
/** Context where docking action events are listened to */
private DockingContext context;
/** Appropriate reaction upon docking actions (vetoing the ones that would break constraints) */
private DockingActionListener actionListener = new DockingActionListener() {
public boolean acceptDockingAction(DockingActionEvent event) {
switch (event.getActionType()){
case DockingActionEvent.ACTION_ADD_DOCKABLE:{
DockingActionAddDockableEvent e = (DockingActionAddDockableEvent) event;
return acceptAddDockable(e);
}
case DockingActionEvent.ACTION_CREATE_TAB:{
DockingActionCreateTabEvent e = (DockingActionCreateTabEvent) event;
return acceptCreateTab(e);
}
case DockingActionEvent.ACTION_SPLIT_COMPONENT:{
DockingActionSplitComponentEvent e = (DockingActionSplitComponentEvent) event;
return acceptSplitComponent(e);
}
case DockingActionEvent.ACTION_SPLIT_DOCKABLE: {
DockingActionSplitDockableEvent e = (DockingActionSplitDockableEvent) event;
return acceptSplitDockable(e);
}
case DockingActionEvent.ACTION_SPLIT_DOCKABLE_CONTAINER:{
DockingActionSplitDockableContainerEvent e = (DockingActionSplitDockableContainerEvent) event;
return acceptSplitDockableContainer(e);
}
default :
return true; // accepting everything else
}
}
public void dockingActionPerformed(DockingActionEvent event) {
}
};
/** Constructs a new AnchorManager responsible for a container (desktop or compound)
*
* @param context the context (can be taken from DockingDesktop.getDockingContext() used by this manager
* @param container the "top level" container managed (usually a DockingDesktop or a CompoundDockingPanel)
*/
public AnchorManager(DockingContext context, Container container) {
this.context = context;
this.container = container;
context.addDockingActionListener(actionListener);
}
/** Cleanup for this manager : removes references and listeners */
public void clear(){
context.removeDockingActionListener(actionListener);
constraintsByDockable.clear();
}
/** Associates an anchor constraints to a given dockable
* @param dockable the dockable to anchor
* @param constraints associated anchor constraints
*/
public void putDockableContraints(Dockable dockable, AnchorConstraints constraints){
constraintsByDockable.put(dockable, constraints);
}
/** Returns the anchor constraints associated to a given dockable
* @param dockable the dockable to anchor
* @return the constraints for this dockable, or null if no constraints is associated
*/
public AnchorConstraints getDockableConstraints(Dockable dockable){
return (AnchorConstraints) constraintsByDockable.get(dockable);
}
/** Removes an anchor constraints to a given dockable
* @param dockable the dockable whose anchor is to be removed
*/
public AnchorConstraints removeDockableConstraints(Dockable dockable){
return (AnchorConstraints) constraintsByDockable.remove(dockable);
}
/** Look up the spilt hierarchy to find which borders a dockable is touching.
*
*/
private int getContactBorders(Dockable dockable){
return RelativeDockingUtilities.findAnchors(dockable.getComponent(), container);
}
/** Returns a list of all dockables contained into base
*/
private ArrayList findDockables(Container base){
ArrayList dockables = new ArrayList(10);
Iterator it = constraintsByDockable.keySet().iterator();
while (it.hasNext()){
Dockable d = (Dockable) it.next();
if (base.isAncestorOf(d.getComponent())){
dockables.add(d);
}
}
return dockables;
}
private boolean acceptSplitComponent(DockingActionSplitComponentEvent event ){
Component base = event.getBase();
ArrayList baseDockables = findDockables((Container)base);
// we suppose that dockables in "base" are ok (respecting their own set of constraints before the split)
// we still have to check is splitting will break a constraint or not
int contactBorders = RelativeDockingUtilities.findAnchors(base, container);
switch (event.getSplitPosition().value()){
case DockingConstants.INT_SPLIT_TOP:
// as we won't be touching TOP anymore, check if this
// constraint is not set in contained dockables
if (isConstraintSet(AnchorConstraints.ANCHOR_TOP, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_BOTTOM;
break;
case DockingConstants.INT_SPLIT_LEFT:
if (isConstraintSet(AnchorConstraints.ANCHOR_LEFT, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_RIGHT;
break;
case DockingConstants.INT_SPLIT_BOTTOM:
if (isConstraintSet(AnchorConstraints.ANCHOR_BOTTOM, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_TOP;
break;
case DockingConstants.INT_SPLIT_RIGHT:
if (isConstraintSet(AnchorConstraints.ANCHOR_RIGHT, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_LEFT;
break;
}
// now, we're sure we won't break a 'base' constraint
// we have to check if the moved dockable will respect its own constraints
AnchorConstraints acDockable = getDockableConstraints(event.getDockable());
if (acDockable != null){
int anchor = acDockable.getAnchor();
if ((anchor & contactBorders) != anchor){ // anchor is not respected
return false;
}
}
return true;
}
private boolean acceptSplitDockable(DockingActionSplitDockableEvent event ){
// two rules to enforce :
// the added component must respect its own set of constraints
// the base dockable, once the new component added, must also respect its own set of constraints
Dockable base = event.getBase();
AnchorConstraints acBase = getDockableConstraints(base);
int contactBorders = getContactBorders(base);
switch (event.getSplitPosition().value()){
case DockingConstants.INT_SPLIT_TOP:
// as we won't be touching TOP anymore, check if this
// constraint is not set in contained dockables
if (isConstraintSet(AnchorConstraints.ANCHOR_TOP, base)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_BOTTOM;
break;
case DockingConstants.INT_SPLIT_LEFT:
if (isConstraintSet(AnchorConstraints.ANCHOR_LEFT, base)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_RIGHT;
break;
case DockingConstants.INT_SPLIT_BOTTOM:
if (isConstraintSet(AnchorConstraints.ANCHOR_BOTTOM, base)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_TOP;
break;
case DockingConstants.INT_SPLIT_RIGHT:
if (isConstraintSet(AnchorConstraints.ANCHOR_RIGHT, base)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_LEFT;
break;
}
// now, we're sure we won't break a 'base' constraint
// we have to check if the moved dockable will respect its own constraints
AnchorConstraints acDockable = getDockableConstraints(event.getDockable());
if (acDockable != null){
int anchor = acDockable.getAnchor();
if ((anchor & contactBorders) != anchor){ // anchor is not respected
return false;
}
}
return true;
}
private boolean acceptSplitDockableContainer(DockingActionSplitDockableContainerEvent event ){
Component base = event.getBase();
ArrayList baseDockables = findDockables((Container)base);
// we suppose that dockables in "base" are ok (respecting their own set of constraints before the split)
// we still have to check is splitting will break a constraint or not
int contactBorders = RelativeDockingUtilities.findAnchors(base, container);
switch (event.getSplitPosition().value()){
case DockingConstants.INT_SPLIT_TOP:
// as we won't be touching TOP anymore, check if this
// constraint is not set in contained dockables
if (isConstraintSet(AnchorConstraints.ANCHOR_TOP, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_BOTTOM;
break;
case DockingConstants.INT_SPLIT_LEFT:
if (isConstraintSet(AnchorConstraints.ANCHOR_LEFT, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_RIGHT;
break;
case DockingConstants.INT_SPLIT_BOTTOM:
if (isConstraintSet(AnchorConstraints.ANCHOR_BOTTOM, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_TOP;
break;
case DockingConstants.INT_SPLIT_RIGHT:
if (isConstraintSet(AnchorConstraints.ANCHOR_RIGHT, baseDockables)){
return false;
}
contactBorders = contactBorders & ~AnchorConstraints.ANCHOR_LEFT;
break;
}
// now, we're sure we won't break a 'base' constraint
// we have to check if the moved dockable container will respect its own constraints
if (event.getDockableContainer() instanceof TabbedDockableContainer){
// the only one managed currently (drag gesture : move a whole tabbed pane around)
ArrayList containersDockables = findDockables(event.getDockableContainer());
// check if these dockable have constraints
for (int i=0; i < containersDockables.size(); i++){
Dockable d = (Dockable) containersDockables.get(i);
AnchorConstraints acDockable = getDockableConstraints(d);
if (acDockable != null){
int anchor = acDockable.getAnchor();
if ((anchor & contactBorders) != anchor){ // anchor is not respected
return false;
}
}
}
}
return true;
}
private boolean acceptAddDockable(DockingActionAddDockableEvent event ){
Container parent = event.getParentContainer();
int contactBorders = RelativeDockingUtilities.findAnchors(parent, container);
Dockable d = event.getDockable();
AnchorConstraints acDockable = getDockableConstraints(d);
if (acDockable != null){
int anchor = acDockable.getAnchor();
if ((anchor & contactBorders) != anchor){ // anchor is not respected
return false;
}
}
return true;
}
private boolean acceptCreateTab(DockingActionCreateTabEvent event ){
int contactBorders = getContactBorders(event.getBase());
Dockable d = event.getDockable();
AnchorConstraints acDockable = getDockableConstraints(d);
if (acDockable != null){
int anchor = acDockable.getAnchor();
if ((anchor & contactBorders) != anchor){ // anchor is not respected
return false;
}
}
return true;
}
/** checks if a given anchor is set into one of the given dockables*/
private boolean isConstraintSet(int anchor, ArrayList baseDockables) {
for (int i=0; i < baseDockables.size(); i++){
AnchorConstraints ac = (AnchorConstraints) constraintsByDockable.get(baseDockables.get(i));
if (ac != null){ // 2007/01/08
if ((ac.getAnchor() & anchor) > 0){
return true;
}
}
}
return false;
}
/** checks if a given anchor is set for a dockable*/
private boolean isConstraintSet(int anchor, Dockable dockable) {
AnchorConstraints ac = (AnchorConstraints) constraintsByDockable.get(dockable);
if (ac == null){ //2007/01/08
return false;
}
if ((ac.getAnchor() & anchor) > 0){
return true;
}
return false;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AutoHideBorderLayout.java 0000644 0001750 0001750 00000017642 10573516346 027156 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.util.*;
import java.awt.*;
/** A Layout Manager for auto-hide borders.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class AutoHideBorderLayout implements LayoutManager2{
private ArrayList components = new ArrayList();
private boolean isHorizontal;
private int gap; // gap in pixels between components
/** Constructs a new Layout.
*
* @param isHorizontal indicates if the layout will be horizontal or vertical.
*
* */
public AutoHideBorderLayout(boolean isHorizontal) {
this(isHorizontal, AutoHidePolicy.getPolicy().getDefaultGap());
/** @todo we do not yet listen to gap property change */
}
/** Constructs a new Layout.
* @param isHorizontal indicates if the layout will be horizontal or vertical.
* @param gap gap in pixels between components
* */
public AutoHideBorderLayout(boolean isHorizontal, int gap) {
this.isHorizontal = isHorizontal;
this.gap = gap;
}
public float getLayoutAlignmentX(Container target) {
return 0.5F;
}
public float getLayoutAlignmentY(Container target) {
return 0.5F;
}
public void invalidateLayout(Container target) {
}
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints == null){
components.add(comp);
} else {
Integer i = (Integer) constraints;
components.add(i.intValue(), comp);
}
}
public void removeLayoutComponent(Component comp) {
components.remove(comp);
}
public void addLayoutComponent(String name, Component comp) {
}
public Dimension minimumLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int visible = 0;
for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
Dimension d = comp.getPreferredSize();
if (comp.isVisible()){
visible ++;
if (isHorizontal) {
dim.width += d.width;
dim.height = Math.max(dim.height, d.height);
} else {
dim.width = Math.max(dim.width, d.width);
dim.height += d.height;
}
}
}
// add the gap between components
if (isHorizontal) {
dim.width += (visible - 1) * gap;
} else {
dim.height += (visible - 1) * gap;
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
public Dimension preferredLayoutSize(Container parent) {
return minimumLayoutSize(parent);
}
/** overridden to adjust position (x(top) = width(left), y(left) = height(top)
*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int top = insets.top;
int left = insets.left;
if (isHorizontal){
for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
left += d.width + gap;
}
}
} else {
for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
top += d.height + gap;
}
}
}
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AutoHideButton.java 0000644 0001750 0001750 00000024030 10573516346 026003 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.event.ActionEvent;
import java.awt.Font;
import java.awt.event.MouseListener;
import java.awt.event.ActionListener;
import java.awt.Component;
import java.awt.Insets;
import java.awt.Graphics2D;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.FontMetrics;
import java.awt.Color;
import java.beans.*;
/** The button used to show Dockables in auto-hide borders.
*
* This component displays the label, tooltip and icon properties of a
*
* Values are : AutoHideButtonPanel.TOP, AutoHideButtonPanel.LEFT,
* AutoHideButtonPanel.BOTTOM, AutoHideButtonPanel.RIGHT
*/
public int getBorderZone(){
return border;
}
/** Adds a new AutoHideButton.
* */
public void add(AutoHideButton btn){
add((Component)btn);
btn.addMouseListener(buttonHighlighter);
btn.addMouseListener(expandPanel.getControler());
}
/** Removes an AutoHideButton */
public void remove(AutoHideButton btn){
super.remove(btn);
btn.removeMouseListener(buttonHighlighter);
}
private class ButtonHighlighter extends MouseAdapter {
Color highlight = UIManager.getColor("controlLtHighlight");
public void mouseEntered(MouseEvent e){
AutoHideButton btn = (AutoHideButton) e.getSource();
if (! btn.isSelected()){ // selected buttons have their own pain style
btn.setBackground(highlight);
btn.setOpaque(true);
btn.repaint();
}
}
public void mouseExited(MouseEvent e){
AutoHideButton btn = (AutoHideButton) e.getSource();
if (! btn.isSelected()){ // selected buttons have their own pain style
btn.setOpaque(false);
btn.repaint();
}
}
}
public String getUIClassID() {
return uiClassID;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AutoHideExpandPanel.java 0000644 0001750 0001750 00000117362 10573516346 026742 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.beans.*;
import java.awt.event.*;
import java.lang.reflect.InvocationTargetException;
import javax.swing.*;
import java.awt.*;
import java.util.HashMap;
import com.vlsolutions.swing.docking.animation.ComponentAnimator;
import com.vlsolutions.swing.docking.animation.*;
import java.lang.reflect.Method;
import javax.swing.border.*;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
/** A component used to show the currently expanded view.
*
* Auto-Hide / Auto-Expand feature is a means to save space of screen replacing
* a Dockable by a Button on one of the Desktop borders.
* When the user clicks on the button or his mouse rolls over it, the component
* is shown (with an expansion animation) as if it was coming from behind the button's
* border.
*
* @author Lilian Chamontin, vlsolutions.
* @version 2.0
* @update 2005/10/06 Lilian Chamontin : protected access to the exansion timer that might be
* null when AutoHidePolicy is EXPAND_ON_CLICK
* @update 2005/11/01 Lilian Chamontin : enhanced timer management to auto-collaspe the panel
* when mouse out of bounds
* @update 2005/12/08 Lilian Chamontin : updated the order of component insertion for JDIC support.
* @update 2006/12/19 Lilian Chamontin : fixed a memory leak issue.
* @update 2007/01/08 Lilian Chamontin : updated to use the new titlebar factory method
*
* */
public class AutoHideExpandPanel extends JPanel implements SingleDockableContainer {
public static final String uiClassID = "AutoHideExpandPanelUI";
/** Constant for the Expanded property (a bound property) */
public static final String PROPERTY_EXPANDED = "AutoHideExpanded";
private Timer expansionTimer;
private boolean isRolloverTimer = false;
private boolean isExpanding = false;
// true during animation phase, will be used to avoid concurrent animations (@todo)
private HashMap savedDimensions = new HashMap(); // Component/Dimension
ExpandControler controler = new ExpandControler(); // hide event listener
private AutoHideButton selectedButton;
private Component expandedComponent; // current component
DockingDesktop desk;
private JPanel topDragger = getTopDragger(); // indirection because those components are used by the ui delegate
private JPanel leftDragger = getLeftDragger();
private JPanel bottomDragger = getBottomDragger();
private JPanel rightDragger = getRightDragger();
private JPanel lastDragger; // last used dragger
private JPanel content = new JPanel(new BorderLayout()); // content displayed (user component)
private Panel heavyPanel; // used only when mixing lightweight and heavyweight components
private DockViewTitleBar titleBar = createTitleBar();
private AnimationControler animationControler = new AnimationControler();
private Border expandFromTopBorder, expandFromLeftBorder, expandFromBottomBorder,
expandFromRightBorder;
/** this boolean is used to disable auto-hiding temporarily, especially during
* drag operation (where mouse can leave the component) */
private boolean shouldCollapse = true;
/** flag used when heavywieght usage + single heavyweight component */
private boolean isHeavyPanelInstalled = false;
/** Used by the collapse timer*/
private long lastTimeMouseWasIn = 0;
private boolean canUseMouseInfo = DockingUtilities.canUseMouseInfo();
private FocusCollapser collapser = new FocusCollapser(); // 2006/12/19
/** Timer used to collapse the expand panel (when mouse is out of bounds).
* (only for java > 1.5)
*/
private javax.swing.Timer collapseTimer // 2005/11/01
= new javax.swing.Timer(250, new ActionListener() {
// timer used to hide the expanded panel when mouse is out too long
public void actionPerformed(ActionEvent actionEvent) {
// all this mess to allow compilation from java 1.4
Point mouseLocation = DockingUtilities.getMouseLocation();
if (mouseLocation == null){
return;
}
Point p = new Point();
SwingUtilities.convertPointToScreen(p, AutoHideExpandPanel.this);
Rectangle expandPanelBounds = new Rectangle(p.x, p.y, getWidth(), getHeight());
if (expandPanelBounds.contains(mouseLocation)){
// we're inside the expand panel
lastTimeMouseWasIn = System.currentTimeMillis();
} else {
// not inside the component : check also into its associated button
Point btnPoint = new Point();//selectedButton.getX(),selectedButton.getY());
SwingUtilities.convertPointToScreen(btnPoint, selectedButton);
Rectangle btnRect = new Rectangle(btnPoint.x, btnPoint.y, selectedButton.getWidth(), selectedButton.getHeight());
if (btnRect.contains(mouseLocation)){
lastTimeMouseWasIn = System.currentTimeMillis();
} else {
if (System.currentTimeMillis() - lastTimeMouseWasIn > 1000 ){
// it's time to collapse
if (!isActive() && shouldCollapse()) {
// do not hide it if it has got the focus
// or if a non-collapsible operation is occuring
if (selectedButton != null){
collapse();
}
}
}
}
}
}
});
public AutoHideExpandPanel() {
super(new BorderLayout());
if (!DockingPreferences.isLightWeightUsageEnabled()){
this.heavyPanel = new Panel(new BorderLayout());
}
if (AutoHidePolicy.getPolicy().getExpandMode() ==
AutoHidePolicy.EXPAND_ON_ROLLOVER) {
expansionTimer = new Timer(AutoHidePolicy.getPolicy().
getRolloverTriggerDelay(), controler);
expansionTimer.setRepeats(false);
isRolloverTimer = true;
}
initBorders();
setFocusCycleRoot(true); // keep keyboard focus
//requiered to trap mouse events under the panel (so they don't go to the mousegrabber)
addMouseListener(new MouseAdapter(){
});
if (DockingPreferences.isLightWeightUsageEnabled()){
// for Swing only : direct usage of the content jpanel
add(content, BorderLayout.CENTER);
} else {
if (!DockingPreferences.isSingleHeavyWeightComponent()){
// when mixing heavyweight and lightweight component, we have
// to ensure our content will not be covered by an underlying heavy component.
// to do this, we add an intermediary heavyweight panel.
// note : if there is only one heavyweight dockable,
// we delay and delegate this operation to installHeavyWeightIfNeeded
heavyPanel.add(content, BorderLayout.CENTER);
// jdk1.5 only, but we compile with 1.4 source level
try {
// this.setComponentZOrder(heavyPanel, 0); // top most
Method m = Container.class.getMethod("setComponentZOrder", new Class[]{
Component.class, int.class});
m.invoke(this, new Object[]{heavyPanel, new Integer(0)});
} catch (Exception ignore){
}
add(heavyPanel, BorderLayout.CENTER);
} else {
// (heavy + single) will be dynamically changed depending on the expanded dockable
add(content, BorderLayout.CENTER);
add(topDragger, BorderLayout.NORTH);
add(bottomDragger, BorderLayout.SOUTH);
add(leftDragger, BorderLayout.WEST);
add(rightDragger, BorderLayout.EAST);
}
}
addAncestorListener(new AncestorListener() { //2006/12/19 : reworked to avoid GC leak
public void ancestorAdded(AncestorEvent event) {
AutoHidePolicy.getPolicy().addPropertyChangeListener(controler);
if (DockingPreferences.isLightWeightUsageEnabled()){
KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(
"focusOwner", collapser);
}
}
public void ancestorMoved(AncestorEvent event) {
}
public void ancestorRemoved(AncestorEvent event) {
AutoHidePolicy.getPolicy().removePropertyChangeListener(controler);
if (DockingPreferences.isLightWeightUsageEnabled()){
KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(
"focusOwner", collapser);
}
}
});
content.add(titleBar, BorderLayout.NORTH);
// initDockingFunctions();
}
private void installHeavyWeightParentIfNeeded(Dockable target){
if (DockingPreferences.isLightWeightUsageEnabled()){
return; // not needed as we are in pure lightweight
}
if (!DockingPreferences.isSingleHeavyWeightComponent()){
return; // not possible as there are multiple heavyweight
}
if (DockingUtilities.isHeavyWeightComponent(target.getComponent())){
// no need to install the heavypanel
if (isHeavyPanelInstalled){
// we even have to remove it
this.removeAll();
this.add(content, BorderLayout.CENTER);
add(topDragger, BorderLayout.NORTH);
add(bottomDragger, BorderLayout.SOUTH);
add(leftDragger, BorderLayout.WEST);
add(rightDragger, BorderLayout.EAST);
revalidate();
isHeavyPanelInstalled = false;
}
} else {
if (isHeavyPanelInstalled){
// nothing more to do, content is already inside heavypanel
} else {
this.removeAll();
this.add(heavyPanel, BorderLayout.CENTER);
heavyPanel.add(content, BorderLayout.CENTER);
heavyPanel.add(topDragger, BorderLayout.NORTH);
heavyPanel.add(bottomDragger, BorderLayout.SOUTH);
heavyPanel.add(leftDragger, BorderLayout.WEST);
heavyPanel.add(rightDragger, BorderLayout.EAST);
isHeavyPanelInstalled = true;
revalidate();
// jdk1.5 only, but we compile with 1.4 source level
try {
// this.setComponentZOrder(heavyPanel, 0); // top most
Method m = Container.class.getMethod("setComponentZOrder", new Class[]{
Component.class, int.class});
m.invoke(this, new Object[]{heavyPanel, new Integer(0)});
} catch (Exception ignore){
}
}
}
}
public boolean isOptimizedDrawingEnabled(){
return DockingPreferences.isLightWeightUsageEnabled();
// only when lightweight components (to ensure correct zorder for AWT)
}
/** Returns true if this panel is the ancestor of the focused component */
public boolean isActive() {
if (titleBar.isActive()){
return true;
} else {
// since 2.1 : the autohide component can contain a nested set of dockables, so the
// titlebar's activity isn't always usable : we have to verify if the focus is still
// inside
Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
if (focusOwner == null){
return false;
} else {
return isAncestorOf(focusOwner);
}
}
//return titleBar.isActive();
}
/** Returns true if this panel agrees to beeing hidden.
*
* During drag operations (resizing), some mouseEnter/mouseExit events
* can be lost. In that case, the desktop relies on this method to
* request collaping or not.
* */
public boolean shouldCollapse(){
return shouldCollapse;
}
/** Returns the component used to modify the expand panel size when expanded from the bottom */
public JPanel getTopDragger(){
/* This method is used by the UI to install proper borders */
if (topDragger == null){
topDragger = new JPanel();
}
return topDragger;
}
/** Returns the component used to modify the expand panel size when expanded from the right */
public JPanel getLeftDragger(){
/* This method is used by the UI to install proper borders */
if (leftDragger == null){
leftDragger = new JPanel();
}
return leftDragger;
}
/** Returns the component used to modify the expand panel size when expanded from the top */
public JPanel getBottomDragger(){
/* This method is used by the UI to install proper borders */
if (bottomDragger == null){
bottomDragger = new JPanel();
}
return bottomDragger;
}
/** Returns the component used to modify the expand panel size when expanded from the right */
public JPanel getRightDragger(){
/* This method is used by the UI to install proper borders */
if (rightDragger == null){
rightDragger = new JPanel();
}
return rightDragger;
}
/** creates the shared title bar for all expanded panels */
protected DockViewTitleBar createTitleBar(){
return DockableContainerFactory.getFactory().createTitleBar(); //2007/01/08
//return new DockViewTitleBar();
}
public DockViewTitleBar getTitleBar(){
return this.titleBar;
}
/** Creates the default borders for the expand panel */
public void resetBorders(){
Color shadow = UIManager.getColor("controlShadow");
Color highlight = UIManager.getColor("controlLtHighlight");
getTopDragger().setBorder(BorderFactory.createMatteBorder(1, 1, 0, 1, shadow));
getLeftDragger().setBorder(BorderFactory.createMatteBorder(1, 1, 1, 0, shadow));
getBottomDragger().setBorder(BorderFactory.createMatteBorder(0, 1, 1, 1, shadow));
getRightDragger().setBorder(BorderFactory.createMatteBorder(1, 0, 1, 1, shadow));
expandFromTopBorder = BorderFactory.createCompoundBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(1, 1, 0, 1, shadow),
BorderFactory.createMatteBorder(1, 1, 1, 0, highlight)),
BorderFactory.createEmptyBorder(2, 2, 2, 2)
);
expandFromLeftBorder = BorderFactory.createCompoundBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(1, 1, 1, 0, shadow),
BorderFactory.createMatteBorder(1, 1, 1, 1, highlight)),
BorderFactory.createEmptyBorder(2, 2, 2, 2)
);
expandFromBottomBorder = BorderFactory.createCompoundBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(0, 1, 1, 1, shadow),
BorderFactory.createMatteBorder(1, 1, 1, 1, highlight)),
BorderFactory.createEmptyBorder(2, 2, 2, 2)
);
expandFromRightBorder = BorderFactory.createCompoundBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(1, 0, 1, 1, shadow),
BorderFactory.createMatteBorder(1, 1, 1, 1, highlight)),
BorderFactory.createEmptyBorder(2, 2, 2, 2)
);
}
/** Installs borders used to drag the expand panel around */
protected void initBorders(){
Dimension min = new Dimension(4, 4);
topDragger.setVisible(false);
topDragger.setPreferredSize(min);
topDragger.setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));
DragListener topListener = new DragListener(DockingConstants.INT_HIDE_BOTTOM);
topDragger.addMouseMotionListener(topListener);
topDragger.addMouseListener(topListener);
leftDragger.setVisible(false);
leftDragger.setPreferredSize(min);
leftDragger.setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));
DragListener leftListener = new DragListener(DockingConstants.INT_HIDE_RIGHT);
leftDragger.addMouseMotionListener(leftListener);
leftDragger.addMouseListener(leftListener);
bottomDragger.setVisible(false);
bottomDragger.setPreferredSize(min);
bottomDragger.setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));
DragListener bottomListener = new DragListener(DockingConstants.INT_HIDE_TOP);
bottomDragger.addMouseMotionListener(bottomListener);
bottomDragger.addMouseListener(bottomListener);
rightDragger.setVisible(false);
rightDragger.setPreferredSize(min);
rightDragger.setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));
DragListener rightListener = new DragListener(DockingConstants.INT_HIDE_LEFT);
rightDragger.addMouseMotionListener(rightListener);
rightDragger.addMouseListener(rightListener);
if (DockingPreferences.isLightWeightUsageEnabled()){
add(topDragger, BorderLayout.NORTH);
add(bottomDragger, BorderLayout.SOUTH);
add(leftDragger, BorderLayout.WEST);
add(rightDragger, BorderLayout.EAST);
} else {
if(!DockingPreferences.isSingleHeavyWeightComponent()){
heavyPanel.add(topDragger, BorderLayout.NORTH);
heavyPanel.add(bottomDragger, BorderLayout.SOUTH);
heavyPanel.add(leftDragger, BorderLayout.WEST);
heavyPanel.add(rightDragger, BorderLayout.EAST);
}
}
}
private void initDockingFunctions(){
PropertyChangeListener listener = new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_AUTOHIDE)) {
// from autohide to dock
// remember values after autohide
Dockable d = selectedButton.getDockable();
desk.setAutoHide(d, false);
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_CLOSED)) {
Dockable d = selectedButton.getDockable();
collapse();
desk.close(d);
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_DRAGGED)){
// the user is starting a drag gesture : we must collapse !
collapse();
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_FLOAT)){
Dockable d = selectedButton.getDockable();
collapse();
desk.setFloating(d, true);
}
}
};
titleBar.addPropertyChangeListener(DockViewTitleBar.PROPERTY_AUTOHIDE, listener);
titleBar.addPropertyChangeListener(DockViewTitleBar.PROPERTY_CLOSED, listener);
titleBar.addPropertyChangeListener(DockViewTitleBar.PROPERTY_DRAGGED, listener);
titleBar.addPropertyChangeListener(DockViewTitleBar.PROPERTY_FLOAT, listener);
titleBar.installDocking(desk);
desk.installDockableDragSource(titleBar);
}
/** Returns the component responsible for managing auto-expansion.
* */
/* package protected */ ExpandControler getControler() {
return controler;
}
/** Selects a button (may collapse a prevoiusly selected button) */
public void select(AutoHideButton btn){
if (selectedButton != null && selectedButton != btn){
collapse();
}
selectedButton = btn;
btn.setSelected(true);
}
private void restartCollapseTimer(){
// if (!DockingPreferences.isLightWeightUsageEnabled()){
if (canUseMouseInfo){ // not for 1.4
this.lastTimeMouseWasIn = System.currentTimeMillis();
collapseTimer.restart();
}
}
private void stopCollapseTimer(){
// if (!DockingPreferences.isLightWeightUsageEnabled()){
if (canUseMouseInfo){ // not for 1.4
collapseTimer.stop();
}
}
/** Expands the currently selected button */
public void expand(){
if (selectedButton == null){
return;//2007/01/10
//throw new IllegalStateException("No button selected for expansion");
}
installComponent();
restartCollapseTimer();
setVisible(true);
Rectangle bounds = desk.getBounds();
Dimension bestDimension = (Dimension)savedDimensions.get(selectedButton);
if (bestDimension == null) {
bestDimension = selectedButton.getDockable().getComponent().getPreferredSize();
switch (selectedButton.getZone()) {
case DockingConstants.INT_HIDE_TOP:
case DockingConstants.INT_HIDE_BOTTOM:
if (bestDimension.height > bounds.height / 2) {
bestDimension.height = bounds.height / 2;
}
break;
case DockingConstants.INT_HIDE_LEFT:
case DockingConstants.INT_HIDE_RIGHT:
if (bestDimension.width > bounds.width / 2) {
bestDimension.width = bounds.width / 2;
}
break;
}
}
// outer insets (including autohide borders)
Insets i = desk.getDockingPanelInsets();
// inner insets (of expandPanel : mouse grabbers etc..)
Insets i2 = getComponentInsets();
switch (selectedButton.getZone()) {
case DockingConstants.INT_HIDE_TOP:
new ComponentAnimator(this,
new Rectangle(i.left,
i.top,
bounds.width - i.left - i.right, 0),
new Rectangle(i.left,
i.top,
bounds.width - i.left - i.right,
bestDimension.height + i2.top + i2.bottom),
AutoHidePolicy.getPolicy().getExpansionDuration()/1000f,
animationControler);
break;
case DockingConstants.INT_HIDE_BOTTOM:
new ComponentAnimator(this,
new Rectangle(i.left,
bounds.height - i.bottom,
bounds.width - i.left - i.right, 0),
new Rectangle(i.left,
bounds.height - bestDimension.height - i.bottom - i2.top - i2.bottom,
bounds.width - i.left - i.right,
bestDimension.height +i2.top + i2.bottom),
AutoHidePolicy.getPolicy().getExpansionDuration()/1000f,
animationControler);
break;
case DockingConstants.INT_HIDE_LEFT:
new ComponentAnimator(this,
new Rectangle(i.left,
i.top,
0, bounds.height - i.top - i.bottom),
new Rectangle(i.left,
i.top,
bestDimension.width + i2.left + i2.right ,
bounds.height - i.top - i.bottom),
AutoHidePolicy.getPolicy().getExpansionDuration()/1000f,
animationControler);
break;
case DockingConstants.INT_HIDE_RIGHT:
new ComponentAnimator(this,
new Rectangle(bounds.width - i.right,
i.top,
0, bounds.height - i.top - i.bottom),
new Rectangle(bounds.width - bestDimension.width - i.right - i2.left - i2.right,
i.top,
bestDimension.width +i2.left + i2.right,
bounds.height - i.top - i.bottom),
AutoHidePolicy.getPolicy().getExpansionDuration()/1000f,
animationControler);
break;
default : assert false;
}
firePropertyChange(PROPERTY_EXPANDED, false, true);
}
/** Removes a dockable (if it was the currently expanded one) */
public void remove(Dockable dockable){
Component comp = dockable.getComponent();
if (expandedComponent != null && expandedComponent == comp) {
content.remove(expandedComponent);
expandedComponent = null;
}
}
private void installComponent(){
final Component comp = selectedButton.getDockable().getComponent();
if (expandedComponent != null){
if (expandedComponent != comp){
content.remove(expandedComponent);
content.add(comp, BorderLayout.CENTER); //2005/12/08 back again in this order (JDIC workaround)
installHeavyWeightParentIfNeeded(selectedButton.getDockable());
expandedComponent = comp;
}
} else {
content.add(comp, BorderLayout.CENTER);
installHeavyWeightParentIfNeeded(selectedButton.getDockable());
expandedComponent = comp;
}
/* // the workaround isn't needed anymore : we use the heavyweightTimer instead
if (!DockingPreferences.isLightWeightUsageEnabled()){
// this is a workaround : mouse listener doesn't work properly
// on AWT components (they grab the event even if they are 'under'
// our mouse grabber.
SwingUtilities.invokeLater(new Runnable(){
public void run(){
// heavyPanel.requestFocus();
comp.requestFocus();
}
// by requesting focus, we can rely on the safer focusOwner property
// and use it to collapse thi panel (see FocusCollapser code below)
});
}*/
titleBar.setDockable(selectedButton.getDockable());
desk.installDockableDragSource(titleBar);
switch (selectedButton.getZone()) {
case DockingConstants.INT_HIDE_TOP:
content.setBorder(expandFromTopBorder);
bottomDragger.setVisible(true);
// remove previous border
if (lastDragger != null && lastDragger != bottomDragger) {
lastDragger.setVisible(false);
}
lastDragger = bottomDragger;
break;
case DockingConstants.INT_HIDE_BOTTOM:
content.setBorder(expandFromBottomBorder);
topDragger.setVisible(true);
if (lastDragger != null && lastDragger != topDragger) {
lastDragger.setVisible(false);
}
lastDragger = topDragger;
break;
case DockingConstants.INT_HIDE_LEFT:
content.setBorder(expandFromLeftBorder);
rightDragger.setVisible(true);
if (lastDragger != null && lastDragger != rightDragger) {
lastDragger.setVisible(false);
}
lastDragger = rightDragger;
break;
case DockingConstants.INT_HIDE_RIGHT:
content.setBorder(expandFromRightBorder);
leftDragger.setVisible(true);
if (lastDragger != null && lastDragger != leftDragger) {
lastDragger.setVisible(false);
}
lastDragger = leftDragger;
break;
default : assert false;
}
revalidate();
repaint();
}
/** Calculates the insets needed around the center component.
* This is the sum of border sizes and bordercomponents sizes.
* */
private Insets getComponentInsets(){
Insets i = getInsets(); // borders
Insets i2 = content.getInsets();
i.top += i2.top;
i.left += i2.left;
i.bottom += i2.bottom;
i.right += i2.right;
if (topDragger.isVisible()){
i.top += topDragger.getHeight();
}
i.top += titleBar.getHeight();
if (leftDragger.isVisible()){
i.left += leftDragger.getWidth();
}
if (bottomDragger.isVisible()){
i.bottom += bottomDragger.getHeight();
}
if (rightDragger.isVisible()){
i.right += rightDragger.getWidth();
}
return i;
}
/** Collapse the expand panel (making it unvisible) */
public void collapse() {
if (selectedButton != null){
savedDimensions.put(selectedButton, selectedButton.getDockable().getComponent().getSize());
selectedButton.setSelected(false);
firePropertyChange(PROPERTY_EXPANDED, true, false);
}
selectedButton = null;
setVisible(false);
titleBar.closePopUp();
stopCollapseTimer();
if (!DockingPreferences.isLightWeightUsageEnabled()){
// we'd better repaint (ugly traces on linux)
desk.repaint();
}
}
public void uninstallDocking(DockingDesktop desktop) {
titleBar.uninstallDocking(desk);
}
public void installDocking(DockingDesktop desktop) {
this.desk = desktop;
initDockingFunctions();
}
public Dockable getDockable() {
if (selectedButton != null){
return selectedButton.getDockable();
} else {
return null;
}
}
public String getUIClassID() {
return uiClassID;
}
/** Clears the state of this expand panel.
*
* This is useful when re-installing a desktop from readXml (for example,
* it resets dockable expand sizes)
*/
public void clear(){
// clear
savedDimensions.clear();
}
/** inner class that follows animations of expansion */
private class AnimationControler implements AnimationListener {
public void animation(AnimationEvent e) {
isExpanding = e.getState() != AnimationEvent.ANIMATION_END;
if (e.getState() == AnimationEvent.ANIMATION_END){
SwingUtilities.invokeLater(new Runnable(){
public void run(){
content.repaint();
}
});
}
}
}
/** This class hides expansion implementation from API */
private class ExpandControler implements MouseListener, ActionListener, PropertyChangeListener{
/* temporary button : the next to be selected after a mouseEntered event and
* triggered timer delay. */
private AutoHideButton mouseEnteredButton;
/** used to avoid bad interactions between focus listeners and expand controler */
private boolean isUnderControl = false;
public void mouseClicked(MouseEvent e) {
// don't do anything during animation phase
if (!isExpanding){
if (expansionTimer != null){ //2005/10/06
expansionTimer.stop();
}
AutoHideButton clicked = (AutoHideButton) e.getSource();
if (selectedButton != clicked) {
// we need to tell the focus listener not to manage focus while
// this operation is occuring
isUnderControl = true;
select(clicked); // will trigger a focus change is DockingPreferences.isHeavuWeight
SwingUtilities.invokeLater(new Runnable(){
public void run(){
expand();
isUnderControl = false;
}
});
} else {
collapse();
}
}
}
public void mouseEntered(MouseEvent e) {
if (! isRolloverTimer) return;
AutoHideButton btn = (AutoHideButton) e.getSource();
if (! btn.isSelected()){ // nothing more to do if selected
if (expansionTimer != null){
expansionTimer.restart(); // 2005/10/06
}
mouseEnteredButton = btn;
}
}
public void mouseExited(MouseEvent e) {
if (! isRolloverTimer) return;
AutoHideButton btn = (AutoHideButton) e.getSource();
if (! btn.isSelected()){ // nothing more to do if selected
expansionTimer.stop();
mouseEnteredButton = null;
}
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public void propertyChange(PropertyChangeEvent e) {
/* triggered by autohide policy change*/
if (e.getPropertyName().equals(AutoHidePolicy.PROPERTY_EXPAND_MODE)) {
if (AutoHidePolicy.getPolicy().getExpandMode() ==
AutoHidePolicy.EXPAND_ON_ROLLOVER) {
expansionTimer = new Timer(AutoHidePolicy.getPolicy().
getRolloverTriggerDelay(), this);
isRolloverTimer = true;
} else {
expansionTimer.stop();
expansionTimer = null;
isRolloverTimer = false;
}
} else if (e.getPropertyName().equals(AutoHidePolicy.
PROPERTY_ROLLOVER_TRIGGER_DELAY)) {
if (AutoHidePolicy.getPolicy().getExpandMode() ==
AutoHidePolicy.EXPAND_ON_ROLLOVER) {
expansionTimer.setDelay(
AutoHidePolicy.getPolicy().getRolloverTriggerDelay());
}
}
}
public void actionPerformed(ActionEvent e) {
// timer event : there is a button to expand
assert mouseEnteredButton != null;
isUnderControl = true;
select(mouseEnteredButton); // will collapse the previous button
SwingUtilities.invokeLater(new Runnable(){
public void run(){
expand();
isUnderControl = false;
}
});
}
}
private class DragListener implements MouseListener, MouseMotionListener{
/* inner class of expand panel*/
int zone;
DragListener(int zone){
this.zone = zone;
}
public void mouseDragged(MouseEvent e) {
/* implement the drag effect on expand panel : a single border
* can be dragged (the one not overlapping the borders of the panel
*/
// new height/width (including borders)
int newHeight, newWidth;
// where are we on the desk ?
Point p = SwingUtilities.convertPoint( (Component) e.getSource(),
e.getPoint(), desk);
Insets insets = getInsets();
Insets idesk = desk.getDockingPanelInsets();
switch (zone) {
case DockingConstants.INT_HIDE_TOP:
// drag from top to bottom : change the height of the panel
newHeight = p.y - idesk.top + bottomDragger.getHeight()/2 +
insets.bottom + insets.top;
newHeight = Math.max(10, Math.min(newHeight, desk.getHeight())) ; // clip
setSize(getWidth(), newHeight);
invalidate();
validate();
repaint();
break;
case DockingConstants.INT_HIDE_BOTTOM:
newHeight = desk.getHeight() - idesk.bottom - p.y
+ topDragger.getHeight()/2 +insets.top + insets.bottom;
int maxHeight = desk.getHeight() -
topDragger.getHeight();
if (newHeight > maxHeight) {
newHeight = maxHeight;
} else if (newHeight < 10) {
newHeight = 10;
}
Rectangle bounds = getBounds();
bounds.y = desk.getHeight() - idesk.bottom - newHeight;
bounds.height = newHeight;
setBounds(bounds);
invalidate();
validate();
repaint();
break;
case DockingConstants.INT_HIDE_LEFT:
newWidth = p.x + rightDragger.getWidth()/2 - idesk.left +
insets.right + insets.left;
int maxWidth = desk.getWidth() - rightDragger.getWidth();
if (newWidth > maxWidth) {
newWidth = maxWidth;
} else if (newWidth < 10) {
newWidth = 10;
}
setSize(newWidth,getHeight());
invalidate();
validate();
repaint();
break;
case DockingConstants.INT_HIDE_RIGHT:
newWidth = desk.getWidth()- idesk.right - p.x
+ leftDragger.getWidth()/2
+ insets.left + insets.right;
maxWidth = desk.getWidth() - leftDragger.getWidth();
if (newWidth > maxWidth) {
newWidth = maxWidth;
} else if (newWidth < 10) {
newWidth = 10;
}
bounds = getBounds();
bounds.x = desk.getWidth() - idesk.right - newWidth;
bounds.width = newWidth;
setBounds(bounds);
invalidate();
validate();
repaint();
break;
}
desk.repaint();
}
public void mouseMoved(MouseEvent e) {}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {
shouldCollapse = false; // begining or drag
}
public void mouseReleased(MouseEvent e) {
shouldCollapse = true; // end of drag
}
}
private class FocusCollapser implements PropertyChangeListener {
// focusOwner
public void propertyChange(PropertyChangeEvent e) {
if (!controler.isUnderControl){
// this is not a focus lost due to the expand controler
Component c = (Component) e.getNewValue();
if (c != null && !AutoHideExpandPanel.this.isAncestorOf(c)) {
// avoid collapsing when focus is given to a component which isn't a dockable
if (DockingUtilities.findSingleDockableContainerAncestor(c) != null){
collapse();
}
}
}
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AutoHidePolicy.java 0000644 0001750 0001750 00000022252 10573516346 025773 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.beans.*;
/** This class holds preferences on default autohiding behaviour.
*
* @see AutoHideButtonPanel
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class AutoHidePolicy {
/** A constant for expanding a button on rollover */
public static final int EXPAND_ON_ROLLOVER = 0;
/** A constant for expanding a button on click */
public static final int EXPAND_ON_CLICK = 1;
/** a constant designing the bound property DEFAULT_HIDE_BORDER */
public static final String PROPERTY_DEFAULT_HIDE_BORDER = "defaultHideBorder";
/** a constant designing the bound property DEFAULT_GAP */
public static final String PROPERTY_DEFAULT_GAP = "defaultGap";
/** a constant designing the bound property EXPAND_MODE */
public static final String PROPERTY_EXPAND_MODE = "expandMode";
/** a constant designing the bound property ROLLOVER_TRIGGER_DELAY */
public static final String PROPERTY_ROLLOVER_TRIGGER_DELAY = "rolloverTriggerDelay";
/** a constant designing the bound property EXPANSION_DURATION */
public static final String PROPERTY_EXPANSION_DURATION = "expansionDuration";
private static AutoHidePolicy policy = new AutoHidePolicy();
/** where do we put the button at startup */
private DockingConstants.Hide defaultHideBorder = DockingConstants.HIDE_LEFT;
/** pixels between two buttons */
private int defaultGap = 4;
private int expandMode; // rollover / click
private int rolloverTriggerDelay = 500; // wait before expansion (only for expandMode==ROLLOVER)
private int expansionDuration = 300; // millis
private PropertyChangeSupport propertySupport = new PropertyChangeSupport(this);
private AutoHidePolicy() {
}
/** Updates the default hide border.
*
* Default is AutoHideExpandPanel.LEFT;
*
* @param defaultHideBorder values taken from DockingConstants.HIDE_TOP, HIDE_LEFT, HIDE_BOTTOM, HIDE_RIGHT
* */
public void setDefaultHideBorder(DockingConstants.Hide defaultHideBorder){
DockingConstants.Hide old = this.defaultHideBorder;
this.defaultHideBorder = defaultHideBorder;
propertySupport.firePropertyChange(PROPERTY_DEFAULT_HIDE_BORDER, old, defaultHideBorder);
}
/** Returns the default hide border (used when not specified in a DockKey)*/
public DockingConstants.Hide getDefaultHideBorder(){
return defaultHideBorder;
}
/** Returns the default gap between border components */
public int getDefaultGap(){
return defaultGap;
}
/** Updates the gap (in pixels) between auto-hide buttons*/
public void setDefaultGap(int gap){
int old = this.defaultGap;
this.defaultGap = gap;
propertySupport.firePropertyChange(PROPERTY_DEFAULT_GAP, old, gap);
}
/** Returns the singleton instance of this class */
public static AutoHidePolicy getPolicy(){
return policy;
}
/** Returns the expand mode in use.
* @return EXPAND_ON_ROLLOVER or EXPAND_ON_CLICK
* */
public int getExpandMode(){
return expandMode;
}
/** Updates the expand mode.
* @param expandMode legal values are EXPAND_ON_ROLLOVER or EXPAND_ON_CLICK
* */
public void setExpandMode(int expandMode){
int old = this.expandMode;
this.expandMode = expandMode;
propertySupport.firePropertyChange(PROPERTY_EXPAND_MODE, old, expandMode);
}
/** Returns the rollover trigger delay (in millis)
*
* */
public int getRolloverTriggerDelay(){
return rolloverTriggerDelay;
}
/** Updates the rollover trigger delay
* @param delay delay in millis before expanding a Dockable
*/
public void setRolloverTriggerDelay(int delay){
int old = this.rolloverTriggerDelay;
this.rolloverTriggerDelay = delay;
propertySupport.firePropertyChange(PROPERTY_ROLLOVER_TRIGGER_DELAY, old, delay);
}
/** Returns the expansion duration (in millis) */
public int getExpansionDuration(){
return expansionDuration;
}
/** Updates the expansion duration (time in millis) */
public void setExpansionDuration(int millis){
int old = expansionDuration;
this.expansionDuration = millis;
propertySupport.firePropertyChange(PROPERTY_EXPANSION_DURATION, old, millis);
}
/** Hook for property change notification */
public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
/** Hook for property change notification */
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(propertyName, listener);
}
/** Remove a property change notification */
public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
/** Remove a property change notification */
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(propertyName, listener);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/BorderSplitter.java 0000644 0001750 0001750 00000030400 10573516346 026047 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import java.awt.geom.Rectangle2D;
import java.awt.*;
import com.vlsolutions.swing.docking.event.*;
/** An utility class used to delegate the border drag/drop scanning for docking (
* since the same code is used in many DockDropReceivers).
*
* This class is only meant for API Extenders.
*
* Taking a DockDragEvent or DockDropEvent, check if mouse is near of one border.
* If so, accepts the drag or drop operation.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/10/21 Lilian Chamontin : updated the shape to show real size of drop (and not 20 pixeles width/height)
* @update 2005/11/14 Lilian Chamontin : added support for drag and drop of a whole tabbed container
* @update 2005/12/08 Lilian Chamontin : fixed a bug when dropping into itself
*/
public class BorderSplitter {
Component delegator;
public BorderSplitter(Component delegator) {
this.delegator = delegator;
}
public void processDockableDrag(DockDragEvent e){
scanDrop(e, false);
}
public void processDockableDrop(DockDropEvent e){
scanDrop(e, true);
}
/** This method should be overriden if the delegator doesn't belong to the
* docking containment hierarchy after drop acceptance.
* Here is a case :
*
* Then, tabpane will be replaced by a simple DockableContainer on drop acceptance
* (because only one tab left).
*
* And DockingDesktop.splitContainer(Component base, Split position) cannot be
* called with tabpane as "base" (instead, it should be called with the replacer of
* tabpane, or use the other split method which takes a dockable as base.
*
*
* */
public void split(DockDropEvent event, Container draggedContainer, DockingConstants.Split position){
/* standard splitting */
// event.getDesktop().splitComponent(delegator, event.getDragSource().getDockable(),
// position);
event.getDesktop().splitComponent(delegator, draggedContainer, position); //2005/11/14
}
private void acceptSplit(DockDropEvent event, DockingConstants.Split position){
Container container = event.getDragSource().getDockableContainer();
Dockable dockable = event.getDragSource().getDockable();//2005/12/08
TabbedDockableContainer tabAncestor = DockingUtilities.findTabbedDockableContainer(dockable);
( (DockDropEvent) event).acceptDrop();
if (container instanceof TabbedDockableContainer){
split(event, container, position);
} else {
if (tabAncestor != null && tabAncestor.getTabCount() == 1 && tabAncestor == delegator){
// we have detected a dropping onto itself :
// the drop gesture comes from the tabAncestor (as it's given by the drag source)
// and translates into a border split
// if only one tab remains, that means the tabAncestor is no longer useful and
// so we now need to remove that tab and replace it by a standard singledockable
// which is done by the standard desktop "split" public method.
Dockable remainingDockable = tabAncestor.getDockableAt(0);
event.getDesktop().split(
remainingDockable, // the only remaining dockable
dockable,
position);
} else {
// standard dropping, just use the internal API to relayout the desktop.
event.getDesktop().splitComponent(delegator, dockable, position);
}
}
}
/** Accept the drag gesture and setup the docking action event associated to it */
private void acceptDragSplit(DockDragEvent event, DockingConstants.Split position, Shape shape){
Container container = event.getDragSource().getDockableContainer();
Dockable dockable = event.getDragSource().getDockable();//2005/12/08
TabbedDockableContainer tabAncestor = DockingUtilities.findTabbedDockableContainer(dockable);
int initialState = dockable.getDockKey().getDockableState();
int borderSpliterState = DockingUtilities.getDockableStateFromHierarchy(delegator);
if (container instanceof TabbedDockableContainer){
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, initialState, borderSpliterState, container, position, 0.5f));
} else {
if (tabAncestor != null && tabAncestor.getTabCount() == 1 && tabAncestor == delegator){
// we have detected a dropping onto itself :
// the drop gesture comes from the tabAncestor (as it's given by the drag source)
// and translates into a border split
// if only one tab remains, that means the tabAncestor is no longer useful and
// so we now need to remove that tab and replace it by a standard singledockable
// which is done by the standard desktop "split" public method.
Dockable remainingDockable = tabAncestor.getDockableAt(0);
event.setDockingAction(new DockingActionSplitDockableEvent(event.getDesktop(),
dockable, initialState, borderSpliterState, remainingDockable, position, 0.5f));
} else {
// standard dropping, just use the internal API to relayout the desktop.
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, initialState, borderSpliterState, delegator, position, 0.5f));
}
}
event.acceptDrag(shape);
}
private void scanDrop(DockEvent event, boolean drop){
Point p = event.getMouseEvent().getPoint();
Dimension size = delegator.getSize();
int distTop = p.y;
int distLeft = p.x;
int min = Math.min(distTop, distLeft);
int distRight = size.width - p.x;
min = Math.min(min, distRight);
int distBottom = size.height - p.y;
min = Math.min(min, distBottom);
Dimension draggedSize = null;
DockableDragSource source = event.getDragSource();
// the drag size is the one of the parent dockable container
//draggedSize = dragged.getComponent().getParent().getSize();
draggedSize = source.getDockableContainer().getSize();
int bestHeight = (int)Math.min(draggedSize.height , size.height * 0.5);
int bestWidth = (int)Math.min(draggedSize.width , size.width * 0.5);
if (min == distTop && min < delegator.getHeight()/4) {
// dock on top
if (drop) {
acceptSplit((DockDropEvent) event, DockingConstants.SPLIT_TOP);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
0,
size.width,
bestHeight);
acceptDragSplit((DockDragEvent) event, DockingConstants.SPLIT_TOP, r2d);
}
} else if (min == distLeft && min < delegator.getWidth()/4) {
if (drop) {
acceptSplit((DockDropEvent) event, DockingConstants.SPLIT_LEFT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
0,
bestWidth,
size.height);
acceptDragSplit((DockDragEvent) event, DockingConstants.SPLIT_LEFT, r2d);
}
} else if (min == distBottom && min < delegator.getHeight()/4) {
if (drop) {
acceptSplit((DockDropEvent) event, DockingConstants.SPLIT_BOTTOM);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
size.height - bestHeight, //20,
size.width,
bestHeight);
acceptDragSplit((DockDragEvent) event, DockingConstants.SPLIT_BOTTOM, r2d);
}
} else if (min == distRight && min < delegator.getWidth()/4){ // right
if (drop) {
acceptSplit((DockDropEvent) event, DockingConstants.SPLIT_RIGHT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(
size.width - bestWidth,
0,
bestWidth,
size.height);
acceptDragSplit((DockDragEvent) event, DockingConstants.SPLIT_RIGHT, r2d);
}
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/CompoundDockable.java 0000644 0001750 0001750 00000013773 10573516346 026332 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.Component;
/** Describes a Dockable that can contain sub-dockables.
*
* This class allows dockable nesting, with full support for workspace save and restore.
*
* Currently this class is associated to a CompoundDockingPanel component : you
* insert dockables into it with an initial addDockable(CompoundDockable) invocation from DockingDesktop,
* and further dockables with split/createTab calls.
*
* Example :
*
* CompoundDockables are displayed as SingleDockableContainers (with a title bar). Don't
* forget to properly initialize the DockKey of this dockable to have it well presented on
* screen (name, tooltip, icon).
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1
*/
public class CompoundDockable implements Dockable {
private CompoundDockingPanel panel = new CompoundDockingPanel(this);
private DockKey key;
/** Constructs a new CompoundDockable with a given key */
public CompoundDockable(DockKey key){
this.key = key;
}
/** Returns the key used to describe this dockable */
public DockKey getDockKey() {
return key;
}
/** Returns the component used by this dockable.
*
*
* Implementation note : this method always returns a CompoundDockingPanel.
*
*/
public final Component getComponent() {
return panel;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/CompoundDockingPanel.java 0000644 0001750 0001750 00000016646 10573516346 027166 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import com.vlsolutions.swing.docking.event.DockEvent;
import com.vlsolutions.swing.docking.event.DockingActionAddDockableEvent;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.geom.Rectangle2D;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
/** A specialized container used to nest dockables inside that sub-part of the
* desktop.
*
* This component is used by the API (as the associate component of a CompoundDockable)
* and shouldn't be used outside this context.
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1
* @see CompoundDockable
*/
public class CompoundDockingPanel extends JPanel implements DockDropReceiver {
private CompoundDockable dockable;
/** Constructs a new CompoundDockingPanel, for a given dockable */
public CompoundDockingPanel(CompoundDockable dockable) {
setLayout(new BorderLayout());
this.dockable = dockable;
}
/** act the same as a splitContainer : allow drop on the borders*/
public void processDockableDrag(DockDragEvent event) {
scanContainer(event, false);
}
public void processDockableDrop(DockDropEvent event) {
scanContainer(event, true);
}
private void acceptDrop(DockEvent event){
( (DockDropEvent) event).acceptDrop();
Dockable d = event.getDragSource().getDockable();
DockableContainer dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(d, DockableContainerFactory.PARENT_DESKTOP);
dockableContainer.installDocking(event.getDesktop());
add((JComponent)dockableContainer, BorderLayout.CENTER);
}
private void scanContainer(DockEvent event, boolean drop) {
// reject operation if the source is an ancestor of this component
if (event.getDragSource().getDockableContainer().isAncestorOf(this)){
// this is possible for compound containers (as they contain sub-dockables)
// in that case, you cannnot drop a compound into one of its children // 2007/01/08
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
Point p = event.getMouseEvent().getPoint();
Rectangle compBounds = getBounds();
Dockable dragged = event.getDragSource().getDockable();
int initialState = dragged.getDockKey().getDockableState();
int nextState = dockable.getDockKey().getDockableState();
event.setDockingAction(new DockingActionAddDockableEvent(event.getDesktop(),
dragged, initialState, nextState, this));
if (drop) {
acceptDrop(event);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
0,
compBounds.width,
compBounds.height);
( (DockDragEvent) event).acceptDrag(r2d);
}
}
/** Returns the compound dockable this container is for */
public CompoundDockable getDockable() {
return dockable;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DefaultDockableContainerFactory.java 0000644 0001750 0001750 00000015423 10573516346 031317 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.Dialog;
import java.awt.Frame;
import java.awt.Window;
/** Default implementation of the DockableContainerFactory.
*
* Uses
* Note : the API has changed between VLDocking 1.1 and 2.0 : the createDockableContainer
* now uses a second parameter to specify the context of the container creation.
*
* @author Lilian Chamontin, vlsolutions.
* @version 2.0
*/
public class DefaultDockableContainerFactory extends DockableContainerFactory {
public DefaultDockableContainerFactory() {
}
/** Returns the component used to modify the expand panel size when expanded from the top.
* This implementation uses the following components :
*
* Current implementation uses the DockTabbedPane class.
*
* @see DockTabbedPane
*/
public TabbedDockableContainer createTabbedDockableContainer() {
return new DockTabbedPane();
}
/** This method is called when a dockable is detached from the DockingDesktop and put
* in the FLOATING state.
*
* The floating container must be an instanceof Dialog or Window.
*/
public FloatingDockableContainer createFloatingDockableContainer(Window owner){
if (owner instanceof Dialog){
return new FloatingDialog((Dialog)owner);
} else {
return new FloatingDialog((Frame)owner);
}
}
/** This implementation of the factory method return a default DockViewTitleBar
* object.
*@since 2.1.3
*/
public DockViewTitleBar createTitleBar() {
return new DockViewTitleBar();
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DetachedDockView.java 0000644 0001750 0001750 00000017457 10573516346 026261 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import com.vlsolutions.swing.docking.event.DockEvent;
import com.vlsolutions.swing.docking.event.DockingActionCreateTabEvent;
import java.awt.Rectangle;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
/** A DockView suitable for detached dockables (in their own window).
*
* @see DockView
*
* @author Lilian Chamontin, VLSolutions
* @since 2.0
*/
public class DetachedDockView extends DockView {
private static final String uiClassID = "DetachedDockViewUI";
public DetachedDockView(Dockable dockable) {
super(dockable);
}
/** {@inheritDoc}
* @since 2.0
*/
public String getUIClassID() {
return uiClassID;
}
/* common method for drag && drop, overriden from DockView to only allow tabbed drops */
protected void scanDrop(DockEvent event, boolean drop){
if (getParent() instanceof TabbedDockableContainer){
// cannot nest DockTabbedPanes
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
if (event.getDragSource().getDockable() == dockable) {
// cannot drop onto itself
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
// The dockview isn't contained inside a tabbedpane,
// there is only one possible option : to create an tab
if (event.getDragSource().getDockableContainer() instanceof TabbedDockableContainer) {
// but you cannot drop a whole tab container into a detached view
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
Rectangle bounds = getBounds();
// not on the borders : we should create a new tab
// reject if key groups aren't compatible
DockGroup thisGroup = dockable.getDockKey().getDockGroup();
DockGroup dragGroup = event.getDragSource().getDockable().getDockKey().getDockGroup();
if (!DockGroup.areGroupsCompatible( thisGroup, dragGroup)){
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
Dockable d = event.getDragSource().getDockable();
int dockableState = d.getDockKey().getDockableState();
int viewState = dockable.getDockKey().getDockableState();
if (drop){
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(),
d, dockableState, viewState, dockable, 0));
((DockDropEvent) event).acceptDrop(false); // don't remove the floatable : we have to find it's current position
desktop.createTab(dockable, event.getDragSource().getDockable(), 0, true);
} else {
Rectangle2D r2d = new Rectangle2D.Float(bounds.x, bounds.y,
bounds.width,
bounds.height);
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(),
d, dockableState, viewState, dockable, 0));
if (r2d.equals(lastDropShape)) {
// optimized shape caching
( (DockDragEvent) event).acceptDrag(lastDropGeneralPath);
} else {
// draw a 'tabbed pane shape'
GeneralPath path = buildPathForTab(bounds);;
lastDropShape = r2d;
lastDropGeneralPath = path;
( (DockDragEvent) event).acceptDrag(lastDropGeneralPath);
}
}
}
/** {@inheritDoc}
*/
public String toString(){
return "DetachedDockView of " + dockable.getDockKey();
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockDropReceiver.java 0000644 0001750 0001750 00000014244 10573516346 026305 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.*;
import com.vlsolutions.swing.docking.event.*;
/** An interface implemented by components that can accept docking action with mouse drag and drop.
*
* This interface is used by API Extenders to create new kind of drop receivers.
*
* The DockDropReceiver is responsible for the Drag and Drop gesture recognition of
* a docking movement. When a user starts a drag gesture over a {@link DockableDragSource},
* the DockingDesktop scans its containment hierarchy (under the mouse pointer), looking
* for DockDropReceivers. If one is found, it is asked for drag or drop processing.
*
* The receiver can reject a drag, or display a shape explaining to the user how a
* drop of the component would affect the global layout.
*
*
* @see DockableDragSource
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* */
public interface DockDropReceiver {
/** The component is notified of a drag operation.
*
*
* This method is used to give a visual clue of dropping capability
* (for example, mouse cursor change, painting a shadow of future component position)
*
*
*
* These clues are transmitted via the event's methods.
*
* @see DockDragEvent
* @see DockDropEvent
*
* */
public void processDockableDrag(DockDragEvent event);
/** The component is requested to perform a docking drop action.
*
* This method is called only after a successful {@link #processDockableDrag(DockDragEvent)}
*
* The parameters provided for the drop are the same than those of the last drag
* (in order to avoid an allowed last drag followed by a rejected drop).
*
* On event acceptation ( {@link DockDropEvent#acceptDrop() } , the source component
* will be removed from its container, so the DropReceiver must add the
* component to its own hierarchy otherwise
* the component would be lost (from a user's point of view).
* */
public void processDockableDrop(DockDropEvent event) ;
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockGroup.java 0000644 0001750 0001750 00000017625 10573516346 025016 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.util.ArrayList;
import javax.swing.Action;
/** This class describes a logical group of Dockables.
*
* When a dockable is associated to a DockGroup (via its DockKey) drag and drop operations
* are limited to dockables of the same group (or new location) or compatible group (a group with
* a common ancestor see {@link #isCompatibleGroup(DockGroup)} ).
*
* It becomes easy to develop, for example, and MDI program : all documents are given the same
* DockGroup, and other dockable are given another group so they don't mess with each other.
*
* The DockGroups can be nested to allow some mixing (for example, an editor application can consist of
* 4 groups : "Formaters" and "Files" the parent of "TextFiles" and "HTMLfile". In that case,
* Textfiles and Htmlfiles can be part of tha same tabbed container whereas Formaters are kept outside.
*
*
* @see DockKey#setDockGroup(DockGroup)
* @author Lilian Chamontin, VLSolutions
* @since 2.0
*/
public class DockGroup {
/** The optional parent of this group */
private DockGroup parent;
/** internal name for comparisons */
private String name;
/** Constructs a new dockgroup with a given name.
* Note that names must be unique (this feature is not controlled by the framework)
* through all DockGroups.
*/
public DockGroup(String name) {
this.name = name;
}
/** Constructs a new dockgroup with a given name and a parent group.
* Note that names must be unique (this feature is not controlled by the framework)
* through all DockGroups.
*/
public DockGroup(String name, DockGroup parent) {
this.name = name;
this.parent = parent;
}
/** returns the parent of this group (may be null) */
public DockGroup getParent(){
return parent;
}
/** Updates the parent of this group */
public void setParent(DockGroup parent){
this.parent = parent;
}
/** returns the name of this group (which is used as an internal key) */
public String getName(){
return name;
}
/** overriden for storage/comparisons with the "name" property */
public boolean equals(Object o){
return o != null && o instanceof DockGroup && ((DockGroup)o).name.equals(name);
}
/** overriden for storage/comparisons with the "name" property */
public int hashCode(){
return name.hashCode();
}
/** returns true if this group is the ancestor of group g.
* To be an ancestor, this group must be either equel to g, or to one of g's parents chain.
*/
public boolean isAncestorOf(DockGroup g){
if (this.equals(g)){
return true;
} else {
DockGroup parent = g.parent;
while (parent != null){
if (this.equals(parent)){
return true;
} else {
parent = parent.parent;
}
}
}
return false;
}
/** returns true is this group is compatible with the given parameter.
*
* two groups are compatible if they share the same ancestor or if one is the
* ancestor of the other.
*
* When compatibility is found, dockables of those groups can be docked in
* the same tab container.
*/
public boolean isCompatibleGroup(DockGroup g){
if (g == null) return false;
if (this.equals(g)){
return true;
} else if (this.isAncestorOf(g)) {
return true;
} else if (g.isAncestorOf(this)){
return true;
} else if (parent != null){
return parent.isCompatibleGroup(g.parent);
} else {
return false;
}
}
/** convenience method to check compatibility between groups */
public static boolean areGroupsCompatible(DockGroup g1, DockGroup g2){
if (g1 == null){
return g2 == null;
} else if (g2 == null){
return g1 == null;
} else {
return g1.isCompatibleGroup(g2);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockKey.java 0000644 0001750 0001750 00000044242 10573516346 024445 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.beans.*;
import java.util.HashMap;
/**
* Provides a unique identification for a Dockable and runtime properties, like icon, name,
* tooltip, preferred audohide-zone...
*
*
* As it is the object which identifies uniquely a user Dockable component,
* it should be associated with one and only one
* The unique key used for equals() comparison is the dockKey property,
* other properties can be shared by a set of DockKey (for example,
* you can share an icon, or even a display name between
* dockable Components).
*
*
* Another usage is the decoration of a dockable container, providing informations
* such as its name, tooltip or icon.
*
* Properties of a DockKey are listened to by the docking framework, so a change
* of name or icon is reflected on the GUI without further programming.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*
* @update 2006/12/01 Lilian Chamontin : added client property support
*
*/
public class DockKey {
/** Key identifying a change in the tooltip property */
public static final String PROPERTY_TOOLTIP = "tooltip";
/** Key identifying a change in the name property */
public static final String PROPERTY_NAME = "name";
/** Key identifying a change in the tabname property (title used by tabbed containers) */
public static final String PROPERTY_TAB_NAME = "tabName";
/**
* Key identifying a change in the dockKey property
*/
public static final String PROPERTY_DOCKKEY = "dockKey";
/** Key identifying a change in the icon property */
public static final String PROPERTY_ICON = "icon";
/** Key identifying a change in the autohideEnabled property */
public static final String PROPERTY_AUTOHIDEABLE = "autohide";
/** Key identifying a change in the closeEnabled property */
public static final String PROPERTY_CLOSEABLE = "close";
/** Key identifying a change in the maximizedEnabled property */
public static final String PROPERTY_MAXIMIZABLE = "maximizable";
/** Key identifying a change in the notification property */
public static final String PROPERTY_NOTIFICATION = "notification";
/** Key identifying a change in the floatableEnabled property */
public static final String PROPERTY_FLOATABLE = "floatable";
/**
* Key identifying a change in the dockable dockableState
*/
public static final String PROPERTY_DOCKABLE_STATE = "dockablestate";
private String dockKey;
private String name;
/** new as 2.1 : the tab name property is used to display the dockable title when tabbed*/
private String tabName;
private String tooltip;
private Icon icon;
private DockingConstants.Hide autoHideBorder ;
private boolean isAutoHideEnabled = true;
private boolean isCloseEnabled = true;
private boolean isMaximizeEnabled = true;
private boolean isFloatEnabled = false; // for compatiblity with version 1.1
/** resize weight of the dockable, this is not a bound property and should be set
* during initialization.
*/
private float resizeWeight = 0f;
private boolean notification = false;
/** additional client properties
* @since 2.1.2
*/
private HashMap clientProperties = null;
/**
* Current visibility dockableState of the dockable (DockableState.STATE_CLOSED, STATE_AUTO_HIDE, STATE_DOCKED, STATE_MAXIMIZED,
* STATE_FLOATING)
*/
private int dockableState = DockableState.STATE_CLOSED;
// these are not bound properties
private DockGroup dockGroup;
private DockableActionCustomizer actionCustomizer;
private transient PropertyChangeSupport propertySupport = new PropertyChangeSupport(this);
/**
* JavaBeans constructor : If used, also think to set the dockKey property.
*/
public DockKey() {
}
/**
* Constructs a DockKey with dockKey (unique key) and name set to the same value
*/
public DockKey(String dockKey){
this(dockKey, dockKey, null, null, null);
}
/**
* Constructs a DockKey with dockKey (unique key) and a displayed name
*/
public DockKey(String dockKey, String name){
this(dockKey, name, null, null, null);
}
/**
* Constructs a DockKey with dockKey (unique key), a displayed name and a tooltip
*/
public DockKey(String dockKey, String name, String tooltip){
this(dockKey, name, tooltip, null, null);
}
/**
* Constructs a DockKey with dockKey (unique key), a displayed name, a tooltip and
* an icon.
*/
public DockKey(String dockKey, String name, String tooltip, Icon icon){
this(dockKey, name, tooltip, icon, null);
}
/**
* Constructs a DockKey with dockKey (unique key), a displayed name, a tooltip, an icon
* and a default autohide border.
*/
public DockKey(String dockKey, String name, String tooltip, Icon icon, DockingConstants.Hide hideBorder){
this.dockKey = dockKey;
this.name = name;
this.tooltip = tooltip;
this.icon = icon;
this.autoHideBorder = hideBorder;
}
/** Hook for property change notification */
public void addPropertyChangeListener(PropertyChangeListener listener){
propertySupport.addPropertyChangeListener(listener);
}
/** Remove a property change notification */
public void removePropertyChangeListener(PropertyChangeListener listener){
propertySupport.removePropertyChangeListener(listener);
}
/** Returns the icon displayed in title bars */
public Icon getIcon() {
return icon;
}
/** Returns the name (or title) displayed in title bars */
public String getName() {
return name;
}
/** Returns the tooltip associated to the title bar */
public String getTooltip() {
if (tooltip == null) {
return name;
}
return tooltip;
}
/** Returns the unique id designating the user component.
*
* Note : This used to be the getDockName prior version 2.0. It has been renamed
* to clarify the concept (there was a naming problem between getName() and getDockName()
*
*/
public String getKey() {
return dockKey;
}
/** Updates the tooltip property.
* PropertyListeners are notified of that change
* */
public void setTooltip(String tooltip) {
String old = this.tooltip;
this.tooltip = tooltip;
propertySupport.firePropertyChange(PROPERTY_TOOLTIP, old, tooltip);
}
/** Updates the name property.
* The name property is used by dockable container headers to associate a title with a dockable.
* PropertyListeners are notified of that change
* */
public void setName(String name) {
String old = this.name;
this.name = name;
propertySupport.firePropertyChange(PROPERTY_NAME, old, name);
}
/** Returns the tab name (or tab title) displayed when the component is contained into a tabbed container.
*/
public String getTabName() {
return tabName;
}
/** Updates the tabname property.
* This property is used by tabbed containers to display a shorter version of the title of this dockable.
*
* Default value is null, meaning the name
*
* PropertyListeners are notified of that change
*
*@since 2.1
* */
public void setTabName(String tabName) {
String old = this.tabName;
this.tabName = tabName;
propertySupport.firePropertyChange(PROPERTY_TAB_NAME, old, tabName);
}
/** Updates the icon property.
*
* PropertyListeners are notified of that change */
public void setIcon(Icon icon) {
Icon old = this.icon;
this.icon = icon;
propertySupport.firePropertyChange(PROPERTY_ICON, old, icon);
}
/**
* Updates the dockKey property.
*
* Although PropertyListeners are notified of that change,
* it is not recommended to change dynamicaly the dockKey property, as it is heavily used in
* the docking framework to identify dockable components.
*
* Note : This used to be the getDockName prior version 2.0. It has been renamed
* to clarify the concept (there was a naming problem between getName() and getDockName()
*/
public void setKey(String dockKey) {
String old = this.dockKey;
this.dockKey = dockKey;
propertySupport.firePropertyChange(PROPERTY_DOCKKEY, old, dockKey);
}
/** @see #getKey()
* @deprecated use getKey instead
*/
public String getDockName(){
return getKey();
}
/** @see #setKey(String)
* @deprecated use setKey instead
*/
public void setDockName(String name){
setKey(name);
}
/** Returns the autohide border of this dockable, or null if not set*/
public DockingConstants.Hide getAutoHideBorder(){
return autoHideBorder;
}
/** Updates the autohide border property */
public void setAutoHideBorder(DockingConstants.Hide border){
this.autoHideBorder = border;
}
/** Returns try if autohiding is enabled */
public boolean isAutoHideEnabled(){
return isAutoHideEnabled;
}
/** Updates the autohideEnabled propety.
*
* PropertyListeners are notified of that change
* */
public void setAutoHideEnabled(boolean enabled) {
boolean old = this.isAutoHideEnabled;
this.isAutoHideEnabled = enabled;
propertySupport.firePropertyChange(PROPERTY_AUTOHIDEABLE, old, enabled);
}
/** Returns true if this dockable can be closed */
public boolean isCloseEnabled(){
return isCloseEnabled;
}
/** Updates the closeEnabled propety.
* PropertyListeners are notified of that change
* */
public void setCloseEnabled(boolean enabled) {
boolean old = this.isCloseEnabled;
this.isCloseEnabled = enabled;
propertySupport.firePropertyChange(PROPERTY_CLOSEABLE, old, enabled);
}
/** Returns true if this dockable can be maximized */
public boolean isMaximizeEnabled(){
return isMaximizeEnabled;
}
/** Updates the maximizeEnabled propety.
* PropertyListeners are notified of that change
* */
public void setMaximizeEnabled(boolean enabled) {
boolean old = this.isMaximizeEnabled;
this.isMaximizeEnabled = enabled;
propertySupport.firePropertyChange(PROPERTY_MAXIMIZABLE, old, enabled);
}
/** Returns true if this dockable can be detached from its desktop */
public boolean isFloatEnabled(){
return isFloatEnabled;
}
/** Updates the floatEnabled propety.
* PropertyListeners are notified of that change
* */
public void setFloatEnabled(boolean enabled) {
boolean old = this.isFloatEnabled;
this.isFloatEnabled = enabled;
propertySupport.firePropertyChange(PROPERTY_FLOATABLE, old, enabled);
}
/** Returns true is a notification has been set.
* default notification is making title bars blink.
* */
public boolean isNotification(){
return notification;
}
/** Updates the notification propety. Notification results in
* a visual change of the dockable in order to attract attention from the
* user to this dockable.
*
* PropertyListeners are notified of that change.
* */
public void setNotification(boolean notification) {
boolean old = this.notification;
this.notification = notification;
propertySupport.firePropertyChange(PROPERTY_NOTIFICATION, old, notification);
}
/** Overriden for Map storage needs */
public int hashCode(){
return dockKey.hashCode();
}
/** Overriden for Map storage needs */
public boolean equals(Object o){
return o instanceof DockKey && dockKey.equals(((DockKey)o).dockKey);
}
public String toString(){
return "DockKey[" + name +']';
}
/** Returns the action customizer associated to this dockkey (may return null)
*
*/
public DockableActionCustomizer getActionCustomizer(){
return actionCustomizer;
}
/** Updates the action customizer of this dockable
*
*/
public void setActionCustomizer(DockableActionCustomizer actionCustomizer){
this.actionCustomizer = actionCustomizer;
}
/** Updates the dockGroup of this dockable.
*/
public void setDockGroup(DockGroup group){
this.dockGroup = group;
}
/** returns the dockGroup of this dockable */
public DockGroup getDockGroup(){
return this.dockGroup;
}
/**
* returns the current visible dockableState of the dockable (see DockableState.STATE_ for enumaration values)
* @see DockableState
*/
public int getDockableState(){
return dockableState;
}
/** updates the dockableState property.
*
* Warning : do not call this method, it is for the sole use of the DockingDesktop API.
* @see DockableState
*/
public void setDockableState(int dockableState){
int old = this.dockableState;
this.dockableState = dockableState;
propertySupport.firePropertyChange(PROPERTY_DOCKABLE_STATE, old, dockableState);
}
public float getResizeWeight(){
return this.resizeWeight;
}
/** updates the resize weight of this dockable. Valid values range between 0.0f and 1.0f */
public void setResizeWeight(float weight){
this.resizeWeight = weight;
}
/** Allows any property to be stored in a map associated with this dockkey. A property change event
* is propagated to listeners (with a property name equal to "clientProperty." + name)
*
*
* @param name the name used to lookup the property
* @param value the value of the property
* @since 2.1.2
*/
public void putProperty(String name, Object value) {
if (clientProperties == null){
clientProperties = new HashMap();
}
clientProperties.put(name, value);
propertySupport.firePropertyChange("clientProperty."+name, null, value);
}
/** returns a property associated to this name, or null if the property is undefined
* @param name the name used to lookup the property
* @since 2.1.2
*/
public Object getProperty(String name) {
if (clientProperties != null){
return clientProperties.get(name);
} else {
return null;
}
}
/** returns and removes a property associated to this name, or null if the property is undefined
* @param name the name used to lookup the property
* @since 2.1.2
*/
public Object removeProperty(String name){
if (clientProperties != null){
return clientProperties.remove(name);
} else {
return null;
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockTabbedPane.java 0000644 0001750 0001750 00000130112 10573516346 025672 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.tabbedpane.JTabbedPaneSmartIcon;
import com.vlsolutions.swing.tabbedpane.JTabbedPaneSmartIconManager;
import com.vlsolutions.swing.tabbedpane.SmartIconJButton;
import java.awt.*;
import java.awt.geom.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.*;
import com.vlsolutions.swing.docking.event.*;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/** A JTabbedPane customized for integration with the docking framework.
*
*
* Defaults :
*
* This tabbed pane is not meant to be used outside of DockingDesktop because of
* their connected behaviour (drag/drop support, docking constraints, etc).
*
* As of version 2.0 of the framework, the tabbed pane displays a close icon (other functions
* are available with a right click menu).
*
* @see DockingDesktop
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/11/01 Lilian Chamontin : enhanced shape painting (tries to avoid
* going outside the tab bounds)
* @update 2005/11/10 Lilian Chamontin : added support for DnD multiple tabs at once.
* @update 2005/12/08 Lilian Chamontin : removed a portion of code as its been refactored in BorderSplitter
*/
public class DockTabbedPane extends JTabbedPane
implements DockDropReceiver, DockableDragSource, TabbedDockableContainer {
/* no UI for this component, as it is look and feel dependent : we cannot extend BasicTabbedPaneUI */
/** cache for reusing the general path lastDropPath between calls to getDropShape */
private Rectangle lastDropBounds, lastDropTabBounds;
private GeneralPath lastDropPath;
/** set by a drag operation */
private SingleDockableContainer draggedDockable = null;
/** True when the whole tabbedpane is dragged */
private boolean isMultipleDrag = false;
protected DockingDesktop desktop;
/** The pop-up menu used to provide fast "close" shortcuts (close all, close others) */
protected JPopupMenu popup = new JPopupMenu();
/** the tab currently associated with the pop-up */
protected int popupTab = -1;
/** The tab that was selected before the current one */
protected int previousSelectedDockable = -1;
private HashMap closeActions = new HashMap(); // DockKey , Action
private JTabbedPaneSmartIconManager tabManager = new JTabbedPaneSmartIconManager(this);
/* This pseudo-dockable is used during drag and drop operations of the whole tabbed pane */
static int instanceCount = 0;
private Dockable selfDockable= new Dockable(){
DockKey selfKey = new DockKey("dockTab" + instanceCount++);
public DockKey getDockKey(){
selfKey.setName(getDockableAt(0).getDockKey().getName() + "...");
return selfKey;
}
public Component getComponent(){
return DockTabbedPane.this;
}
};
private PropertyChangeListener keyChangeListener = new PropertyChangeListener(){
public void propertyChange(PropertyChangeEvent e){
DockKey k =(DockKey)e.getSource();
if (e.getPropertyName().equals(DockKey.PROPERTY_CLOSEABLE)){
Action closeAction = (Action)closeActions.get(k);
if (closeAction != null){
closeAction.setEnabled(k.isCloseEnabled());
}
} else if (e.getPropertyName().equals(DockKey.PROPERTY_ICON)){
int tab = getDockableIndex(k);
if (tab >= 0){
JTabbedPaneSmartIcon tabIcon = (JTabbedPaneSmartIcon) getIconAt(tab);
tabIcon.setIcon((Icon) e.getNewValue());
JTabbedPaneSmartIcon newIcon = tabIcon.copy();
// we create a copy to trigger a repaint event
setIconAt(tab, newIcon);
}
} else if (e.getPropertyName().equals(DockKey.PROPERTY_NAME)){
int tab = getDockableIndex(k);
if (tab >= 0){
JTabbedPaneSmartIcon tabIcon = (JTabbedPaneSmartIcon) getIconAt(tab);
String old = tabIcon.getLabel();
String label = (String) e.getNewValue();
tabIcon.setLabel(label);
JTabbedPaneSmartIcon newIcon = tabIcon.copy();
// we create a copy to trigger a repaint event
setIconAt(tab, newIcon);
SwingUtilities.invokeLater(new Runnable(){
public void run(){
// we have to revalidate/repaint to ensure the new icon size is correctly
// taken into account
revalidate();
repaint();
}
});
}
} else if (e.getPropertyName().equals(DockKey.PROPERTY_TOOLTIP)){
int tab = getDockableIndex(k);
if (tab >= 0){
JTabbedPaneSmartIcon tabIcon = (JTabbedPaneSmartIcon) getIconAt(tab);
tabIcon.setTooltipText((String) e.getNewValue());
}
}
}
};
public DockTabbedPane() {
int tabPlacement = UIManager.getInt("TabbedDockableContainer.tabPlacement");
setTabLayoutPolicy(WRAP_TAB_LAYOUT);
setTabPlacement(tabPlacement);
addMouseListener(new MouseAdapter(){
// depending on the platform, pop-up is triggered either by mousePressed or mouseReleased
public void mousePressed(MouseEvent e){
if (e.isPopupTrigger()){
// popup only when left button is not pressed
checkForPopUp(e);
}
}
public void mouseReleased(MouseEvent e){
if (e.isPopupTrigger()){
checkForPopUp(e);
}
}
public void mouseClicked(MouseEvent e){
if (e.getClickCount() == 2 && SwingUtilities.isLeftMouseButton(e)){
Dockable d = findDockableAt(e);
if (d != null && d.getDockKey().isMaximizeEnabled()
&& d.getDockKey().getDockableState() == DockableState.STATE_DOCKED){ // 2005/10/10 don't maximize floatings
desktop.maximize(d);
}
}
}
});
if (UIManager.getBoolean("TabbedPane.alternateTabIcons")){ //2005/11/14
// we use a different set of icons
addChangeListener(new ChangeListener(){
int prevTab = -1;
public void stateChanged(ChangeEvent e){
int selectedTab = getSelectedIndex();
installTabIcons(selectedTab, true);
if (prevTab != -1){
installTabIcons(prevTab, false);
}
previousSelectedDockable = prevTab;
prevTab = selectedTab;
}
});
}
}
private void installTabIcons(int tab, boolean selected){
if (tab < getTabCount()){
JTabbedPaneSmartIcon icon = (JTabbedPaneSmartIcon) getIconAt(tab);
if (icon != null){
SmartIconJButton closeIcon = icon.getSmartButton(0);
if (selected){
closeIcon.setIcon(UIManager.getIcon("DockTabbedPane.close"));
closeIcon.setPressedIcon(UIManager.getIcon("DockTabbedPane.close.pressed"));
closeIcon.setRolloverIcon(UIManager.getIcon("DockTabbedPane.close.rollover"));
} else {
closeIcon.setIcon(UIManager.getIcon("DockTabbedPane.unselected_close"));
closeIcon.setPressedIcon(UIManager.getIcon("DockTabbedPane.unselected_close.pressed"));
closeIcon.setRolloverIcon(UIManager.getIcon("DockTabbedPane.unselected_close.rollover"));
}
icon.setSmartButton(0, closeIcon);
}
}
}
/** Returns the tab index of the dockable corresponding to the given key, or null if the dockable
* doesn't belong to this tab.
*/
public int getDockableIndex(DockKey key){
for (int i=0; i < getTabCount(); i++){
Dockable d = getDockableAt(i);
if (d != null //2006/12/07
&& d.getDockKey().equals(key)){
return i;
}
}
return -1;
}
private void checkForPopUp(MouseEvent e){
/* Tabbed dockable can be of two states : docked and floating
* when floating, the only option is to attach again.
*/
Dockable d = findDockableAt(e);
if (d != null){
DockKey key = d.getDockKey();
// first add the standard menu
JPopupMenu popup = new JPopupMenu(key.getName());
int menuCount = 0;
if (key.getDockableState() == DockableState.STATE_DOCKED){
if (key.isAutoHideEnabled()){
popup.add(new JMenuItem(TabbedContainerActions.createHideTabAction(d,
desktop)));
menuCount++;
}
if (key.isFloatEnabled()){
popup.add(new JMenuItem(TabbedContainerActions.createFloatTabAction(d,
desktop)));
menuCount++;
}
if (key.isMaximizeEnabled()){
popup.add(new JMenuItem(TabbedContainerActions.createMaximizeTabAction(d,
desktop)));
menuCount++;
}
if (key.isCloseEnabled()){
JMenuItem mItem = new JMenuItem(TabbedContainerActions.createCloseAction(d,
desktop));
mItem.setPressedIcon(new ImageIcon(getClass().getResource("close16.gif")));
popup.add(mItem);
menuCount++;
}
} else if (key.getDockableState() == DockableState.STATE_FLOATING){
if (DockingUtilities.isChildOfCompoundDockable(d)){
// as of v2.1 floating dockable which is a child of compound dockable don't have "attach" menu
} else {
popup.add(new JMenuItem(TabbedContainerActions.createAttachTabAction(d,
desktop)));
menuCount++;
}
} else if (key.getDockableState() == DockableState.STATE_HIDDEN){
// a tabbed hidden dockable can only occur when the dockable is child of a compound dockable
// in that case, there isn't any general popup option available
} else {
throw new RuntimeException("invalid state for a tabbed dockable");
}
DockableActionCustomizer customizer = d.getDockKey().getActionCustomizer();
if (customizer != null && customizer.isTabSelectorPopUpCustomizer()){
if (menuCount > 0){
popup.addSeparator();
}
customizer.visitTabSelectorPopUp(popup, d);
}
if (menuCount>0){
popup.pack();
popup.show(this, e.getX(), e.getY());
}
}
}
private Dockable findDockableAt(MouseEvent e){
Point p = e.getPoint();
// find the tab on which the mouse has been pressed
popupTab = -1;
for (int i = 0; i < getTabCount(); i++) {
Rectangle tabbounds = getBoundsAt(i);
if (tabbounds.contains(p)) {
// all right
return getDockableAt(i);
}
}
return null;
}
/** Adds a new tab respecting the presentation and constraints of the component.
*
* {@inheritDoc}
* */
public void addDockable(Dockable dockable, int tab){
SingleDockableContainer dc = DockableContainerFactory.getFactory().createDockableContainer(dockable,
DockableContainerFactory.PARENT_TABBED_CONTAINER);
dc.installDocking(desktop);
addDockableContainer(dc, tab);
}
private void addDockableContainer(final SingleDockableContainer dc, int tab){
final DockKey key = dc.getDockable().getDockKey();
AbstractAction closeAction = new AbstractAction("Close"){
public void actionPerformed(ActionEvent e){
desktop.close(dc.getDockable());
}
};
closeActions.put(key, closeAction);
SmartIconJButton closeIcon = new SmartIconJButton(closeAction);
if (UIManager.getBoolean("TabbedPane.alternateTabIcons")){ //2005/12/09
closeIcon.setIcon(UIManager.getIcon("DockTabbedPane.unselected_close"));
closeIcon.setPressedIcon(UIManager.getIcon("DockTabbedPane.unselected_close.pressed"));
closeIcon.setRolloverIcon(UIManager.getIcon("DockTabbedPane.unselected_close.rollover"));
} else {
closeIcon.setIcon(UIManager.getIcon("DockTabbedPane.close"));
closeIcon.setPressedIcon(UIManager.getIcon("DockTabbedPane.close.pressed"));
closeIcon.setRolloverIcon(UIManager.getIcon("DockTabbedPane.close.rollover"));
}
closeAction.setEnabled(key.isCloseEnabled());
// add a tooltip
closeAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockTabbedPane.closeButtonText"));
final JTabbedPaneSmartIcon smartIcon = new JTabbedPaneSmartIcon(key.getIcon(), key.getName(),
new SmartIconJButton[]{ closeIcon});
smartIcon.setTooltipText(key.getTooltip());
smartIcon.setIconForTabbedPane(this);
if (tab >= getTabCount()){
//addTab(key.getName(), key.getIcon(), (Component)dc, key.getTooltip());
addTab("",smartIcon, (Component) dc, key.getTooltip());
//addTab(key.getName(),smartIcon, (Component) dc, key.getTooltip());
tab = getTabCount()-1;
} else {
//insertTab(key.getName(), key.getIcon(), (Component)dc, key.getTooltip(), tab);
insertTab("", smartIcon, (Component)dc, key.getTooltip(), tab);
//insertTab(key.getName(), smartIcon, (Component)dc, key.getTooltip(), tab);
}
key.addPropertyChangeListener(keyChangeListener);
revalidate();
repaint();
/* SwingUtilities.invokeLater(new Runnable(){
public void run(){
setTitleAt(getDockableIndex(key), ""); // workaround for painting problems
}
});*/
}
public void processDockableDrag(DockDragEvent e) {
scanDrop(e, false);
}
private void scanDrop(DockEvent event, boolean drop) {
// dockDropReceiver
DockableDragSource dragSource = event.getDragSource();
// reject operation if the source is an ancestor of this component.
if (dragSource.getDockableContainer().isAncestorOf(this)){
// this is possible for compound containers (as they contain sub-dockables)
// in that case, you cannnot drop a compound into one of its children // 2007/01/08
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
Dockable dockable = null;
SingleDockableContainer dc = null;
Container dragContainer = event.getDragSource().getDockableContainer();
if (dragContainer instanceof TabbedDockableContainer){
if (dragContainer == this){ // drop onto itself not possible
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
return;
}
} else {
// fast check to avoid processing a dockable of unknown type
dockable = dragSource.getDockable();
dc = DockingUtilities.findSingleDockableContainer(dockable);
if (dc == null){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
return;
}
}
Point p = event.getMouseEvent().getPoint();
Rectangle vbounds = getSelectedComponent().getBounds();
// is point inside the main tab area ?
if (vbounds.contains(p)) {
scanMainTabZone(event, drop, dragSource, vbounds);
return;
}
// deny DnD coming from whole tabs
if (dragSource.getDockableContainer() instanceof TabbedDockableContainer){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
return;
}
// not in the main zone, check for tabs positions
// (but reject first if groups are not compatible)
DockableDragSource s = event.getDragSource();
Dockable d = s.getDockable();
DockGroup dragGroup = d.getDockKey().getDockGroup();
for (int i=0; i < getTabCount(); i++){
DockGroup thisGroup = getDockableAt(i).getDockKey().getDockGroup();
if (!DockGroup.areGroupsCompatible( thisGroup, dragGroup)){
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
}
for (int i = 0; i < getTabCount(); i++) {
Rectangle tabbounds = getBoundsAt(i);
if (tabbounds.contains(p)) {
// insert before this tab if allowed
SingleDockableContainer tab = (SingleDockableContainer)getComponentAt(i);
if (tab.getDockable() == dragSource.getDockable()){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
if (i > 0){
tab = (SingleDockableContainer) getComponentAt(i - 1);
if (tab.getDockable() == dragSource.getDockable()) {
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
}
if (vbounds.equals(lastDropBounds) && tabbounds.equals(lastDropTabBounds)){
// optimized (cached)
} else {
GeneralPath gp = buildPathForCurrentTab(vbounds, tabbounds);
lastDropBounds = vbounds;
lastDropTabBounds = tabbounds;
lastDropPath = gp;
}
Dockable draggedDockable = dragSource.getDockable();
int initialState = draggedDockable.getDockKey().getDockableState();
Dockable base = getDockableAt(0);
int nextState = base.getDockKey().getDockableState();
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(), draggedDockable,
initialState, nextState, base, i));
if (drop){
if (DockingUtilities.findTabbedDockableContainer(dockable) == this){
// the dockable IS another tab of this container, so we just have to
// change its tab order.
((DockDropEvent)event).acceptDrop(false); // don't remove
addDockableContainer(dc, i); // simply move
} else {
// request the desktop to create the tab
if (base.getDockKey().getDockableState() == DockableState.STATE_FLOATING){ //2005/12/09
if (dragSource.getDockable().getDockKey().getDockableState() == DockableState.STATE_FLOATING){
// this is new 2.1 feature : allowed DnD if the tab is a child of a compund dockable
( (DockDropEvent) event).acceptDrop(); // remove
} else {
( (DockDropEvent) event).acceptDrop(false); // don't remove it yet, we need to store its previous dockable state
}
} else {
( (DockDropEvent) event).acceptDrop();
}
desktop.createTab(base, dragSource.getDockable(), i); //2005/10/08
//addDockable(dragSource.getDockable(), i); //2005/10/08
}
setSelectedIndex(i);
} else {
((DockDragEvent) event).acceptDrag(lastDropPath);
}
return;
}
}
// not on the tabs, check if after the last
int lastTab = getTabCount() -1;
Rectangle lasttabbounds = getBoundsAt(lastTab);
Rectangle afterlast = new Rectangle(lasttabbounds.x + lasttabbounds.width,
lasttabbounds.y, getX() + getWidth() - (lasttabbounds.x+ lasttabbounds.width),
lasttabbounds.height);
if (afterlast.contains(p)){
SingleDockableContainer dockableContainer = (SingleDockableContainer)getComponentAt(lastTab);
if (dockableContainer.getDockable() == dragSource.getDockable()){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
if (vbounds.equals(lastDropBounds) && afterlast.equals(lastDropTabBounds)){
} else {
GeneralPath gp = buildPathAfterLastTab(vbounds, afterlast);
lastDropBounds = vbounds;
lastDropTabBounds = afterlast;
lastDropPath = gp;
}
Dockable draggedDockable = dragSource.getDockable();
int initialState = draggedDockable.getDockKey().getDockableState();
Dockable base = getDockableAt(0);
int nextState = base.getDockKey().getDockableState();
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(), draggedDockable,
initialState, nextState, base, lastTab+1));
if (drop){
if (DockingUtilities.findTabbedDockableContainer(dockable) == this){
// the dockable IS another tab of this container, so we just have to
// change its tab order.
((DockDropEvent)event).acceptDrop(false); // don't remove
addDockableContainer(dc, lastTab+1); // simply move
} else {
if (base.getDockKey().getDockableState() == DockableState.STATE_FLOATING){ //2005/12/09
if (dragSource.getDockable().getDockKey().getDockableState() == DockableState.STATE_FLOATING){
// this is new 2.1 feature : allowed DnD if the tab is a child of a compund dockable
( (DockDropEvent) event).acceptDrop(); // remove
} else {
( (DockDropEvent) event).acceptDrop(false); // don't remove it yet, we need to store its previous dockable state
}
} else {
( (DockDropEvent) event).acceptDrop();
}
desktop.createTab(base, dragSource.getDockable(), lastTab+1); //2005/10/08
//addDockable(dragSource.getDockable(), lastTab+1);
}
setSelectedIndex(getTabCount()-1);
} else {
((DockDragEvent) event).acceptDrag(lastDropPath);
}
return;
}
lastDropBounds = null;
lastDropTabBounds = null;
lastDropPath = null;
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
}
/** Creates a general path suitable for showing tab insertion before the currentTab*/
protected GeneralPath buildPathForCurrentTab(Rectangle vbounds, Rectangle tabbounds){
GeneralPath gp = new GeneralPath();
if (getTabPlacement() == SwingConstants.BOTTOM){
gp.moveTo(vbounds.x, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
int height = Math.min(16, tabbounds.height);
if (getTabRunCount() > 1 && (tabbounds.y > vbounds.y + vbounds.height + 10) ){
gp.lineTo(vbounds.x , vbounds.y + vbounds.height);
gp.closePath();
gp.moveTo(tabbounds.x, tabbounds.y);
gp.lineTo(tabbounds.x + 30, tabbounds.y);
gp.lineTo(tabbounds.x + 25, tabbounds.y + height);
gp.lineTo(tabbounds.x, tabbounds.y + height);
gp.closePath();
} else {
gp.lineTo(tabbounds.x + 30, vbounds.y + vbounds.height);
gp.lineTo(tabbounds.x + 25,
vbounds.y + vbounds.height + height);
gp.lineTo(tabbounds.x, vbounds.y + vbounds.height + height);
gp.lineTo(tabbounds.x, vbounds.y + vbounds.height);
gp.lineTo(vbounds.x, vbounds.y + vbounds.height);
gp.closePath();
}
} else { // TOP
int height = Math.min(16, tabbounds.height);
gp.moveTo(vbounds.x, vbounds.y);
if (getTabRunCount() > 1 && (tabbounds.y + tabbounds.height < vbounds.y - 10) ){
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
gp.lineTo(vbounds.x , vbounds.y + vbounds.height);
gp.closePath();
gp.moveTo(tabbounds.x, tabbounds.y);
gp.lineTo(tabbounds.x + 25, tabbounds.y);
gp.lineTo(tabbounds.x + 30, tabbounds.y + height);
gp.lineTo(tabbounds.x, tabbounds.y + height);
gp.closePath();
} else {
gp.lineTo(tabbounds.x, vbounds.y);
gp.lineTo(tabbounds.x, vbounds.y - height);
gp.lineTo(tabbounds.x + 25,
vbounds.y - height);
gp.lineTo(tabbounds.x + 30, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
gp.lineTo(vbounds.x, vbounds.y + vbounds.height);
gp.closePath();
}
}
return gp;
}
/** Creates a general path suitable for showing tab insertion after the last tab*/
protected GeneralPath buildPathAfterLastTab(Rectangle vbounds, Rectangle afterlast){
GeneralPath gp = new GeneralPath();
if (getTabPlacement() == SwingConstants.BOTTOM){
int height = Math.min(16, afterlast.height);
gp.moveTo(vbounds.x, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
if (getTabRunCount() > 1){
gp.lineTo(vbounds.x , vbounds.y + vbounds.height);
gp.closePath();
gp.moveTo(afterlast.x, afterlast.y);
gp.lineTo(afterlast.x + 30, afterlast.y);
gp.lineTo(afterlast.x + 25, afterlast.y + height);
gp.lineTo(afterlast.x, afterlast.y + height);
gp.closePath();
} else {
if (afterlast.x + 30 > vbounds.x +vbounds.width){
// we're outside the component bounds, so we go back a little bit
int newX = vbounds.x + vbounds.width - 30;
gp.lineTo(newX + 30, vbounds.y + vbounds.height);
gp.lineTo(newX + 25,
vbounds.y + vbounds.height + height);
gp.lineTo(newX, vbounds.y + vbounds.height + height);
gp.lineTo(newX, vbounds.y + vbounds.height);
} else {
gp.lineTo(afterlast.x + 30, vbounds.y + vbounds.height);
gp.lineTo(afterlast.x + 25,
vbounds.y + vbounds.height + height);
gp.lineTo(afterlast.x, vbounds.y + vbounds.height + height);
gp.lineTo(afterlast.x, vbounds.y + vbounds.height);
}
gp.lineTo(vbounds.x, vbounds.y + vbounds.height);
gp.closePath();
}
} else { // TOP
int height = Math.min(16, afterlast.height);
gp.moveTo(vbounds.x, vbounds.y);
if (getTabRunCount() > 1){
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
gp.lineTo(vbounds.x , vbounds.y + vbounds.height);
gp.closePath();
gp.moveTo(afterlast.x, afterlast.y);
gp.lineTo(afterlast.x + 25, afterlast.y);
gp.lineTo(afterlast.x + 30, afterlast.y + height);
gp.lineTo(afterlast.x, afterlast.y + height);
gp.closePath();
} else {
if (afterlast.x + 30 > vbounds.x +vbounds.width){//2005/11/01
// we're outside the component bounds, so we go back a little bit
int newX = vbounds.x + vbounds.width - 30;
gp.lineTo(newX, vbounds.y);
gp.lineTo(newX, vbounds.y - height);
gp.lineTo(newX + 25, vbounds.y - height);
gp.lineTo(newX + 30, vbounds.y);
} else {
gp.lineTo(afterlast.x, vbounds.y);
gp.lineTo(afterlast.x, vbounds.y - height);
gp.lineTo(afterlast.x + 25, vbounds.y - height);
gp.lineTo(afterlast.x + 30, vbounds.y);
}
gp.lineTo(vbounds.x + vbounds.width, vbounds.y);
gp.lineTo(vbounds.x + vbounds.width, vbounds.y + vbounds.height);
gp.lineTo(vbounds.x, vbounds.y + vbounds.height);
gp.closePath();
}
}
return gp;
}
private void scanMainTabZone(DockEvent event, boolean drop,
DockableDragSource dragSource, Rectangle vbounds) {
Point p = event.getMouseEvent().getPoint();
/* allow drop :
* - on the current tab
* - between tabs
* delegate drop if mouse to near of the borders
*/
if (scanBorderBounds(event, drop, p)) {
return;
}
// deny DnD coming from whole tabs
if (dragSource.getDockableContainer() instanceof TabbedDockableContainer){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
return;
}
if (scanSameComponent(event, drop, dragSource)){
return;
}
if (scanAdjacentTab(event, drop, dragSource)) {
return ;
}
// reject if all key groups aren't compatible
DockGroup dragGroup = event.getDragSource().getDockable().getDockKey().getDockGroup();
for (int i=0; i < getTabCount(); i++){
DockGroup thisGroup = getDockableAt(i).getDockKey().getDockGroup();
if (!DockGroup.areGroupsCompatible( thisGroup, dragGroup)){
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
}
// now we know we can insert the dragged component here
int tab = getSelectedIndex();
Rectangle tabbounds = getBoundsAt(tab);
if (vbounds.equals(lastDropBounds) && tabbounds.equals(lastDropTabBounds)) {
// optimized (cached)
} else {
// insert before tab
GeneralPath gp = buildPathForCurrentTab(vbounds, tabbounds);
lastDropBounds = vbounds;
lastDropTabBounds = tabbounds;
lastDropPath = gp;
}
Dockable base = getDockableAt(0);
Dockable draggedDockable = dragSource.getDockable();
int initialState = draggedDockable.getDockKey().getDockableState();
int nextState = base.getDockKey().getDockableState();
if (drop) {
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(), draggedDockable,
initialState, nextState, base, tab ));
if (base.getDockKey().getDockableState() == DockableState.STATE_FLOATING){//2005/12/09
if (dragSource.getDockable().getDockKey().getDockableState() == DockableState.STATE_FLOATING){
// this is new 2.1 feature : allowed DnD if the tab is a child of a compound dockable
( (DockDropEvent) event).acceptDrop(); // remove
} else {
( (DockDropEvent) event).acceptDrop(false); // don't remove it yet, we need to store its previous dockable state
}
} else {
( (DockDropEvent) event).acceptDrop();
}
//addDockable(event.getDragSource().getDockable(), tab);
//event.getDesktop().addToTabbedGroup(base, event.getDragSource().getDockable()); //2005/07/13
desktop.createTab(base, dragSource.getDockable(), tab); //2005/10/08
setSelectedIndex(tab);
// dockingPanel.moveDock(dragSource.getTargetKey(), dc);
} else {
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(), draggedDockable,
initialState, nextState, base, tab ));
( (DockDragEvent) event).acceptDrag(lastDropPath);
}
return;
}
private boolean scanAdjacentTab(DockEvent event, boolean drop,
DockableDragSource dragSource) {
if (getSelectedIndex() > 0){
// check and reject a drag/drop of [tab-1] on [tab]
SingleDockableContainer dockableContainer = (SingleDockableContainer)getComponentAt(getSelectedIndex()-1);
if (dockableContainer.getDockable() == dragSource.getDockable()){
if (drop){
((DockDropEvent)event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return true;
}
}
return false;
}
private boolean scanSameComponent(DockEvent event, boolean drop,
DockableDragSource dragSource) {
SingleDockableContainer dockableContainer = (SingleDockableContainer)getSelectedComponent();
if (dockableContainer.getDockable() == dragSource.getDockable()){
// cannot drag/drop onto itself
if (drop) {
( (DockDropEvent) event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
return true;
}
return false;
}
private boolean scanBorderBounds(DockEvent event, boolean drop, Point p) {
/** we early reject this operation if the tab is used by a floating dialog */
Dockable firstDockable = getDockableAt(0);
if (firstDockable.getDockKey().getDockableState() == DockableState.STATE_FLOATING){
// as of v2.1 this DnD operation is allowed if the tabbed pane is a child of a compund dockable
if (!DockingUtilities.isChildOfCompoundDockable(firstDockable)){
// not a nested child
return false;
}
}
Rectangle innerBounds = null;
if (getTabPlacement() == SwingConstants.BOTTOM){
int yTab = getBoundsAt(0).y; // upper coordinate of tabbed selectors
innerBounds = new Rectangle(20, 20, getWidth()-20-20, yTab-20-20);
/** @todo : clamp values */
} else { // TOP
Rectangle tabBounds = getBoundsAt(0);
int yTab = tabBounds.y + tabBounds.height; // lower coordinate of tabbed selectors
innerBounds = new Rectangle(20, yTab+20, getWidth()-20-20, getHeight() - yTab-20-20);
}
if (! innerBounds.contains(p)){
// too near of the bounds, suggest a split docking
BorderSplitter splitter = new BorderSplitter(this)
/* NO LONGER NEEDED : REIMPLEMENTED IN BORDER SPLITTER 2005/12/08
{
// we override split in order to resolve the case where
// the drop operation would remove this tabpane from the containment
// hierarchy
public void split(DockDropEvent event, Container draggedContainer, DockingConstants.Split position){
if (getTabCount() == 1){
// there is only one tab left, meaning
// this tabbedpane has already been removed from containment hierarchy
Dockable remainingDockable = getDockableAt(0);
event.getDesktop().split(
remainingDockable, // one of the remaining dockables
event.getDragSource().getDockable(),
position);
} else {
super.split(event, draggedContainer, position); // standard behaviour
}
}
}*/;
if (drop){
splitter.processDockableDrop((DockDropEvent) event);
} else {
splitter.processDockableDrag((DockDragEvent) event);
}
return true;
}
return false;
}
/** {@inheritDoc} */
public void processDockableDrop(DockDropEvent event) {
scanDrop(event, true);
}
/** {@inheritDoc} */
public boolean startDragComponent(Point p) {
clearDragState();
// which component is dragged ?
for (int i = 0; i < getTabCount(); i++) {
Rectangle tabbounds = getBoundsAt(i);
if (tabbounds.contains(p)) {
draggedDockable = (SingleDockableContainer) getComponentAt(i);
if (i > 2 && i == getTabCount()-1){
// workaround for a focus problem : when the JTabbedPane has focus on the last tab
// and we start a drag (and drop outside the tabbedpane, there is a
// nonblocking stacktrace due to a bad focusIndex in BasicTabbedPaneUI (method focusLost() of the Handler)
KeyboardFocusManager.getCurrentKeyboardFocusManager().upFocusCycle();
// by putting the focus up before the drop occurs, we ensure a good focusIndex is set
}
return true;
}
}
// search for whole tab drag : look after last tab and in-between tabs
Rectangle header = getBoundsAt(0);
header.x = 0;
int lastTab = getTabCount() -1;
Rectangle lasttabbounds = getBoundsAt(lastTab);
header = header.union(lasttabbounds);
Rectangle afterlast = new Rectangle(lasttabbounds.x + lasttabbounds.width,
lasttabbounds.y, getX() + getWidth() - (lasttabbounds.x+ lasttabbounds.width),
lasttabbounds.height);
if (afterlast.contains(p) || header.contains(p)){ // either after the last tab or between tabs
this.isMultipleDrag = true;
return true;
}
return false;
}
/** {@inheritDoc} */
public Dockable getDockable() { // from DockableDragSource
if (isMultipleDrag){
return selfDockable;
} else {
if (draggedDockable != null){
return draggedDockable.getDockable();
}
return null;
}
}
/** {@inheritDoc} */
public Dockable getSelectedDockable() {
Component comp = getComponentAt(getSelectedIndex());
if (comp instanceof SingleDockableContainer){
return ((SingleDockableContainer)comp).getDockable() ;
} else {
// this may happen when the dockable is maximized : it is temporarily replaced by an
// impostor (a JLabel)
return null;
}
}
/** {@inheritDoc} */
public void setSelectedDockable(Dockable dockable) {
Component c = (Component)DockingUtilities.findSingleDockableContainer(dockable);
if (c != null && indexOfComponent(c) >= 0){
setSelectedComponent(c);
}
}
/** {@inheritDoc} */
public Dockable getDockableAt(int index) {
Component c = getComponentAt(index);
if (c instanceof SingleDockableContainer){
return ((SingleDockableContainer)c).getDockable() ;
} else {
return null;
}
}
/** {@inheritDoc} */
public void removeDockable(Dockable dockable) {
DockableContainer dc = DockingUtilities.findSingleDockableContainer(dockable);
if (dc != null){
// after a dockable is removed, we go back to the previously selected if still visible
if (previousSelectedDockable != -1 && previousSelectedDockable < getTabCount()){
final Dockable d = getDockableAt(previousSelectedDockable);
SwingUtilities.invokeLater(new Runnable(){
public void run(){
setSelectedDockable(d);
}
});
}
remove( (Component) dc);
// clean up key / actions references / listeners
closeActions.remove(dockable.getDockKey());
dockable.getDockKey().removePropertyChangeListener(keyChangeListener);
}
}
/** {@inheritDoc} */
public void removeDockable(int index) {
Dockable dockable = getDockableAt(index);
final int prev = this.previousSelectedDockable;
SwingUtilities.invokeLater(new Runnable(){
public void run(){
if (prev != -1 && prev < getTabCount()){
setSelectedIndex(prev);
}
}
});
removeTabAt(index);
// clean up key / actions references / listeners
closeActions.remove(dockable.getDockKey());
dockable.getDockKey().removePropertyChangeListener(keyChangeListener);
}
private void clearDragState(){
// reset drag variables
this.draggedDockable = null;
this.isMultipleDrag = false;
}
/** {@inheritDoc} */
public String toString(){
return "DockTabbedPane [" + Integer.toHexString(hashCode()) + " - tabcount=" + getTabCount() + "]";
}
/** {@inheritDoc} */
public int indexOfDockable(Dockable dockable) {
DockableContainer dc = DockingUtilities.findSingleDockableContainer(dockable);
if (dc != null){
return indexOfComponent((Component)dc);
} else {
return -1;
}
}
/** {@inheritDoc} */
public void installDocking(DockingDesktop desktop) {
this.desktop = desktop;
desktop.installDockableDragSource(this);
}
/** {@inheritDoc} */
public void uninstallDocking(DockingDesktop desktop) {
desktop.uninstallDockableDragSource(this);
}
public Container getDockableContainer() {
if (isMultipleDrag){
return this;
} else {
return ((Container)draggedDockable);
}
}
public void endDragComponent(boolean dropped) {
// nothing more to do
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockView.java 0000644 0001750 0001750 00000040151 10573516346 024622 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.beans.*;
import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.*;
import com.vlsolutions.swing.docking.event.*;
/** DefaultImplementation of the SingleDockableContainer.
*
* A Dockview is the component responsible for displaying a single user
* component inside a DockingPanel.
*
* The DockView contains a DockViewTitleBar, used as a header to display useful information
* and optional controls (close/maximize/hide/float)
*
* UI : The user component is displayed with decorations provided by a
* {@link com.vlsolutions.swing.docking.ui.DockViewUI} delegate.
*
* Here is an example (VLDocking 1.1 "shadow" style) :
*
* Note : multiple user-components are not displayable by the dockview :
* the default implementation of TabbedDockableContainer is the {@link DockTabbedPane}.
*
* @see DockViewTitleBar
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/12/09 Lilian Chamontin : added NPE safety check around uninstallDocking as sometimes
* uninstalling is done twice.
* @update 2007/01/08 Lilian Chamontin : delegated the creation of the titlebar to allow easy override.
*/
public class DockView extends JPanel implements DockDropReceiver, SingleDockableContainer {
private static final String uiClassID = "DockViewUI";
protected DockViewTitleBar title = getTitleBar();
/** the desktop managing this view */
protected DockingDesktop desktop;
/** the dockable managed by this view */
protected Dockable dockable; //user component
/** remember the last drop position to cache the shape used for showing the drop position */
protected Shape lastDropShape, lastDropGeneralPath;
/** listen to the titlebar actions */
private PropertyChangeListener listener = new PropertyChangeListener(){
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_AUTOHIDE)){
if (e.getOldValue().equals(Boolean.TRUE)){
// from autohide to dock : not possible because DockView isn't used
} else {
// dock to autohide
desktop.setAutoHide(dockable, true);
}
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_CLOSED)){
desktop.close(dockable);
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_MAXIMIZED)){
if (e.getNewValue().equals(Boolean.TRUE)){
desktop.maximize(dockable);
} else {
desktop.restore(dockable);
}
} else if (e.getPropertyName().equals(DockViewTitleBar.PROPERTY_FLOAT)){
desktop.setFloating(dockable, ((Boolean)e.getNewValue()).booleanValue());
}
}
};
/** Constructs an empty DockView.
*
* A {@link #setDockable(Dockable)} call is requiered for this constructor to be usefull.
* */
public DockView() {
super(new BorderLayout());
add(title, BorderLayout.NORTH);
}
/** Constructs a new DockView for the given dockable.
*
* @param dockable the dockable to show
* */
public DockView(Dockable dockable){
this();
setDockable(dockable);
}
/** Constructs a new DockView for the given dockable.
*
* @param dockable the dockable to show
* */
public DockView(Dockable dockable, boolean showTitle){
super(new BorderLayout());
add(title, BorderLayout.NORTH);
if (!showTitle){
title.setVisible(false);
}
setDockable(dockable);
}
/** Returns the contained component
*
* {@inheritDoc}
* */
public Dockable getDockable(){
return dockable;
}
/** Adds the dockable's component to this DockView.
*
*
* @param dockable the user dockable
*/
public void setDockable(Dockable dockable){
this.dockable = dockable;
add(dockable.getComponent(), BorderLayout.CENTER);
if (title != null){
title.setDockable(dockable);
}
// allow resizing of split pane beyond minimum size
// could be replaced by adding a JScrollPane instead of panels
setMinimumSize(new Dimension(30,30));
}
/** {@inheritDoc}
*/
public String toString(){
return "DockView of " + dockable.getDockKey();
}
/** {@inheritDoc}
* @since 2.0
*/
public String getUIClassID() {
return uiClassID;
}
/** {@inheritDoc}.
*/
public void processDockableDrag(DockDragEvent event) {
scanDrop(event, false);
}
/** {@inheritDoc}
*
* Please note that a drag into a DockView can also lead to create a DockTabbedPane.
*/
public void processDockableDrop(DockDropEvent event) {
scanDrop(event, true);
}
/* common method for drag && drop gesture support */
protected void scanDrop(DockEvent event, boolean drop){
// reject operation if the source is an ancestor of this view.
if (event.getDragSource().getDockableContainer().isAncestorOf(this)){
// this is possible for compound containers (as they contain sub-dockables)
// in that case, you cannnot drop a compound into one of its children // 2007/01/08
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
if (getParent() instanceof TabbedDockableContainer){
// cannot nest DockTabbedPanes
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
if (event.getDragSource().getDockable() == dockable) {
// cannot drop onto itself
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
// The dockview isn't contained inside a tabbedpane, so there are now 5 drop zones :
// - center : create a tabbedpane
// - top/left/bottom/right : split the view
Rectangle bounds = getBounds();
BorderSplitter splitter = new BorderSplitter(this);
boolean accepted;
if (drop){
splitter.processDockableDrop((DockDropEvent)event);
accepted = ((DockDropEvent)event).isDropAccepted();
} else {
splitter.processDockableDrag((DockDragEvent)event);
accepted = ((DockDragEvent)event).isDragAccepted();
}
if (! accepted){
// not on the borders : we should create a new tab
if (event.getDragSource().getDockableContainer() instanceof TabbedDockableContainer) {
// cannot drop a whole tab container
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
// reject if key groups aren't compatible
DockGroup thisGroup = dockable.getDockKey().getDockGroup();
DockGroup dragGroup = event.getDragSource().getDockable().getDockKey().getDockGroup();
if (!DockGroup.areGroupsCompatible( thisGroup, dragGroup)){
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).rejectDrag();
}
return;
}
Dockable d = event.getDragSource().getDockable();
int dockableState = d.getDockKey().getDockableState();
int viewState = dockable.getDockKey().getDockableState();
if (drop){
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(),
d, dockableState, viewState, dockable, 0));
/*if (dockable.getDockKey().getDockableState() == DockableState.STATE_FLOATING){
((DockDropEvent) event).acceptDrop(false); // don't remove a floating dockable from its hierarchy yet
} else {*/
((DockDropEvent) event).acceptDrop();
/*} */
desktop.createTab(dockable, event.getDragSource().getDockable(), 0, true);
} else {
event.setDockingAction(new DockingActionCreateTabEvent(event.getDesktop(),
d, dockableState, viewState, dockable, 0));
Rectangle2D r2d = new Rectangle2D.Float(bounds.x, bounds.y,
bounds.width,
bounds.height);
if (r2d.equals(lastDropShape)) {
// optimized shape caching
( (DockDragEvent) event).acceptDrag(lastDropGeneralPath);
} else {
// draw a 'tabbed pane shape'
GeneralPath path = buildPathForTab(bounds);;
lastDropShape = r2d;
lastDropGeneralPath = path;
( (DockDragEvent) event).acceptDrag(lastDropGeneralPath);
}
}
}
}
/** Create a path used to display the drag shape of a tab container */
protected GeneralPath buildPathForTab(Rectangle bounds){
GeneralPath path = new GeneralPath();
int tabPlacement = UIManager.getInt("TabbedDockableContainer.tabPlacement");
if (tabPlacement == SwingConstants.BOTTOM){
Rectangle tabRect = new Rectangle(0, 0,
bounds.width - 5, bounds.height - 5);
path.moveTo(tabRect.x, tabRect.y);
path.lineTo(tabRect.x + tabRect.width, tabRect.y);
path.lineTo(tabRect.x + tabRect.width, tabRect.y + tabRect.height - 15);
path.lineTo(tabRect.x + 30, tabRect.y + tabRect.height - 15);
path.lineTo(tabRect.x + 25, tabRect.y + tabRect.height);
path.lineTo(tabRect.x + 10, tabRect.y + tabRect.height);
path.lineTo(tabRect.x + 10, tabRect.y + tabRect.height - 15);
path.lineTo(tabRect.x, tabRect.y + tabRect.height - 15);
path.closePath();
} else { // TOP
Rectangle tabRect = new Rectangle(0, 20,
bounds.width - 5, bounds.height - 20-5);
path.moveTo(tabRect.x, tabRect.y);
path.lineTo(tabRect.x + 10, tabRect.y);
path.lineTo(tabRect.x + 10, tabRect.y - 15);
path.lineTo(tabRect.x + 25, tabRect.y - 15);
path.lineTo(tabRect.x + 30, tabRect.y );
path.lineTo(tabRect.x + tabRect.width, tabRect.y);
path.lineTo(tabRect.x + tabRect.width, tabRect.y + tabRect.height);
path.lineTo(tabRect.x, tabRect.y + tabRect.height);
path.closePath();
}
return path;
}
/** {@inheritDoc} */
public void installDocking(DockingDesktop desktop) {
this.desktop = desktop;
desktop.installDockableDragSource(title);
title.addPropertyChangeListener(DockViewTitleBar.PROPERTY_AUTOHIDE, listener);
title.addPropertyChangeListener(DockViewTitleBar.PROPERTY_CLOSED, listener);
title.addPropertyChangeListener(DockViewTitleBar.PROPERTY_MAXIMIZED, listener);
title.addPropertyChangeListener(DockViewTitleBar.PROPERTY_FLOAT, listener);
title.installDocking(desktop);
}
/** {@inheritDoc} */
public void uninstallDocking(DockingDesktop desktop) {
if (title != null){ // safety check, as removing is sometimes cascaded and done once more than it should be 2005/12/09
desktop.uninstallDockableDragSource(title);
title.removePropertyChangeListener(DockViewTitleBar.PROPERTY_AUTOHIDE, listener);
title.removePropertyChangeListener(DockViewTitleBar.PROPERTY_CLOSED, listener);
title.removePropertyChangeListener(DockViewTitleBar.PROPERTY_MAXIMIZED, listener);
title.removePropertyChangeListener(DockViewTitleBar.PROPERTY_FLOAT, listener);
title.uninstallDocking(desktop);
}
//remove(title);
title = null;
this.desktop = null;
}
/** Returns (or creates) the title bar of this dockview */
public DockViewTitleBar getTitleBar(){
if (title == null){
title = DockableContainerFactory.getFactory().createTitleBar();//2007/01/08
}
return title;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockViewAsTab.java 0000644 0001750 0001750 00000041260 10573516344 025535 0 ustar twerner twerner package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.tabbedpane.JTabbedPaneSmartIcon;
import com.vlsolutions.swing.tabbedpane.JTabbedPaneSmartIconManager;
import com.vlsolutions.swing.tabbedpane.SmartIconJButton;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import javax.swing.AbstractAction;
import javax.swing.Icon;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTabbedPane;
import javax.swing.KeyStroke;
import javax.swing.UIManager;
/** This component is used to display single dockables like if they were in a tabbed pane.
*
* Please note this component is still in its early stages and might change in future releases.
*
* To use it, just install the TabFactory as DockableContainerFactory
*
* @author Lilian Chamontin, VLSolutions
* @see TabFactory
* @since 2.1.3
*/
public class DockViewAsTab extends DockView implements SingleDockableContainer {
private static final String CLOSE_TEXT = UIManager.getString("DockViewTitleBar.closeButtonText");
private static final String ICONIFY_TEXT = UIManager.getString("DockViewTitleBar.minimizeButtonText");
private static final String RESTORE_TEXT = UIManager.getString("DockViewTitleBar.restoreButtonText");
private static final String MAXIMIZE_TEXT = UIManager.getString("DockViewTitleBar.maximizeButtonText");
private static final String FLOAT_TEXT = UIManager.getString("DockViewTitleBar.floatButtonText");
private static final String ATTACH_TEXT = UIManager.getString("DockViewTitleBar.attachButtonText");
private static Icon closeIcon = UIManager.getIcon("DockViewTitleBar.menu.close");
private static Icon maximizeIcon = UIManager.getIcon("DockViewTitleBar.menu.maximize");
private static Icon restoreIcon = UIManager.getIcon("DockViewTitleBar.menu.restore");
private static Icon hideIcon = UIManager.getIcon("DockViewTitleBar.menu.hide");
private static Icon dockIcon = UIManager.getIcon("DockViewTitleBar.menu.dock");
private static Icon floatIcon = UIManager.getIcon("DockViewTitleBar.menu.float");
private static Icon attachIcon = UIManager.getIcon("DockViewTitleBar.menu.attach");
/** The tab container in which the components are added */
protected TabHeader tabHeader = createTabHeader();
/** smart icon manager */
protected JTabbedPaneSmartIconManager tpManager = new JTabbedPaneSmartIconManager(tabHeader);
/** smart icon used to display the title */
protected JTabbedPaneSmartIcon smartIcon = new JTabbedPaneSmartIcon(null, " ", null);
protected AbstractAction closeAction = new AbstractAction("Close"){
public void actionPerformed(ActionEvent e){
desktop.close(getDockable());
}
};
protected SmartIconJButton closeSmartIcon = new SmartIconJButton(closeAction);
protected AbstractAction maximizeAction = new AbstractAction("Maximize"){
public void actionPerformed(ActionEvent e){
maximizeAction();
}
};
protected SmartIconJButton maximizeSmartIcon = new SmartIconJButton(maximizeAction);
protected AbstractAction hideAction = new AbstractAction("Hide"){
public void actionPerformed(ActionEvent e){
desktop.setAutoHide(getDockable(), true);
}
};
protected SmartIconJButton hideSmartIcon = new SmartIconJButton(hideAction);
protected AbstractAction floatAction = new AbstractAction("Float"){
public void actionPerformed(ActionEvent e){
desktop.setFloating(getDockable(), true);
}
};
protected SmartIconJButton floatSmartIcon = new SmartIconJButton(floatAction);
// flags to hide/show buttons in the title bar (they are always visible in the contextual menu, but might
// take too much space on the titles (for example a minimum set could be hide/float/close
// as maximize is accessed by double click)
protected boolean isCloseButtonDisplayed = UIManager.getBoolean("DockViewTitleBar.isCloseButtonDisplayed");
protected boolean isHideButtonDisplayed = UIManager.getBoolean("DockViewTitleBar.isHideButtonDisplayed");
protected boolean isDockButtonDisplayed = UIManager.getBoolean("DockViewTitleBar.isDockButtonDisplayed");
protected boolean isMaximizeButtonDisplayed= UIManager.getBoolean("DockViewTitleBar.isMaximizeButtonDisplayed");
protected boolean isRestoreButtonDisplayed= UIManager.getBoolean("DockViewTitleBar.isRestoreButtonDisplayed");
protected boolean isFloatButtonDisplayed= UIManager.getBoolean("DockViewTitleBar.isFloatButtonDisplayed");
protected boolean isAttachButtonDisplayed= UIManager.getBoolean("DockViewTitleBar.isAttachButtonDisplayed");
/** listen to the key changes */
private PropertyChangeListener keyListener = new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
String pName = e.getPropertyName();
if (pName.equals(DockKey.PROPERTY_ICON)) {
smartIcon.setIcon( (Icon) e.getNewValue());
} else if (pName.equals(DockKey.PROPERTY_NAME)) {
smartIcon.setLabel( (String) e.getNewValue());
revalidate();
} else if (pName.equals(DockKey.PROPERTY_TOOLTIP)) {
smartIcon.setTooltipText( (String) e.getNewValue());
} else if (pName.equals(DockKey.PROPERTY_AUTOHIDEABLE)){
resetTabIcons();
} else if (pName.equals(DockKey.PROPERTY_CLOSEABLE)){
resetTabIcons();
} else if (pName.equals(DockKey.PROPERTY_FLOATABLE)){
resetTabIcons();
} else if (pName.equals(DockKey.PROPERTY_MAXIMIZABLE)){
resetTabIcons();
}
}
};
private JPopupMenu currentPopUp = null;
/** reacts to single and double click on title bar */
private MouseListener titleMouseListener = new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
maximizeAction();
} else {
getDockable().getComponent().requestFocus();
}
}
public void mousePressed(MouseEvent e){
if (e.isPopupTrigger()){
checkForPopUp(e);
}
}
public void mouseReleased(MouseEvent e){
if (e.isPopupTrigger()){
checkForPopUp(e);
}
}
};
private ActionListener actionListener = new ActionListener(){
public void actionPerformed(ActionEvent e){
if (e.getActionCommand().equals("dock")){
dockAction();
} else if (e.getActionCommand().equals("close")){
closeAction();
} else if (e.getActionCommand().equals("maximize")){
maximizeAction();
} else if (e.getActionCommand().equals("float")){
floatAction();
}
}
};
public DockViewAsTab(Dockable dockable){
super(dockable, false);
add(tabHeader, BorderLayout.CENTER);
tabHeader.addMouseListener(titleMouseListener);
configureCloseButton();
configureHideButton();
configureMaximizeButton();
configureFloatButton();
setDockableAsTab(dockable);
}
private void checkForPopUp(MouseEvent e){
Dockable target = getDockable();
JPopupMenu popup = new JPopupMenu(target.getDockKey().getName());
// first add the standard menu
DockKey key = target.getDockKey();
switch (key.getDockableState()){
case DockableState.STATE_DOCKED:
initDockedPopUp(popup);
break;
case DockableState.STATE_HIDDEN:
//initAutoHidePopUp(popup);
break;
case DockableState.STATE_MAXIMIZED:
initMaximizedPopUp(popup);
break;
case DockableState.STATE_FLOATING:
initFloatingPopUp(popup);
break;
default:
// nothing to do
}
DockableActionCustomizer customizer = target.getDockKey().getActionCustomizer();
if (customizer != null && customizer.isSingleDockableTitleBarPopUpCustomizer()){
if (popup.getComponentCount() > 0){
popup.addSeparator();
}
customizer.visitSingleDockableTitleBarPopUp(popup, target);
}
if (popup.getComponentCount() > 0){
popup.show(tabHeader, e.getX(), e.getY());
this.currentPopUp = popup;
}
}
private JMenuItem createPopUpItem(String text, Icon icon, String tooltip, String actionCommand, KeyStroke accelerator){
JMenuItem menuItem = new JMenuItem(text, icon);
menuItem.setActionCommand(actionCommand);
menuItem.addActionListener(actionListener);
if (accelerator != null){
menuItem.setAccelerator(accelerator);
}
return menuItem;
}
/** Init the popup displayed as the title bar contextual menu */
protected void initMaximizedPopUp(JPopupMenu popup){
popup.add(createPopUpItem(RESTORE_TEXT, restoreIcon, RESTORE_TEXT,
"maximize", (KeyStroke)UIManager.get("DockingDesktop.maximizeActionAccelerator") ));
}
protected void initAutoHidePopUp(JPopupMenu popup){
if (DockingUtilities.isChildOfCompoundDockable(getDockable())){
// restore option not allowed for children of a compound dockable
} else {
popup.add(createPopUpItem(RESTORE_TEXT, dockIcon, RESTORE_TEXT,
"dock", (KeyStroke)UIManager.get("DockingDesktop.dockActionAccelerator")));
}
if (getDockable().getDockKey().isCloseEnabled()){
popup.add(createPopUpItem(CLOSE_TEXT, closeSmartIcon, CLOSE_TEXT,
"close", (KeyStroke)UIManager.get("DockingDesktop.closeActionAccelerator")));
}
}
protected void initDockedPopUp(JPopupMenu popup){
DockKey key = getDockable().getDockKey();
if (key.isAutoHideEnabled()){
popup.add(createPopUpItem(ICONIFY_TEXT, hideSmartIcon, ICONIFY_TEXT,
"dock", (KeyStroke)UIManager.get("DockingDesktop.dockActionAccelerator")));
}
if (key.isFloatEnabled()){
popup.add(createPopUpItem(FLOAT_TEXT, floatSmartIcon, FLOAT_TEXT,
"float", (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator")));
}
if (key.isMaximizeEnabled()){
popup.add(createPopUpItem(MAXIMIZE_TEXT, maximizeSmartIcon, MAXIMIZE_TEXT,
"maximize", (KeyStroke)UIManager.get("DockingDesktop.maximizeActionAccelerator")));
}
if (key.isCloseEnabled()){
popup.add(createPopUpItem(CLOSE_TEXT, closeSmartIcon, CLOSE_TEXT,
"close", (KeyStroke)UIManager.get("DockingDesktop.closeActionAccelerator")));
}
}
/** Init the popup displayed as the title bar contextual menu */
protected void initFloatingPopUp(JPopupMenu popup){
if (DockingUtilities.isChildOfCompoundDockable(getDockable())){
// attach option not allowed for children of a compound dockable
} else {
popup.add(createPopUpItem(ATTACH_TEXT, attachIcon, ATTACH_TEXT,
"float", (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator")));
}
}
/** This method is invoked to hide the pop-up that could still be visible
* (To avoid a visible pop-up for an invisible component)
*/
public void closePopUp(){
if (currentPopUp != null){
currentPopUp.setVisible(false);
// @todo uncertain about correct gc of the pop-up in that case
currentPopUp = null;
}
}
private void dockAction() {
if (isAutoHide()){
desktop.setAutoHide(getDockable(), false);
} else {
desktop.setAutoHide(getDockable(), true);
}
}
protected void maximizeAction(){
if (isMaximized()) {
desktop.restore(getDockable());
} else {
desktop.maximize(getDockable());
}
}
private void closeAction() {
desktop.close(getDockable());
}
private void floatAction() {
if (getDockable().getDockKey().getDockableState() == DockableState.STATE_FLOATING){
desktop.setFloating(getDockable(), true);
} else {
desktop.setFloating(getDockable(), false);
}
}
private boolean isAutoHide(){
return getDockable().getDockKey().getDockableState() == DockableState.STATE_HIDDEN;
}
private boolean isMaximized(){
return getDockable().getDockKey().getDockableState() == DockableState.STATE_MAXIMIZED;
}
protected void configureFloatButton() {
if (isFloatButtonDisplayed){
floatSmartIcon.setIcon(UIManager.getIcon("DockViewTitleBar.float"));
floatSmartIcon.setPressedIcon(UIManager.getIcon("DockViewTitleBar.float.pressed"));
floatSmartIcon.setRolloverIcon(UIManager.getIcon("DockViewTitleBar.float.rollover"));
// add a tooltip
floatAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockViewTitleBar.floatButtonText"));
}
}
protected void configureMaximizeButton() {
if (isMaximizeButtonDisplayed){
maximizeSmartIcon.setIcon(UIManager.getIcon("DockViewTitleBar.maximize"));
maximizeSmartIcon.setPressedIcon(UIManager.getIcon("DockViewTitleBar.maximize.pressed"));
maximizeSmartIcon.setRolloverIcon(UIManager.getIcon("DockViewTitleBar.maximize.rollover"));
// add a tooltip
maximizeAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockViewTitleBar.maximizeButtonText"));
}
}
protected void configureHideButton() {
if (isHideButtonDisplayed){
hideSmartIcon.setIcon(UIManager.getIcon("DockViewTitleBar.hide"));
hideSmartIcon.setPressedIcon(UIManager.getIcon("DockViewTitleBar.hide.pressed"));
hideSmartIcon.setRolloverIcon(UIManager.getIcon("DockViewTitleBar.hide.rollover"));
// add a tooltip
hideAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockViewTitleBar.minimizeButtonText"));
}
}
protected void configureCloseButton() {
if (isCloseButtonDisplayed){
closeSmartIcon.setIcon(UIManager.getIcon("DockTabbedPane.close"));
closeSmartIcon.setPressedIcon(UIManager.getIcon("DockTabbedPane.close.pressed"));
closeSmartIcon.setRolloverIcon(UIManager.getIcon("DockTabbedPane.close.rollover"));
// add a tooltip
closeAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockTabbedPane.closeButtonText"));
}
}
public void setDockable(Dockable d){
// overriden to disable DockView settings
}
public void setDockableAsTab(final Dockable d){
this.dockable = d;
if (title != null){ // still needed as removeing it triggers Exception... we'll have to
// remove it one day (when building a proper ui class)
title.setDockable(dockable);
}
resetTabIcons();
// allow resizing of split pane beyond minimum size
// could be replaced by adding a JScrollPane instead of panels
setMinimumSize(new Dimension(30,30));
}
public void resetTabIcons(){
ArrayList icons = new ArrayList();
DockKey k = getDockable().getDockKey();
if (k.isCloseEnabled() && isCloseButtonDisplayed){
icons.add(closeSmartIcon);
}
if (k.isMaximizeEnabled() && isMaximizeButtonDisplayed){
icons.add(maximizeSmartIcon);
}
if (k.isAutoHideEnabled()&& isHideButtonDisplayed){
icons.add(hideSmartIcon);
}
if (k.isFloatEnabled() && isFloatButtonDisplayed){
icons.add(floatSmartIcon);
}
// this is an attempt to create the set of icons displayed for this dockable
// currently, only "close" is managed, but other buttons could be added, as
// the jTabebdPaneSmartIcon supports(simulates) many sub-buttons.
if (icons.size()> 0){
SmartIconJButton [] iconsArray = (SmartIconJButton[]) icons.toArray(new SmartIconJButton[0]);
smartIcon = new JTabbedPaneSmartIcon(k.getIcon(), k.getName(), iconsArray);
smartIcon.setIconForTabbedPane(tabHeader);
tabHeader.addTab("", smartIcon, getDockable().getComponent());
} else {
tabHeader.addTab(k.getName(), k.getIcon(), getDockable().getComponent());
}
}
/** {@inheritDoc} */
public void installDocking(DockingDesktop desktop) {
this.desktop = desktop;
desktop.installDockableDragSource(tabHeader);
dockable.getDockKey().addPropertyChangeListener(keyListener);
}
/** {@inheritDoc} */
public void uninstallDocking(DockingDesktop desktop) {
desktop.uninstallDockableDragSource(tabHeader);
dockable.getDockKey().removePropertyChangeListener(keyListener);
}
public String getUIClassID() {
return "PanelUI"; // default panel UI
}
protected TabHeader createTabHeader(){
return new TabHeader();
}
protected class TabHeader extends JTabbedPane implements DockableDragSource {
public boolean startDragComponent(Point p) {
Rectangle bounds = getBoundsAt(0);
return bounds.contains(p);
}
public Container getDockableContainer() {
return DockViewAsTab.this;
}
public Dockable getDockable() {
return dockable;
}
public void endDragComponent(boolean dropped) {
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockViewTitleBar.java 0000644 0001750 0001750 00000071600 10573516350 026247 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.beans.PropertyChangeEvent;
import java.awt.event.MouseEvent;
import java.awt.Component;
import java.awt.Point;
import java.util.*;
/** A title bar, associated to a DockView (container of a single user component).
*
* Here is an example of a title bar :
* DockViewTitleBar is able to display the following properties of a DockKey :
*
* This title bar supports buttons used for docking features :
*
* The buttons managed have no effect on the state of the dockable : they just fire
* property change events, and it is the responsibility of the DockableContainer to
* listen to those events and to relay the operation to the docking desktop.
*
* Note : the UI Delegate of the DockViewTitleBar is the {@link com.vlsolutions.swing.docking.ui.DockViewTitleBarUI}
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class DockViewTitleBar extends JPanel implements DockableDragSource {
/** Property name designating the autohide button selection */
public static final String PROPERTY_AUTOHIDE = "DockTitle.AUTOHIDE";
/** Property name designating the close button selection */
public static final String PROPERTY_CLOSED = "DockTitle.CLOSED";
/** Property name designating a drag gesture beginning */
public static final String PROPERTY_DRAGGED = "DockTitle.DRAGGED";
/** Property name designating the maximized button selection */
public static final String PROPERTY_MAXIMIZED = "DockTitle.MAXIMIZED";
/** Property name designating the float button selection */
public static final String PROPERTY_FLOAT = "DockTitle.FLOAT";
private static final String uiClassID = "DockViewTitleBarUI";
private static final String CLOSE_TEXT = UIManager.getString("DockViewTitleBar.closeButtonText");
private static final String ICONIFY_TEXT = UIManager.getString("DockViewTitleBar.minimizeButtonText");
private static final String RESTORE_TEXT = UIManager.getString("DockViewTitleBar.restoreButtonText");
private static final String MAXIMIZE_TEXT = UIManager.getString("DockViewTitleBar.maximizeButtonText");
private static final String FLOAT_TEXT = UIManager.getString("DockViewTitleBar.floatButtonText");
private static final String ATTACH_TEXT = UIManager.getString("DockViewTitleBar.attachButtonText");
private static Icon closeIcon = UIManager.getIcon("DockViewTitleBar.menu.close");
private static Icon maximizeIcon = UIManager.getIcon("DockViewTitleBar.menu.maximize");
private static Icon restoreIcon = UIManager.getIcon("DockViewTitleBar.menu.restore");
private static Icon hideIcon = UIManager.getIcon("DockViewTitleBar.menu.hide");
private static Icon dockIcon = UIManager.getIcon("DockViewTitleBar.menu.dock");
private static Icon floatIcon = UIManager.getIcon("DockViewTitleBar.menu.float");
private static Icon attachIcon = UIManager.getIcon("DockViewTitleBar.menu.attach");
// ------------ member fields --------------
// this creation tricks to manage the UI class requiring access to the components
// before they are created
private JLabel titleLabel = getTitleLabel();
private JButton closeButton = getCloseButton();
private JButton dockButton = getHideOrDockButton();
private JButton maximizeButton = getMaximizeOrRestoreButton();
private JButton floatButton = getFloatButton();
private boolean active;
private ActionListener actionListener = new ActionListener(){
public void actionPerformed(ActionEvent e){
if (e.getActionCommand().equals("dock")){
dockAction();
} else if (e.getActionCommand().equals("close")){
closeAction();
} else if (e.getActionCommand().equals("maximize")){
maximizeAction();
} else if (e.getActionCommand().equals("float")){
floatAction();
}
}
};
private Dockable target; // the component this title is for
/** used to have a state of blinking (notification) */
private boolean isNotification = false;
private JPopupMenu currentPopUp = null;
/** current blinking count (the limit to the notification timer) */
private int blinkCount = 0;
private int MAX_BLINKS = UIManager.getInt("DockingDesktop.notificationBlinkCount");
/** reacts to single and double click on title bar */
private MouseListener titleMouseListener = new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
maximizeAction();
} else {
//requestFocus();
// replaced by a better focus behaviour for 1.2
target.getComponent().requestFocus();
}
}
public void mousePressed(MouseEvent e){
if (e.isPopupTrigger()){
checkForPopUp(e);
}
}
public void mouseReleased(MouseEvent e){
if (e.isPopupTrigger()){
checkForPopUp(e);
}
}
};
/** listen to the key changes */
private PropertyChangeListener dockKeyListener = new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
String pName = e.getPropertyName();
if (pName.equals(DockKey.PROPERTY_ICON)) {
titleLabel.setIcon( (Icon) e.getNewValue());
} else if (pName.equals(DockKey.PROPERTY_NAME)) {
titleLabel.setText( (String) e.getNewValue());
revalidate();
} else if (pName.equals(DockKey.PROPERTY_TOOLTIP)) {
setToolTipText( (String) e.getNewValue());
} else if (pName.equals(DockKey.PROPERTY_NOTIFICATION)) {
// attract user attention
boolean isOn = ( (Boolean) e.getNewValue()).booleanValue();
if (isOn && !isActive()) {
if (notificationTimer == null) {
notificationTimer = new javax.swing.Timer(1000,
new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
setNotification(!isNotification);
if (!isNotification){
blinkCount ++;
if (blinkCount >= MAX_BLINKS){
blinkCount = 0;
notificationTimer.stop(); // enough blinking
}
}
}
});
}
notificationTimer.restart();
} else {
if (notificationTimer != null) {
notificationTimer.stop();
blinkCount = 0;
}
setNotification(false);
}
}
/*else if (pName.equals(DockKey.PROPERTY_DOCKABLE_STATE)){
*
int newState = ((Integer)e.getNewValue()).intValue();
int oldState = ((Integer)e.getOldValue()).intValue();
switch (newState){
case DockableState.STATE_HIDDEN :
setAutoHide(true);
break;
case DockableState.STATE_MAXIMIZED :
setMaximized(true);
break;
case DockableState.STATE_DOCKED :
if (oldState == DockableState.STATE_HIDDEN){
setAutoHide(false);
}
break;
default:
//@todo : managed the floatable state
// nothing to track here
}
}*/
}
};
/** Timer used to trigger repaint event for notification (blinking title bar) */
private javax.swing.Timer notificationTimer;
/** singleton for keyboard management */
private static FocusHighlighter focusHighlighter = new FocusHighlighter(); //2005/11/10
private DockingDesktop desktop;
/** Constructs an empty title bar (no dockable yet associated).
*/
public DockViewTitleBar() {
this(null);
}
/** Constructs a title bar for the specified dockable.
*
* Warning : a DockViewTitleBar can be used with multiple dockables (this is the case
* for example in autohide borders, where a single titlebar is shared by all hidden dockables
* (shown only when one is expanding).
*/
public DockViewTitleBar(Dockable dockable) {
setDockable(dockable);
setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
setOpaque(true);
closeButton.setText("");
dockButton.setText("");
maximizeButton.setText("");
closeButton.setActionCommand("close");
dockButton.setActionCommand("dock");
maximizeButton.setActionCommand("maximize");
floatButton.setActionCommand("float");
closeButton.addActionListener(actionListener);
dockButton.addActionListener(actionListener);
maximizeButton.addActionListener(actionListener);
floatButton.addActionListener(actionListener);
this.addMouseListener(titleMouseListener);
//maximizeButton.addMouseListener(new ButtonRolloverEffect());
}
/** Returns the desktop associated to this title bar, if one has been registered
* with #installDocking(DockingDesktop), or null.
*/
public DockingDesktop getDesktop(){
return desktop;
}
/** Overriden as a means to unregister internal listeners, do not call directly */
public void removeNotify(){
super.removeNotify();
/* KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(
focusHighlighter); 2005/11/10: now it's shared between title bars*/
if (target != null){
target.getDockKey().removePropertyChangeListener(dockKeyListener);
}
}
/** called to build the title bar */
protected void layoutTitleBar(){
removeAll();
add(Box.createHorizontalStrut(4)); // keep the label not to close to the border
add(titleLabel);
add(Box.createHorizontalGlue());
int height = UIManager.getInt("DockViewTitleBar.height");
add(Box.createRigidArea(new Dimension(4,height))); // fixed height
add(dockButton);
add(floatButton);
add(maximizeButton);
add(closeButton);
}
/** Returns the label used to display the dockkey name.
* Shouldn't be used to update the title : the best way is to update the
* DockKey (property listener ensure the labels and buttons stay in sync).
*
*@since 2.0
*/
public JLabel getTitleLabel(){
if (titleLabel == null){
titleLabel = new JLabel();
}
return titleLabel;
}
public JButton getCloseButton(){
if (closeButton == null){
closeButton = new JButton();
}
return closeButton;
}
/** returns the button used for hiding or docking the view.
*
* As hiding and docking are mutually exclusive, the same button is used for both purposes
*/
public JButton getHideOrDockButton(){
if (dockButton == null){
dockButton = new JButton();
}
return dockButton;
}
/** returns the button used for maximizing or restoring the view.
*
* As those operations are mutually exclusive, the same button is used for both purposes
*/
public JButton getMaximizeOrRestoreButton(){
if (maximizeButton == null){
maximizeButton = new JButton();
}
return maximizeButton;
}
/** returns the button used for floating (detach) the view.
*/
public JButton getFloatButton(){
if (floatButton == null){
floatButton = new JButton();
}
return floatButton;
}
private void setNotification(boolean notification) {
boolean old = this.isNotification;
this.isNotification = notification;
firePropertyChange("titlebar.notification", old, notification);
}
private boolean isAutoHide(){
return target.getDockKey().getDockableState() == DockableState.STATE_HIDDEN;
}
private boolean isMaximized(){
return target.getDockKey().getDockableState() == DockableState.STATE_MAXIMIZED;
}
private void dockAction() {
boolean old = isAutoHide();
firePropertyChange(PROPERTY_AUTOHIDE, old, !old);
}
private void maximizeAction() {
// we use the visible property of the button to check if maximization
// is enabled or not
if (maximizeButton.isVisible()){
boolean old = isMaximized();
// we don't really change the maximized property,
// which will be updated if the desktop accepts this maximization
/* We do not use fireVetoableChange, to keep maximization processing outside
* the title bar (everything is driven par the dockingdesktop and the
* SingleDockableContainer
*/
firePropertyChange(PROPERTY_MAXIMIZED, old, !old);
}
}
private void closeAction() {
firePropertyChange(PROPERTY_CLOSED, false, true);
}
private void floatAction() {
if (target.getDockKey().getDockableState() == DockableState.STATE_FLOATING){
firePropertyChange(PROPERTY_FLOAT, true, false);
} else {
firePropertyChange(PROPERTY_FLOAT, false, true);
}
}
/** This method is invoked to hide the pop-up that could still be visible
* (To avoid a visible pop-up for an invisible component)
*/
public void closePopUp(){
if (currentPopUp != null){
currentPopUp.setVisible(false);
// @todo uncertain about correct gc of the pop-up in that case
currentPopUp = null;
}
}
/** {@inheritDoc}
* @since 2.0
*/
public String getUIClassID() {
return uiClassID;
}
/** Returns true if the dockable is the currently active one.
*
* There is at most one active dockable for a dekstop, and it there is one,
* it is the one which contains the keybord focused component.
* */
public boolean isActive() {
return active;
}
/** Updates the active property.
* A title bar is active when the dockable it is for is ancestor of
* the keybord focused component.
* */
public void setActive(boolean active) {
boolean old = this.active;
this.active = active;
firePropertyChange("active", old, active);
}
/** Changes the dockable this title bar is for */
public void setDockable(Dockable dockable) {
Dockable old = target;
if (target != null && target != dockable) {
target.getDockKey().removePropertyChangeListener(dockKeyListener);
}
if (dockable != null) {
this.target = dockable;
layoutTitleBar();
DockKey key = dockable.getDockKey();
titleLabel.setText(key.getName());
titleLabel.setIcon(key.getIcon());
setToolTipText(key.getTooltip());
revalidate();
/*dockButton.setVisible(key.isAutoHideEnabled());
this.autoHide = key.getDockableState() == DockableState.STATE_HIDDEN;
setDockButtonAsAutoHide(autoHide);
closeButton.setVisible(key.isCloseEnabled());
maximizeButton.setVisible(key.isMaximizeEnabled() && !autoHide);*/
key.addPropertyChangeListener(dockKeyListener);
}
firePropertyChange("dockable", old, dockable);
}
/** {@inheritDoc} */
public Dockable getDockable() {
return target;
}
/** {@inheritDoc} */
public boolean startDragComponent(Point p) {
// disable DnD for some cases :
// - child of a compound dockable, in hidden state
// - child of a maximized compund dockable
// - maximized dockable
int targetState = target.getDockKey().getDockableState();
if (targetState == DockableState.STATE_HIDDEN){
if (DockingUtilities.isChildOfCompoundDockable(target)){
// nested hidden dockables cannot be drag and dropped
return false;
}
} else if (targetState == DockableState.STATE_DOCKED){
boolean isChildOfMaximizedContainer = false;
if (desktop != null){
Dockable max = desktop.getMaximizedDockable();
if (max != null && max.getComponent().getParent().isAncestorOf(this)){
isChildOfMaximizedContainer = true;
}
}
if (isChildOfMaximizedContainer){
return false;
}
} else if (targetState == DockableState.STATE_MAXIMIZED){
return false;
}
// notify our listeners that drag has begun
firePropertyChange(PROPERTY_DRAGGED, false, true);
return true;
}
/** Returns a readeable String representing this title bar */
public String toString() {
if (target != null) {
return "DockViewTitleBar of [" + target.getDockKey() + "]";
} else {
return "DockViewTitleBar";
}
}
private JMenuItem createPopUpItem(String text, Icon icon, String tooltip, String actionCommand, KeyStroke accelerator){
JMenuItem menuItem = new JMenuItem(text, icon);
menuItem.setActionCommand(actionCommand);
menuItem.addActionListener(actionListener);
if (accelerator != null){
menuItem.setAccelerator(accelerator);
}
return menuItem;
}
private void checkForPopUp(MouseEvent e){
JPopupMenu popup = new JPopupMenu(target.getDockKey().getName());
// first add the standard menu
DockKey key = target.getDockKey();
switch (key.getDockableState()){
case DockableState.STATE_DOCKED:
initDockedPopUp(popup);
break;
case DockableState.STATE_HIDDEN:
initAutoHidePopUp(popup);
break;
case DockableState.STATE_MAXIMIZED:
initMaximizedPopUp(popup);
break;
case DockableState.STATE_FLOATING:
initFloatingPopUp(popup);
break;
default:
// nothing to do
}
DockableActionCustomizer customizer = target.getDockKey().getActionCustomizer();
if (customizer != null && customizer.isSingleDockableTitleBarPopUpCustomizer()){
if (popup.getComponentCount() > 0){
popup.addSeparator();
}
customizer.visitSingleDockableTitleBarPopUp(popup, target);
}
if (popup.getComponentCount() > 0){
popup.show(DockViewTitleBar.this, e.getX(), e.getY());
this.currentPopUp = popup;
}
}
/** Init the popup displayed as the title bar contextual menu */
protected void initMaximizedPopUp(JPopupMenu popup){
popup.add(createPopUpItem(RESTORE_TEXT, restoreIcon, RESTORE_TEXT,
"maximize", (KeyStroke)UIManager.get("DockingDesktop.maximizeActionAccelerator") ));
}
protected void initAutoHidePopUp(JPopupMenu popup){
if (DockingUtilities.isChildOfCompoundDockable(target)){
// restore option not allowed for children of a compound dockable
} else {
popup.add(createPopUpItem(RESTORE_TEXT, dockIcon, RESTORE_TEXT,
"dock", (KeyStroke)UIManager.get("DockingDesktop.dockActionAccelerator")));
}
if (target.getDockKey().isCloseEnabled()){
popup.add(createPopUpItem(CLOSE_TEXT, closeIcon, CLOSE_TEXT,
"close", (KeyStroke)UIManager.get("DockingDesktop.closeActionAccelerator")));
}
}
protected void initDockedPopUp(JPopupMenu popup){
DockKey key = target.getDockKey();
if (key.isAutoHideEnabled()){
popup.add(createPopUpItem(ICONIFY_TEXT, hideIcon, ICONIFY_TEXT,
"dock", (KeyStroke)UIManager.get("DockingDesktop.dockActionAccelerator")));
}
if (key.isFloatEnabled()){
popup.add(createPopUpItem(FLOAT_TEXT, floatIcon, FLOAT_TEXT,
"float", (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator")));
}
if (key.isMaximizeEnabled()){
popup.add(createPopUpItem(MAXIMIZE_TEXT, maximizeIcon, MAXIMIZE_TEXT,
"maximize", (KeyStroke)UIManager.get("DockingDesktop.maximizeActionAccelerator")));
}
if (key.isCloseEnabled()){
popup.add(createPopUpItem(CLOSE_TEXT, closeIcon, CLOSE_TEXT,
"close", (KeyStroke)UIManager.get("DockingDesktop.closeActionAccelerator")));
}
}
/** Init the popup displayed as the title bar contextual menu */
protected void initFloatingPopUp(JPopupMenu popup){
if (DockingUtilities.isChildOfCompoundDockable(target)){
// attach option not allowed for children of a compound dockable
} else {
popup.add(createPopUpItem(ATTACH_TEXT, attachIcon, ATTACH_TEXT,
"float", (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator")));
}
}
/** Returns the container of the dockable's component */
public Container getDockableContainer() {
// easy
return getParent();
}
public void installDocking(DockingDesktop desktop) {
this.desktop = desktop;
}
public void uninstallDocking(DockingDesktop desktop){
this.desktop = null;
}
/** notifies the source when the drag operation has ended (by a drop or cancelled)
* @since 2.1.3
*/
public void endDragComponent(boolean dropped){
// nothing more to do
}
/* used to highlight the title bar when its parent is ancestor of the
* focused component
*/
private static class FocusHighlighter implements PropertyChangeListener {
private DockViewTitleBar activeTitleBar;
FocusHighlighter(){
// this is a singleton so we register here for keyboard focus events properties
KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(
"focusOwner", this);
}
// focusOwner
public void propertyChange(PropertyChangeEvent e) {
Component c = (Component) e.getNewValue();
Component ancestor = c;
// is the focus contained in a single dockable container
while(ancestor != null && !(ancestor instanceof SingleDockableContainer) ){
ancestor = ancestor.getParent();
}
if (ancestor != null){
if (ancestor instanceof DockView){
DockView view = (DockView) ancestor;
DockViewTitleBar tb = view.getTitleBar();
if (tb == activeTitleBar){
// no view change in focus
} else if (tb != null){
if (activeTitleBar != null){
activeTitleBar.setActive(false);
}
tb.setActive(true);
// reset notification (blinking)
Dockable target = tb.target;
if (target != null && target.getDockKey() != null){ //2007/02/27 fixed NPE
target.getDockKey().setNotification(false);
}
} else { // tb == null && tb != activeTitleBar
activeTitleBar.setActive(false);
}
activeTitleBar = tb;
} else if (ancestor instanceof AutoHideExpandPanel){
DockViewTitleBar tb = ((AutoHideExpandPanel)ancestor).getTitleBar();
if (tb == activeTitleBar){
// no view change in focus
} else if (tb != null){
if (activeTitleBar != null){
activeTitleBar.setActive(false);
}
tb.setActive(true);
// reset notification (blinking)
tb.target.getDockKey().setNotification(false);
} else { // tb == null && tb != activeTitleBar
activeTitleBar.setActive(false);
}
activeTitleBar = tb;
} else {
if (activeTitleBar != null){
activeTitleBar.setActive(false);
}
activeTitleBar = null;
}
} else {
if (activeTitleBar != null){
activeTitleBar.setActive(false);
}
activeTitleBar = null;
}
/* // try to find if the component taking the focus is the ancestor
if (activeTitleBar != null){
Container parent = activeTitleBar.getParent();
if (parent != null && c != null && parent.isAncestorOf(c)) {
if (!active) {
setActive(true);
}
// reset notification (blinking)
target.getDockKey().setNotification(false);
} else if (active) {
setActive(false);
}
*/
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/Dockable.java 0000644 0001750 0001750 00000013054 10573516350 024610 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.*;
/** Interface describing a component (AWT/Swing) that can be managed by the
* DockingDesktop.
*
*
* Objects implementing this interface are usually wrappers around user components,
* or user components themselves.
*
* It can be used, for example, to add a set of menu items to the contextual menu
* associated with any dockable.
* Example :
*
* Implementation Note : the customizer is invoked every time a pop-up is triggered
* from the associated dockable container. It is a good practice to keep object creation
* and listener attachments outside the visit..() methods.
*
* @author Lilian Chamontin, VLSolutions
*/
public class DockableActionCustomizer {
private boolean isSingleDockableTitleBarPopUpCustomizer = false;
private boolean isTabSelectorPopUpCustomizer = false;
/** Default constructor */
public DockableActionCustomizer() {
}
/** Override this method to add contextual items at the end of the pop-up menu
* which can be triggered on a tab selector.
*
* It is recommended to add menu items at the end to the pop-up menu as other
* items may have been installed by other visitors (DockGroup for example)
*
* implementation note : This method can be called multiple times as pop-up menus are built during
* the contextual event dispatch (not stored for the life of the dockable).
*
*/
public void visitTabSelectorPopUp(JPopupMenu popUpMenu, Dockable tabbedDockable){
}
/** Override this method to add contextual items at the end of the pop-up menu
* which can be triggered on the title bar of a single dockable.
*
* It is recommended to add menu items at the end to the pop-up menu as other
* items may have been installed by other visitors (DockGroup for example)
*
* implementation note : This method can be called multiple times as pop-up menus are built during
* the contextual event dispatch (not stored for the life of the dockable).
*
*/
public void visitSingleDockableTitleBarPopUp(JPopupMenu popUpMenu, Dockable dockable){
}
/** Returns wether this customizer is used in the context of a SingleDockableContainer */
public boolean isSingleDockableTitleBarPopUpCustomizer(){
return this.isSingleDockableTitleBarPopUpCustomizer;
}
/** Updates the singleDockableTitleBar property.
* @see #isSingleDockableTitleBarPopUpCustomizer()
*/
public void setSingleDockableTitleBarPopUpCustomizer(boolean isCustomizer){
this.isSingleDockableTitleBarPopUpCustomizer = isCustomizer;
}
/** Returns wether this customizer is used in the context of a TabbedDockableContainer */
public boolean isTabSelectorPopUpCustomizer(){
return this.isTabSelectorPopUpCustomizer;
}
/** Updates the tabSelectorDockableTitleBar property
* @see #isTabSelectorPopUpCustomizer()
*/
public void setTabSelectorPopUpCustomizer(boolean isCustomizer){
this.isTabSelectorPopUpCustomizer = isCustomizer;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableContainer.java 0000644 0001750 0001750 00000013135 10573516350 026453 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
/** A DockableContainer is the base interface of GUI components used to
* display
* The components are usually displayed with decorations
* (a title bar, docking state management buttons, a drop shadow, ...)
*
* This interface is meant for API extenders that would like to create new kind of
* containers (via the sub-interfaces {@link SingleDockableContainer}
* and {@link TabbedDockableContainer} and the {@link DockableContainerFactory}).
*
* Usually, a DockableContainer also contains (or implements) one ore more
*
*
* @see DockableDragSource
* @see DockableContainerFactory
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public interface DockableContainer {
/** Invoked once after creation, in order to let this component register
* its DockableDragSources to the DockingDesktop, and have a reference of this
* Desktop.
*
* basic implementation use a single DragSource, and thus calls
* desk.installDockableDragSource(dragSource).
*
*
* */
public void installDocking(DockingDesktop desktop);
/** Called once, when the dockablecontainer is no longer used by the desktop,
* in order to releases resources and listeners taken on
* This factory enables API Extenders to change part of the behaviour on the DockingDesktop
* (mostly about look and feel issues) without modifying the code of that central class.
*
* @see DockableContainer
* @see DefaultDockableContainerFactory : the default implementation
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.1
* @update 2007/01/08 Lilian Chamontin : updated to declare a new titlebar factory method
* */
public abstract class DockableContainerFactory {
private static DockableContainerFactory factory;
/** Constant used to describe the type of usage a SingleDockableContainer is for*/
public static final int PARENT_DESKTOP = 0;
/** Constant used to describe the type of usage a SingleDockableContainer is for*/
public static final int PARENT_TABBED_CONTAINER = 1;
/** Constant used to describe the type of usage a SingleDockableContainer is for*/
public static final int PARENT_SPLIT_CONTAINER = 2;
/** Constant used to describe the type of usage a SingleDockableContainer is for*/
public static final int PARENT_DETACHED_WINDOW = 3;
/** This method is called by the DockingDesktop whenever a dockable is inserted
* in its containment hierachy.
*
*/
public abstract SingleDockableContainer createDockableContainer(Dockable dockable, int parentType);
/** @deprecated use the other createDockableContainer method ({@link #createDockableContainer(Dockable, int)}
*/
public SingleDockableContainer createDockableContainer(Dockable dockable, boolean c){
return createDockableContainer(dockable, PARENT_SPLIT_CONTAINER);
}
/** This method is called when a tab insertion is requested by the DockingDesktop. */
public abstract TabbedDockableContainer createTabbedDockableContainer();
/** This method is called when a dockable is detached from the DockingDesktop and put
* in the FLOATING state.
*
* The floating container must be an instanceof Dialog or Window.
*/
public abstract FloatingDockableContainer createFloatingDockableContainer(Window owner);
/** This method is invoked when a dockable container needs to install a title bar.
*
* This method is used by the standard implementation of Docking (DockView, etc) but is optional
* for other implementations, as currently the titlebar isn't specified as a core component of
* the docking framework (i.e. it is not an interface).
*@since 2.1.3
*/
public abstract DockViewTitleBar createTitleBar();
/** Returns the current factory.
* it no factory has been provided, it will
* fall back on DefaultDockableContainerFactory
*/
public static DockableContainerFactory getFactory(){
if (factory == null){
factory = new DefaultDockableContainerFactory();
}
return factory;
}
/** Changes the factory to be used by DockingDesktop.
*
* Note that this change is not propagated to already docked components.
* */
public static void setFactory(DockableContainerFactory f){
factory = f;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableDragSource.java 0000644 0001750 0001750 00000013516 10573516350 026572 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.*;
/** An interface implemented by visual components used for drag and drop operations
* on a DockableContainer.
*
* This interface is used by API Extenders to create new kind of drag sources.
*
* A "Drag Source" is a component, linked to a
* For example, the title bar of a docked component is usually the drag source of
* this component (meaning : when a user drags the title bar, he expects the dockable
* to be dragged around).
*
* These draggable components must be able to give informations about their
* target (the component known to the user, which is actually dragged).
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public interface DockableDragSource {
/** Notifies this source that a drag operation has begun.
* The source may reject the drag according to internal conditions (in that case
* this method shall return
* It's a JPanel with a BorderLayout, and it can display a single Dockable.
*
* This class is provided as an intermediary between a User Component and the docking
* desktop (for example, for application that don't want to be too tied with the
* DockingFramework).
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class DockablePanel extends JPanel implements Dockable{
private DockKey key;
public DockablePanel() {
setLayout(new BorderLayout());
}
public DockablePanel(Component contained, DockKey key) {
setLayout(new BorderLayout());
add(contained, BorderLayout.CENTER);
this.key = key;
}
public DockKey getDockKey() {
return key;
}
public void setDockKey(DockKey key){
this.key = key;
}
public Component getComponent() {
return this;
}
/** Removes all contained components (normally no more than one), and
* put this This is mainly to allow auto-registration of new dockables when loading a new workspace.
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1.2
*/
public interface DockableResolver {
/** Returns the dockable which should be associated to this DockKey identifier, or null if
* not found.
*/
public Dockable resolveDockable(String keyName);
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableState.java 0000644 0001750 0001750 00000021646 10573516350 025617 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.*;
/** General information about the current state of a dockable component.
*
* This class is a simple record of a dockable and its current display state.
* It is used together with DockableStateChangeEvents (and listeners) to
* track changes of Dockable visibility.
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*
* @update 2005/10/07 Lilian Chamontin : added getStateName(int state) method
*/
public class DockableState implements Comparable {
private Dockable dockable;
private static final String [] stateNames = {"CLOSED", "DOCKED", "HIDDEN", "MAXIMIZED", "FLOATING"};
/** A constant describing a Dockable that is not visible.
*
*/
public static final int STATE_CLOSED = 0; // only registered
/** A constant describing a Dockable that is visible (displayed in a DockableContainer) */
public static final int STATE_DOCKED = 1;
/** A constant describing a Dockable that is in auto-hide mode (reduced to a button) */
public static final int STATE_HIDDEN = 2;
/** A constant describing a Dockable that is currently maximized */
public static final int STATE_MAXIMIZED = 3;
/** A constant describing a Dockable that is currently floating (detached from the desktop) */
public static final int STATE_FLOATING = 4;
private int state ;
/** Relative position for hidden/closed dockable show-again */
private RelativeDockablePosition position;
/** Desktop currently using this dockable */
private DockingDesktop desktop;
public DockableState() {
position = new RelativeDockablePosition();
}
public DockableState(DockingDesktop desktop, Dockable dockable, int state) {
this.desktop = desktop;
this.dockable = dockable;
this.state = state;
position = new RelativeDockablePosition();
}
public DockableState(DockingDesktop desktop, Dockable dockable, int state, RelativeDockablePosition position) {
this.desktop = desktop;
this.dockable = dockable;
this.state = state;
this.position = position;
}
/** Creates a dockable state based on an existing state, with another relative positionning */
public DockableState(DockableState copy, RelativeDockablePosition position) {
this.desktop = copy.desktop;
this.dockable = copy.dockable;
this.state = copy.state;
this.position = position;
}
/** Comparable interface, used to sort components by name order.
* */
public int compareTo(Object object) {
if (object instanceof DockableState){
return dockable.getDockKey().getName().compareTo( ( (DockableState)
object).dockable.getDockKey().getName());
} else {
return -1;
}
}
/** Returns the dockable this state is for */
public Dockable getDockable() {
return dockable;
}
/** Convenience method returning wether the dockable is in the DOCKED state */
public boolean isDocked(){
return state == STATE_DOCKED;
}
/** Convenience method returning wether the dockable is in the HIDDEN state */
public boolean isHidden(){
return state == STATE_HIDDEN;
}
/** Convenience method returning wether the dockable is in the CLOSED state */
public boolean isClosed(){
return state == STATE_CLOSED;
}
/** Convenience method returning wether the dockable is in the FLOATING state */
public boolean isFloating(){
return state == STATE_FLOATING;
}
/** Convenience method returning wether the dockable is in the MAXIMIZED state */
public boolean isMaximized(){
return state == STATE_MAXIMIZED;
}
/** Returns the current state of the dockable (CLOSED, DOCKED, HIDDEN...).
*/
public int getState() {
return state;
}
/** Returns the relative restore position of the dockable when it is not shown (auto-hide
* or closed).
*
* Please note that this position is meaningless for visible components
* (as it is not automatically calculated at every move / resize of the dockable ).
*
* */
public RelativeDockablePosition getPosition(){
return position;
}
public String toString(){
return "DockableState [" + dockable.getDockKey() + ", state=" + stateNames[state] + ", position="
+ position;
}
/** Returns a litteral representation of the given state
*@since 2.0.1
*/
public static String getStateName(int state){ //2005/10/07
return stateNames[state];
}
/** Returns the desktop currently using this dockable, or null if none
*
* @since 2.1
*/
public DockingDesktop getDesktop() {
return desktop;
}
/** Updates the desktop field (desktop using this dockable)
* @since 2.1
*/
public void setDesktop(DockingDesktop desktop) {
this.desktop = desktop;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableStoreButton.java 0000644 0001750 0001750 00000011275 10573516344 027027 0 ustar twerner twerner package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import java.awt.Container;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Icon;
import javax.swing.JButton;
/** A Button that can be used to store a dockable (for example to allow moving a dockable
* between two workspaces).
*
*
* The button is able to display the Icon, text and toolip of a dockable key, and can be used as a drag
* source (to initiate a drop into a desktop).
*
* @author Lilian Chamontin, VLSolutions
*/
public class DockableStoreButton extends JButton implements DockDropReceiver, DockableDragSource {
private Dockable dockable;
private String emptyText = "Nothing stored";
private String emptyTooltip = "Move and drop a view of your application above this button to store it";
private Icon emptyIcon = null;
private String fullText = "View &1 stored";
private String fullTooltip = "Drag this button to move the view &1 to a new position";
public DockableStoreButton(String emptyText) {
super(emptyText);
this.emptyText = emptyText;
updateButtonText();
}
public DockableStoreButton() {
updateButtonText();
}
/** when a dockable is dragged above this button, the button stores it as its new
* target dockable.
* @see #getDockable()
*/
public void processDockableDrag(DockDragEvent event) {
event.rejectDrag();
}
/** Rejects the drop as this action isn't possible on this component */
public void processDockableDrop(DockDropEvent event) {
setDockable(event.getDragSource().getDockable());
event.rejectDrop();
}
public void setDockable(Dockable dockable) {
this.dockable = dockable;
updateButtonText();
}
/** Override this method if you want to change the display (text and icon) of this button and
* the default settings don't suit your needs.
*/
public void updateButtonText(){
if (dockable == null){
setText(emptyText);
setToolTipText(emptyTooltip);
setIcon(null);
} else {
String text = fullText.replaceAll("&1", dockable.getDockKey().getName());
setText(text);
String tttext = fullTooltip.replaceAll("&1", dockable.getDockKey().getName());
setToolTipText(tttext);
setIcon(dockable.getDockKey().getIcon());
}
}
public boolean startDragComponent(Point p) {
return dockable != null;
}
/** Return the dockable currently stored (may be null) */
public Dockable getDockable() {
return dockable;
}
public Container getDockableContainer() {
return (Container) DockingUtilities.findDockableContainer(dockable);
}
public void endDragComponent(boolean dropped) {
if (dropped){
dockable = null;
updateButtonText();
}
}
/** Returns the text used for this button when no dockable is stored*/
public String getEmptyText() {
return emptyText;
}
/** updates the text used for this button when no dockable is stored*/
public void setEmptyText(String emptyText) {
this.emptyText = emptyText;
}
/** Returns the text used as tooltip for this button when no dockable is stored*/
public String getEmptyTooltip() {
return emptyTooltip;
}
/** Updates the text used as tooltip for this button when no dockable is stored*/
public void setEmptyTooltip(String emptyTooltip) {
this.emptyTooltip = emptyTooltip;
}
/** Returns the Icon used with this button when no dockable is selected */
public Icon getEmptyIcon() {
return emptyIcon;
}
/** Updates the icon used for this button when no dockable is stored*/
public void setEmptyIcon(Icon emptyIcon) {
this.emptyIcon = emptyIcon;
}
/** Returns the text used for this button when a dockable is stored*/
public String getFullText() {
return fullText;
}
/** Returns the text used for this button when a dockable is stored*/
public void setFullText(String fullText) {
this.fullText = fullText;
}
/** Returns the text used for as tooltip this button when a dockable is stored*/
public String getFullTooltip() {
return fullTooltip;
}
/** Updates the text used as tooltip for this button when no dockable is stored.
* The special value '&1' will be replaced by the name of this dockable.
*
* For example "&1 stored" could be replaced by "MyDockable stored"
*/
public void setFullTooltip(String fullTooltip) {
this.fullTooltip = fullTooltip;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingBorderLayout.java 0000644 0001750 0001750 00000025031 10573516350 027014 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.util.Hashtable;
import java.awt.*;
import javax.swing.*;
/** A layout adapted to autohide panels.
*
* This layout is like a BorderLayout but corners are always empty
* (for example, the TOP component starts with an x coordinate equal to the
* width of the LEFT component).
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class DockingBorderLayout implements LayoutManager2{
Component topComp, leftComp, bottomComp, rightComp, centerComp;
public DockingBorderLayout() {
}
public float getLayoutAlignmentX(Container target) {
return 0.5F;
}
public float getLayoutAlignmentY(Container target) {
return 0.5F;
}
public void invalidateLayout(Container target) {
}
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
public void addLayoutComponent(Component comp, Object constraints) {
addLayoutComponent((String)constraints, comp);
}
public void removeLayoutComponent(Component comp) {
}
public void addLayoutComponent(String name, Component comp) {
if (name.equals(BorderLayout.NORTH)){
topComp = comp;
} else if (name.equals(BorderLayout.EAST)){
rightComp = comp;
} else if (name.equals(BorderLayout.SOUTH)){
bottomComp = comp;
} else if (name.equals(BorderLayout.WEST)){
leftComp = comp;
} else if (name.equals(BorderLayout.CENTER)){
centerComp = comp;
} else {
throw new IllegalArgumentException("wrong constraint");
}
}
public Dimension minimumLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
if (leftComp != null && leftComp.isVisible()) {
Dimension d = leftComp.getMinimumSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (rightComp != null && rightComp.isVisible()) {
Dimension d = rightComp.getMinimumSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (centerComp != null && centerComp.isVisible()) {
Dimension d = centerComp.getMinimumSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (topComp != null && topComp.isVisible()) {
Dimension d = topComp.getMinimumSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height;
}
if (bottomComp != null && bottomComp.isVisible()) {
Dimension d = bottomComp.getMinimumSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height;
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
public Dimension preferredLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
if (leftComp != null && leftComp.isVisible()) {
Dimension d = leftComp.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (rightComp != null && rightComp.isVisible()) {
Dimension d = rightComp.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (centerComp != null && centerComp.isVisible()) {
Dimension d = centerComp.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(d.height, dim.height);
}
if (topComp != null && topComp.isVisible()) {
Dimension d = topComp.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height;
}
if (bottomComp != null && bottomComp.isVisible()) {
Dimension d = bottomComp.getPreferredSize();
dim.width = Math.max(d.width, dim.width);
dim.height += d.height;
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
private int getSideWidth(Component comp){
if (comp == null) return 0;
if (comp.isVisible()) return comp.getPreferredSize().width;
return 0;
}
private int getSideHeight(Component comp){
if (comp == null) return 0;
if (comp.isVisible()) return comp.getPreferredSize().height;
return 0;
}
/** overridden to adjust position (x(top) = width(left), y(left) = height(top)
*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int top = insets.top;
int bottom = target.getHeight() - insets.bottom;
int left = insets.left;
int right = target.getWidth() - insets.right;
int lw = getSideWidth(leftComp);
int rw = getSideWidth(rightComp);
int th = getSideHeight(topComp);
int bh = getSideHeight(bottomComp);
if (topComp != null && topComp.isVisible()) {
topComp.setSize(right - left - lw - rw, topComp.getHeight());
Dimension d = topComp.getPreferredSize();
topComp.setBounds(left + lw, top,
right - left - lw - rw, d.height);
}
if (bottomComp != null && bottomComp.isVisible()) {
bottomComp.setSize(right - left - lw - rw, bottomComp.getHeight());
Dimension d = bottomComp.getPreferredSize();
bottomComp.setBounds(left + lw, bottom - d.height,
right - left - lw - rw , d.height);
}
if (rightComp != null && rightComp.isVisible()) {
rightComp.setSize(rightComp.getWidth(), bottom - top - th - bh);
Dimension d = rightComp.getPreferredSize();
rightComp.setBounds(right - d.width,
top + th, d.width, bottom - top - th - bh);
}
if (leftComp != null && leftComp.isVisible()) {
leftComp.setSize(leftComp.getWidth(), bottom - top);
Dimension d = leftComp.getPreferredSize();
leftComp.setBounds(left,
top + th, d.width, bottom - top - th - bh);
}
if (centerComp != null && centerComp.isVisible()) {
centerComp.setBounds(left + lw, top + th,
right - left-lw - rw,
bottom - top - th - bh);
}
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingConstants.java 0000644 0001750 0001750 00000015454 10573516350 026365 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
/** Constants used by the DockingDesktop to position Dockables.
*
* API Users will use these constants to interact with the DockingDesktop.
*
* These constants are defined as enumerations of Hide and Split classes, in order
* to avoid runtime errors.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class DockingConstants {
public static final int INT_SPLIT_TOP = 0;
public static final int INT_SPLIT_LEFT = 1;
public static final int INT_SPLIT_BOTTOM = 2;
public static final int INT_SPLIT_RIGHT = 3;
/** A constant describing a VERTICAL splitting operation where the new component
* goes on the TOP part */
public static final Split SPLIT_TOP = new Split(INT_SPLIT_TOP);
/** A constant describing an HORIZONTAL splitting operation where the new component
* goes on the LEFT part */
public static final Split SPLIT_LEFT = new Split(INT_SPLIT_LEFT);
/** A constant describing a VERTICAL splitting operation where the new component
* goes on the BOTTOM part */
public static final Split SPLIT_BOTTOM = new Split(INT_SPLIT_BOTTOM);
/** A constant describing an HORIZONTAL splitting operation where the new component
* goes on the RIGHT part */
public static final Split SPLIT_RIGHT = new Split(INT_SPLIT_RIGHT);
public static final int INT_HIDE_TOP = 0;
public static final int INT_HIDE_LEFT = 1;
public static final int INT_HIDE_BOTTOM = 2;
public static final int INT_HIDE_RIGHT = 3;
/** A constant describing an auto-hide operation where the component
* goes on the TOP border */
public static final Hide HIDE_TOP = new Hide(INT_HIDE_TOP);
/** A constant describing an auto-hide operation where the component
* goes on the LEFT border */
public static final Hide HIDE_LEFT = new Hide(INT_HIDE_LEFT);
/** A constant describing an auto-hide operation where the component
* goes on the BOTTOM border */
public static final Hide HIDE_BOTTOM = new Hide(INT_HIDE_BOTTOM);
/** A constant describing an auto-hide operation where the component
* goes on the RIGHT border */
public static final Hide HIDE_RIGHT = new Hide(INT_HIDE_RIGHT);
/** Typesafe enumeration describing a split operation on the DockingDesktop.*/
public static class Split {
private int value;
private Split(int value){
this.value = value;
}
public int value(){
return value;
}
}
/** Typesafe enumeration describing an auto-hide operation on the DockingDesktop.*/
public static class Hide {
private int value;
private Hide(int value){
this.value = value;
}
public int value(){
return value;
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingContext.java 0000644 0001750 0001750 00000054443 10573516350 026036 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockableSelectionEvent;
import com.vlsolutions.swing.docking.event.DockableSelectionListener;
import com.vlsolutions.swing.docking.event.DockableStateChangeEvent;
import com.vlsolutions.swing.docking.event.DockableStateChangeListener;
import com.vlsolutions.swing.docking.event.DockableStateWillChangeEvent;
import com.vlsolutions.swing.docking.event.DockableStateWillChangeListener;
import com.vlsolutions.swing.docking.event.DockingActionEvent;
import com.vlsolutions.swing.docking.event.DockingActionListener;
import java.awt.Container;
import java.awt.KeyboardFocusManager;
import java.awt.Window;
import java.awt.event.WindowEvent;
import java.beans.PropertyChangeEvent;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.WeakHashMap;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/** A context that can be shared by multiple docking desktops.
*
* Keeps track of registered dockables and manages import export.
*
* A DockingContext can be seen as the top-most grouping element of docking
* (as DockingDesktop can be contained is a context), and as such, all
* methods related to workspace management have been promoted to this class.
*
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1
* @update 2007/01/08 Lilian Chamontin : updated registerDockable to
* put the dockable in the CLOSED state if not previously registered (was null before v2.1.3)
*/
public class DockingContext {
/** All dockables must be registered (even if not shown) in order to be processed
* by the XML Parser or to be displayed in the DockingSelectorDialog
*/
protected ArrayList registeredDockables = new ArrayList();
/** inner state of the dockables */
protected HashMap dockableStates = new HashMap(); // key : Dockable / value :
* if this method is invoked and the dockable is already registered, nothing happens.
* if the dockable is still unknown, it is added to the dockables set and (since 2.1.3)
* its state is set to CLOSED (prior 2.1.3, the state was null).
*
* */
public void registerDockable(Dockable dockable){
if (! registeredDockables.contains(dockable)){
registeredDockables.add(dockable);
}
if (getDockableState(dockable) == null){
// should be always the case here // 2007/01/08
setDockableState(dockable, new DockableState(null, dockable, DockableState.STATE_CLOSED));
}
}
/** Unregisters the dockable, which can be garbage collected (no longer used
* by docking desktops.
* */
public void unregisterDockable(Dockable dockable){
close(dockable); // in case it was still visible
registeredDockables.remove(dockable);
dockableStates.remove(dockable); // 2005/11/09
}
/** Close this dockable */
public void close(Dockable dockable){
DockableState state = (DockableState) dockableStates.get(dockable);
DockingDesktop desk = state.getDesktop();
if (desk != null){
desk.close(dockable);
}
}
/** Returns the current state of a dockable (CLOSED, HIDDEN, DOCKED, MAXIMIZED, FLOATING) */
public DockableState getDockableState(Dockable dockable){
return (DockableState) dockableStates.get(dockable);
}
/** Updates the current state of a dockable */
public void setDockableState(Dockable dockable, DockableState state){
dockableStates.put(dockable, state);
}
/** Adds a new DockableStateChangeListener to this desktop.
*
* DockableStateChange Events are triggered after the state change.
*
* As of version 2.0 of the framework, this method can also be replaced by
* adding a propertychangeListener on the DockKey object (and react to its DockableState
* property).
*
* */
public void addDockableStateChangeListener(DockableStateChangeListener listener){
if (!dockableStateChangeListeners.contains(listener)){
dockableStateChangeListeners.add(listener);
}
}
/** Removes a DockableStateChangeListener from this desktop.
* */
public void removeDockableStateChangeListener(DockableStateChangeListener listener){
dockableStateChangeListeners.remove(listener);
}
/** Adds a new DockableStateWillChangeListener to this desktop.
*
* DockableStateWillChange Events are triggered before the state change, and
* are vetoable.
* */
public void addDockableStateWillChangeListener(DockableStateWillChangeListener listener){
if (!dockableStateWillChangeListeners.contains(listener)){
dockableStateWillChangeListeners.add(listener);
}
}
/** Removes a DockableStateWillChangeListener from this desktop.
* */
public void removeDockableStateWillChangeListener(DockableStateWillChangeListener listener){
dockableStateWillChangeListeners.remove(listener);
}
/** Creates and returns an array of all registered dockable with their current
* state.
*
* Visibility states are [DockableState.STATE_CLOSED, STATE_DOCKED, STATE_HIDDEN]
* @return an array of DockableState
*/
public DockableState[] getDockables(){
DockableState [] states = new DockableState[registeredDockables.size()];
for (int i = 0; i < states.length; i++) {
Dockable d = (Dockable) registeredDockables.get(i);
states[i] = (DockableState) dockableStates.get(d);
if (states[i] == null){
DockableState closed = new DockableState(null, d, DockableState.STATE_CLOSED);
states[i] = closed;
}
}
return states;
}
/** Saves the current desktop configuration into an XML stream.
*
* The workspace is composed of every desktop layouts associated
* with this context (desktops are identified by their 'desktopName' property).
*
*
* The stream is not closed at the end of the operation.
*
* @see #readXML(InputStream)
* */
public void writeXML(OutputStream stream) throws IOException {
PrintWriter out = new PrintWriter(stream);
out.println("");
out.println("
* When the method returns, the desktops associated to this context are totally
* reconfigured with posiibly different dockables at different positions.
*
* Note : The
* Note : altenatively (since 2.1.2) if a DockableResolver has been set, it will
* be use to auto-register the new dockables encountered along the stream.
* Dismisses all visible dockables (docked and auto-hidden), and clear their DockableState.
*
* The stream is not closed at the end of the operation.
*
* Note : When multiple desktops are loaded from the stream, the context uses their "desktopName"
* property (desk.getDesktopName()) to identify them.
*
* @see #writeXML(OutputStream)
* @see #registerDockable(Dockable)
* @see #setDockableResolver(DockableResolver)
* */
public void readXML(InputStream in)
throws ParserConfigurationException, IOException, SAXException {
// remove all dockable states
for (int i=0; i < desktops.size(); i++){
DockingDesktop desk = (DockingDesktop) desktops.get(i);
desk.clear();
}
dockableStates.clear();
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(in);
Element root = doc.getDocumentElement();
if (root.getNodeName().equals("DockingDesktop")){
// this is an old desktop file, missing the VLDocking root node (VLDocking 2.0 format)
// so we noly have a single desktop
DockingDesktop desk = getDesktopByName(null); // only one
desk.readDesktopNode(root);
} else {
NodeList desktopChildren = root.getChildNodes();
for (int i = 0, len = desktopChildren.getLength(); i < len; i++) {
Node node = desktopChildren.item(i);
if (node instanceof Element){
Element deskChild = (Element) node;
DockingDesktop desk = getDesktopByName(deskChild.getAttribute("name"));
desk.readDesktopNode(deskChild);
}
}
}
}
private DockingDesktop getDesktopByName(String name){
if (desktops.size() == 1){
// always found if only one desktop
DockingDesktop desktop = (DockingDesktop) desktops.get(0);
return desktop;
}
for (int i=0; i < desktops.size(); i++){
DockingDesktop desktop = (DockingDesktop) desktops.get(i);
if (desktop.getDesktopName().equals(name)){
return desktop;
}
}
throw new RuntimeException("No desktop found with name : " + name);
}
/** constructs and returns the list of dockables corresponding to a desktop, at a specific state*/
public ArrayList getDockablesByState(DockingDesktop desktop, int state) {
ArrayList list = new ArrayList();
for (int i=0; i < registeredDockables.size(); i++){
Dockable d = (Dockable) registeredDockables.get(i);
DockableState dState = (DockableState)dockableStates.get(d);
if (dState != null && dState.getDesktop() == desktop && dState.getState() == state){
list.add(d);
}
}
return list;
}
/** Returns the (registered) dockable corresponding to the given key id,
* or null if not found
*
* Note : since VLDocking 2.1.2, this method also tries to use its DockableResolver
* if null would have been returned.
* @see DockableResolver
*/
public Dockable getDockableByKey(String dockKey){
for (int i = 0; i < registeredDockables.size(); i++) {
Dockable d = (Dockable)registeredDockables.get(i);
if (d.getDockKey().getKey().equals(dockKey)){
return d;
}
}
// not found
if (dockableResolver != null){
Dockable d = dockableResolver.resolveDockable(dockKey);
if (d != null){
registerDockable(d); // a new one
}
return d; // might be null
}
return null;
}
/*package protected */ void fireDockableStateChange(DockableStateChangeEvent e){
for (int i = 0; i < dockableStateChangeListeners.size(); i++) {
DockableStateChangeListener listener = (DockableStateChangeListener)
dockableStateChangeListeners.get(i);
listener.dockableStateChanged(e);
}
}
/*package protected */ boolean fireDockableStateWillChange(DockableStateWillChangeEvent e){
DockingDesktop desk = e.getFutureState().getDesktop();
if (desk.getMaximizedDockable() != null){
// veto events coming from autohide and floating components if a component is maximized
// @todo : this could be improved by disabling the dock and attach properties of
// the remaining visible dockables to avoid having the user don't understand
// why a button doesn't react.
if (desk.getMaximizedDockable() != e.getCurrentState().getDockable()){
if (e.getFutureState().isDocked()){
if (e.getCurrentState().isHidden()){
return false; // refused
} else if (e.getCurrentState().isFloating()){
return false;
}
}
}
}
// dispatch events and listen to vetoes
for (int i = 0; i < dockableStateWillChangeListeners.size(); i++) {
DockableStateWillChangeListener listener = (
DockableStateWillChangeListener)
dockableStateWillChangeListeners.get(i);
listener.dockableStateWillChange(e);
if (!e.isAccepted()){ // stop as soon as the operation is cancelled
return false;
}
}
return true;
}
/** Adds a new DockableSelectionListener to this desktop.
*
* DockableSelection Events are triggered when a dockable takes the focus.
*
*/
public void addDockableSelectionListener(DockableSelectionListener listener){
if (!dockableSelectionListeners.contains(listener)){
dockableSelectionListeners.add(listener);
}
}
/** Removes a DockableSelectionListener from this desktop.
* */
public void removeDockableSelectionListener(DockableSelectionListener listener){
dockableSelectionListeners.remove(listener);
}
/*package protected */ void fireDockableSelectionChange(DockableSelectionEvent e){
for (int i = 0; i < dockableSelectionListeners.size(); i++) {
DockableSelectionListener listener =
(DockableSelectionListener) dockableSelectionListeners.get(i);
listener.selectionChanged(e);
}
}
public void addDockingActionListener(DockingActionListener listener) {
if (!dockingActionListeners.contains(listener)){
dockingActionListeners.add(listener);
}
}
public void removeDockingActionListener(DockingActionListener listener) {
dockingActionListeners.remove(listener);
}
/** returns false if the docking action is rejected, or true if accepted by all listeners*/
boolean fireAcceptDockingAction(DockingActionEvent e){
/*package protected */
for (int i = 0; i < dockingActionListeners.size(); i++) {
DockingActionListener listener =
(DockingActionListener) dockingActionListeners.get(i);
if (!listener.acceptDockingAction(e)){
return false;
}
}
return true;
}
/*package protected */ void fireDockingActionPerformed(DockingActionEvent e){
for (int i = 0; i < dockingActionListeners.size(); i++) {
DockingActionListener listener =
(DockingActionListener) dockingActionListeners.get(i);
listener.dockingActionPerformed(e);
}
}
/** Returns a list of the desktops sharing this context */
public ArrayList getDesktopList() {
return desktops;
}
/** used to track window activation (to have an up to date z ordered list of window) */
void windowActivated(WindowEvent e){
/* package protected */
/* these events are forwarded by docking desktops */
Window w = e.getWindow();
if (ownedWindowActivationOrder.size()>0 && ownedWindowActivationOrder.getFirst() != w){
ownedWindowActivationOrder.remove(w);
ownedWindowActivationOrder.addFirst(w);
}
}
/** Returns a list of owned windows, ordered by window z-order */
LinkedList getOwnedWindowActionOrder(){
/* package protected */
return ownedWindowActivationOrder;
}
/** Registers a new window */
void registerWindow(Window w) {
/* package protected */
ownedWindowActivationOrder.addLast(w);
}
/** Returns the dockable resolver used by this context (or null if none defined)
* @since 2.1.2
*/
public DockableResolver getDockableResolver() {
return dockableResolver;
}
/** Updates the dockable resolver used by this context (can be set to null)
* @since 2.1.2
*/
public void setDockableResolver(DockableResolver dockableResolver) {
this.dockableResolver = dockableResolver;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingDesktop.java 0000644 0001750 0001750 00000457370 10573516350 026031 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.beans.*;
import java.io.*;
import java.util.*;
import javax.xml.parsers.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import org.w3c.dom.*;
import org.xml.sax.*;
import com.vlsolutions.swing.docking.event.*;
import com.vlsolutions.swing.docking.ui.DockingUISettings;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
* The DockingDesktop is the main class of the VLDocking Framework.
* It is the equivalent of what is JDesktopPane for JInternalWindow :
* a JLayeredPane customized to include :
*
* This also constructs a new Docking Context, that can be shared with other Desktops.
*/
public DockingDesktop(String desktopName) {
this(desktopName, null);
}
/** Constructs a DockingDesktop with a given name (suitable for multiple-desktop applications).
*/
public DockingDesktop(String desktopName, DockingContext context) {
setDesktopName(desktopName);
if (context == null){
this.context = new DockingContext(); // initial (single desktop) context
} else {
this.context = context; // shared context issued from another dekstop
}
this.context.addDesktop(this);
this.dragControler = new DragControler(this);
//
// add(contentPane, BorderLayout.CENTER);
topBorderPane.setVisible(false);
leftBorderPane.setVisible(false);
bottomBorderPane.setVisible(false);
rightBorderPane.setVisible(false);
contentPane.add(topBorderPane, BorderLayout.NORTH);
contentPane.add(leftBorderPane, BorderLayout.WEST);
contentPane.add(bottomBorderPane, BorderLayout.SOUTH);
contentPane.add(rightBorderPane, BorderLayout.EAST);
contentPane.add(dockingPanel, BorderLayout.CENTER);
add(contentPane, DEFAULT_LAYER);
mouseMotionGrabber.setVisible(false);
mouseMotionGrabber.addMouseListener(new MouseAdapter() {
boolean canUseMouseInfo = DockingUtilities.canUseMouseInfo();
public void mouseEntered(MouseEvent e) {
// means that the mouse is not above the expanded panel
if (! canUseMouseInfo){ // only for 1.4 codebase or untrusted envs
mouseOutOfExpandedPanelTimer.restart(); //2005/11/01
}
}
public void mouseExited(MouseEvent e) {
// means that the mouse is probably above the expanded panel (or out of the window)
if (! canUseMouseInfo){ // only for 1.4 codebase or untrusted envs
mouseOutOfExpandedPanelTimer.stop(); //2005/11/01
}
}
public void mousePressed(MouseEvent e) {
// collapse the expanded panel and redispatch the event to the underlying frame
// for processing by the real component clicked by the user
expandPanel.collapse();
Window w = SwingUtilities.getWindowAncestor(DockingDesktop.this);
if (w != null) {
w.dispatchEvent(e);
}
}
});
expandPanel.installDocking(this);
expandPanel.setVisible(false);
add(mouseMotionGrabber, new Integer(MODAL_LAYER.intValue() - 1));
add(expandPanel, MODAL_LAYER);
ComponentListener resizeListener = new ComponentAdapter() {
/* resize listener is added to the desktop and to the contentPane */
public void componentResized(ComponentEvent event) {
int w = getWidth();
int h = getHeight();
Insets i = getDockingPanelInsets();
if (event.getComponent() == DockingDesktop.this){
// hide the expanded panel if necessary
expandPanel.collapse();
// resize the panel
contentPane.setBounds(0, 0, w, h);
revalidate();
} else if (event.getComponent() == dockingPanel){
if (maximizedComponent != null) {
if (DockingPreferences.isLightWeightUsageEnabled()){
maximizedComponent.setBounds(i.left, i.top, w - i.left - i.right,
h - i.top - i.bottom);
} else {
if (DockingPreferences.isSingleHeavyWeightComponent()){
if (DockingUtilities.isHeavyWeightComponent(maximizedComponent)){
maximizedComponent.setBounds(i.left, i.top, w - i.left - i.right,
h - i.top - i.bottom);
} else {
maximizedComponent.getParent().setBounds(i.left, i.top, w - i.left - i.right,
h - i.top - i.bottom);
}
} else {
maximizedComponent.getParent().setBounds(i.left, i.top, w - i.left - i.right,
h - i.top - i.bottom);
}
}
}
mouseMotionGrabber.setBounds(i.left, i.top, w - i.left - i.right, h - i.top - i.bottom);
dockingPanel.revalidate();
}
}
};
addComponentListener(resizeListener);
dockingPanel.addComponentListener(resizeListener);
expandPanel.addPropertyChangeListener(AutoHideExpandPanel.PROPERTY_EXPANDED,
new PropertyChangeListener(){
public void propertyChange(PropertyChangeEvent e) {
if (e.getNewValue().equals(Boolean.TRUE)){
mouseMotionGrabber.setVisible(true);
} else {
mouseMotionGrabber.setVisible(false);
}
}
});
mouseOutOfExpandedPanelTimer.setRepeats(false); // avoid loops
/*KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(
"focusOwner", focusHandler); //2006/08/21 : back to life (was in comments in 2.1.0)*/
installKeyboardBindings();
// optional window following
final boolean floatingContainerFollowParentWindow = UIManager.getBoolean("FloatingContainer.followParentWindow");
addAncestorListener(new AncestorListener(){
public void ancestorAdded(AncestorEvent event) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(
"focusOwner", focusHandler); //2006/08/21 : back to life (was in comments in 2.1.0)
// 2006/12/19 now integrated to ancestor hierarchy to avoid gc leaks
Window w = SwingUtilities.getWindowAncestor(DockingDesktop.this);
w.addWindowListener(windowListener);
DockingDesktop.this.context.registerWindow(w); // first activation required to register the window
if (floatingContainerFollowParentWindow){
w.addComponentListener(windowMovementListener);
}
}
public void ancestorRemoved(AncestorEvent event){// 2005/12/08
KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(
"focusOwner", focusHandler); //2006/12/19
if (event == null || event.getAncestorParent() == null){
// 2006/12/01 protection againts NPE
return;
} else {
Window w = SwingUtilities.getWindowAncestor(event.getAncestorParent());
if (w !=null){ // 2007/03/07 hope it helps with desktops on JDialogs
w.removeWindowListener(windowListener);
if (floatingContainerFollowParentWindow){
w.removeComponentListener(windowMovementListener);
}
}
}
}
public void ancestorMoved(AncestorEvent event){
}
});
}
/** Registers listeners for notable keyboard events (CLOSE, DOCK/HIDE, MAXIMIZE/RESTORE, float/attach).
* KeyStroke bindings can be defined and overriden this UIManager properties (see DockingUISettings for
* details).
*
*/
private void installKeyboardBindings(){
KeyStroke ks = (KeyStroke) UIManager.get("DockingDesktop.closeActionAccelerator");
if (ks != null){
getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks, "close");
getActionMap().put("close", closeAction);
}
ks = (KeyStroke) UIManager.get("DockingDesktop.maximizeActionAccelerator");
if (ks != null){
getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks, "maximize");
getActionMap().put("maximize", maximizeAction);
}
ks = (KeyStroke) UIManager.get("DockingDesktop.dockActionAccelerator");
if (ks != null){
getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks, "dock");
getActionMap().put("dock", dockAction);
}
ks = (KeyStroke) UIManager.get("DockingDesktop.floatActionAccelerator");
if (ks != null){
getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks, "float");
getActionMap().put("float", floatAction);
}
ks = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0); // general cancel action 2005/10/07
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(ks, "cancel");
getActionMap().put("cancel", cancelAction);
}
/** Returns the currently selected dockable, or null if none is selected.
*
* A selected dockable is a dockable whose component contains the keyboard focus.
*/
public Dockable getSelectedDockable(){
return focusHandler.currentDockable;
}
/** Set the desktop contents to be opaque or transparent.
*
* Transparent contents allow adding background images/information when no dockable is visible (everything closed
* or autohidden).
*
* Default value is true (opaque).
*
* @since 2.0.4
*/
public void setOpaqueContents(boolean opaque){
contentPane.setOpaque(opaque);
dockingPanel.setOpaque(opaque);
}
/** Returns whether this desktop's contents are opaque or not.
*
* Default value is true (opaque).
*
* @see #setOpaqueContents(boolean).
* @since 2.0.4
*/
public boolean isOpaqueContents(){
return contentPane.isOpaque();
}
/** Returns the docking panel used by this desktop */
DockingPanel getDockingPanel(){
/* package protected method */
return dockingPanel;
}
/** Every dockable must be registered in order to be shown in the DockingDesktop.
*
* Registration is automatic for shown dockables :
* methods setCentralDockable(), split(), createTab(), hide()... leading to have the dockable
* visible call registerDockable() )
* for not shown dockable (in order to read a configuration from an XML stream, or to list
* the dockable in DockingSelectorDialog ), this method must be called manually.
*
* As of version 2.1, this method call is forwarded to the DockingContext
* */
public void registerDockable(Dockable dockable){
context.registerDockable(dockable);
}
/** Unregisters the dockable, which can be garbage collected (no longer used
* by the docking desktop.
*
* As of version 2.1, this method call is forwarded to the DockingContext
* */
public void unregisterDockable(Dockable dockable){
//context.registerDockable(dockable); // 2006/09/06
context.unregisterDockable(dockable); // 2006/09/06
}
/** Returns a String containing the version of the docking framework in the format M.m.r
* where M is the major , m the minor and r the release.
*@since 2.0
*/
public static String getDockingFrameworkVersion(){
return CURRENT_VERSION_NUMBER;
}
/** Returns a String containing the release date of the current version.
*@since 2.0
*/
public static String getDockingFrameworkBuildDate(){
return BUILD_DATE;
}
/** Adds a view in a tab, or create it if it doesn't exist.
*
* @param base the reference dockable
* @param dockable a dockable to add at the same position than Optional added tab selection.
*
* @param base an existing dockable, either displayed in a DockableContainer or
* in a TabbedDockableContainer.
* If base is displayed by a DockableContainer, this container will be replaced
* by a TabbedDockableContainer.
* @param dockable the dockable to add
* @param order the tab order of view in its tabbed pane.
* @param select if true, will select the added tab (make it appear at front)
*
*/
public void createTab(Dockable base, Dockable dockable, int order, boolean select){
createTab(base, dockable, order, select, true);
}
/** private implementation wich allows for triggering state change event or not
* (depending on the caller).
*/
private void createTab(Dockable base, Dockable dockable, int order, boolean select, boolean triggerEvents){
/* createTab() is called by :
* - DockView/DetachedDockView during DnD
* - DockTabbedPane during DnD
* - show() which is called by
* - setFloating(false)
* - setAutoHide(false)
*/
if (base == null)throw new NullPointerException("base must not be null");
if (dockable == null)throw new NullPointerException(
"dockable must not be null");
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
// currentState might be null CLOSED HIDDEN DOCKED FLOATING
DockableState newState = null ; // 2005/10/06 - support for floatable tabs : the future state can be docked or floating
if (base.getDockKey().getDockableState() == DockableState.STATE_FLOATING){
RelativeDockablePosition position = new RelativeDockablePosition(dockingPanel, dockable);
newState = new DockableState(this, dockable,
base.getDockKey().getDockableState(), position);
} else {
newState = new DockableState(this, dockable,
base.getDockKey().getDockableState());
}
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionCreateTabEvent(this, dockable,
currentStateAsInt, newState.getState(), base, order);
//boolean stateChange = currentState == null || !currentState.isDocked();
//boolean stateChange = currentState == null || currentState.getState() != newState.getState(); //2005/10/07
if (triggerEvents){
if (! isDockingActionAccepted(dae, dswe)) {
return; // vetoed
}
}
TabbedDockableContainer dockableTab = null;
if (currentStateAsInt != DockableState.STATE_CLOSED){
// don't search tabs for closed dockables // 2007/02/27
dockableTab = DockingUtilities.findTabbedDockableContainer(dockable);
}
// TabbedDockableContainer baseTab = DockingUtilities.findTabbedDockableContainer(dockable); // 2005/05/19
TabbedDockableContainer baseTab = DockingUtilities.findTabbedDockableContainer(base); // 2005/05/19
if (dockableTab != null
&& dockableTab != baseTab){
// don't belong to the same tabbed pane, so remove first the dockable
remove(dockable); // TODO : check this : removal should have been done earlier (in dropRemove() )
}
// if ( currentState != null && (!currentState.isFloating()) && newState.isFloating()){
if ( currentState != null && currentState.isFloating() && newState.isFloating()){
// this case is when dragging a floating dockable into another floating window
Window w = SwingUtilities.getWindowAncestor(dockable.getComponent());
Window w2 = SwingUtilities.getWindowAncestor(base.getComponent());
if (w == null){
// the dockable has already been removed
} else if (w != w2){
// when creating a floating tab, we have to manually remove the dockable
remove(dockable);
} else { // else same window : no need to remove it
remove(dockable);
}
} else if ( currentState != null && (!currentState.isFloating()) && newState.isFloating()){
// from !floating to floating :
// when creating a floating tab, we have to manually remove the dockable
remove(dockable);
}
if (!newState.isFloating()){
// remove old attachment except when creating a floating tab
removeFromTabbedGroup(dockable); // 2005/07/13
}
if (baseTab != null){
// add a tab
baseTab.addDockable(dockable, order);
} else {
// base isn't included in a tabbed pane, so we have to create one
DockableContainer baseOldContainer = DockingUtilities.findSingleDockableContainer(base);
baseTab = DockableContainerFactory.getFactory().createTabbedDockableContainer();
baseTab.installDocking(this);
baseTab.addDockable(base,0);
baseTab.addDockable(dockable,1);
((JTabbedPane) baseTab).addChangeListener(focusHandler); // our best way to track selection (focus) changes
DockingUtilities.replaceChild(((Component)baseOldContainer).getParent(),
(Component)baseOldContainer, (Component)baseTab);
}
if (select){
baseTab.setSelectedDockable(dockable);
}
context.registerDockable(dockable);
context.setDockableState(dockable, newState);
if (newState.isFloating() && !currentState.isFloating()){
// we need to store the return information
storePreviousFloatingState(dockable, currentState);
}
if (triggerEvents){
dockable.getDockKey().setDockableState(base.getDockKey().getDockableState()); //2005/10/06
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
}
if (!newState.isFloating()){
// register tab group association except if we are going floating...
addToTabbedGroup(base, dockable); //2005/07/13
}
DockingUtilities.updateResizeWeights(dockingPanel);
}
/** Splits a Dockable in 2 parts, if possible.
*
* The base dockable is the reference, the second newDockable will be
* added according to the position parameter.
*
* If base is contained in a non splitable container (like a tab of DockTabbedPane)
* then, a splitable ancestor will be searched (until the root desktop pane is reached)
* to apply splitting.
*
* @param base an already docked Dockable
* @param newDockable the added dockable
* @param position position of newDockable relative to base
*/
public void split(Dockable base, Dockable newDockable, DockingConstants.Split position){
/* split() is used internally by the framework in the following cases :
* - from a move() API invocation
* - from a DnD on DockTabbedPane (overriding BorderSplitter) but only when the dockable is not floating
*
* => we can safely assume that the future state of the dockable will be "Docked"
*/
if (base == null) throw new NullPointerException("base must not be null");
if (newDockable == null) throw new NullPointerException("newDockable must not be null");
DockableState currentState = getDockableState(newDockable);
int currentStateAsInt = getStateAsInt(currentState);
boolean stateChange = currentState == null || !currentState.isDocked();
// todo : new state should be DOCKED *OR* FLOATING
DockableState newState = new DockableState(this, newDockable,
DockableState.STATE_DOCKED);
DockingActionEvent dae = new DockingActionSplitDockableEvent(this, newDockable,
currentStateAsInt, newState.getState(), base, position, 0.5f);
DockableStateWillChangeEvent event = new DockableStateWillChangeEvent(
currentState, newState);
if (!isDockingActionAccepted(dae,event)) {
return; // vetoed
}
TabbedDockableContainer baseTab = DockingUtilities.findTabbedDockableContainer(base);
DockableContainer dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(newDockable, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
dockableContainer.installDocking(this);
// create a new splitcontainer that will replace baseDockable's container
SplitContainer split;
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_BOTTOM){
split = new SplitContainer(JSplitPane.VERTICAL_SPLIT);
} else /*if (position == DockingConstants.SPLIT_LEFT
|| position == DockingConstants.SPLIT_RIGHT)*/{
split = new SplitContainer(JSplitPane.HORIZONTAL_SPLIT);
}
Component left, right;
// baseTab = null; // V2.1 TEST
if (baseTab != null){
// base is contained in a tab, so the split will occur between the tab and
// newDockable (a tabbed component cannot be splitted)
DockingUtilities.replaceChild(((Component)baseTab).getParent(),
((Component)baseTab), split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
left = (Component)dockableContainer;
right = (Component)baseTab;
} else {
left = (Component)baseTab;
right = (Component)dockableContainer;
}
} else {
// base is not contained in a tab, so it must be a DockableContainer
DockableContainer baseContainer = DockingUtilities.findSingleDockableContainer(
base);
assert baseContainer != null;
DockingUtilities.replaceChild(((Component)baseContainer).getParent(),
((Component)baseContainer), split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
left = (Component)dockableContainer;
right = (Component)baseContainer;
} else {
left = (Component)baseContainer;
right = (Component)dockableContainer;
}
}
// now, we have to fill split with base and dockable
split.setLeftComponent(left);
split.setRightComponent(right);
context.registerDockable(newDockable);
context.setDockableState(newDockable, newState);
newDockable.getDockKey().setDockableState(DockableState.STATE_DOCKED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
removeFromTabbedGroup(newDockable); //2005/10/10
DockingUtilities.updateResizeWeights(dockingPanel);
}
/** Replaces the base component by a split pane oriented according to position,
* and put dockable at position.
*
* Note : This method is for DockableContainers. API users should
* use the {@link #split(Dockable,Dockable,DockingConstants.Split) split} method.
*
* @param base the reference component (a dockablecontainer or a split container)
* @param dockable the dockable to add
* @param position the position of
* Note : This method is for DockableContainers. API users should
* use the {@link #split(Dockable,Dockable,DockingConstants.Split) split} method.
*
* @param base the reference component (a dockablecontainer or a split container)
* @param dockablesContainer the dockable container
* @param position the position of
* The dockable is inserted in the docking desktop where it was before, if possible.
* if not, an approximated place will be looked for.
* */
private void show(Dockable dockable, DockingActionEvent action){
if (dockable == null) throw new NullPointerException("dockable must not be null");
DockableState state = context.getDockableState(dockable);
RelativeDockablePosition position = state.getPosition();
if (position == null){
// not shown before, ask best position to the preferences
// TODO
throw new NullPointerException("trying to show a view that was not hidden");
}
LinkedList group = (LinkedList) tabbedGroups.get(dockable); //2005/07/13...
boolean tabbed = false;
if (group != null){
// look for a still visible dockable in the group
Iterator it = group.iterator();
while (it.hasNext() && ! tabbed){
Dockable d = (Dockable) it.next();
if (d != dockable && getDockableState(d).isDocked()){
createTab(d, dockable, Integer.MAX_VALUE, true, false);
tabbed = true;
}
}
}
if (! tabbed){ // ...2005/07/13
SingleDockableContainer sdc = RelativeDockingUtilities.applyDockingAction(dockable, action);
// SingleDockableContainer sdc = RelativeDockingUtilities.insertDockable(
// position.getRelativeAncestorContainer(), dockable, position);
sdc.installDocking(this);
}
}
/** Removes a visible dockable from the containment hierarchy (including autohide border buttons).
*
* This method shouldn't be used by user applications (only by the framework).
*
* To poperly remove a component from the desktop, use the close(Dockable) method instead
*
* If the dockable is not visible, an error will occur
*
* This method does not unregister the dockable.
*
* @throws IllegalArgumentException if the dockable is not visible (docked or auto-hide)
* */
public void remove(Dockable dockable) {
// TODO : check this : split this method in two (removeImpl() should be used form inside the framework, and
// remove should trigger CLOSE state change events
//if (dockingPanel.isAncestorOf(dockable.getComponent())){ //2005/10/06 ...
int dockState = dockable.getDockKey().getDockableState();
SingleDockableContainer dockableContainer = null;
Container parentOfSdc = null;
boolean isChildOfCompoundDockable = false; // v2.1
if ( dockState == DockableState.STATE_DOCKED
|| dockState == DockableState.STATE_FLOATING){ // ...2005/10/06
// we must guess that before removing the dockable from its parent...
isChildOfCompoundDockable = DockingUtilities.isChildOfCompoundDockable(dockable);
dockableContainer = DockingUtilities.findSingleDockableContainer(dockable);
parentOfSdc = ((JComponent)dockableContainer).getParent();
removeContainer(dockableContainer);
}
if (dockState == DockableState.STATE_FLOATING){
FloatingDockableContainer fdc = (FloatingDockableContainer) SwingUtilities.getWindowAncestor(dockable.getComponent());
if (parentOfSdc instanceof TabbedDockableContainer){
// dockable was contained in a tab on the floatable : we must not dispose the window
} else if (isChildOfCompoundDockable){
// dockable was a child of a compound dockable : don't dispose
} else {
DockingUtilities.dispose(fdc);
//((JDialog)dlg).dispose();
}
} else if (dockState == DockableState.STATE_HIDDEN){
// DockableState state = (DockableState) dockableStates.get(dockable);
// if (state.isHidden()) {
// component is removed from the auto-hide list
//dockableStates.put(dockable, new DockableState(dockable, DockableState.STATE_CLOSED));
// 2005/10/10 removed this : wrong place to change a dockable state
AutoHideButton btn = (AutoHideButton) autoHideButtons.get(dockable.
getDockKey());
if (btn == null){
// (v2.1) no button : that means this dockable is a child of a hidden compound dockable
// so we just use the standard removing pattern
dockableContainer = DockingUtilities.findSingleDockableContainer(dockable);
parentOfSdc = ((JComponent)dockableContainer).getParent();
removeContainer(dockableContainer);
} else {
// single auto-hide dockable
btn.setVisible(false);
expandPanel.remove(dockable); // in case the dockable was the current visible dockable
}
revalidate();
/* } else if (state.isFloating()){
Window w = SwingUtilities.getWindowAncestor(dockable.getComponent());
w.dispose();
} else { // well, it's not shown, and not hidden...
// nop
}*/
}
}
/** Removes a visible dockable : called from a drag and drop operation.
* Don't call this method directly, as it is meant to be used only by the drag and drop
* event components.
*/
public void dropRemove(DockableDragSource dragSource){
// before removing the dockable, we update its state to store its new relative position
Dockable d = dragSource.getDockable();
DockableState state = context.getDockableState(d);
if (state != null){
// some drag source don't have state associated with them (like whole TabbedContainers)
DockableState updatedState = new DockableState(state, new RelativeDockablePosition(getRelativeAncestorContainer(d), d));
context.setDockableState(dragSource.getDockable(), updatedState);
}
Container dockableContainer = dragSource.getDockableContainer();
if (dockableContainer instanceof TabbedDockableContainer){
remove((TabbedDockableContainer)dockableContainer);
} else {
remove(dragSource.getDockable());
}
//removeFromTabbedGroup(dockable); 2005/10/10 don't remove from tab : it's too early to be sure we won't need it again
// for example : when removing from a tab to create a floating tab (we have to keep the old attachment)
}
/** Removes a whole tab container (which is beeing moved to somewhere else)
*
* This operation is done only during a drag and drop process.
*
* @throws IllegalArgumentException if the dockable is not visible (docked or auto-hide)
*
*/
private void remove(TabbedDockableContainer tdc) {
// TODO : check this : split this method in two (removeImpl() should be used form inside the framework, and
// remove should trigger CLOSE state change events
Dockable firstDockable = tdc.getDockableAt(0);
//if (dockingPanel.isAncestorOf(dockable.getComponent())){ //2005/10/06 ...
int dockState = firstDockable.getDockKey().getDockableState();
if (dockState == DockableState.STATE_FLOATING){
FloatingDockableContainer fdc = (FloatingDockableContainer) SwingUtilities.getWindowAncestor((Container) tdc);
DockingUtilities.dispose(fdc);
//((JDialog)dlg).dispose();
}
boolean invalidateDesktop = true; // always, except for floating dockables
Component parent = ((Component)tdc).getParent();
if (parent != null){
if (parent instanceof SplitContainer) {
SplitContainer viewParent = (SplitContainer) parent;
if (viewParent.getLeftComponent() == tdc) {
viewParent.remove((Component)tdc);
Component other = viewParent.getRightComponent();
// replace viewParent by other in viewParent's hierarchy
Container viewGParent = (Container) viewParent.getParent();
DockingUtilities.replaceChild(viewGParent, viewParent, other);
} else {
viewParent.remove((Component)tdc);
Component other = viewParent.getLeftComponent();
Container viewGParent = (Container) viewParent.getParent();
DockingUtilities.replaceChild(viewGParent, viewParent, other);
}
} else if (parent == dockingPanel) { // no more views to show
dockingPanel.remove(0);
} else if (SwingUtilities.getWindowAncestor(parent) instanceof FloatingDockableContainer){
// removing from a FloatingDockableContainer... nothing to do
invalidateDesktop = false;
} else {
throw new IllegalStateException("View is not contained in desktop hierarchy " + parent);
}
if (invalidateDesktop){
dockingPanel.invalidate();
dockingPanel.validate();
dockingPanel.repaint();
}
}
}
/** Extends the size of this dockable to fill the docking panel.
*
* The component must be docked before beeing maximized, otherwise an IllegalArgumentException will
* be thrown.
*
* The opposite method of maximize is restore(Dockable).
* @see #restore(Dockable)
* */
public void maximize(Dockable dockable){
if (dockable.getDockKey().getDockableState() != DockableState.STATE_DOCKED){
// development error (could have been an assertion).
throw new IllegalArgumentException("Dockable isn't currently in the DOCKED state : " + dockable);
}
DockableState currentState = getDockableState(dockable);
boolean stateChange = currentState == null || !currentState.isMaximized();
DockableState newState = new DockableState(this, dockable, DockableState.STATE_MAXIMIZED);
int currentStateAsInt = getStateAsInt(currentState);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(
currentState, newState);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, dockable,
currentStateAsInt, DockableState.STATE_MAXIMIZED);
if (!isDockingActionAccepted(dae, dswe)){
return; // vetoed
}
// v2.1 : if the currently maximized dockable is a compound dockable, than its children
// can still be maximized.
// to avoid "stacking" maximized component, we just "restore" the compound dockable
SingleDockableContainer currentMaximizedContainer = (SingleDockableContainer)maximizedComponent;
if (currentMaximizedContainer != null && currentMaximizedContainer.getDockable() != dockable){
// there's already a dockable which is maximized : restore it first
restore(currentMaximizedContainer.getDockable());
}
SingleDockableContainer sdc = DockingUtilities.findSingleDockableContainer(dockable);
Component dockableContainer = (Component) sdc;
DockingUtilities.replaceChild(dockableContainer.getParent(), dockableContainer, dummyMaximedReplacer);
SingleDockableContainer maxDockableContainer = DockableContainerFactory.getFactory()
.createDockableContainer(dockable, DockableContainerFactory.PARENT_DESKTOP);
maxDockableContainer.installDocking(this);
this.maximizedComponent = (Component) maxDockableContainer;
Insets i = getDockingPanelInsets();
if (DockingPreferences.isLightWeightUsageEnabled()){
maximizedComponent.setBounds(i.left,i.top, getWidth() - i.left - i.right,
getHeight() - i.top - i.bottom);
add(maximizedComponent, JLayeredPane.PALETTE_LAYER);
} else {
this.currentMaximizedComponentIsHeavyWeight = false;
if (DockingPreferences.isSingleHeavyWeightComponent()){
// first, check if the heavyweight component IS this dockable
Component comp = dockable.getComponent(); //2005/10/20 support for single heavyweight
if (DockingUtilities.isHeavyWeightComponent(comp)){
// it's the heavyweight component (and the only one)
// so we just have to put it there (no need for an in-between awt panel)
maximizedComponent.setBounds(i.left,i.top, getWidth() - i.left - i.right,
getHeight() - i.top - i.bottom);
add(maximizedComponent, JLayeredPane.PALETTE_LAYER);
currentMaximizedComponentIsHeavyWeight = true;
} else {
// this one is not the heavyweight : we have to put it on top of a fresh awt Panel
Panel awtPanel = new Panel(new BorderLayout());
awtPanel.setBounds(i.left,i.top, getWidth() - i.left - i.right,
getHeight() - i.top - i.bottom);
awtPanel.add(maximizedComponent, BorderLayout.CENTER);
awtPanel.validate();
add(awtPanel, JLayeredPane.PALETTE_LAYER);
}
} else {
// if there are heavyweight components around, we need to add an in-between
// awt Panel to avoid those components to be drawn on top of the maximized component
Panel awtPanel = new Panel(new BorderLayout());
awtPanel.setBounds(i.left,i.top, getWidth() - i.left - i.right,
getHeight() - i.top - i.bottom);
awtPanel.add(maximizedComponent, BorderLayout.CENTER);
awtPanel.validate();
add(awtPanel, JLayeredPane.PALETTE_LAYER);
}
}
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_MAXIMIZED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
dockable.getComponent().requestFocus();
repaint();
}
/** Restore the dockable to the docking position it was before beeing maximized.
*
* The dockable must be already maximized (otherwise an IllegalArgumentException will be thrown)
*
* @see #maximize(Dockable)
* */
public void restore(final Dockable dockable){
if (dockable.getDockKey().getDockableState() != DockableState.STATE_MAXIMIZED){
// development error (could have been an assertion).
throw new IllegalArgumentException("Dockable isn't currently in the MAXIMIZED state : " + dockable);
}
DockableState currentState = getDockableState(dockable);
boolean stateChange = currentState != null || currentState.isMaximized();
DockableState newState = new DockableState(this, dockable, DockableState.STATE_DOCKED);
int currentStateAsInt = getStateAsInt(currentState);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(
currentState, newState);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, dockable, currentStateAsInt, DockableState.STATE_DOCKED);
if (! isDockingActionAccepted(dae, dswe)){
return; // vetoed
}
if (!DockingPreferences.isLightWeightUsageEnabled()){
if (DockingPreferences.isSingleHeavyWeightComponent() && this.currentMaximizedComponentIsHeavyWeight){ // 2005/10/20
remove(maximizedComponent);
} else {
remove(maximizedComponent.getParent()); // remove the awt panel
}
} else {
remove(maximizedComponent);
}
((SingleDockableContainer) maximizedComponent ).uninstallDocking(this);
SingleDockableContainer sdc = null;
if (dummyMaximedReplacer.getParent() instanceof TabbedDockableContainer){
sdc = DockableContainerFactory.getFactory().createDockableContainer(dockable,
DockableContainerFactory.PARENT_TABBED_CONTAINER);
} else {
sdc = DockableContainerFactory.getFactory().createDockableContainer(dockable,
DockableContainerFactory.PARENT_SPLIT_CONTAINER);
}
DockingUtilities.replaceChild(dummyMaximedReplacer.getParent(), dummyMaximedReplacer, (Component)sdc);
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_DOCKED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
SwingUtilities.invokeLater(new Runnable(){
public void run(){
dockable.getComponent().requestFocus();
}
});
sdc.installDocking(this);
maximizedComponent = null;
repaint();
}
/** Detach or attach the dockable from/to the desktop.
*
* When detached, the dockable is centered on the desktop.
*/
public void setFloating(final Dockable dockable, boolean floating){
setFloating(dockable, floating, null);
}
/** Used only with DOCKED dockables : returns the nearest ancestor container
* (can be a CompoundDockingPanel if nested, or the DockingPanel).
*/
private Container getRelativeAncestorContainer(Dockable dockable){
Container compoundAncestor = DockingUtilities.findCompoundAncestorContainer(dockable);
if (compoundAncestor != null){
return compoundAncestor;
} else {
return dockingPanel;
}
}
/** Detach or attach the dockable from/to the desktop.
*
* show the dockable at sceenPosition (when not null) or centered (if screenPosition is null)
*
*/
public void setFloating(final Dockable dockable, boolean floating, Point screenPosition){
if (dockable == null)throw new NullPointerException("dockable");
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
SingleDockableContainer dockableContainer = DockingUtilities.
findSingleDockableContainer(dockable);
if (floating){
int state = dockable.getDockKey().getDockableState();
RelativeDockablePosition position = null;
if (state == DockableState.STATE_DOCKED){
position = new RelativeDockablePosition(getRelativeAncestorContainer(dockable), dockable);
} else if (state == DockableState.STATE_HIDDEN){
position = currentState.getPosition(); // get the position that was stored before
} else if (state == DockableState.STATE_FLOATING){
// from floating..to floating. It's still possible, if the component was previously tabbed (now it will have its
// own window
if (DockingUtilities.findTabbedDockableContainer(dockable) != null){
// ok, it was tabbed and floating
} else {
throw new IllegalArgumentException("floating not tabbed");
}
} else if (state == DockableState.STATE_CLOSED){
return; // ignore : to detach a dockable it must be somehow visible //2006/02/20
} else {
throw new IllegalArgumentException("not docked " + state);
}
DockableState newState = new DockableState(this, dockable, DockableState.STATE_FLOATING, position);
DockableStateWillChangeEvent event = new DockableStateWillChangeEvent(currentState, newState);
if (state == DockableState.STATE_FLOATING){
// floating to floating (create a new floating dialog by removing a dockable from a detached tab)
// note (@todo): as of version 2.1, we should trigger a dockingActionEvent here... but which one ?
// an addDockable with a floating state ?
Dimension previousSize = null;
remove(dockable);
if (dockableContainer !=null){
previousSize = ((Component)dockableContainer).getSize();
}
FloatingDockableContainer fdc = createFloatingDockableContainer(dockable);
//JDialog dialog = (JDialog) fdc;
if (previousSize != null){
DockingUtilities.setSize(fdc, previousSize); //2006/02/20
DockingUtilities.validate(fdc);
//dialog.setSize(previousSize);
//dialog.validate();
} else {
DockingUtilities.pack(fdc);
//dialog.pack();
}
if (screenPosition == null){
DockingUtilities.setLocationRelativeTo(fdc, this);
//dialog.setLocationRelativeTo(this);
} else {
DockingUtilities.setLocation(fdc, screenPosition);
//dialog.setLocation(screenPosition);
}
DockingUtilities.setVisible(fdc, true);
//dialog.setVisible(true);
} else if (currentState != null){
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, dockable, currentStateAsInt,
DockableState.STATE_FLOATING);
if (isDockingActionAccepted(dae, event)){
// not already floating so we trigger state events
Dimension previousSize = null;
if (dockableContainer !=null){
previousSize = ((Component)dockableContainer).getSize();
}
remove(dockable);
// store a return state, based on the current state + updated relative position
storePreviousFloatingState(dockable, new DockableState(currentState, position));
FloatingDockableContainer fdc = createFloatingDockableContainer(dockable);
//JDialog dialog = (JDialog) fdc;
if (previousSize != null){
DockingUtilities.setSize(fdc, previousSize);
DockingUtilities.validate(fdc);
//dialog.setSize(previousSize);
//dialog.validate();
} else {
DockingUtilities.pack(fdc);
//dialog.pack();
}
if (screenPosition == null){
DockingUtilities.setLocationRelativeTo(fdc, this);
//dialog.setLocationRelativeTo(this);
} else {
DockingUtilities.setLocation(fdc, screenPosition);
//dialog.setLocation(screenPosition);
}
DockingUtilities.setVisible(fdc, true);
//dialog.setVisible(true);
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_FLOATING);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
if (dockable instanceof CompoundDockable){
updateCompoundChildrenState((CompoundDockable)dockable, DockableState.STATE_FLOATING);
}
DockingUtilities.updateResizeWeights(dockingPanel);
revalidate();
}
}
} else { // attach !
// remove the button, show again the view
// was the dockable docked or hidden ?
DockableState previousState = getPreviousDockableState(dockable);
DockableState newState = new DockableState(this, dockable, previousState.getState(), previousState.getPosition());
DockableStateWillChangeEvent event = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae;
if (currentState != null && currentState.isFloating()){
if (previousState.isDocked()){
RelativeDockablePosition prevPos = previousState.getPosition();
Container relativeAncestor = prevPos.getRelativeAncestorContainer();
if (relativeAncestor == null){
relativeAncestor = dockingPanel; // safety : @todo we have to refactor xmlBuildFloatingNode to
// store the relativeAncestorContainer
}
dae = RelativeDockingUtilities.getInsertionDockingAction(
relativeAncestor, dockable, currentState, newState);
} else if (previousState.isHidden()){ // it was hidden
dae = new DockingActionSimpleStateChangeEvent(this, dockable, DockableState.STATE_FLOATING, DockableState.STATE_HIDDEN);
} else {
// shoudn't be possible
throw new RuntimeException();
}
if (isDockingActionAccepted(dae, event)){
removePreviousFloatingState(dockable);
Container parentOfSdc = null; //2005/10/07
parentOfSdc = ((JComponent)dockableContainer).getParent();
removeContainer(dockableContainer);
FloatingDockableContainer fdc = (FloatingDockableContainer) SwingUtilities.getWindowAncestor(dockable.getComponent());
if (parentOfSdc instanceof TabbedDockableContainer){
// dockable was contained in a tab on the floatable : we must not dispose the window
} else {
DockingUtilities.dispose(fdc);
//((JDialog)fdc).dispose();
}
context.setDockableState(dockable, newState);
if (previousState.isDocked()){
show(dockable, dae); // TODO Fix this null
} else if (previousState.isHidden()){ // it was hidden
floatingToHide(dockable, previousState.getPosition());
} else { // unmanaged state
throw new RuntimeException();
}
dockable.getDockKey().setDockableState(previousState.getState());
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
dockable.getComponent().requestFocus();
if (dockable instanceof CompoundDockable){
updateCompoundChildrenState((CompoundDockable)dockable, newState.getState());
}
DockingUtilities.updateResizeWeights(dockingPanel);
revalidate();
}
}
}
}
/** Detach or attach a whole tabbed dockable container from/to the desktop.
*
* displays the component at sceenPosition (when not null) or centered (if screenPosition is null)
*
*/
void setFloating(final TabbedDockableContainer tdc, Point screenPosition){
/* package protected, used by DragControler to detach a tabbedcontainer */
Dockable firstDockable = tdc.getDockableAt(0);
// all dockables have the same state, as they are in the same tabpane
DockableState currentState = getDockableState(firstDockable);
if (!currentState.isDocked()){
throw new IllegalArgumentException("not docked");
} else {
if (checkDockableStateWillChange(tdc, DockableState.STATE_FLOATING)){
RelativeDockablePosition position = new RelativeDockablePosition(dockingPanel, firstDockable);
// no veto has been raised by the compound dockables
Dimension previousSize = ((Component)tdc).getSize();
remove(tdc);
storePreviousFloatingStates(tdc);
FloatingDockableContainer fdc = createFloatingDockableContainer(tdc);
//JDialog dialog = (JDialog) fdc;
//dialog.setSize(previousSize);
//dialog.validate();
DockingUtilities.setSize(fdc, previousSize);
DockingUtilities.validate(fdc);
if (screenPosition == null){
DockingUtilities.setLocationRelativeTo(fdc, this);
//dialog.setLocationRelativeTo(this);
} else {
DockingUtilities.setLocation(fdc, screenPosition);
//dialog.setLocation(screenPosition);
}
DockingUtilities.setVisible(fdc, true);
//dialog.setVisible(true);
fireStateChanged(tdc, DockableState.STATE_FLOATING, position);
DockingUtilities.updateResizeWeights(dockingPanel);
revalidate();
}
}
}
private void storePreviousFloatingStates(TabbedDockableContainer tdc){
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
DockableState current = getDockableState(d);
storePreviousFloatingState(d, current);
}
}
private boolean checkDockableStateWillChange(TabbedDockableContainer tdc, int futureState){
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
DockableState currentState = getDockableState(d);
int currentStateAsInt = getStateAsInt(currentState);
DockableState newState = new DockableState(this, d, futureState, null);
DockableStateWillChangeEvent event = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, d, currentStateAsInt, newState.getState());
if (!isDockingActionAccepted(dae,event)){
return false;
}
}
return true;
}
private void fireStateChanged(TabbedDockableContainer tdc, int futureState, RelativeDockablePosition position){
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
DockableState currentState = getDockableState(d);
int currentStateAsInt = getStateAsInt(currentState);
DockableState newState = new DockableState(this, d, futureState, position);
context.setDockableState(d, newState);
d.getDockKey().setDockableState(DockableState.STATE_FLOATING);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, d, currentStateAsInt, newState.getState());
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
}
}
private DockableState removePreviousFloatingStates(TabbedDockableContainer tdc){
DockableState first = removePreviousFloatingState(tdc.getDockableAt(0));
for (int i=1; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
removePreviousFloatingState(d);
}
return first;
}
/** Returns the previous state of a hidden or floating dockable (when that dockable
* was in the DOCKED state.
*@since 2.0.4
*
*/
public DockableState getPreviousDockableState(Dockable dockable){
/* method mostly used internally */
return (DockableState) previousFloatingDockableStates.get(dockable);
}
private DockableState removePreviousFloatingState(Dockable dockable){
if (dockable instanceof CompoundDockable){
// we also need to clear states of the compound children
ArrayList children = DockingUtilities.findCompoundDockableChildren((CompoundDockable)dockable);
for (int i=0; i < children.size(); i++){
Dockable d = (Dockable) children.get(i);
previousFloatingDockableStates.remove(d);
}
}
return (DockableState) previousFloatingDockableStates.remove(dockable);
}
private void storePreviousFloatingState(Dockable dockable, DockableState state){
// when storing a previous dockable state before going floating, we have
// to ensure the relativeDockableAncestorContainer is defined
RelativeDockablePosition pos = state.getPosition();
if (pos.getRelativeAncestorContainer() == null){
Container c = DockingUtilities.findCompoundAncestorContainer(dockable);
if (c != null){
pos.resetRelativePosition(c, dockable);
} else {
pos.resetRelativePosition(dockingPanel, dockable);
}
}
previousFloatingDockableStates.put(dockable, state);
if (dockable instanceof CompoundDockable){
// more to do : the compund dockable may have children : they will share the
// same return position
ArrayList children = DockingUtilities.findCompoundDockableChildren((CompoundDockable)dockable);
for (int i=0; i < children.size(); i++){
Dockable d = (Dockable) children.get(i);
previousFloatingDockableStates.put(d, new DockableState(this, d, state.getState(), state.getPosition()));
}
}
}
/** simplified auto-hide version used when the dockable was previously in FLOATING state */
private void floatingToHide(Dockable dockable, RelativeDockablePosition position){
// doesn't trigger change event as it is managed by setFloatin(false)
DockKey k = dockable.getDockKey();
AutoHideButton btn = (AutoHideButton) autoHideButtons.get(k);
if (btn == null) {
btn = new AutoHideButton();
autoHideButtons.put(k, btn);
int zone;
if (k.getAutoHideBorder() == null) {
zone = AutoHidePolicy.getPolicy().getDefaultHideBorder().value();
} else {
zone = k.getAutoHideBorder().value();
}
btn.init(dockable, zone);
borderPanes[zone].setVisible(true); // border may not be visible
borderPanes[zone].add(btn);
borderPanes[zone].revalidate();
} else { // btn already existing, show it again
int zone = btn.getZone();
borderPanes[zone].setVisible(true); // may not be visible
btn.setVisible(true);
borderPanes[zone].revalidate();
}
}
private void moveFloatingWindows(){ //2005/10/10
Window w = SwingUtilities.getWindowAncestor(this);
if (w == null){
return; // 2007/02/27 fixed NPE
}
Point newLocation = w.getLocation();
if (this.lastWindowLocation != null){
int dx = newLocation.x - lastWindowLocation.x;
int dy = newLocation.y - lastWindowLocation.y;
Window [] childWindow = w.getOwnedWindows();
for (int i=0; i < childWindow.length; i++){
if (childWindow[i] instanceof FloatingDockableContainer && childWindow[i].isVisible()){
Point p = childWindow[i].getLocation();
childWindow[i].setLocation(p.x + dx, p.y +dy);
}
}
}
lastWindowLocation = newLocation;
}
/** Creates a floating JDialog to be used with this dockable.
*
* This method is protected to give access to implementors wanting to
* customize its look and feel (for example : removing the title bar by
* setting it to "undecorated").
*
* The old API has been removed (it returned a JDialog) as the DockingDesktop can only
* work with FloatingDockableContainers.
*/
protected FloatingDockableContainer createFloatingDockableContainer(final Dockable dockable){
Window ownerWindow = SwingUtilities.getWindowAncestor(this);
FloatingDockableContainer fdc = DockableContainerFactory.getFactory().createFloatingDockableContainer(ownerWindow);
fdc.installDocking(this);
fdc.setInitialDockable(dockable);
//JDialog dialog = (JDialog) fdc;
KeyStroke ks = (KeyStroke) UIManager.get("DockingDesktop.floatActionAccelerator");
if (ks != null){
JRootPane root = DockingUtilities.getRootPane(fdc);
root.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(ks, "float");
root.getActionMap().put("float", floatAction);
}
// dialog.pack();
// dialog.setVisible(true);
return fdc;
}
/** Creates a floating JDialog to be used for a whole TabbedDockableContainer.
*
* This method is protected to give access to implementors wanting to
* customize its look and feel (for example : removing the title bar by
* setting it to "undecorated").
*
* The old API has been removed (it returned a JDialog) as the DockingDesktop can only
* work with FloatingDockableContainers.
*/
protected FloatingDockableContainer createFloatingDockableContainer(TabbedDockableContainer tdc){
Window ownerWindow = SwingUtilities.getWindowAncestor(this);
FloatingDockableContainer fdc = DockableContainerFactory.getFactory().createFloatingDockableContainer(ownerWindow);
fdc.installDocking(this);
fdc.setInitialTabbedDockableContainer(tdc);
//JDialog dialog = (JDialog) fdc;
KeyStroke ks = (KeyStroke) UIManager.get("DockingDesktop.floatActionAccelerator");
if (ks != null){
JRootPane root = DockingUtilities.getRootPane(fdc);
root.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(ks, "float");
root.getActionMap().put("float", floatAction);
}
// dialog.pack();
// dialog.setVisible(true);
return fdc;
}
/** Removes a dockable container. */
protected void removeContainer(SingleDockableContainer dc){
/* to be improved : this method supposes a direct ancestor link
between DockableContainer and TabbedDockableContainer */
dc.uninstallDocking(this);
boolean invalidateDesktop = true; // always, except for floating dockables
Component parent = ((Component)dc).getParent();
if (parent != null){
if (parent instanceof SplitContainer) {
SplitContainer viewParent = (SplitContainer) parent;
if (viewParent.getLeftComponent() == dc) {
viewParent.remove((Component)dc);
Component other = viewParent.getRightComponent();
// replace viewParent by other in viewParent's hierarchy
Container viewGParent = (Container) viewParent.getParent();
DockingUtilities.replaceChild(viewGParent, viewParent, other);
} else {
viewParent.remove((Component)dc);
Component other = viewParent.getLeftComponent();
Container viewGParent = (Container) viewParent.getParent();
DockingUtilities.replaceChild(viewGParent, viewParent, other);
}
} else if (parent instanceof TabbedDockableContainer) {
TabbedDockableContainer tparent = (TabbedDockableContainer) parent;
tparent.removeDockable(dc.getDockable());
if (tparent.getTabCount() == 1) { // no more use for tabs
tparent.uninstallDocking(this);
((JTabbedPane)tparent).removeChangeListener(focusHandler);
Dockable last = tparent.getDockableAt(0);
boolean floating = last.getDockKey().getDockableState() == DockableState.STATE_FLOATING;
DockableContainer lastContainer = null;
if (floating) {
lastContainer = DockableContainerFactory.getFactory().
createDockableContainer(last, DockableContainerFactory.PARENT_DETACHED_WINDOW);
} else {
lastContainer = DockableContainerFactory.getFactory().
createDockableContainer(last, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
}
lastContainer.installDocking(this);
DockingUtilities.replaceChild( ( (Component) tparent).getParent(), (Component) tparent,
(Component)lastContainer);
}
} else if (parent == dockingPanel) { // no more views to show
dockingPanel.remove(0);
} else if (SwingUtilities.getWindowAncestor(parent) instanceof FloatingDockableContainer){
// removing from a FloatingDockableContainer... nothing to do
invalidateDesktop = false;
} else {
((Container) parent).remove((Component)dc);
//throw new IllegalStateException("View is not contained in desktop hierarchy " + parent);
}
if (invalidateDesktop){
dockingPanel.invalidate();
dockingPanel.validate();
dockingPanel.repaint();
}
}
}
/** Returns the current state of a dockable (CLOSED, HIDDEN, DOCKED, MAXIMIZED, FLOATING) */
public DockableState getDockableState(Dockable dockable){
return context.getDockableState(dockable);
}
/** Disposes the dockable container of this dockable.
* If the dockable is not currently displayed (or auto-hidden), this method will do nothing.
* the dockable remains registered and can later be shown again at the same
* location.
* */
public void close(Dockable dockable){
// keep track of where the dockable was
DockableState currentState = getDockableState(dockable);
if (currentState == null || currentState.isClosed()){// 2006/12/01
return; // no need to continue
}
int currentStateAsInt = getStateAsInt(currentState);
RelativeDockablePosition position = new RelativeDockablePosition(dockingPanel, dockable);
DockableState newState = new DockableState(this, dockable, DockableState.STATE_CLOSED, position);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionCloseEvent(this, dockable, currentStateAsInt);
if (dockingPanel.isAncestorOf(dockable.getComponent())){
if (isDockingActionAccepted(dae, dswe)){
if (dockable instanceof CompoundDockable){
// V2.1 : propagate closing state to children
updateCompoundChildrenState((CompoundDockable)dockable, DockableState.STATE_CLOSED);
}
remove(dockable);
removeFromTabbedGroup(dockable); // 2005/07/13
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_CLOSED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
DockingUtilities.updateResizeWeights(dockingPanel);
}
} else if (currentState.isHidden()) {
if (isDockingActionAccepted(dae, dswe)){
if (dockable instanceof CompoundDockable){
// V2.1 : propagate closing state to children
updateCompoundChildrenState((CompoundDockable)dockable, DockableState.STATE_CLOSED);
}
remove(dockable);
removeFromTabbedGroup(dockable); // 2005/07/13
context.setDockableState(dockable, new DockableState(this, dockable,
DockableState.STATE_CLOSED, currentState.getPosition()));
dockable.getDockKey().setDockableState(DockableState.STATE_CLOSED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
}
} else if (currentState.isFloating()){
if (isDockingActionAccepted(dae, dswe)){
if (dockable instanceof CompoundDockable){
// V2.1 : propagate closing state to children
updateCompoundChildrenState((CompoundDockable)dockable, DockableState.STATE_CLOSED);
}
remove(dockable);
removeFromTabbedGroup(dockable);
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_CLOSED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
}
} else if (currentState.isMaximized()){ // 2006/11/20
restore(dockable);
if (getDockableState(dockable).isDocked()){
// ok restore hasn't been vetoed
close(dockable); // once again we close, but this time with standard (DOCKED) behaviour
}
}
}
/** Iterates through this compound children and properly close them
* (without removing them from their parent container)
*/
private void updateCompoundChildrenState(CompoundDockable cDockable, int state){
ArrayList children = DockingUtilities.findCompoundDockableChildren(cDockable);
for (int i=0; i < children.size(); i++){
Dockable d = (Dockable) children.get(i);
d.getDockKey().setDockableState(state);
DockableState childState = getDockableState(d);
DockableState childNewState = new DockableState(this, d, state);
context.setDockableState(d, childNewState);
context.fireDockableStateChange(new DockableStateChangeEvent(childState, childNewState));
}
}
/** Convenience method to close all dockables of a TabbedDockableContainer except one.
*
* Note : is a dockable is not allowed to close (key.isCloseEnabled() returns false) then it
* won't be closed by this method.
*
* If the 'exception' dockable isn't contained in a tab, then nothing will happen.
*/
public void closeAllOtherDockablesInTab(Dockable exception){
TabbedDockableContainer tabContainer = DockingUtilities.findTabbedDockableContainer(exception);
if (tabContainer != null){
ArrayList dockables = new ArrayList(tabContainer.getTabCount()-1);
for (int i=0; i < tabContainer.getTabCount(); i++){
if (tabContainer.getDockableAt(i) != exception){
dockables.add(tabContainer.getDockableAt(i));
}
}
for (int i=0; i < dockables.size(); i++){
Dockable d = (Dockable) dockables.get(i);
if (d.getDockKey().isCloseEnabled()){
this.close(d);
}
}
}
}
/** Convenience method to close all dockables of the tabbedContainer
* containing "base" (including the base dockable).
*
* see also {@link #closeAllOtherDockablesInTab(Dockable)}.
*
* Note : is a dockable is not allowed to close (key.isCloseEnabled() returns false) then it
* won't be closed by this method.
*
* If the 'base' dockable isn't contained in a tab, then nothing will happen.
*
*/
public void closeAllDockablesInTab(Dockable base){
TabbedDockableContainer tabContainer = DockingUtilities.findTabbedDockableContainer(base);
if (tabContainer != null){
ArrayList dockables = new ArrayList(tabContainer.getTabCount());
for (int i=0; i < tabContainer.getTabCount(); i++){
dockables.add(tabContainer.getDockableAt(i));
}
for (int i=0; i < dockables.size(); i++){
Dockable d = (Dockable) dockables.get(i);
if (d.getDockKey().isCloseEnabled()){
this.close(d);
}
}
}
}
/** Toggles the position of a view between hidden (true) and docked (false).
*
*/
public void setAutoHide(Dockable dockable, boolean hide){
/* setAutoHide is called by user applications (or addHidenDockable() ) and from inside the framework :
* - Tab actions (only when in the DOCKED state)
* - DockView (listening to DockViewTitleBar property change
* - key events from the desktop
* - the AutoHideExpandPanel listening to DockViewTitleBar changes
*
* this method is not used when hiding from FLOATING state,
* the "floatingToHide" method is used istead to avoid triggering unused events
*/
DockKey k = dockable.getDockKey();
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
if (hide){
// build a relative position based on the compound container or top container.
RelativeDockablePosition position = new RelativeDockablePosition(getRelativeAncestorContainer(dockable), dockable);
DockableState newState = new DockableState(this, dockable, DockableState.STATE_HIDDEN, position);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, dockable,
currentStateAsInt, DockableState.STATE_HIDDEN);
if (currentStateAsInt != DockableState.STATE_HIDDEN
&& isDockingActionAccepted(dae, dswe)){
AutoHideButton btn = (AutoHideButton) autoHideButtons.get(k);
if (btn == null) {
btn = new AutoHideButton();
autoHideButtons.put(k, btn);
int zone;
if (k.getAutoHideBorder() == null) {
zone = AutoHidePolicy.getPolicy().getDefaultHideBorder().value();
} else {
zone = k.getAutoHideBorder().value();
}
btn.init(dockable, zone);
borderPanes[zone].setVisible(true); // border may not be visible
borderPanes[zone].add(btn);
borderPanes[zone].revalidate();
} else { // btn already existing, show it again
int zone = btn.getZone();
borderPanes[zone].setVisible(true); // may not be visible
btn.setVisible(true);
borderPanes[zone].revalidate();
}
// now, remove the view from the splitcontainers
hide(dockable);
context.setDockableState(dockable, newState);
k.setDockableState(DockableState.STATE_HIDDEN);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
if (dockable instanceof CompoundDockable){
// V2.1 : also trigger a dockable state change event for compound dockable children
updateCompoundChildrenState((CompoundDockable) dockable, DockableState.STATE_HIDDEN);
}
DockingUtilities.updateResizeWeights(dockingPanel);
revalidate();
}
} else { // SHOW
// remove the button, show again the view
DockableState newState = new DockableState(this, dockable, DockableState.STATE_DOCKED);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
RelativeDockablePosition pos = currentState.getPosition();
Container relativeContainer = pos.getRelativeAncestorContainer();
if (relativeContainer == null){
relativeContainer = dockingPanel; // safety : when a component is loaded from workspace,
// we currently loose the container information @todo fix this container in xmlBuildAutoHideNode
}
DockingActionEvent dae = RelativeDockingUtilities.getInsertionDockingAction(
relativeContainer, dockable, currentState, newState);
if (! currentState.isDocked() && isDockingActionAccepted(dae, dswe)){
AutoHideButton btn = (AutoHideButton) autoHideButtons.get(k);
assert btn != null;
int zone = btn.getZone();
btn.setVisible(false);
expandPanel.collapse();
if (borderPanes[zone].getVisibleButtonCount() == 0){
// hide button panel if no more buttons (to avoid a remaining visible border)
borderPanes[zone].setVisible(false);
revalidate();
}
expandPanel.remove(dockable);
show(dockable, dae);
context.setDockableState(dockable, newState);
k.setDockableState(DockableState.STATE_DOCKED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
if (dockable instanceof CompoundDockable){
// V2.1 : also trigger a dockable state change event for compound dockable children
updateCompoundChildrenState((CompoundDockable) dockable, DockableState.STATE_DOCKED);
}
DockingUtilities.updateResizeWeights(dockingPanel);
revalidate();
}
}
}
/** hide the view (used with autohide features) */
private void hide(Dockable dockable) {
if (dockable == null){
throw new NullPointerException("dockable");
}
DockableContainer dockableContainer = DockingUtilities.
findSingleDockableContainer(dockable);
if (dockableContainer == null){// || !dockingPanel.isAncestorOf((Component) dockableContainer)){
throw new IllegalArgumentException("not docked");
}
remove(dockable);
}
/** recalculates and returns the insets taken by autoexpand
* borders around the docking panel.
* */
public Insets getDockingPanelInsets() {
// recalculate the location and size of the mouse grabber
Insets i = new Insets(0, 0, 0, 0);
if (topBorderPane != null && topBorderPane.isVisible()) {
i.top += topBorderPane.getHeight();
}
if (leftBorderPane != null && leftBorderPane.isVisible()) {
i.left += leftBorderPane.getWidth();
}
if (bottomBorderPane != null && bottomBorderPane.isVisible()) {
i.bottom += bottomBorderPane.getHeight();
}
if (rightBorderPane != null && rightBorderPane.isVisible()) {
i.right += rightBorderPane.getWidth();
}
return i;
}
/** Creates and returns an array of all registered dockable with their current
* state.
*
* Visibility states are [DockableState.STATE_CLOSED, STATE_DOCKED, STATE_HIDDEN]
* @return an array of DockableState
*/
public DockableState[] getDockables(){
return context.getDockables();
}
/** Installs multiple drag sources.
* @see #installDockableDragSource(DockableDragSource)
*
* */
public void installDockableDragSources(DockableDragSource[] sources){
if (sources != null){
for (int i = 0; i < sources.length; i++) {
installDockableDragSource(sources[i]);
}
}
}
/** Uninstalls multiple drag sources.
*@see #uninstallDockableDragSource(DockableDragSource)
*
* */
public void uninstallDockableDragSources(DockableDragSource[] sources){
if (sources != null){
for (int i = 0; i < sources.length; i++) {
uninstallDockableDragSource(sources[i]);
}
}
}
/** This method is used by DockableContainers in order to register their
* DockableDragSource(s) to the DragControler.
*
* Adds a MouseListener and a MouseMotionListener to the
* Component-DockableDragSource
* Removes the MouseListener and MouseMotionListener added on installDockableDragSource()
*
* @see #installDockableDragSource(DockableDragSource)
* */
public void uninstallDockableDragSource(DockableDragSource source) {
((Component)source).removeMouseListener(dragControler);
((Component)source).removeMouseMotionListener(dragControler);
}
/** Request this desktop to reset it's contained views to their preferred size, if
* possible.
*
* This method should be invoked when the component is realized (visible) due
* to Split Panes implementation.
* */
public void resetToPreferredSize() {
dockingPanel.resetToPreferredSize();
}
/** Saves the current desktop configuration into an XML stream.
*
* The stream is not closed at the end of the operation.
*
* As of version 2.1, this method delegates the work to DockingContext.writeXML, which
* will export every dekstop sharing the same context (and not only this one)
*
* @see #readXML(InputStream)
* */
public void writeXML(OutputStream stream) throws IOException {
context.writeXML(stream);
// will call back writeDesktopXML for each desktop
}
/* package protected for callback from DockingContext */
void writeDesktopNode(PrintWriter out) throws IOException {
out.println("
* When the method returns, the desktop is totally reconfigured with posiibly different
* dockable at different positions.
*
* Note : The
* Dismisses all visible dockables (docked and auto-hidden), and clear their DockableState.
*
* The stream is not closed at the end of the operation.
* @see #writeXML(OutputStream)
* @see #registerDockable(Dockable)
* */
public void readXML(InputStream in) throws ParserConfigurationException, IOException, SAXException {
context.readXML(in);
}
/** removes every dockables from this desktop */
public void clear(){
dockingPanel.removeAll();
for (int i = 0; i < borderPanes.length; i++) {
borderPanes[i].removeAll();
borderPanes[i].setVisible(false);
}
boolean wasHeavyMaximized = false;
if (maximizedComponent != null){ // clean up maximization state
if (DockingPreferences.isLightWeightUsageEnabled()){
remove(maximizedComponent); // remove the single dockable container
} else {
remove(maximizedComponent.getParent()); // remove the awt panel
wasHeavyMaximized = true;
}
maximizedComponent = null; // 2006/11/20 ooops !
}
autoHideButtons.clear();
expandPanel.collapse();
expandPanel.clear();
previousFloatingDockableStates.clear();
tabbedGroups.clear();
// clear the floatables windows
ArrayList floatingDockables = context.getDockablesByState(this, DockableState.STATE_FLOATING);
for (int i=0; i < floatingDockables.size(); i++){
Dockable d = (Dockable) floatingDockables.get(i);
remove(d);
}
}
/* package protected */
void readDesktopNode(Element desktopElement) throws SAXException {
/* called back by DockingContext to read (and install) a desktop configuration from an xml stream
*/
NodeList children = desktopElement.getChildNodes();
for (int i = 0, len = children.getLength(); i < len; i++) {
Node child = children.item(i);
xmlBuildRootNode(child);
}
DockingUtilities.updateResizeWeights(dockingPanel); // 2006/12/01
revalidate();
}
private void xmlBuildRootNode(Node node) throws SAXException{
if (node.getNodeType() == Node.ELEMENT_NODE){
Element elt = (Element) node;
String name = elt.getNodeName();
if (name.equals("DockingPanel")){
// only one child at most
NodeList children = elt.getChildNodes();
for (int i = 0, len = children.getLength(); i < len; i++) {
xmlBuildDockingPanelNode(elt.getChildNodes().item(i));
}
} else if (name.equals("Border")){
int zone = Integer.parseInt(elt.getAttribute("zone"));
AutoHideButtonPanel borderPanel = borderPanes[zone];
borderPanel.setVisible(true); // border may not be visible
NodeList children = elt.getElementsByTagName("Dockable");
for (int i = 0, len = children.getLength(); i < len; i++) {
xmlBuildAutoHideNode(borderPanel, (Element)children.item(i));
}
borderPanel.revalidate();
} else if (name.equals("Floating")){
int x = Integer.parseInt(elt.getAttribute("x"));
int y = Integer.parseInt(elt.getAttribute("y"));
int width = Integer.parseInt(elt.getAttribute("width"));
int height = Integer.parseInt(elt.getAttribute("height"));
NodeList children = elt.getElementsByTagName("Dockable");
xmlBuildFloatingNode(children, new Rectangle(x, y, width, height)); //2005/10/10
/* for (int i = 0, len = children.getLength(); i < len; i++) {
xmlBuildFloatingNode((Element)children.item(i), new Rectangle(x, y, width, height));
}*/
} else if (name.equals("TabGroups")){
NodeList children = elt.getElementsByTagName("TabGroup");
xmlBuildTabGroup(children); //2005/10/10
} else {
throw new SAXNotRecognizedException(name);
}
}
}
private void xmlBuildAutoHideNode(AutoHideButtonPanel borderPanel, Element dockableElt) throws SAXException {
Element hideElt = (Element)dockableElt.getElementsByTagName("RelativePosition").item(0);
float x = Float.parseFloat(hideElt.getAttribute("x"));
float y = Float.parseFloat(hideElt.getAttribute("y"));
float w = Float.parseFloat(hideElt.getAttribute("w"));
float h = Float.parseFloat(hideElt.getAttribute("h"));
RelativeDockablePosition position = new RelativeDockablePosition(x, y, w, h);
AutoHideButton btn = new AutoHideButton();
Dockable dockable = xmlGetDockable(dockableElt);
autoHideButtons.put(dockable.getDockKey(), btn);
context.setDockableState(dockable, new DockableState(this, dockable, DockableState.STATE_HIDDEN, position));
dockable.getDockKey().setDockableState(DockableState.STATE_HIDDEN);
btn.init(dockable, borderPanel.getBorderZone());
borderPanel.add(btn);
if (dockable instanceof CompoundDockable){
// check for children and build them
xmlBuildCompoundDockable((CompoundDockable) dockable, dockableElt, DockableState.STATE_HIDDEN);
}
}
/* private void xmlBuildFloatingNode(Element dockableElt, Rectangle bounds) {
*/
private void xmlBuildFloatingNode(NodeList dockables, Rectangle bounds) throws SAXException {
// @todo not optimal.. we should refactor it oustide this method
Window desktopWindow = SwingUtilities.getWindowAncestor(this);
if (desktopWindow != null){
Point windowLocation = desktopWindow.getLocation();
bounds.x += windowLocation.x; // position is relative
bounds.y += windowLocation.y;
}
//JDialog dialog = null;
FloatingDockableContainer fdc = null;
TabbedDockableContainer tdc = null;
if (dockables.getLength()>1){ // it's a floating tab
tdc = DockableContainerFactory.getFactory().createTabbedDockableContainer();
tdc.installDocking(this);
((JTabbedPane) tdc).addChangeListener(focusHandler); // our best way to track selection (focus) changes
}
Dockable baseDockable = null; // used when there are tabs
for (int i=0; i < dockables.getLength(); i++){
Element dockableElt = (Element) dockables.item(i);
Element hideElt = (Element)dockableElt.getElementsByTagName("RelativePosition").item(0);
float x = Float.parseFloat(hideElt.getAttribute("x"));
float y = Float.parseFloat(hideElt.getAttribute("y"));
float w = Float.parseFloat(hideElt.getAttribute("w"));
float h = Float.parseFloat(hideElt.getAttribute("h"));
RelativeDockablePosition position = new RelativeDockablePosition(dockingPanel, x, y, w, h);
Dockable dockable = xmlGetDockable(dockableElt);
if (i == 0){
baseDockable = dockable;
}
Element previousState = (Element)dockableElt.getElementsByTagName("PreviousState").item(0);
int istate = Integer.parseInt(previousState.getAttribute("state"));
DockableState state = new DockableState(this, dockable, istate, position);
storePreviousFloatingState(dockable, state);
if (fdc == null){
//if (dialog == null}){
// dialog = (JDialog) createFloatingDockableContainer(dockable);
fdc = createFloatingDockableContainer(dockable);
} else {
// add as a tab
if (tdc.getTabCount() == 0){
// first tab : replace the current DetachedDockView by the tab container
// not very efficient... @todo : sort this out
DockableContainer base = DockingUtilities.findDockableContainer(baseDockable);
DockingUtilities.replaceChild(((Component)base).getParent(),
(Component)base, (Component)tdc);
tdc.addDockable(baseDockable, 0);
}
tdc.addDockable(dockable, tdc.getTabCount());
}
context.setDockableState(dockable, new DockableState(this, dockable, DockableState.STATE_FLOATING, position));
dockable.getDockKey().setDockableState(DockableState.STATE_FLOATING);
if (dockable instanceof CompoundDockable){
// check for children and build them
xmlBuildCompoundDockable((CompoundDockable) dockable, dockableElt, DockableState.STATE_FLOATING);
}
}
DockingUtilities.setBounds(fdc, bounds);
//dialog.setBounds(bounds);
//dialog.validate();
//dialog.setVisible(true);
DockingUtilities.validate(fdc);
DockingUtilities.setVisible(fdc, true);
}
private void xmlBuildDockingPanelNode(Node node) throws SAXException {
if (node.getNodeType() == Node.ELEMENT_NODE){
Component comp = xmlCreateComponent((Element) node, DockableState.STATE_DOCKED);
if (comp != null){
dockingPanel.add(comp, BorderLayout.CENTER);
}
}
}
private Component xmlCreateComponent(Element elt, int dockableState) throws SAXException {
if (elt.getNodeName().equals("Split")){
SplitContainer split = xmlBuildSplitContainer(elt, dockableState);
return split;
} else if (elt.getNodeName().equals("Dockable")){
Dockable d = xmlGetDockable(elt);
SingleDockableContainer sdc = DockableContainerFactory.getFactory()
.createDockableContainer(d, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
context.setDockableState(d, new DockableState(this, d, dockableState));
d.getDockKey().setDockableState(dockableState);
sdc.installDocking(this);
if (d instanceof CompoundDockable){
// check for children and build them
xmlBuildCompoundDockable((CompoundDockable) d, elt, dockableState);
}
return (Component) sdc;
} else if (elt.getNodeName().equals("TabbedDockable")){
TabbedDockableContainer tdc = xmlBuildTabbedDockableContainer(elt, dockableState);
return (Component) tdc;
} else if (elt.getNodeName().equals("MaximizedDockable")){
// this should be the last element from DockingPanel node
Dockable d = xmlGetDockable(elt);
maximize(d);
return null;
} else {
throw new SAXNotRecognizedException(elt.getNodeName());
}
}
private void xmlBuildCompoundDockable(CompoundDockable dockable,
Element compoundElt, int dockableState) throws SAXException{
/* a compound dockable can hold a sub dockable (or split/tabs) */
CompoundDockingPanel compoundPanel = (CompoundDockingPanel) dockable.getComponent();
compoundPanel.removeAll(); // cleanup the compound at every workspace reloading 2007/01/08
NodeList children = compoundElt.getChildNodes();
for (int i = 0, len = children.getLength(); i < len; i++) {
Node node = children.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE){
Element elt = (Element) node;
if (elt.getNodeName().equals("Key")){
// ignore : it's the key of the compound dockable
} else {
Component comp = xmlCreateComponent(elt, dockableState);
compoundPanel.add(comp, BorderLayout.CENTER);
return; // no more than a single child
}
}
}
}
private SplitContainer xmlBuildSplitContainer(Node node, int dockableState) throws SAXException{
Element elt = (Element) node;
int orientation = Integer.parseInt(elt.getAttribute("orientation"));
String loc = elt.getAttribute("location");
double location = 0.5;
if (loc != null && !loc.equals("")){
location = Double.parseDouble(loc);
}
SplitContainer split = new SplitContainer(orientation);
split.setDividerLocation(location);
boolean left = true;
for (int i = 0; i < node.getChildNodes().getLength(); i++) {
Node child = node.getChildNodes().item(i);
if (child.getNodeType() == Node.ELEMENT_NODE){
Component comp = xmlCreateComponent((Element)child, dockableState);
if (left){
split.setLeftComponent(comp);
left = false;
} else {
split.setRightComponent(comp);
}
}
}
return split;
}
private TabbedDockableContainer xmlBuildTabbedDockableContainer(Element elt,
int dockableState) throws SAXException {
TabbedDockableContainer tdc = DockableContainerFactory.getFactory().createTabbedDockableContainer();
tdc.installDocking(this);
((JTabbedPane) tdc).addChangeListener(focusHandler); // our best way to track selection (focus) changes
Dockable base = null;
for (int i = 0; i < elt.getChildNodes().getLength(); i++) {
Node child = elt.getChildNodes().item(i);
if (child.getNodeType() == Node.ELEMENT_NODE){
Dockable d = xmlGetDockable((Element) child);
if (base == null){
base = d;
}
context.setDockableState(d, new DockableState(this, d, dockableState));
d.getDockKey().setDockableState(dockableState);
tdc.addDockable(d, tdc.getTabCount());
// update the tab group
if (base != d){
addToTabbedGroup(base, d);
}
if (d instanceof CompoundDockable){
// check for children and build them is needed
xmlBuildCompoundDockable((CompoundDockable) d, (Element) child, dockableState);
}
}
}
return tdc;
}
private Dockable xmlGetDockable(Element dockableElt) {
Element key = (Element)dockableElt.getElementsByTagName("Key").item(0);
String name = key.getAttribute("dockName");
Dockable dockable = context.getDockableByKey(name);
if (dockable == null){
throw new NullPointerException("Dockable " + name + " not registered");
}
return dockable;
}
/** rebuild the tabbedGroups structure (memory of tabbed dockables) */
private void xmlBuildTabGroup(NodeList group) {
// this pass is useful for hidden dockable that need to be reassociated
// with their tab group.
// (tabbed dockable don't need it as this information is implicit (during xml tab creation)
for (int i=0; i < group.getLength(); i++){
Element groupElt = (Element)group.item(i);
NodeList dockables = groupElt.getElementsByTagName("Dockable");
Dockable base = null;
for (int j=0; j < dockables.getLength(); j++){
Element dockableElt = (Element)dockables.item(j);
Dockable d = xmlGetDockable(dockableElt);
if (j == 0){
base = d;
} else {
addToTabbedGroup(base, d);
}
}
}
}
/** Adds a dockable in the docking desktop.
*
* This method can be used mainly in two situations :
*
* This method is used to reposition a closed dockable at its previous location
* on the desktop. As it relies on the Component.findComponentAt(Point) method ,
* the desktop must already be visible.
*
*
* The preferred way to obtain a particular visual docking confuguration is to
* use a combination of add(), split() and createTab() methods, as these methods do
* not rely on an interpretation (and approximation) of constraints.
*
*
* Precision of constraints : as the docking management is based on a mix of
* horizontal and vertical splitting zones, it is not always possible to
* respect the constraints given.
*
* The current implementation will do the following :
*
* Useful for example to reserve some space on a desktop by using a "placeholder' when
* other dockables aren't visible (Multiple Tabbed Document Interface with always a dockable
* visible even when no document is loaded).
*
* Implementation note : this method assumes only the "base" dockable is visible (the replacer must be
* in the CLOSED state). It also assumes the base dockable isn't a compound dockable. These limitations
* will be removed in a later release.
*
*
* There is currently no DnD gesture associated to this action (although the
* "HotSwap" gesture would be a good candidate). So this method currently doesn't trigger any event
* (state change, action), yet it could change later.
*
* @since 2.1
* @throws IllegalArgumentException when dockables aren't in the appropriate state or hierarchy.
*/
public void replace(Dockable base, Dockable replacer){
DockableState baseState = context.getDockableState(base);
DockableState replacerState = context.getDockableState(replacer);
DockableState newBaseState = new DockableState(replacerState.getDesktop(), base, replacerState.getState());
DockableState newReplacerState = new DockableState(baseState.getDesktop(), replacer, baseState.getState());
TabbedDockableContainer tdcBase = DockingUtilities.findTabbedDockableContainer(base);
if (!replacerState.isClosed()){
throw new IllegalArgumentException("replacer isn't closed");
}
if (base instanceof CompoundDockable){
throw new IllegalArgumentException("base cannot be a compound dockable");
}
if (tdcBase != null){
int iBase = tdcBase.indexOfDockable(base);
tdcBase.removeDockable(base);
tdcBase.addDockable(replacer, iBase);
} else {
SingleDockableContainer sdcBase = DockingUtilities.findSingleDockableContainer(base);
Container sdcBaseParent = ((Component)sdcBase).getParent();
if (sdcBaseParent instanceof SplitContainer){
SplitContainer split = (SplitContainer) sdcBaseParent;
boolean isLeft = split.getLeftComponent() == sdcBase;
SingleDockableContainer sdc = DockableContainerFactory.getFactory().createDockableContainer(
replacer, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
sdc.installDocking(this);
if (isLeft){
split.setLeftComponent((Component)sdc);
} else {
split.setRightComponent((Component)sdc);
}
split.revalidate();
} else if (sdcBaseParent instanceof DockingPanel){
// a single component
DockingPanel dp = (DockingPanel)sdcBaseParent;
dp.remove(0);
SingleDockableContainer sdc = DockableContainerFactory.getFactory().createDockableContainer(
replacer, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
sdc.installDocking(this);
dp.add((Component) sdc, BorderLayout.CENTER);
dp.revalidate();
} else if (sdcBaseParent instanceof CompoundDockingPanel){
// a single component
CompoundDockingPanel cdp = (CompoundDockingPanel)sdcBaseParent;
cdp.remove(0);
SingleDockableContainer sdc = DockableContainerFactory.getFactory().createDockableContainer(
replacer, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
sdc.installDocking(this);
cdp.add((Component) sdc, BorderLayout.CENTER);
cdp.revalidate();
} else {
throw new RuntimeException("Wrong container hierarchy : " + sdcBaseParent);
}
}
// swap states
context.setDockableState(base, newBaseState);
context.setDockableState(replacer, newReplacerState);
}
/* small utility method to avoid bloating code everywhere (return a default state value if state object is null) */
private static int getStateAsInt(DockableState state){
if (state == null){
return DockableState.STATE_CLOSED;
} else {
return state.getState();
}
}
/** Adds a dockable inside a compound dockable.
*
* This is the method to start a nesting hierarchy inside a compound dockable
* (once the first dockable is added, you add subsequent dockables with standard split/createTab methods)
*
* DockableStateChange Events are triggered after the state change.
*
* As of version 2.0 of the framework, this method can also be replaced by
* adding a propertychangeListener on the DockKey object (and react to its DockableState
* property).
*
* */
public void addDockableStateChangeListener(DockableStateChangeListener listener){
context.addDockableStateChangeListener(listener);
}
/** Removes a DockableStateChangeListener from this desktop.
* */
public void removeDockableStateChangeListener(DockableStateChangeListener listener){
context.removeDockableStateChangeListener(listener);
}
/** Adds a new DockableStateWillChangeListener to this desktop.
*
* DockableStateWillChange Events are triggered before the state change, and
* are vetoable.
* */
public void addDockableStateWillChangeListener(DockableStateWillChangeListener listener){
context.addDockableStateWillChangeListener(listener);
}
/** Removes a DockableStateWillChangeListener from this desktop.
* */
public void removeDockableStateWillChangeListener(DockableStateWillChangeListener listener){
context.removeDockableStateWillChangeListener(listener);
}
/** Adds a new DockingActionListener to this desktop.
*
* DockingAction Events are triggered before and after any docking action (split, tab, close, hide...) and
* allow for precise tracking (and vetoing) of these operations.
*
* @see #removeDockingActionListener(DockingActionListener)
*/
public void addDockingActionListener(DockingActionListener listener){
context.addDockingActionListener(listener);
}
/** Removes a DockingActionListener from this desktop.
*
* @see #addDockingActionListener(DockingActionListener)
*/
public void removeDockingActionListener(DockingActionListener listener){
context.removeDockingActionListener(listener);
}
/** Adds a new DockableSelectionListener to this desktop.
*
* DockableSelection Events are triggered when a dockable takes the focus.
*
*/
public void addDockableSelectionListener(DockableSelectionListener listener){
context.addDockableSelectionListener(listener);
}
/** Removes a DockableSelectionListener from this desktop.
* */
public void removeDockableSelectionListener(DockableSelectionListener listener){
context.removeDockableSelectionListener(listener);
}
/** Registers and add a dockable on an auto-hide border.
* this method should be called at startup time (when the dockable isn't yet
* displayed). to toggle a dockable from docked to auto-hide, please use
* setAutoHide(Dockable, boolean) instead.
*
* However, this method will not fail if the dockable is already displayed :
* in that case, it will delegate autohide to setAutoHide(Dockable, boolean), thus
* dropping the dockedPosition argument.
*
* @param dockable the dockable to add (to select the border where the dockable
* will be positionned, use the DockKey.setAutoHideBorder mehod
*
* @param dockedPosition relative positionning (may be null) indicating where to
* dock the dockable when leaving its auto-hide border.
* */
public void addHiddenDockable(Dockable dockable, RelativeDockablePosition dockedPosition){
/* not used from inside the API : only for user applications */
DockableState currentState = getDockableState(dockable); // should be null
if (currentState != null && !currentState.isHidden()){
// delegate autohide to the right method
setAutoHide(dockable, true);
return;
}
registerDockable(dockable);
currentState = getDockableState(dockable); // now should be CLOSED
int currentStateAsInt = getStateAsInt(currentState);
DockableState newState = new DockableState(this, dockable, DockableState.STATE_HIDDEN, dockedPosition);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(this, dockable, currentStateAsInt,
DockableState.STATE_HIDDEN);
DockKey k = dockable.getDockKey();
if (currentStateAsInt != DockableState.STATE_HIDDEN && isDockingActionAccepted(dae, dswe)){
AutoHideButton btn = (AutoHideButton) autoHideButtons.get(k);
if (btn == null) {
btn = new AutoHideButton();
autoHideButtons.put(k, btn);
int zone;
if (k.getAutoHideBorder() == null) {
zone = AutoHidePolicy.getPolicy().getDefaultHideBorder().value();
} else {
zone = k.getAutoHideBorder().value();
}
btn.init(dockable, zone);
borderPanes[zone].setVisible(true); // border may not be visible
borderPanes[zone].add(btn);
borderPanes[zone].revalidate();
} else { // btn already existing, show it again
int zone = btn.getZone();
borderPanes[zone].setVisible(true); // may not be visible
btn.setVisible(true);
borderPanes[zone].revalidate();
}
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_HIDDEN);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
revalidate();
}
}
/** Changes the width of a dockable (the dockable must already be visible).
*
*
* Note that this method works by modifying the divider location of the
* nearest SplitContainer ancestor of the dockable (the first splitted horizontally).
*
*
* As this method must be called when the desktop is visible, a simple way to
* do this is to add a window listener to the parent frame of the desktop, and call this
* method from the windowOpened(WindowEvent) notification.
*
* @param width new width (if between 0 and 1, width is taken as a proportional width,
* otherwise it is a pixel width.
*
* */
public void setDockableWidth(Dockable dockable, double width){
SplitContainer split = DockingUtilities.getSplitPane(dockable, JSplitPane.HORIZONTAL_SPLIT);
if (split == null) return;
if ( ( (Container) split.getLeftComponent()).isAncestorOf(dockable.
getComponent())) {
split.setDividerLocation(width);
} else {
split.setDividerLocation(1.0 - width);
}
}
/** Changes the height of a dockable (the dockable must already be visible).
*
* Note that this method works by modifying the divider location of the
* nearest SplitContainer ancestor of the dockable (the first splitted vertically).
*
* As this method must be called when the desktop is visible, a simple way to
* do this is to add a window listener to the parent frame of the desktop, and call this
* method from the windowOpened(WindowEvent) notification.
*
* @param height new height (if between 0 and 1, height is taken as a proportional height,
* otherwise it is a pixel height.
*
* */
public void setDockableHeight(Dockable dockable, double height){
SplitContainer split = DockingUtilities.getSplitPane(dockable, JSplitPane.VERTICAL_SPLIT);
if (split == null) return;
if ( ( (Container) split.getTopComponent()).isAncestorOf(dockable.
getComponent())) {
split.setDividerLocation(height);
} else {
split.setDividerLocation(1 - height);
}
}
/** Updates the resizing behaviour of the desktop in order to resize
* this dockable (and keep others at fixed size).
* This method should be called at least once (prior to showing the desktop) with an
* already docked dockable.
* If the dockable doesn't belong to the desktop containment hierarchy,
* this method will do nothing.
* @deprecated use setResizeWeight() in every dockKey for a better resizing behaviour
*
*/
public void setAutoResizableDockable(Dockable dockable){
/*this.autoResizeableDockable = dockable; */
DockingUtilities.updateResizeWeights(dockingPanel);
}
/** Registers a dockable as belonging to a tab group.
* It is used to have a memory of grouped (tabbed) dockables in order to keep the
* group together when dockable are restored from auto-hide mode.
* This method is generally called by the tabbed container management, and not directly
* by the developper.
*
* However, there is a case where calling this method can be usefull :
* when, at startup, a desktop is built with multiple hidden dockables, and the developper wants
* them to be grouped in a tab container when they are restored to the desktop.
*
* note that the method is symetric when a group is empty : it such a case base and newTab
* args can be swapped.
*
* @param base an already tabbed dockable
* @param newTab a dockable to add to the tab group
*
*@since 1.1.2
*/
public void addToTabbedGroup(Dockable base, Dockable newTab){//2005/07/13
/* this method is called when a dockable is added to a dockableTabbedContainer */
LinkedList group = (LinkedList) tabbedGroups.get(base);
if (group == null){
group = new LinkedList();
group.add(base);
tabbedGroups.put(base, group);
}
if (!group.contains(newTab)){
group.add(newTab);
tabbedGroups.put(newTab, group);
}
}
/** Unregisters a dockable from its current tab group (when it's removed from it).
* For an application developper, there should be no need to call this method as it is managed
* internally by the framework, unless the developper wants to explicitely remove a component from
* a tab group when this component is in the auto-hide state.
*@since 1.1.2
*/
public void removeFromTabbedGroup(Dockable dockable){ // 2005/07/13
/* package protected */
/* This method is invoked when a component is dragged outside of a tab group : meaning
* the user doesn't want anymore this dockable to be grouped in that tab.
*
*/
LinkedList group = (LinkedList) tabbedGroups.get(dockable);
if (group != null){
tabbedGroups.remove(dockable);
group.remove(dockable);
if (group.size() == 1){ // end of grouping as there are no more dockables linked.
Dockable d = (Dockable)group.removeFirst();
tabbedGroups.remove(d);
}
}
}
/** Creates the autohide expand panel to be used in this desktop.
*
* This method gives a chance to the developer to override expand panel creation
* and provide a custom subclass.
*/
protected AutoHideExpandPanel createAutoHideExpandPanel(){
return new AutoHideExpandPanel();
}
/** used to track focus changes for DockableSelection events
*/
private class FocusHandler implements PropertyChangeListener, ChangeListener {
/** this one is never null (except at first time) */
Dockable lastFocusedDockable;
/** this one can be null between focusLost() and focusGained() */
Dockable currentDockable;
// focusOwner
public void propertyChange(PropertyChangeEvent e) {
Component c = (Component) e.getNewValue();
while (c != null && ! (c instanceof SingleDockableContainer)){
c = c.getParent();
}
if (c instanceof SingleDockableContainer){
SingleDockableContainer sdc = (SingleDockableContainer) c;
currentDockable = sdc.getDockable();
if (sdc.getDockable() != lastFocusedDockable){
context.fireDockableSelectionChange(new DockableSelectionEvent(sdc.getDockable()));
}
lastFocusedDockable = sdc.getDockable();
} else { // c == null
currentDockable = null;
}
}
// This method is called whenever the selected tab of all TabbedDockableContainers changes
public void stateChanged(ChangeEvent evt) {
// our only problem is at startup : the focus may be out of the tabbed pane
// and we are firing a false selection event.
// @todo correct this behaviour by checking if the focus is not already
// outside this component
JTabbedPane pane = (JTabbedPane)evt.getSource();
TabbedDockableContainer tdc = ((TabbedDockableContainer)pane);
Dockable selDockable = tdc.getSelectedDockable();
if (selDockable == null){ // this may happen when maximization occurs
// ignore
} else {
currentDockable = selDockable;
if (selDockable != lastFocusedDockable){
lastFocusedDockable = selDockable;
context.fireDockableSelectionChange(new DockableSelectionEvent(selDockable));
}
}
}
Dockable getCurrentDockable(){
return currentDockable;
}
}
/** Returns the name of this desktop (used by workspace management) */
public String getDesktopName() {
return desktopName;
}
/** Updates the name of this desktop (used by workspace management) */
public void setDesktopName(String desktopName) {
this.desktopName = desktopName;
}
/** Returns the docking context used by this desktop (might be shared with other desktop).
*
* @since 2.1
*/
public DockingContext getContext() {
return context;
}
/** Updates the docking context used by this desktop.
*
* Warning : this method should only be used by the framework itself : changing
* a context "live" can have unpredicted and undesired side effect.
* @since 2.1
*/
public void setContext(DockingContext context) {
this.context = context;
}
/** returns the currently maximized dockable
* (or null if no dockable is in that state)
*/
public Dockable getMaximizedDockable() {
if (maximizedComponent == null){
return null;
} else {
SingleDockableContainer maxContainer = (SingleDockableContainer)maximizedComponent;
return maxContainer.getDockable();
}
}
/** combines a docking action event and vetoable state change event to accept or reject
* a docking action.
*/
private boolean isDockingActionAccepted(DockingActionEvent dae, DockableStateWillChangeEvent dse){
boolean accepted = context.fireAcceptDockingAction(dae);
if (accepted){
if (dse != null && dae.getInitialDockableState() != dae.getNextDockableState()){
return context.fireDockableStateWillChange(dse);
} else {
return true;
}
} else {
return false;
}
}
private void fireDockingAction(DockingActionEvent dae, DockableStateChangeEvent dse){
context.fireDockingActionPerformed(dae);
if (dse != null && dae.getInitialDockableState() != dae.getNextDockableState()){
context.fireDockableStateChange(dse);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingPanel.java 0000644 0001750 0001750 00000023134 10573516350 025442 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockingActionSplitComponentEvent;
import com.vlsolutions.swing.docking.event.DockingActionSplitDockableContainerEvent;
import java.awt.Shape;
import javax.swing.*;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockEvent;
import java.awt.Rectangle;
import java.awt.BorderLayout;
import java.awt.geom.Rectangle2D;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import java.awt.Point;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
/** This class is responsible for the containment of a Dockable component.
*
* Users of the VLDocking Framework should not call this class which is
* a utility component of DockingDesktop.
*
*
* Please rely on DockingDesktop capabilities.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/11/08 Lilian Chamontin : added support for global width/height drop
*/
public class DockingPanel extends JPanel implements DockDropReceiver{
/** @todo see if we still need the DockDropReceiver */
/** Javabeans constructor */
public DockingPanel(){
super(new BorderLayout());
}
/** act the same as a splitContainer : allow drop on the borders*/
public void processDockableDrag(DockDragEvent event) {
scanContainer(event, false);
}
public void processDockableDrop(DockDropEvent event) {
scanContainer(event, true);
}
private void acceptDrop(DockEvent event, DockingConstants.Split position){
Container dragContainer = event.getDragSource().getDockableContainer();
( (DockDropEvent) event).acceptDrop();
if (dragContainer instanceof TabbedDockableContainer){
event.getDesktop().splitComponent(this, dragContainer, position);
} else {
event.getDesktop().splitComponent(this, event.getDragSource().getDockable(), position);
}
}
private void acceptDrag(DockEvent event, DockingConstants.Split position, Shape shape){
Container dragContainer = event.getDragSource().getDockableContainer();
Dockable dockable = event.getDragSource().getDockable();
int initialState = dockable.getDockKey().getDockableState();
int nextState = DockableState.STATE_DOCKED;
if (dragContainer instanceof TabbedDockableContainer){
event.setDockingAction(new DockingActionSplitDockableContainerEvent(
event.getDesktop(), initialState, nextState,
this, dragContainer, position, 0.5f));
} else {
event.setDockingAction(new DockingActionSplitComponentEvent(
event.getDesktop(), dockable, initialState, nextState,
this, position, 0.5f));
}
( (DockDragEvent) event).acceptDrag(shape);
}
private void scanContainer(DockEvent event, boolean drop) {
Point p = event.getMouseEvent().getPoint();
Rectangle compBounds = getBounds();
int distTop = p.y;
int distLeft = p.x;
int min = Math.min(distTop, distLeft);
int distRight = compBounds.width - p.x;
int distBottom = compBounds.height - p.y;
int min2 = Math.min(distBottom, distRight);
min = Math.min(min, min2);
Dimension size = getSize();
Dockable dragged = event.getDragSource().getDockable();
// the drag size is the one of the parent dockable container
Dimension draggedSize = dragged.getComponent().getParent().getSize();
int bestHeight = (int)Math.min(draggedSize.height , size.height * 0.5);
int bestWidth = (int)Math.min(draggedSize.width , size.width * 0.5);
if (min == distTop) {
// dock on top
if (drop) {
acceptDrop(event, DockingConstants.SPLIT_TOP);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
0,
compBounds.width,
bestHeight);
acceptDrag(event, DockingConstants.SPLIT_TOP, r2d);
}
} else if (min == distLeft) {
if (drop) {
acceptDrop(event, DockingConstants.SPLIT_LEFT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
0,
bestWidth,
compBounds.height);
acceptDrag(event, DockingConstants.SPLIT_LEFT, r2d);
}
} else if (min == distBottom) {
if (drop) {
acceptDrop(event, DockingConstants.SPLIT_BOTTOM);
} else {
Rectangle2D r2d = new Rectangle2D.Float(0,
compBounds.height - bestHeight,
compBounds.width,
bestHeight);
acceptDrag(event, DockingConstants.SPLIT_BOTTOM, r2d);
}
} else { // right
if (drop) {
acceptDrop(event, DockingConstants.SPLIT_RIGHT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(
compBounds.width - bestWidth,
0,
bestWidth,
compBounds.height);
acceptDrag(event, DockingConstants.SPLIT_RIGHT, r2d);
}
}
}
public void resetToPreferredSize() {
Component mainComp = getComponent(0);
if (mainComp instanceof SplitContainer){
((SplitContainer)mainComp).resetToPreferredSizes();
}
}
public String toString(){
return "DockingPanel["+hashCode()+"]"; // 2007/01/24
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingPreferences.java 0000644 0001750 0001750 00000026033 10573516350 026645 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.ui.DockingUISettings;
import java.awt.Color;
import java.awt.image.BufferedImage;
import javax.swing.BorderFactory;
import javax.swing.JPopupMenu;
import javax.swing.SwingConstants;
import javax.swing.ToolTipManager;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** This is the centralized settings repository for managing docking look and feel.
*
* It acts as a facade for installing common settings.
*
* This class contains only high-level settings, like the heavyweight components support
* or the global desktop style (shadowed or flat). To access low-level properties, use
* the DockingUISettings class instead.
*
* @author Lilian Chamontin, VLSolutions
* @since 1.1
* @see com.vlsolutions.swing.docking.ui.DockingUISettings
*/
public class DockingPreferences {
private static boolean isLightWeightUsageEnabled = true;
private static boolean isSingleHeavyWeightComponent = false;
/** private stuff : use static methods only */
private DockingPreferences() {
}
public static final AutoHidePolicy getAutoHidePolicy(){
return AutoHidePolicy.getPolicy();
}
/** A simple utility method to configure the docking framework to work properly with
* heavyweight component.
*
* Don't forget to invoke also the following general swing methods :
*
* If you are sure you will always use heavyweight component, you can replace this
* method invocation by initHeavyWeightUsage(), which will do all the work for you
* (even the general swing methods invocation).
*
*/
public static void setLightweigthComponentEnabled(boolean lightweight){
isLightWeightUsageEnabled = lightweight;
}
public static boolean isLightWeightUsageEnabled(){
return isLightWeightUsageEnabled;
}
/** Notifies the framework that there is only one dockable that is heavyweight.
* This allows optimizations and workarounds (for properly using the JDIC WebBrowser
* for example).
*/
public static void setSingleHeavyWeightComponent(boolean single){
isSingleHeavyWeightComponent = single;
}
public static boolean isSingleHeavyWeightComponent(){
return isSingleHeavyWeightComponent;
}
/** Facade method used to allow mixing of lightweight and heavyweight components in the
* desktop.
*
* This method is a shortcut for :
*
* The new "flat style" uses light borders around dockables and top tab placements.
*
* This style is the new default one, so there is no need to call this method unless you want
* to swap dynamically between desktop styles.
*/
public static void setFlatDesktopStyle(){
DockingUISettings.getInstance().installUI();
// flat style is the default (outside : empty 1 pix / inside : hightlight-top-left + shadow-bottom-right
Color shadow = UIManager.getColor("controlShadow");
Color highlight = UIManager.getColor("controlLtHighlight");
Border innerFlatSingleBorder = BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(1,1,0,0, highlight),
BorderFactory.createMatteBorder(0,0,1,1, shadow));
Border flatSingleBorder = BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(1,1,1,1),
innerFlatSingleBorder);
UIManager.put("DockView.singleDockableBorder", flatSingleBorder);
UIManager.put("DockView.tabbedDockableBorder", null);
UIManager.put("TabbedDockableContainer.tabPlacement", new Integer(SwingConstants.TOP));
}
/** Another docking style with ligh dots between dockables.
*/
public static void setDottedDesktopStyle(){
DockingUISettings.getInstance().installUI();
Color shadow = UIManager.getColor("controlShadow");
Color highlight = UIManager.getColor("controlLtHighlight");
Border innerFlatSingleBorder = BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(1,1,0,0, highlight),
BorderFactory.createMatteBorder(0,0,1,1, shadow));
UIManager.put("DockView.singleDockableBorder", innerFlatSingleBorder);
//BorderFactory.createLineBorder(shadow));
UIManager.put("DockView.tabbedDockableBorder", null);
UIManager.put("TabbedDockableContainer.tabPlacement", new Integer(SwingConstants.TOP));
UIManager.put("SplitContainer.drawDotsDelimitors", Boolean.TRUE);
}
/** Another docking style with custom tiles between dockables.
*/
public static void setCustomSplitDesktopStyle(BufferedImage horizontalTile,
BufferedImage verticalTile){
DockingUISettings.getInstance().installUI();
//UIManager.put("DockView.singleDockableBorder", null);
UIManager.put("DockView.tabbedDockableBorder", null);
UIManager.put("TabbedDockableContainer.tabPlacement", new Integer(SwingConstants.TOP));
UIManager.put("SplitContainer.drawDotsDelimitors", Boolean.FALSE);
UIManager.put("SplitContainer.hImage", horizontalTile);
UIManager.put("SplitContainer.vImage", verticalTile);
UIManager.put("SplitContainer.useCustomImages", Boolean.TRUE);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingSelectorDialog.java 0000644 0001750 0001750 00000035267 10573516350 027315 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.event.ActionEvent;
import javax.swing.table.*;
import java.util.ArrayList;
/** A Helper class providing information about the visibility of user components.
*
* This dialog shows which user components are docked, auto-hidden,
* not visible, and is capable of dynamicaly altering the dockingpanel layout
* on user selection (for example, to show an unvisible component).
*
*
* User components shown are those which are already docked and those
* which have been registered with the registerDockableComponent() method of DockingPanel.
*
*
* Example of usage :
* This window helps you to manage the "
+ " views composing your application workspace. By clicking on the table checkboxes below, you can select if "
+ "a view will be diplayed or not Click on the Ok button to apply your changes or on "
+ "the Cancel button if you do not want to save your changes."
+ " ";
private int closingState = CANCEL;
private HashMap visibleViews = new HashMap(); // DockableState / Boolean (visible?)
/** Default constructor.
* modal dialog with DISPOSE_ON_CLOSE option,
* needs a pack() and setVisible(true) after creation
* */
public DockingSelectorDialog() {
setModal(true);
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
setTitle(TITLE);
init();
}
/** Constructor for Dialog parent window.
* modal dialog with DISPOSE_ON_CLOSE option,
* needs a pack() and setVisible(true) after creation.
*/
public DockingSelectorDialog(Dialog owner) {
super(owner, true);
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
setTitle(TITLE);
init();
}
/** Constructor for Frame parent window.
* modal dialog with DISPOSE_ON_CLOSE option,
* needs a pack() and setVisible(true) after creation.
* */
public DockingSelectorDialog(Frame owner) {
super(owner, true);
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
setTitle(TITLE);
init();
}
private void init(){
getContentPane().setLayout(new BorderLayout(5,5));
JScrollPane jsp = new JScrollPane(table);
jsp.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(0,5,0,5),
jsp.getBorder()));
getContentPane().add(jsp, BorderLayout.CENTER);
confirmButton.setToolTipText("Close this window and update the views");
cancelButton.setToolTipText("Close this window without updating the views");
confirmButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
closingState = CONFIRM;
for (int i = 0; i < model.states.length; i++) {
DockableState state = model.states[i];
boolean newVisible = ((Boolean)visibleViews.get(state)).booleanValue();
boolean oldVisible = state.getState() != DockableState.STATE_CLOSED;
if ( oldVisible != newVisible){
if (newVisible){
desktop.addDockable(state.getDockable(), state.getPosition());
} else {
desktop.close(state.getDockable());
}
}
}
DockingSelectorDialog.this.dispose();
}
});
Action closeAction = new AbstractAction("Cancel"){
public void actionPerformed(ActionEvent actionEvent) {
closingState = CANCEL;
DockingSelectorDialog.this.dispose();
}
};
cancelButton.setAction(closeAction);
JPanel buttons = new JPanel(new FlowLayout(FlowLayout.TRAILING));
JPanel grid = new JPanel(new GridLayout(1,0, 5, 0)); // buttons of same size
grid.add(confirmButton);
grid.add(cancelButton);
buttons.add(grid);
getContentPane().add(buttons, BorderLayout.SOUTH);
wizardLabel.setText(wizardLabelText);
wizardLabel.setBorder(
BorderFactory.createCompoundBorder(
BorderFactory.createMatteBorder(0,0,1,0, Color.DARK_GRAY),
BorderFactory.createEmptyBorder(5,5,5,5)));
getContentPane().add(wizardLabel, BorderLayout.NORTH);
// ESCAPE == CLOSE
KeyStroke ESC = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
getRootPane().getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
ESC, "CLOSE");
getRootPane().getActionMap().put("CLOSE", closeAction);
table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
ESC, "CLOSE" );
table.getActionMap().put("CLOSE", closeAction );
addWindowListener(new WindowAdapter(){
public void windowOpened(WindowEvent e){
getRootPane().setDefaultButton(confirmButton);
}
});
}
/** Change the confirm button text (hook for i18n)*/
public void setConfirmButtonText(String text){
confirmButton.setText(text);
}
/** Change the cancel button text (hook for i18n)*/
public void setCancelButtonText(String text){
cancelButton.setText(text);
}
/** Change the confirm button tooltip text (hook for i18n)*/
public void setConfirmButtonTooltipText(String text){
confirmButton.setToolTipText(text);
}
/** Change the cancel button tootip text (hook for i18n)*/
public void setCancelButtonTooltipText(String text){
cancelButton.setToolTipText(text);
}
/** Change the wizard label text (an explanation of the behaviour of this dialog).
* HTML format is supported like in any JLabel.
* */
public void setWizardLabelText(String wizardLabelText) {
this.wizardLabel.setText(wizardLabelText);
}
/** Requiered to initialize this dialog.
* Invoke this method before packing the dialog.
*
* */
public void setDockingDesktop(DockingDesktop desktop){
this.desktop = desktop;
DockableState [] states = desktop.getDockables();
Arrays.sort(states);
this.model = new DockablesTableModel(states);
table.setModel(model);
table.getColumnModel().getColumn(0).setPreferredWidth(25);
table.getColumnModel().getColumn(1).setPreferredWidth(200);
table.getColumnModel().getColumn(2).setPreferredWidth(70);
table.setPreferredScrollableViewportSize(new Dimension(300,300));
table.setCellSelectionEnabled(true);
table.setShowVerticalLines(false);
table.setRowHeight(20);
}
/** Returns the users close choice as CONFIRM or CANCEL (remember this dialog is modal).
* Use this method if you need to know how is was closed.
* If the used has confirmed, the docking panel is automaticaly updated
* by the confirm button action.
*/
public int getClosingState(){
return closingState;
}
class DockablesTableModel extends AbstractTableModel{
String[] colNames = {" ", "Name", "Visible"};
private DockableState [] states;
DockablesTableModel(DockableState [] states) {
this.states = states;
for (int i = 0; i < states.length; i++) {
visibleViews.put(states[i],
states[i].getState() == DockableState.STATE_CLOSED ?
Boolean.FALSE : Boolean.TRUE);
}
}
public int getColumnCount() {
return colNames.length;
}
public int getRowCount() {
return states.length;
}
public String getColumnName(int col){
return colNames[col];
}
public boolean isCellEditable(int row, int col){
if (col != 2) return false;
Dockable dockable = states[row].getDockable();
if (dockable.getDockKey().isCloseEnabled()) {
return true;
} else {
return false;
}
}
public Class getColumnClass(int col) {
switch (col) {
case 0:
return Icon.class;
case 1:
return String.class;
case 2:
return Boolean.class;
}
return null;
}
public Object getValueAt(int row, int col) {
DockableState state = states[row];
switch (col) {
case 0:
return state.getDockable().getDockKey().getIcon();
case 1:
return state.getDockable().getDockKey().getName();
case 2:
return (Boolean) visibleViews.get(state);
}
return null;
}
public void setValueAt(Object v, int row, int col){
DockableState state = states[row];
visibleViews.put(state, v);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockingUtilities.java 0000644 0001750 0001750 00000054747 10573516350 026374 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.*;
import java.awt.peer.LightweightPeer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import javax.swing.*;
/** Utility class implementing search/replace algorithms used by the framework.
*
* This class is not inteded for API users, it should be let to framework developpers.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*
*/
public class DockingUtilities {
private DockingUtilities(){
// singleton
}
/** returns the first DockableContainer which is parent of this dockable component */
public static DockableContainer findDockableContainer(Dockable dockable){
if (dockable == null) return null;
Component comp = dockable.getComponent();
if (comp == null) return null;
while (comp != null){
if (comp instanceof DockableContainer){
return (DockableContainer) comp;
}
comp = comp.getParent();
}
return null;
}
/** returns the first DockableContainer which is parent of this dockable component */
public static SingleDockableContainer findSingleDockableContainer(Dockable dockable){
if (dockable == null) return null;
Component comp = dockable.getComponent();
if (comp == null) return null;
while (comp != null){
if (comp instanceof SingleDockableContainer){
return (SingleDockableContainer) comp;
}
comp = comp.getParent();
}
return null;
}
/** Returns the first TabbedDockableContainer which is parent of this dockable component, or
* null is there isn't any.
* */
public static TabbedDockableContainer findTabbedDockableContainer(Dockable dockable){
if (dockable == null) return null;
Component comp = dockable.getComponent();
if (comp == null) return null;
/* while (comp != null){ //2005/10/10
if (comp instanceof TabbedDockableContainer){
return (TabbedDockableContainer) comp;
}
comp = comp.getParent();
}
*/
while (comp != null){
// new version to support compoundDockable : stop after the first parent of
// the first SingleDockableContainer found
if (comp instanceof SingleDockableContainer){
comp = comp.getParent();
if (comp instanceof TabbedDockableContainer){
return (TabbedDockableContainer)comp;
} else {
return null;
}
}
comp = comp.getParent();
}
return null;
}
private static void swapComponents(SplitContainer split1, SplitContainer split2, Component comp1, Component comp2){
boolean isLeft1 = split1.getLeftComponent()== comp1;
int divider1 = split1.getDividerLocation();
if (split1 == split2){
split1.remove(comp1);
split1.remove(comp2);
if (isLeft1){
split1.setLeftComponent(comp2);
split1.setRightComponent(comp1);
} else {
split1.setLeftComponent(comp1);
split1.setRightComponent(comp2);
}
split1.setDividerLocation(divider1);
split1.revalidate();
} else {
boolean isLeft2 = split2.getLeftComponent()== comp2;
int divider2 = split2.getDividerLocation();
split1.remove(comp1);
split2.remove(comp2);
if (isLeft1){
split1.setLeftComponent(comp2);
} else {
split1.setRightComponent(comp2);
}
split1.setDividerLocation(divider1);
if (isLeft2){
split2.setLeftComponent(comp1);
} else {
split2.setRightComponent(comp1);
}
split2.setDividerLocation(divider2);
}
}
/** Swaps two toplevel DockableContainers (their parent must be a SplitContainer) */
public static void swapComponents(Component comp1, Component comp2){
Container parent1 = comp1.getParent();
Container parent2 = comp2.getParent();
if (parent1 instanceof SplitContainer){
if (parent2 instanceof SplitContainer){
swapComponents((SplitContainer) parent1, (SplitContainer) parent2, comp1, comp2);
} else {
// nothing
}
}
}
/** Invoked every time the layout is changed, to rebuild the weighting of split containers */
public static void updateResizeWeights(DockingPanel dockingPanel){
if (dockingPanel.getComponentCount() > 0){
resetSplitWeight(dockingPanel.getComponent(0));
}
}
private static float resetSplitWeight(Component comp){
if (comp instanceof SplitContainer){
SplitContainer split = (SplitContainer) comp;
float leftWeight = resetSplitWeight(split.getLeftComponent());
float rightWeight = resetSplitWeight(split.getRightComponent());
float sum = leftWeight + rightWeight;
if (sum == 0){
split.setResizeWeight(0.5); // half weight for each side
return 0;
} else if (leftWeight == 0){ // and rightWeight != 0
split.setResizeWeight(0); // every resize goes to the right
return rightWeight;
} else if (rightWeight == 0){ // and leftWeight != 0
split.setResizeWeight(1); // every resize goes to the left
return leftWeight;
} else {
float proportion = leftWeight / sum; // when near 0 => right, when near 1 => left
split.setResizeWeight(proportion);
return Math.max(leftWeight, rightWeight);
}
} else if (comp instanceof SingleDockableContainer){
return ((SingleDockableContainer)comp).getDockable().getDockKey().getResizeWeight();
} else if (comp instanceof TabbedDockableContainer){
TabbedDockableContainer tab = (TabbedDockableContainer) comp;
float max = 0;
for (int i=0; i < tab.getTabCount(); i++){
Dockable d = tab.getDockableAt(i);
if (d != null){
float v = d.getDockKey().getResizeWeight();
if (v > max) {
max = v;
}
}
}
return max;
} else if (comp instanceof MaximizedComponentReplacer){ //2007/01/18
// ignore as this component replaces the maximized dockable in the
// docking container hierarchy
} else {
System.err.println("Wrong hierarchy in docking panel (resetSplitWeight error) " + comp);
}
return 0;
}
/** Child replacement */
public static void replaceChild(Container parent, Component child, Component newChild){
//System.out.println("replace child : PARENT=" + parent + ", CHILD=" + child + ", NEW=" + newChild);
if (parent instanceof SplitContainer) {
final SplitContainer split = (SplitContainer) parent;
final int location = split.getDividerLocation();
if (split.getLeftComponent() == child) {
split.remove(child);
split.setLeftComponent(newChild);
} else if (split.getRightComponent() == child) {
split.remove(child);
split.setRightComponent(newChild);
} else {
throw new IllegalArgumentException("wrong hierarchy");
}
// SwingUtilities.invokeLater(new Runnable() {
// public void run() {
split.setDividerLocation(location);
split.revalidate();
split.doLayout();
// }
// });
} else if (parent instanceof TabbedDockableContainer){ // 2005/07/12...
// interface trick : we need to access the JTabbedPane internals
// the newChild can be a dummy JComponent (when used in maximize/restore)
// or a fully featured dockable (other usages)
// this is not really clean : it's the problem when using interfaces over subclasses...
if (parent instanceof JTabbedPane){
TabbedDockableContainer tparent = (TabbedDockableContainer) parent;
JTabbedPane jtp = (JTabbedPane) tparent;
int index = jtp.indexOfComponent(child);
jtp.remove(index);
if (newChild instanceof SingleDockableContainer){
tparent.addDockable(((SingleDockableContainer) newChild).getDockable(), index);
jtp.setSelectedIndex(index);
} else { // dummy component
jtp.add(newChild, index);
jtp.setSelectedIndex(index);
}
} else {
throw new RuntimeException("Unknown TabbedDockableContainer");
} // ...2005/07/12
} else { // we're on top level (panel with borderlayout)
parent.remove(child);
parent.add(newChild, BorderLayout.CENTER);
parent.invalidate();
parent.validate();
}
}
/** Returns the split pane containing this dockable (if any), or null if this dockable
* isn't contained in a splitpane.
*
* If the dockable is nested in a TabbedDockableContainer, the split pane returned will
* be the one containing the tabbed container (if any).
*
* */
public static SplitContainer getSplitPane(Dockable dockable, int orientation ){
Component comp = dockable.getComponent();
boolean found = false;
while (comp != null && !found){
if (comp instanceof SplitContainer && ((SplitContainer)comp).getOrientation() == orientation){
found = true;
} else {
comp = comp.getParent();
}
}
return (SplitContainer)comp;
}
/** A utility method to find the first single dockable container ancestor of the given component.
*
* This method may return null if no SingleDockableContainer ancestor is found.
*/
public static SingleDockableContainer findSingleDockableContainerAncestor(Component component){
Component parent = component.getParent();
while (parent != null && ! (parent instanceof SingleDockableContainer)){
parent = parent.getParent();
}
return (SingleDockableContainer)parent;
}
/** Utility method to find out if a component is heavyweight (of if it contains a heavyweight comp)*/
public static boolean isHeavyWeightComponent(Component comp){
if (comp instanceof Container){
// short cut
Object peer = comp.getPeer();
if (!(peer == null || peer instanceof LightweightPeer)){
// it's not a lightweight
return true;
} else {
// long way
Container c = (Container) comp;
for (int i=0; i < c.getComponentCount(); i++){
Component child = c.getComponent(i);
if (isHeavyWeightComponent(child)){
return true;
}
}
return false;
}
} else {
Object peer = comp.getPeer();
return !(peer == null || peer instanceof LightweightPeer);
}
}
/** Returns whether we can use the secured and 1.5 MouseInfo class */
public static boolean canUseMouseInfo(){
if (System.getProperty("java.version").compareTo("1.5")>=0){
return getMouseLocation() != null;
} else {
return false; // not present in pre 1.5 versions
}
}
/** Returns the mouse location on screen or null if ran in an untrusted environement/ java 1.4 */
public static Point getMouseLocation(){
try {
//Point mouseLocation = MouseInfo.getPointerInfo().getLocation();
// this class in not compatible with 1.4
// so instead we use reflection for allowing 1.4 compilation
Class mouseInfoClass = Class.forName("java.awt.MouseInfo");
final Class [] noArgs = new Class[0];
Method m = mouseInfoClass.getMethod("getPointerInfo", noArgs);
Object pointerInfo = m.invoke(null, null);
Class pointerInfoClass = Class.forName("java.awt.PointerInfo");
Method getLocationMethod = pointerInfoClass.getMethod("getLocation", noArgs);
Point mouseLocation = (Point)getLocationMethod.invoke(pointerInfo, null);
return mouseLocation;
} catch (ClassNotFoundException ignore){
} catch (NoSuchMethodException ignore){
} catch (IllegalAccessException e){
} catch (InvocationTargetException ignore){
}
return null;
}
/** packs a detached dockable, regardless of its type (frame or dialog) */
public static void pack(FloatingDockableContainer fdc){ //2006/02/20
if (fdc instanceof JFrame){
((JFrame) fdc).pack();
} else if (fdc instanceof JDialog){
((JDialog) fdc).pack();
}
}
/** resizes a detached dockable, regardless of its type (frame or dialog) */
public static void setSize(FloatingDockableContainer fdc, Dimension size){ //2006/02/20
if (fdc instanceof JFrame){
((JFrame) fdc).setSize(size);
} else if (fdc instanceof JDialog){
((JDialog) fdc).setSize(size);
}
}
/** validates a detached dockable, regardless of its type (frame or dialog) */
public static void validate(FloatingDockableContainer fdc){ //2006/02/20
((Window)fdc).validate();
}
/** positions a detached dockable, regardless of its type (frame or dialog) */
public static void setLocation(FloatingDockableContainer fdc, Point location){ //2006/02/20
((Window)fdc).setLocation(location);
}
/** positions a detached dockable, regardless of its type (frame or dialog) */
public static void setLocationRelativeTo(FloatingDockableContainer fdc, Component rel){ //2006/02/20
((Window)fdc).setLocationRelativeTo(rel);
}
/** shows a detached dockable, regardless of its type (frame or dialog) */
public static void setVisible(FloatingDockableContainer fdc, boolean visible){ //2006/02/20
((Window)fdc).setVisible(visible);
}
/** disposes a detached dockable, regardless of its type (frame or dialog) */
public static void dispose(FloatingDockableContainer fdc) {
((Window)fdc).dispose();
}
/** returns the root pane used by this detached dockable container, regardless of its type (frame or dialog)*/
public static JRootPane getRootPane(FloatingDockableContainer fdc) {
if (fdc instanceof JFrame){
return ((JFrame) fdc).getRootPane();
} else if (fdc instanceof JDialog){
return ((JDialog) fdc).getRootPane();
} else {
return null; // not reachable
}
}
static void setBounds(FloatingDockableContainer fdc, Rectangle bounds) {
((Window)fdc).setBounds(bounds);
}
/** Creates a list of all dockable children contained in the given compound dockable.
* If the compound dockable contains another compound dockable this one is also added,
* along with its own children.
* @return an ArrayList of Dockable
*/
public static ArrayList findCompoundDockableChildren(CompoundDockable compoundDockable) {
ArrayList list = new ArrayList();
CompoundDockingPanel cdp = (CompoundDockingPanel) compoundDockable.getComponent();
fillCompoundChildren(cdp, list);
return list;
}
private static void fillCompoundChildren(CompoundDockingPanel cdp, ArrayList list) {
if (cdp.getComponentCount() > 0){
Component c = cdp.getComponent(0);
fillCompoundChildren(c, list);
}
}
private static void fillCompoundChildren(Component c, ArrayList list) {
if (c instanceof CompoundDockingPanel){
fillCompoundChildren((CompoundDockingPanel)c, list);
} else if (c instanceof SingleDockableContainer){
list.add(((SingleDockableContainer)c).getDockable());
} else if (c instanceof SplitContainer){
fillCompoundChildren(((SplitContainer)c).getLeftComponent(), list);
fillCompoundChildren(((SplitContainer)c).getRightComponent(), list);
} else if (c instanceof TabbedDockableContainer){
TabbedDockableContainer tdc = (TabbedDockableContainer)c;
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
if (d instanceof CompoundDockable){
list.add(d);
CompoundDockingPanel cdp = (CompoundDockingPanel) d.getComponent();
fillCompoundChildren(cdp, list);
} else {
list.add(d);
}
}
}
}
/** checks if this dockable is a child of a compound dockable */
public static boolean isChildOfCompoundDockable(Dockable dockable) {
Container container = dockable.getComponent().getParent();
while (container != null){
if (container instanceof CompoundDockingPanel
&& ((CompoundDockingPanel)container).getDockable() != dockable){
// avoid returning true if the dockable if itself a compound
return true;
}
container = container.getParent();
}
return false;
}
/** searches up the dockable container hierarchy and returns the first ancestor
* which is a CompoundDockable (or null if not found).
*/
public static Container findCompoundAncestorContainer(Dockable dockable) {
Container container = dockable.getComponent().getParent();
while (container != null){
if (container instanceof CompoundDockingPanel
&& ((CompoundDockingPanel)container).getDockable() != dockable){
// avoid returning true if the dockable if itself a compound
return container;
}
container = container.getParent();
}
return null;
}
/** searches up the dockable container hierarchy and returns the dockable state of the
* last (top most) ancestor which is a CompoundDockable (or -1 if not found).
*/
public static int getTopMostAncestorContainerState(Dockable dockable) {
Container container = dockable.getComponent().getParent();
Container topMostContainer = null;
while (container != null){
if (container instanceof CompoundDockingPanel
&& ((CompoundDockingPanel)container).getDockable() != dockable){
// avoid returning true if the dockable if itself a compound
topMostContainer = container;
}
container = container.getParent();
}
if (topMostContainer != null){
CompoundDockingPanel cdp = (CompoundDockingPanel) topMostContainer;
return cdp.getDockable().getDockKey().getDockableState();
}
return -1;
}
/** Returns a DockableState value corresponding to this component or -1 if not found.
*
* Two states are currently managed : docked and floating (not hidden/maximized/closed).
*/
public static int getDockableStateFromHierarchy(Component comp) {
if (comp == null){
return -1;
}
while (comp != null){
if (comp instanceof DockingPanel){
return DockableState.STATE_DOCKED;
} else if (comp instanceof FloatingDockableContainer){
return DockableState.STATE_FLOATING;
}
comp = comp.getParent();
}
return -1;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DragControler.java 0000644 0001750 0001750 00000174140 10573516350 025655 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.event.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import javax.swing.*;
import java.awt.geom.*;
import com.vlsolutions.swing.docking.event.*;
import java.lang.reflect.Method;
/** The component that manages mouse events related to docking.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/10/10 Lilian Chamontin : Updated to support multiple windows
* (like the FloatingDockableContainers).
* @update 2005/11/01 Lilian Chamontin : Improved shape and label painting
* @update 2005/11/01 Lilian Chamontin : added support for customizable cursors
* @update 2005/11/01 Lilian Chamontin : added a dead zone for floating (around start drag point) to avoid
* unwanted detach and to allow cancelling a detach action
* @update 2005/11/10 Lilian Chamontin : added support for hot swap, and MultipleDragSource
* unwanted detach and to allow cancelling a detach action
* @update 2006/03/16 Lilian Chamontin : patched a NPE occuring sometimes but not reproducible easily
* @update 2007/01/06 Lilian Chamontin : fixed a DnD bug when droping on a tab bottom border,
* the split was replaced by a createTab
*
*/
class DragControler implements MouseListener, MouseMotionListener {
/* package protected class !!
*
*/
private static boolean isLightWeight = DockingPreferences.isLightWeightUsageEnabled();
/** This new object is responsible for painting shapes on lightweight components
* or heavyweight components
*/
//private ShapePainterStrategy shapePainterStrategy = new ShapePainterStrategy();
private ShapePainterStrategy currentShapePainterStrategy;
private boolean startDrag;
private Shape dropShape;
private boolean isFloatingShape = false; // true during floating Dnd
private DockableDragSource dockableDragSource;
private Point dragPoint; // !=null means that drag is occuring
private Point startDragPoint; // for offset drawing
private DockDropReceiver dropReceiver; // the component receiving the drop
private DockingDesktop desktop;
private boolean ignoreDrag; // flag to ignore a drag operation
private boolean paintFloatingDragShape = UIManager.getBoolean("FloatingContainer.paintDragShape");
private DockingContext dockingContext;
private boolean paintBackgroundUnderDragRect = UIManager.getBoolean("DragControler.paintBackgroundUnderDragRect");
/** instantiates a controler for a given docking panel*/
DragControler(DockingDesktop desktop) {
this.desktop = desktop;
this.dockingContext = desktop.getContext();
}
/** process mouse clicks on DockableDragSource */
public void mouseClicked(MouseEvent e) {
}
/** process mouse entered on DockableDragSource (nothing yet) */
public void mouseEntered(MouseEvent e) {
}
/** process mouse exit on DockableDragSource (nothing yet) */
public void mouseExited(MouseEvent e) {
}
/** process mouse pressed on DockableDragSource : prepares a drag operation */
public void mousePressed(MouseEvent e) {
if (SwingUtilities.isLeftMouseButton(e)){
startDrag = true;
ignoreDrag = false;
} else {
if (dragPoint != null){ // we were dragging
cancelDrag();
}
/* if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK)>0){
// in the middle of a drag gesture
} else {
ignoreDrag = true;
}*/
}
}
/** process mouse released on DockableDragSource */
public void mouseReleased(MouseEvent e) {
if (! SwingUtilities.isLeftMouseButton(e)){ // not the trigger button
if (dragPoint != null){ // we were dragging
notifyDragSourceDragComplete(false);
cancelDrag();
}
} else { // left button
// are we above an insertion point ?
if (ignoreDrag){
return;
}
try {
boolean dropped = false;
if (dragPoint != null && dockableDragSource != null){
dropped = processMouseReleased(e);
}
notifyDragSourceDragComplete(dropped);
} finally {
// clean up state variables
notifyDragSourceDragComplete(false);
cancelDrag();
}
}
}
/** invoked only when a drag gesture has beed done
* @return true if the dockable has been dropped.
*/
private boolean processMouseReleased(MouseEvent e){
// 2007/01/08 updated to return a boolean
//Component underMouse = findComponentAt(desktop, dragPoint.x, dragPoint.y);
DockableDragSource dragSource = ( (DockableDragSource) e.getSource());
this.dragPoint = SwingUtilities.convertPoint(
(Component) e.getSource(), e.getPoint(), desktop);
UnderMouseInfo umInfo = findComponentUnderMouse(e);
Component underMouse = umInfo.underMouse;
Component underMouseNullDesktop = null;
DockingDesktop targetDesktop = umInfo.desktop; //findNearestNestedDesktop(underMouse);//umInfo.desktop
if (targetDesktop == null){
underMouseNullDesktop = findDropReceiverOutsideDesktop(underMouseNullDesktop, e);
}
ShapePainterStrategy shapePainterStrategy = getShapePainter(underMouse, dragSource);
int dx = dragPoint.x - startDragPoint.x;
int dy = dragPoint.y - startDragPoint.y;
if (Math.abs(dx) < 20 && Math.abs(dy) < 10){
// deny drag gesture when too near from start point 2005/11/15
return false;
}
if (targetDesktop == null){
// deny drag gesture when desktops aren't compatible
if (underMouseNullDesktop != null){ // we've found a dock drop receiver
// we send a really simple event
DockDropEvent event = new DockDropEvent(desktop, dragSource, e);
((DockDropReceiver)underMouseNullDesktop).processDockableDrop(event);
// this event will be ignored
}
return false;
} else if (targetDesktop.getContext() != desktop.getContext()){ //2006/09/11
// contexts not compatible, stop here
return false;
}
// 2005/11/08 support for full height/width docking
DockingPanel dp = targetDesktop.getDockingPanel();
Insets i = targetDesktop.getDockingPanelInsets();
Rectangle deskBounds = new Rectangle(i.left, i.top,
targetDesktop.getWidth() - i.left - i.right, targetDesktop.getHeight() - i.top - i.bottom);
Rectangle innerBounds = new Rectangle(deskBounds);
innerBounds.x += 5;
innerBounds.y += 5;
innerBounds.width -= 10;
innerBounds.height -= 10;
if (deskBounds.contains(dragPoint) && ! innerBounds.contains(dragPoint)){
// at less than 5 pixels from a order, promote DockingPanel as the receiver
underMouse = dp;
}
// move up hierarchy till we find a drop receiver
while (underMouse != null && underMouse != targetDesktop &&
! (underMouse instanceof DockDropReceiver)) {
underMouse = underMouse.getParent();
}
umInfo.underMouse = underMouse; // resync
if (underMouse == null){
// || isAncestorOf(dockableDragSource.getDockableContainer(), underMouse)){ 2007/01/08 moved to implementations
// it's not possible to drop a parent on one of its children
if (underMouse instanceof DockDropReceiver){
// but we still have to use the reference on drop receiver to disaplay a floating drag shape
this.dropReceiver = (DockDropReceiver) underMouse;
}
DropProcess dropProcess = new DropProcess(e, dockableDragSource, umInfo);
if (dropProcess.canDockableBeDetached()
&& dropProcess.checkDockableWillBeDetached()){
Point location = new Point(e.getPoint());
SwingUtilities.convertPointToScreen(location, e.getComponent());
dropProcess.setFloating(location);
return true;
} else {
// refused (vetoed)
return false;
}
} else if (underMouse instanceof DockDropReceiver && e.isControlDown()) { //2005/11/08 HOT SWAP FUNCTION
processHotSwap(underMouse, e.getComponent(), null, true);
return true;
} else if (underMouse instanceof DockDropReceiver) {
// MouseEvent convertMouse;
DropProcess process = new DropProcess(e, dockableDragSource, umInfo);
DockDragEvent event = process.findAcceptableEvent(e);
if (event.isDragAccepted() && process.isDockingActionAccepted()) {// triggers vetoable listeners
return process.dropIfPossible();
} else if (process.canDockableBeDetached() // Not accepted on the desktop //2005/10/07
&& process.checkDockableWillBeDetached()){
Point location = new Point(e.getPoint());
SwingUtilities.convertPointToScreen(location, e.getComponent());
process.setFloating(location);
return true;
} else {
// vetoed, nothing can be be done
return false;
}
} else { /*if (underMouse == null){ */ // not under a droppable zone
DropProcess process = new DropProcess(e, dockableDragSource, umInfo);
if (process.canDockableBeDetached()
&& process.checkDockableWillBeDetached()){
Point location = new Point(e.getPoint());
SwingUtilities.convertPointToScreen(location, e.getComponent());
process.setFloating(location);
return true;
} else {
return false;
}
}
}
/** This method cancels the current drag gesture.
*
* It can be used for example by a key listener reacting to the escape key
*
*@since 2.0.1
*/
public void cancelDrag(){
this.ignoreDrag = true;
this.dropShape = null;
this.dockableDragSource = null;
this.startDrag = true;
this.dragPoint = null;
if (currentShapePainterStrategy != null){
currentShapePainterStrategy.endDrag();
}
clearStrategies();
desktop.repaint();
}
private void notifyDragSourceDragComplete(boolean isDropped){
if (dockableDragSource != null){
dockableDragSource.endDragComponent(isDropped);
}
}
public void mouseDragged(MouseEvent e) {
if (! isDragAndDropEnabled()){
// disable dnd right now
ignoreDrag = true;
}
if (ignoreDrag) {
return;
} else if (startDrag){
startDrag = false;
processDragGestureStart(e);
} else {
processMouseDragged(e);
}
}
private void processDragGestureStart(MouseEvent e){
DockableDragSource dragSource = ( (DockableDragSource) e.getSource());
this.dragPoint = SwingUtilities.convertPoint(
(Component) e.getSource(), e.getPoint(), desktop);
this.dropShape = null;
this.dockableDragSource = null;
this.startDragPoint = e.getPoint();
if (dragSource.startDragComponent(startDragPoint)) {
this.dockableDragSource = dragSource;
getShapePainter(e.getComponent(), dragSource).startDrag(dragSource);
this.startDragPoint = new Point(dragPoint); // same coordinate system for future use
processMouseDragged(e); // forward the event to the actual processing
} else { // drag rejected
this.ignoreDrag = true;
}
}
private boolean isDragAndDropEnabled(){
return UIManager.getBoolean("DragControler.isDragAndDropEnabled");
}
private void processMouseDragged(MouseEvent e){
Component dragged = (Component) e.getSource();
DockableDragSource dragSource = ( (DockableDragSource) e.getSource());
this.dragPoint = SwingUtilities.convertPoint(
(Component) e.getSource(), e.getPoint(), desktop);
// if (dockableDragSource == null){
// return; // safety net : there seems to be a case where dockableDragSource can be null on
// // mac os (probable cause : a missing mousepressed/released event)
// }
// continue drag
UnderMouseInfo umInfo = findComponentUnderMouse(e);
Component underMouse = umInfo.underMouse;
Component underMouseNullDesktop = null;
DockingDesktop targetDesktop = umInfo.desktop;//findNearestNestedDesktop(umInfo.underMouse);
if (targetDesktop == null){
underMouseNullDesktop = findDropReceiverOutsideDesktop(underMouseNullDesktop, e);
}
ShapePainterStrategy shapePainterStrategy = getShapePainter(underMouse, dragSource);
if (dragPoint == null || startDragPoint == null){
// 2006/03/16
// safety net again : a bug has been submitted reagrding a NPE and I can't reproduce it
ignoreDrag = true;
return;
}
if (targetDesktop == null){ //2006/09/11
// deny drag gesture when desktops aren't compatible
if (underMouseNullDesktop != null){ // we've found a dock drop receiver
// we send a really simple event
DockDragEvent event = new DockDragEvent(desktop, dragSource, e);
((DockDropReceiver)underMouseNullDesktop).processDockableDrag(event);
}
// finished
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
return;
} else if (targetDesktop.getContext() != desktop.getContext()){ //2006/09/11
// deny drag gesture when desktops aren't compatible
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
return;
}
int dx = dragPoint.x - startDragPoint.x;
int dy = dragPoint.y - startDragPoint.y;
if (Math.abs(dx) < 20 && Math.abs(dy) < 10){
// deny drag gesture when too near from start point 2005/11/15
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
return;
}
// 2005/11/08 support for full height/width docking
DockingPanel dp = targetDesktop.getDockingPanel();
Insets i = targetDesktop.getDockingPanelInsets();
Rectangle deskBounds = new Rectangle(i.left, i.top,
targetDesktop.getWidth() - i.left - i.right, targetDesktop.getHeight() - i.top - i.bottom);
Rectangle innerBounds = new Rectangle(deskBounds);
innerBounds.x += 5;
innerBounds.y += 5;
innerBounds.width -= 10;
innerBounds.height -= 10;
if (deskBounds.contains(dragPoint) && ! innerBounds.contains(dragPoint)
&& underMouse != null && targetDesktop.isAncestorOf(underMouse)){
// at less than 5 pixels from a border, promote DockingPanel as the receiver
underMouse = dp;
}
// go up the hierarchy until we find a component that can receive a drop
while (underMouse != null && underMouse != targetDesktop &&
! (underMouse instanceof DockDropReceiver)) {
underMouse = underMouse.getParent();
}
umInfo.underMouse = underMouse; // resync
if (underMouse == null){// || isAncestorOf(dockableDragSource.getDockableContainer(), underMouse)){
// it's not possible to drop a parent on one of its children
// so we're goind to try and detach it
if (underMouse instanceof DockDropReceiver){
// but we still have to use the reference on drop receiver to display a floating drag shape
this.dropReceiver = (DockDropReceiver) underMouse;
}
DragProcess process = new DragProcess(dockableDragSource, umInfo);
if (process.canDockableBeDetached()
&& process.checkAndDetachDockable(shapePainterStrategy)){
// this method manages the detachement
} else {
// refused (vetoed)
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
} else if (underMouse instanceof DockDropReceiver && e.isControlDown()) { //2005/11/08 HOT SWAP FUNCTION
processHotSwap(underMouse, dragged, shapePainterStrategy, false);
} else if (underMouse instanceof DockDropReceiver) {
// loop if it returns null
DragProcess process = new DragProcess(dockableDragSource, umInfo);
DockDragEvent event = process.findAcceptableEvent(e);
// will it cause a state change ?
// a state change occur when switching between CLOSED, HIDDEN, and DOCKED
// in this context, the drag event can only be generated by a hidden dockable
// (if there is a way to drag its button) or an already docked dockable (no state change)
if (event.isDragAccepted() && process.isDockingActionAccepted()) {
shapePainterStrategy.showDragCursor();
setDropShape(event.getDropShape(), shapePainterStrategy);
} else if (process.canDockableBeDetached()
&& process.checkAndDetachDockable(shapePainterStrategy)){
// detach done by the "if"
} else {
event.rejectDrag(); // vetoed by listeners
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
} else {// not above a drop receiver, might be detachable
DragProcess process = new DragProcess(dockableDragSource, umInfo);
if (process.canDockableBeDetached()
&& process.checkAndDetachDockable(shapePainterStrategy)){
// this method manages the detachement
} else {
// refused (vetoed)
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
}
}
/** Allow hot swappping of two top level dockable containers (during drag) */
private void processHotSwap(Component underMouse, Component dragged,
ShapePainterStrategy shapePainterStrategy, boolean drop){ //2005/11/08
/* This whole method should be reworked to allow hooking a DockingActionEvent subclass
* to process hotswapping.
* This also means we have to get rid of these "Component" and rely on DockableContainers
* instead (which will allow us to properly track dockable state changes)
*/
// ---------------------
// shortcut : if the underMouse component doesn't belong to a DockingPanel, we
// just cancel the hot swap operation
// explanation : hotswap between DOCKED and FLOATING whould otherwise mean
// swapping dockable states, and this will not be allowed until a further release
Component topLevel = underMouse;
while (topLevel != null && !(topLevel instanceof DockingPanel) ){
topLevel = topLevel.getParent();
}
if (topLevel == null){
// doesn't belong to a docking panel == not DOCKED
if (! drop){
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
return;
}
// ---------------------
// to implement the "hot swap" we need to find a top level dockable container
// (whose parent should be SplitContainer).
while (underMouse != null && !(underMouse.getParent() instanceof SplitContainer)){
underMouse = underMouse.getParent();
}
if (underMouse != null){
Component splitChild = dragged;
while (splitChild != null
&& !(splitChild.getParent()instanceof SplitContainer) ){
splitChild = splitChild.getParent();
}
if (splitChild != null && splitChild != underMouse
&& underMouse instanceof DockDropReceiver){// this one should always be true (although as it depends on implementation details, I prefer to keep it safe)
// ok we've found a suitable swap pattern
if (drop){
DockingUtilities.updateResizeWeights(desktop.getDockingPanel());
DockingUtilities.swapComponents(splitChild, underMouse);
DockingUtilities.updateResizeWeights(desktop.getDockingPanel());
} else {
shapePainterStrategy.showSwapDragCursor();
Rectangle bounds = underMouse.getBounds();
Rectangle2D shape = new Rectangle2D.Float(0, 0, bounds.width, bounds.height);
this.dropReceiver = (DockDropReceiver) underMouse;
setDropShape(shape, shapePainterStrategy);
}
} else {
// couldn't find a suitable component
if (!drop){
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
}
} else {
// couldn't find a suitable component
if (! drop){
shapePainterStrategy.showStopDragCursor();
setDropShape(null, shapePainterStrategy);
}
}
}
private void setDropShape(Shape shape, ShapePainterStrategy shapePainterStrategy){
setDropShape(shape, shapePainterStrategy, false);
}
private void setDropShape(Shape shape, ShapePainterStrategy shapePainterStrategy, boolean floating){
if (dropShape == null){
if (shape != null){
this.dropShape = shape;
this.isFloatingShape = floating;
shapePainterStrategy.repaint();
}
} else {
if (shape != null){
if (!dropShape.equals(shape)){
this.dropShape = shape;
this.isFloatingShape = floating;
shapePainterStrategy.repaint();
}
} else {
this.dropShape = shape;
this.isFloatingShape = floating;
shapePainterStrategy.repaint();
}
}
}
/** Checks if a component is an ancestor of another one */
private boolean isAncestorOf(Component probableAncestor, Component child){
while (child != null && child != probableAncestor){
child = child.getParent();
}
return child == probableAncestor;
}
public void mouseMoved(MouseEvent e) {
}
/** Returns information about the component right under the mouse (including other owned windows)*/
private UnderMouseInfo findComponentUnderMouse(MouseEvent e){
// are we above an insertion point ?
Point p = new Point(e.getPoint());
SwingUtilities.convertPointToScreen(p, e.getComponent());
UnderMouseInfo umInfo = new UnderMouseInfo();
//Component underMouse = null;
// iterate through the owned windows (might be floatables)
Window w = SwingUtilities.getWindowAncestor(desktop);
Window [] children = w.getOwnedWindows();
for (int i=0; i < children.length; i++){
if (children[i] instanceof FloatingDockableContainer && children[i].isVisible()){
Window wChild = (Window) children[i]; // assumed by the FloatingDockableContainer interface
Rectangle bounds = wChild.getBounds();
if (bounds.contains(p)){
// an owned window is on top of the desktop, at current mouse position
// we have to try and find a dockable into this window
Point p2 = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), wChild);
Container contentPane = (wChild instanceof JDialog)
? ((JDialog)wChild).getContentPane() : ((JFrame)wChild).getContentPane();
umInfo.underMouse = findComponentAt(contentPane, p2.x, p2.y); // bypass the glasspane
umInfo.desktop = desktop;
}
}
}
if (umInfo.underMouse == null && desktop.getContext().getDesktopList().size() > 1){
// now look for other desktops sharing the same context
// and select the top most window at current mouse location
DockingContext ctx = desktop.getContext();
ArrayList desktops = ctx.getDesktopList();
// create a list of unique windows
ArrayList windows = new ArrayList();
for (int i=0; i < desktops.size(); i++){
DockingDesktop desk = (DockingDesktop) desktops.get(i);
Window deskWin = SwingUtilities.getWindowAncestor(desk);
if (deskWin != null && !windows.contains(deskWin)){
// intersection with mouse ?
if (deskWin.getBounds().contains(p)){
windows.add(deskWin);
}
}
}
// now we have an unordered list of windows all intersecting our point : find which one
// is above
Window topWindow = null;
Iterator it = ctx.getOwnedWindowActionOrder().iterator();
while (it.hasNext()){
Window win = (Window) it.next();
if (windows.contains(win)){
topWindow = win;
break;
}
}
if (topWindow != null){
Point p2 = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), topWindow);
Container contentPane = (topWindow instanceof JDialog)
? ((JDialog)topWindow).getContentPane() : ((JFrame)topWindow).getContentPane();
umInfo.underMouse = findComponentAt(contentPane, p2.x, p2.y); // bypass the glasspane
// now find the desktop associated to the component (there might be more than 1 desktop / window)
// we have to walk up the hierarchy
Component c = umInfo.underMouse;
while ( c != null){
if (c instanceof DockingDesktop){
umInfo.desktop = (DockingDesktop) c;
break;
} else {
c = c.getParent();
}
}
}
// @todo : also check for floating windows belonging to these other desktops
}
if (umInfo.underMouse == null){
umInfo.underMouse = findComponentAt(desktop, dragPoint.x, dragPoint.y);
umInfo.desktop = desktop;
}
return umInfo;
}
/** find the top most component of this container */
private Component findComponentAt(Container container, int x, int y){
if (isLightWeight){
return container.findComponentAt(x, y);
} else {
/* couldn't use the standard Container.findComponentAt(int, int) method for our
* heavyweight support (we need more control on the heavyweight components to skip).
* So we use a custom search instead
*/
return findComponentAtForHeavy(container, x, y);
}
}
/** find the top most component of this container. used only for heavyweight
* support
*/
private Component findComponentAtForHeavy(Container container, int x, int y){
Rectangle bounds = new Rectangle();
int count = container.getComponentCount();
//ShapePainterStrategy shapePainterStrategy = getShapePainter(container, null);
for(int i=0; i < count; i ++){
Component child = container.getComponent(i);
if (child.isVisible()){
child.getBounds(bounds);
if (bounds.contains(x, y)){
if (child instanceof Container){
// recursive
Component found = findComponentAtForHeavy((Container)child, x-bounds.x, y-bounds.y);
if (found != null){
return found;
} else {
return child;
}
} else if (!(child instanceof HeavyShape ||child instanceof HeavyLabel)){
// skip our dedicated components for heavyweight support
return child;
// } else if (child != shapePainterStrategy.heavyShape &&
// child != shapePainterStrategy.heavyShape.label){
// // skip our dedicated components for heavyweight support
// return child;
}
}
}
}
return null;
}
private HashMap shapePainters = new HashMap(); // window / shapePainterStategy
/** searches the best shapePainter */
private ShapePainterStrategy getShapePainter(Component comp, DockableDragSource source){
if (comp == null){
comp = desktop;
}
Window w = SwingUtilities.getWindowAncestor(comp);
ShapePainterStrategy newStrategy = (ShapePainterStrategy)shapePainters.get(w);
if (newStrategy == null){
newStrategy = new ShapePainterStrategy(w);
shapePainters.put(w, newStrategy);
if (currentShapePainterStrategy != null){
currentShapePainterStrategy.endDrag();
}
currentShapePainterStrategy = newStrategy;
newStrategy.startDrag(source);
return newStrategy;
} else if (newStrategy == currentShapePainterStrategy){
return newStrategy;
} else { // newstrategy not null and != currentStategy
currentShapePainterStrategy.endDrag();
currentShapePainterStrategy = newStrategy;
newStrategy.startDrag(source);
return newStrategy;
}
}
/** clears the shape painters cache to avoid keeping references of old windows */
private void clearStrategies(){
Window w = SwingUtilities.getWindowAncestor(desktop);
Window []owned = w.getOwnedWindows();
for (int i=0; i < owned.length; i++){
shapePainters.remove(w);
}
}
/** Looks for nested desktops, and selects the one which is near from underMouse
* or null (but it shouldn't occur)
*/
private DockingDesktop findNearestNestedDesktop(Component underMouse) {
if (underMouse == null){
return null;
}
Container parent = underMouse.getParent();
while (parent != null && !(parent instanceof DockingDesktop)){
parent = parent.getParent();
}
if (parent instanceof DockingDesktop){
return (DockingDesktop) parent;
} else {
return null;
}
}
/** searches for a dockDropReceiver when mouse is outside a docking desktop */
private Component findDropReceiverOutsideDesktop(Component underMouse, MouseEvent e) {
// there's a side case we have to manage : when a DockDropReceiver has been
// installed *outside* a desktop (this is desired when you want to
// listen to drag and drop events (e.g. for a workspace switcher)
// note : the event will be sent to the DockDropReceiver, but just for Drag
// (ignored as a drop)
// go up the hierarchy until we find a component that can receive a drop
// currently this works only for the desktop's own window
Container base = null;
Window w = SwingUtilities.getWindowAncestor(desktop);
if (w instanceof JFrame){
base = ((JFrame)w).getContentPane();
} else if (w instanceof JDialog){
base = ((JDialog)w).getContentPane();
}
if (base !=null){
Point pw = SwingUtilities.convertPoint((Component) e.getSource(), e.getPoint(), base);
underMouse = findComponentAt(base, pw.x, pw.y);
while (underMouse != null &&
! (underMouse instanceof DockDropReceiver)) {
underMouse = underMouse.getParent();
}
}
return underMouse;
}
// -----------------------------------------------------------------------------------------------------------
// --------------------------------- you don't want to look at the code underneath this line... --------------
// -----------------------------------------------------------------------------------------------------------
// I'll rewrite it entirely soon as i'm not pleased with it (much too complex)
/** This class holds implementation strategies of shapes painting.
*
* As painting is different when pure Swing is used (glasspane) and
* heavyweight components are mixed in (glasspane + canvas).
*/
private class ShapePainterStrategy {
private GlassPane dragGlassPane = new GlassPane();
private Component oldGlassPane = null;
private boolean oldGlassPaneVisible = false;
private Window window = null;
private boolean isDragStarted = false;
// heavyweight support
private HeavyShape heavyShape; // instanciated only when heavyweight suport is enabled
/*public ShapePainterStrategy(){
if (! isLightWeight){
dragGlassPane.setPaintShapes(false);
heavyShape = new HeavyShape();
}
}*/
public ShapePainterStrategy(Window window){
this.window = window;
if (! isLightWeight){
dragGlassPane.setPaintShapes(false);
heavyShape = new HeavyShape();
}
}
/** show the drag cursor */
public void showDragCursor(){
dragGlassPane.showDragCursor();
if (! isLightWeight){
heavyShape.setCursor(dragGlassPane.getCursor());
}
}
/** show the stop-drag cursor (drag not enabled)*/
public void showStopDragCursor(){
dragGlassPane.showStopDragCursor();
if (! isLightWeight){
heavyShape.setCursor(dragGlassPane.getCursor());
// heavyShape.setVisible(false);
}
}
/** show the stop-drag cursor (drag not enabled)*/
public void showSwapDragCursor(){
dragGlassPane.showSwapDragCursor();
if (! isLightWeight){
heavyShape.setCursor(dragGlassPane.getCursor());
// heavyShape.setVisible(false);
}
}
/** show the float (detached) cursor */
public void showFloatCursor(){
dragGlassPane.showFloatCursor();
if (! isLightWeight){
heavyShape.setCursor(dragGlassPane.getCursor());
}
}
public void repaint(){
/* this is a hack that will be refactored : we post a repaint when there is
* a need to show a drag shape */
if (isLightWeight){
dragGlassPane.repaint();
} else { // heavy
if (dropShape != null){
heavyShape.moveToShape(dropShape); // adjust to the shape before repainting
} else if (heavyShape.isVisible()){
heavyShape.setVisible(false);
}
}
}
public void startDrag(DockableDragSource source){
if (isDragStarted || source == null){
return;
}
Window aboveWindow = this.window;
isDragStarted = true;
if (! isLightWeight){
if (heavyShape.getParent() == null){
// first use of the heavyshapes components
if (aboveWindow instanceof JFrame) {
JFrame fr = (JFrame) aboveWindow;
fr.getLayeredPane().add(heavyShape, JLayeredPane.DRAG_LAYER);
heavyShape.validate();
fr.getLayeredPane().add(heavyShape.label, JLayeredPane.DRAG_LAYER);
} else if (aboveWindow instanceof JDialog) {
JDialog dlg = (JDialog) aboveWindow;
dlg.getLayeredPane().add(heavyShape, JLayeredPane.DRAG_LAYER);
heavyShape.validate();
dlg.getLayeredPane().add(heavyShape.label, JLayeredPane.DRAG_LAYER);
}
heavyShape.setZOrder();
}
heavyShape.label.setName(source.getDockable().getDockKey().getName());
// take a snapshot of the frame... ugly trick, but couldn't find anything better !
heavyShape.startDrag();
}
if (aboveWindow instanceof JFrame) {
oldGlassPane = ( (JFrame) aboveWindow).getGlassPane();
oldGlassPaneVisible = oldGlassPane.isVisible();
( (JFrame) aboveWindow).setGlassPane(dragGlassPane);
dragGlassPane.setVisible(true);
} else if (aboveWindow instanceof JDialog) {
oldGlassPane = ( (JDialog) aboveWindow).getGlassPane();
oldGlassPaneVisible = oldGlassPane.isVisible();
( (JDialog) aboveWindow).setGlassPane(dragGlassPane);
dragGlassPane.setVisible(true);
}
}
public void endDrag(){
if (! isLightWeight){
heavyShape.setVisible(false);
}
Window aboveWindow = this.window;//SwingUtilities.getWindowAncestor(desktop);
if (aboveWindow instanceof JFrame) {
( (JFrame) aboveWindow).setGlassPane(oldGlassPane);
} else if (aboveWindow instanceof JDialog) {
( (JDialog) aboveWindow).setGlassPane(oldGlassPane);
}
oldGlassPane.setVisible(oldGlassPaneVisible);
isDragStarted = false;
}
}
/** A glasspane use to paint drag / drop shape on top of the desktop */
class GlassPane extends JComponent {
Cursor stopDragCursor, dragCursor, floatCursor, swapDragCursor;
Color innerColor = new Color(64,64,64, 64);
Color textColor = Color.WHITE;
Color textFillColor = new Color(32, 32,32, 128);
Color textBorderColor = new Color(64, 64, 64);
boolean paintShapes = true;
ShapeLabelPainter labelPainter = new ShapeLabelPainter();
ShapeOutlinePainter outlinePainer = new ShapeOutlinePainter();
GlassPane() {
addMouseListener(new MouseAdapter() {}); // grab events
addMouseMotionListener(new MouseMotionAdapter() {});
showDragCursor();
}
/** Enables or disables shape painting */
public void setPaintShapes(boolean paintShapes){
this.paintShapes = paintShapes;
}
public void paintComponent(Graphics g) {
if (paintShapes){
Graphics2D g2 = (Graphics2D) g;
if (dropShape != null) {
Shape s = dropShape;
Point p = SwingUtilities.convertPoint( (Component) dropReceiver, 0, 0, this);
Shape s2 = AffineTransform.getTranslateInstance(p.x,
p.y).createTransformedShape(s);
outlinePainer.paintShape(g2, s2);
labelPainter.paintLabel(g2, s2, dockableDragSource.getDockable().getDockKey().getName());
}
}
}
public void showStopDragCursor() {
if (stopDragCursor == null) {
Image stopDragImage = (Image)UIManager.get("DragControler.stopDragCursor"); //2005/11/01
stopDragCursor = Toolkit.getDefaultToolkit().createCustomCursor(
stopDragImage , new Point(16, 16), "stopdragcursor");
}
setCursor(stopDragCursor);
}
public void showSwapDragCursor() {
if (swapDragCursor == null) {
Image swapDragImage = (Image)UIManager.get("DragControler.swapDragCursor"); //2005/11/01
swapDragCursor = Toolkit.getDefaultToolkit().createCustomCursor(
swapDragImage , new Point(16, 16), "swapdragcursor");
}
setCursor(swapDragCursor);
}
public void showFloatCursor() {
if (floatCursor == null) {
Image floatImage = (Image)UIManager.get("DragControler.detachCursor"); //2005/11/01
floatCursor = Toolkit.getDefaultToolkit().createCustomCursor(
floatImage, new Point(16, 16), "floatcursor" );
}
setCursor(floatCursor);
}
public void showDragCursor() {
if (dragCursor == null) {
Image dragImage = (Image)UIManager.get("DragControler.dragCursor"); //2005/11/01
dragCursor = Toolkit.getDefaultToolkit().createCustomCursor(dragImage,
new Point(16, 16), "dragcursor" );
}
setCursor(dragCursor);
}
}
/** heavyweight component used to paint shapes on top of heavyweight components
*/
private class HeavyShape extends Canvas {
private Rectangle cachedShapeBounds;
private BufferedImage desktopImage; // used for heavyweight painting
private Image subImage;
private Rectangle subImageBounds;
private ShapeOutlinePainter outlinePainter = new ShapeOutlinePainter();
private HeavyLabel label = new HeavyLabel();
public HeavyShape(){
setEnabled(false); // don't override the glaspane cursor
}
public void setZOrder(){
// jdk1.5 only
try {
//desktop.setComponentZOrder(this, -1); // on top
Method m = Container.class.getMethod("setComponentZOrder", new Class[]{
Component.class, int.class});
m.invoke(getParent(), new Object[]{this, new Integer(0)});
} catch (Exception ignore){
}
label.setZOrder();
}
private void startDrag(){
Container parent = getParent();
if (paintBackgroundUnderDragRect ){ // 2007/02/27
if (desktopImage == null
|| (desktopImage.getWidth() != parent.getWidth())
|| (desktopImage.getHeight() != parent.getHeight())){
desktopImage = (BufferedImage)parent.createImage(parent.getWidth(),
parent.getHeight());
subImage = null;
}
Graphics g = desktopImage.getGraphics();
parent.paint(g);
g.dispose();
}
}
public void paint(Graphics g){
if (dropShape != null) {
Point p = SwingUtilities.convertPoint( (Component) dropReceiver, 0, 0, getParent());
Rectangle r = dropShape.getBounds();
int shapeX = r.x, shapeY = r.y;
if (paintBackgroundUnderDragRect){
r.x += p.x;
r.y += p.y;
r.width +=2; // stroked shape (+3 pixels, centered)
r.height +=2;
if (r.x + r.width > desktopImage.getWidth()){
r.width = desktopImage.getWidth() - r.x;
}
if (r.y + r.height > desktopImage.getHeight()){
r.height = desktopImage.getHeight() - r.y;
}
if (subImage == null || !r.equals(subImageBounds)){
subImageBounds = r;
subImage = desktopImage.getSubimage(r.x, r.y, r.width, r.height);
}
g.drawImage(subImage, 0,0, null);
}
Shape s = AffineTransform.getTranslateInstance(-shapeX, -shapeY).createTransformedShape(dropShape);
Graphics2D g2 = (Graphics2D) g;
outlinePainter.paintShape(g2, s);
}
}
public void setVisible(boolean visible){
super.setVisible(visible);
label.setVisible(visible);
}
public void setCursor(Cursor cursor){
super.setCursor(cursor);
label.setCursor(cursor);
}
/** moves and resizes the canvas to the position of the drop shape */
public void moveToShape(Shape newShape){
setVisible(true);
Shape s = dropShape;
Container container = getParent();
Point p = SwingUtilities.convertPoint( (Component) dropReceiver, 0, 0, container);
Rectangle r = dropShape.getBounds();
r.x += p.x;
r.y += p.y;
r.width +=2; // shape has stroke(3), so we must extend it a little bit
r.height +=2;
if (r.x + r.width > container.getWidth()){ // check extend not out of bounds
r.width = container.getWidth() - r.x;
}
if (r.y + r.height > container.getHeight()){
r.height = container.getHeight() - r.y;
}
if (! r.equals(cachedShapeBounds)){
setBounds(r);
cachedShapeBounds = r;
label.moveToCenter(r);
}
}
}
private class HeavyLabel extends Canvas {
private Color textColor = Color.WHITE;
private Color textFillColor = new Color(128,128,128);
private Color textBorderColor = new Color(64, 64, 64);
private String name;
private Icon icon;
public HeavyLabel(){
setEnabled(false); // don't override the glaspane cursor
}
public void setZOrder(){
// jdk1.5 only (but we compile with source=1.4)
try {
//desktop.setComponentZOrder(this, -2); // on top of heavy panel
Method m = Container.class.getMethod("setComponentZOrder", new Class[]{
Component.class, int.class});
m.invoke(getParent(), new Object[]{this, new Integer(0)});
} catch (Exception ignore){
ignore.printStackTrace();
}
}
public void setName(String name){
this.name = name;
}
public void setIcon(Icon icon){
this.icon = icon;
}
public void moveToCenter(Rectangle shapeBounds){
Font f = getFont();
if (f != null){
FontMetrics fm = getFontMetrics(f);
int w = fm.stringWidth(name) + 10;
int h = fm.getHeight() + 5;
setBounds(shapeBounds.x + shapeBounds.width/2 - w/2,
shapeBounds.y + shapeBounds.height/2 - h/2,
w, h);
}
}
public void paint(Graphics g){
FontMetrics fm = g.getFontMetrics();
int w = fm.stringWidth(name);
int h = fm.getHeight();
g.setColor(textFillColor);
g.fillRect(0,0, getWidth(), getHeight());
g.setColor(textBorderColor);
g.drawRect(0,0, getWidth()-1, getHeight()-1);
g.setColor(textColor);
g.drawString(name, getWidth()/2-w/2,getHeight()/2 + h/2);
}
}
/** the object responsible for painting the shape outline */
private class ShapeOutlinePainter {
private Color innerColor = new Color(64,64,64);
public void paintShape(Graphics2D g2, Shape s){
Composite old = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.25f));
g2.setStroke(new BasicStroke(3));
g2.setColor(innerColor);
g2.fill(s);
g2.setComposite(old);
g2.setColor(Color.DARK_GRAY);
g2.draw(s);
}
}
/** the object responsible for painting the shape label */
private class ShapeLabelPainter {
private Color textColor = Color.WHITE;
private Color textFillColor = new Color(32, 32,32, 128);
// private Color textFillColor = new Color(128, 128,128);
private Color textBorderColor = new Color(64, 64, 64);
public void paintLabel(Graphics2D g2, Shape s, String name){
Rectangle bounds = s.getBounds();
FontMetrics fm = g2.getFontMetrics();
int w = fm.stringWidth(name);
g2.setColor(textFillColor);
int bx, by;
if (isFloatingShape){
bx = bounds.x + bounds.width/2 - w/2 ;
by = bounds.y + bounds.height/2 - fm.getHeight()/2;
} else {
bx = 4*((bounds.x + bounds.width/2 - w/2)/4) ;
// 2005/11/01 small hack to overcome small drifts of the label
// (for example when used on a tabbedpane and when the selected tab is
// one or two pixels bigger than a non selected tab.
// just snapping it with a 4*4 grid avoid those glitches (without changing
// too much the shapes algorithm).
by = 4*((bounds.y + bounds.height/2 - fm.getHeight()/2) / 4);
}
g2.fillRect(bx- 5, by, w +10, fm.getHeight());
g2.setStroke(new BasicStroke(1));
g2.setColor(textBorderColor);
g2.drawRect(bx- 5, by, w +10, fm.getHeight());
g2.setColor(textColor);
g2.drawString(name, bx, by + fm.getAscent());
}
}
/** A component that encapsulates the drag process (manages vetoable events, floatability..) */
private class DragProcess {
DockableDragSource source;
UnderMouseInfo umInfo;
boolean stateChange = false;
int futureState;
DockingActionEvent dockingActionEvent;
DragProcess(DockableDragSource source, UnderMouseInfo umInfo){
this.source = source;
this.umInfo = umInfo;
this.futureState = DockingUtilities.getDockableStateFromHierarchy(umInfo.underMouse);
}
/** search until a drag event is accepted or rejected (not delegated) */
public DockDragEvent findAcceptableEvent(MouseEvent e){
DockDragEvent event;
boolean loop = false;
Component underMouse = umInfo.underMouse;
do {
dropReceiver = (DockDropReceiver) underMouse;
MouseEvent convertMouse = SwingUtilities.convertMouseEvent(
(Component) e.getSource(),
e, underMouse);
DockableDragSource dragSource = ( (DockableDragSource) e.getSource());
event = new DockDragEvent(umInfo.desktop, dragSource, convertMouse);
dropReceiver.processDockableDrag(event);
if (event.isDragAccepted()) {
} else if (event.isDragDelegated()) {
// find another dropper
underMouse = underMouse.getParent();
while (underMouse != null && underMouse != umInfo.desktop &&
! (underMouse instanceof DockDropReceiver)) {
underMouse = underMouse.getParent();
}
}
if (event.isDragAccepted()) {
loop = false;
} else if (event.isDragDelegated() &&
underMouse instanceof DockDropReceiver) {
loop = true;
} else {
loop = false;
}
} while (loop);
if (event != null){
this.dockingActionEvent = event.getDockingAction();
umInfo.underMouse = underMouse; // 2007/01/06
}
return event;
}
/** verifies if the dockable(s) movement will not be vetoed by listeners
* */
public boolean isDockingActionAccepted(){
if (source.getDockableContainer() instanceof TabbedDockableContainer){
// here we're dragging a whole tabbed pane
TabbedDockableContainer tdc = (TabbedDockableContainer) source.getDockableContainer();
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
if (! isSingleDockingActionAccepted(d)){
return false;
}
}
return true;
} else {
return isSingleDockingActionAccepted(source.getDockable());
}
}
/** internal method for a single dockable */
private boolean isSingleDockingActionAccepted(Dockable dockable){
DockableState currentState = umInfo.desktop.getDockableState(dockable);
// will it cause a state change ?
// a state change occur when switching between CLOSED, HIDDEN, and DOCKED
// in this context, the drag event can only be generated by a hidden dockable
// (if there is a way to drag its button) or an already docked dockable (no state change)
if (currentState.getState() != futureState) { // state cannot be null
this.stateChange = true;
DockableState newState = new DockableState(umInfo.desktop, dockable , futureState);
DockableStateWillChangeEvent dscwEvent =
new DockableStateWillChangeEvent(currentState, newState);
if (!desktop.getContext().fireDockableStateWillChange(dscwEvent)) {
return false;
}
}
if (dockingActionEvent instanceof DockingActionDockableEvent){
DockingActionDockableEvent dde = (DockingActionDockableEvent) dockingActionEvent;
// also check for DockingActionEvents
if (dde.getDockable() == dockable){
return desktop.getContext().fireAcceptDockingAction(dockingActionEvent);
} else {
// multiple dockable moved at the same time (tabs) : we create copies
// of the original DockingActionEvent
// @todo : see if we couldn't create a new type of action instead
DockingActionDockableEvent dae = (DockingActionDockableEvent) dde.clone();
dae.setDockable(dockable);
return desktop.getContext().fireAcceptDockingAction(dae);
}
} else if (dockingActionEvent instanceof DockingActionSplitDockableContainerEvent){
// we're dragging a full tab dockable around : accept it always @todo check this
return true;
} else {
throw new RuntimeException("unmanaged docking action " + dockingActionEvent);
}
}
/** check if a dockable can be detached from the desktop */
public boolean canDockableBeDetached(){
if (source.getDockableContainer() instanceof TabbedDockableContainer){
// here we're dragging a whole tabbed pane
TabbedDockableContainer tdc = (TabbedDockableContainer) source.getDockableContainer();
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
if (! canSingleDockableBeDetached(d)){
return false;
}
}
// last check : the tab container must not be itself already detached
Dockable any = tdc.getDockableAt(0);
if (any.getDockKey().getDockableState() == DockableState.STATE_FLOATING){
//already detached, refuse another detaching
return false;
} else {
return true;
}
} else {
return canSingleDockableBeDetached(source.getDockable());
}
}
private boolean canSingleDockableBeDetached(Dockable dockable){
/* must not be already detached + floatingenabled + not maximized */
DockKey key = dockable.getDockKey();
if (key.getDockableState() == DockableState.STATE_FLOATING){
if (DockingUtilities.findTabbedDockableContainer(dockable) != null){
return true;
} else {
return false;// already detached and single
}
}
if ( key.isFloatEnabled()){
if (key.getDockableState() != DockableState.STATE_MAXIMIZED){
/* int dx = dragPoint.x - startDragPoint.x;
int dy = dragPoint.y - startDragPoint.y;
if (Math.abs(dx) < 20 && Math.abs(dy) < 10){
// deny detach when too near from start point 2005/11/01
return false;
} else {
return true;
}*/
return true; // the test above has been moved up to filter more drag events
} else {
return false;
}
} else {
return false;
}
}
/** trigers dockableStageWillChangeEvent to allow vetoing the floating */
public boolean checkDockableWillBeDetached(){
if (source.getDockableContainer() instanceof TabbedDockableContainer){
// here we're dragging a whole tabbed pane
TabbedDockableContainer tdc = (TabbedDockableContainer) source.getDockableContainer();
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
if (! checkSingleDockableWillBeDetached(d)){
return false;
}
}
return true;
} else {
return checkSingleDockableWillBeDetached(source.getDockable());
}
}
private boolean checkSingleDockableWillBeDetached(Dockable dockable){
DockableState newState = new DockableState(desktop, dockable, DockableState.STATE_FLOATING);
DockableState currentState = desktop.getDockableState(dockable);
DockableStateWillChangeEvent dscwEvent = new DockableStateWillChangeEvent(currentState, newState);
//
if (! desktop.getContext().fireDockableStateWillChange(dscwEvent)){
return false;
} else {
// also trigger DockingAction
DockingActionEvent dae = new DockingActionSimpleStateChangeEvent(desktop, dockable,
currentState.getState(), DockableState.STATE_FLOATING);
return desktop.getContext().fireAcceptDockingAction(dae);
}
}
public boolean checkAndDetachDockable(ShapePainterStrategy shapePainterStrategy){
if (checkDockableWillBeDetached()){
if (DockingPreferences.isLightWeightUsageEnabled() && paintFloatingDragShape){
Point shapePoint = new Point(dragPoint);
SwingUtilities.convertPointToScreen(shapePoint, desktop);
if (dropReceiver != null){ // we are above a drop receiver and we can show something
SwingUtilities.convertPointFromScreen(shapePoint, (Component)dropReceiver);
Dimension dragSize = dockableDragSource.getDockableContainer().getSize();
setDropShape(new Rectangle2D.Float(shapePoint.x,shapePoint.y,
dragSize.width, dragSize.height), shapePainterStrategy, true);
} else {
setDropShape(null, shapePainterStrategy);
}
} else {
setDropShape(null, shapePainterStrategy);
}
shapePainterStrategy.showFloatCursor();
return true;
} else {
return false;
}
}
}
private class DropProcess extends DragProcess {
MouseEvent event;
DropProcess(MouseEvent event, DockableDragSource source, UnderMouseInfo umInfo){
super(source, umInfo);
this.event = event;
}
public boolean dropIfPossible(){
MouseEvent convertMouse = SwingUtilities.convertMouseEvent(
(Component) event.getSource(), event, umInfo.underMouse);
DockDropEvent dropEvent = new DockDropEvent(
umInfo.desktop,
source,
convertMouse);
dropReceiver.processDockableDrop(dropEvent);
Component underMouse = umInfo.underMouse;
if (dropEvent.isDropAccepted()) {
if (underMouse instanceof JComponent) {
( (JComponent) underMouse).revalidate();
} else if (underMouse instanceof Component){
underMouse.validate();
underMouse.repaint();
}
fireDockingActionEvent();
return true;
} else {
return false;
}
}
public void fireDockingActionEvent(){
if (source.getDockableContainer() instanceof TabbedDockableContainer){
TabbedDockableContainer tdc = (TabbedDockableContainer) source.getDockableContainer();
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
fireSingleDockingActionEvent(tdc.getDockableAt(i));
}
} else {
fireSingleDockingActionEvent(source.getDockable());
}
}
private void fireSingleDockingActionEvent(Dockable dockable){
if (stateChange){
DockableState currentState = desktop.getDockableState(dockable);
dockable.getDockKey().setDockableState(futureState);
dockingContext.fireDockableStateChange(new DockableStateChangeEvent(currentState,
new DockableState(desktop, dockable, futureState)));
}
if (dockingActionEvent instanceof DockingActionDockableEvent){
DockingActionDockableEvent dde = (DockingActionDockableEvent) dockingActionEvent;
if (dde.getDockable() == dockable){
dockingContext.fireDockingActionPerformed(dockingActionEvent);
} else {
DockingActionDockableEvent dae = (DockingActionDockableEvent) dde.clone();
dae.setDockable(dockable);
dockingContext.fireDockingActionPerformed(dae);
}
} else if (dockingActionEvent instanceof DockingActionSplitDockableContainerEvent){
// we're dropping a whole container (currently it is only possible with
// a tabbeddockablecontainer
// @todo : missing event to fire here
} else {
throw new RuntimeException("Unmanaged docking action");
}
}
public void setFloating(Point location){
if (source.getDockableContainer() instanceof TabbedDockableContainer){
desktop.setFloating((TabbedDockableContainer)source.getDockableContainer(), location);
} else {
Dockable dockable = source.getDockable();
desktop.setFloating(source.getDockable(), true, location);
}
}
}
class UnderMouseInfo {
DockingDesktop desktop;
Component underMouse;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/FloatingDialog.java 0000644 0001750 0001750 00000040300 10573516350 025761 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.TexturePaint;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** The floating jdialog for floatable dockables. This is the default implementation of
* the FloatingDockableContainer interface.
*
* @author Lilian Chamontin, VLSolutions
* @since 2.0
* @update 2005/10/06 Lilian Chamontin : Reworked the layout (added border components) to
* have better cursor and resize management and to allow nesting dockables as tabs.
*
*/
public class FloatingDialog extends JDialog implements FloatingDockableContainer {
// constants to listen to border drags
private static final int DRAG_TOP = 1;
private static final int DRAG_LEFT = 2;
private static final int DRAG_RIGHT = 4;
private static final int DRAG_BOTTOM = 8;
/** the drag header height */
protected int titleHeight = 6;
private Color controlColor = UIManager.getColor("control");
private Color highlight = UIManager.getColor("controlLtHighlight");
private Color shadow = UIManager.getColor("controlShadow");
private Color activeCaptionColor = UIManager.getColor("activeCaption");
private Color inactiveCaptionColor = UIManager.getColor("inactiveCaption");
private Color activeCaptionBorderColor = UIManager.getColor("activeCaptionBorder");
private Color inactiveCaptionBorderColor = UIManager.getColor("inactiveCaptionBorder");
private Border activeBorder = BorderFactory.createLineBorder(activeCaptionBorderColor);
private Border inactiveBorder = BorderFactory.createLineBorder(inactiveCaptionBorderColor);
private JComponent title = createTitlePanel();
private Resizer left = new Resizer();
private Resizer right = new Resizer();
private Resizer bottom = new Resizer();
protected DockingDesktop desktop;
public FloatingDialog(Dialog parent) {
super(parent);
init();
}
public FloatingDialog(Frame parent){
super(parent);
//setIconImage(parent.getIconImage());
init();
}
/** initialisation of the title bar */
public void init(){
installDecoration();
installBorders();
installResizers();
addWindowListener(new WindowAdapter(){
public void windowActivated(WindowEvent e){
getRootPane().setBorder(activeBorder);
repaint();
}
public void windowDeactivated(WindowEvent e){
getRootPane().setBorder(inactiveBorder);
repaint();
}
});
title.setPreferredSize(new Dimension(10, titleHeight));
getContentPane().add(title, BorderLayout.NORTH);
// ResizeListener listener = new ResizeListener();
// addMouseMotionListener(listener); //2005/10/06
// addMouseListener(listener);
}
/** Installs or not the window decorations on this dialog.
*
* uses setUndecorated(booelan)
*/
public void installDecoration(){
setUndecorated( true );
}
/** Creates the component used as a header to drag the window */
public JComponent createTitlePanel(){
return new TitlePanel();
}
/** Installs the borders of this dialog and its title header */
public void installBorders(){
Border border = UIManager.getBorder("FloatingDialog.dialogBorder");
Border titleBorder = UIManager.getBorder("FloatingDialog.titleBorder");
title.setBorder(titleBorder);
((JPanel)getContentPane()).setBorder(border);
}
/** installs the components used for resizing (on left/right/bottom borders)
* @since 2.0.1
*/
public void installResizers(){ // 2005/10/06
ResizeListener listener = new ResizeListener();
left.addMouseMotionListener(listener);
left.addMouseListener(listener);
right.addMouseMotionListener(listener);
right.addMouseListener(listener);
bottom.addMouseMotionListener(listener);
bottom.addMouseListener(listener);
title.addMouseMotionListener(listener);
title.addMouseListener(listener);
getContentPane().add(left, BorderLayout.WEST);
getContentPane().add(right, BorderLayout.EAST);
getContentPane().add(bottom, BorderLayout.SOUTH);
Color inactive = UIManager.getColor("inactiveCaption");
left.setBackground(inactive);
right.setBackground(inactive);
bottom.setBackground(inactive);
}
public void installDocking(DockingDesktop desktop){
this.desktop = desktop;
}
public void setInitialDockable(Dockable dockable) {
SingleDockableContainer sdc = DockableContainerFactory.getFactory()
.createDockableContainer(dockable, DockableContainerFactory.PARENT_DETACHED_WINDOW);
sdc.installDocking(desktop);
Component comp = (Component) sdc;
getContentPane().add(comp);
}
public void setInitialTabbedDockableContainer(TabbedDockableContainer tdc) {
Component comp = (Component) tdc;
getContentPane().add(comp);
}
// utility resizer class
private class ResizeListener implements MouseMotionListener, MouseListener {
Point lastPoint = null;
int dragType = -1;
public void mouseDragged( MouseEvent e ) {
Rectangle bounds = getBounds();
Dimension d = getSize();
Point p = e.getPoint();
SwingUtilities.convertPointToScreen( p, e.getComponent() );
int dx = p.x - lastPoint.x;
int dy = p.y - lastPoint.y;
switch (dragType){
case DRAG_TOP:
Point loc = getLocation();
setLocation(loc.x + dx, loc.y+dy);
break;
case DRAG_TOP | DRAG_LEFT:
invalidate();
bounds.x += dx;
bounds.y += dy;
bounds.width -= dx;
bounds.height -= dy;
setBounds(bounds);
validate();
break;
case DRAG_TOP | DRAG_RIGHT:
invalidate();
bounds.y += dy;
bounds.width += dx;
bounds.height -= dy;
setBounds(bounds);
validate();
break;
case DRAG_RIGHT:
invalidate();
setSize(d.width + dx, d.height);
validate();
break;
case DRAG_RIGHT | DRAG_BOTTOM:
invalidate();
setSize(d.width + dx, d.height+dy);
validate();
break;
case DRAG_BOTTOM:
invalidate();
setSize(d.width, d.height+dy);
validate();
break;
case DRAG_BOTTOM | DRAG_LEFT:
invalidate();
bounds.x += dx;
bounds.width -= dx;
bounds.height += dy;
setBounds(bounds);
validate();
break;
case DRAG_LEFT:
invalidate();
bounds.x += dx;
bounds.width -= dx;
setBounds(bounds);
validate();
break;
}
lastPoint = p;
}
public void mouseReleased(MouseEvent e) {
dragType = -1;
}
public void mousePressed(MouseEvent e) {
dragType = 0;
Point p = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), getContentPane());
/*if (p.y < 10){
dragType |= DRAG_TOP;
}
if (p.x < 5){
dragType |= DRAG_LEFT;
}
if (p.x > getWidth() - 5){
dragType |= DRAG_RIGHT;
}
if (p.y > getHeight() - 5){
dragType |= DRAG_BOTTOM;
}*/
if (p.y < title.getY() + title.getHeight()){
dragType |= DRAG_TOP;
}
if (p.x < left.getX() + left.getWidth()){
dragType |= DRAG_LEFT;
}
if (p.x >= right.getX()){//getWidth() - 5){
dragType |= DRAG_RIGHT;
}
if (p.y >= bottom.getY()){
dragType |= DRAG_BOTTOM;
}
lastPoint = e.getPoint();
SwingUtilities.convertPointToScreen( lastPoint, e.getComponent() );
}
public void mouseExited(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
}
public void mouseMoved(MouseEvent e) {
Point p = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), getContentPane());
int dragType = 0;
if (p.y < title.getY() + title.getHeight()){
dragType |= DRAG_TOP;
}
if (p.x < left.getX() + left.getWidth()){
dragType |= DRAG_LEFT;
}
if (p.x >= right.getX()){//getWidth() - 5){
dragType |= DRAG_RIGHT;
}
if (p.y >= bottom.getY()){
dragType |= DRAG_BOTTOM;
}
Cursor c = null;
switch (dragType){
case 0:
c = Cursor.getDefaultCursor();
break;
case DRAG_TOP:
c = Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR);
break;
case DRAG_TOP | DRAG_LEFT:
c = Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);
break;
case DRAG_TOP | DRAG_RIGHT:
c = Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);
break;
case DRAG_RIGHT:
c = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
break;
case DRAG_RIGHT | DRAG_BOTTOM:
c = Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);
break;
case DRAG_BOTTOM:
c = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);
break;
case DRAG_BOTTOM | DRAG_LEFT:
c = Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);
break;
case DRAG_LEFT:
c = Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);
break;
}
if (!e.getComponent().getCursor().equals(c)){
e.getComponent().setCursor(c);
}
}
}
/** Class used as a title for dragging the window around */
protected class TitlePanel extends JComponent {
public void paintComponent(Graphics g){
// @todo : this will be refactored to plug custom title rendering
Color darker, brighter;
if (isActive()){
darker = activeCaptionColor;
brighter = activeCaptionBorderColor;
} else {
darker = inactiveCaptionColor;
brighter = inactiveCaptionBorderColor;
}
/* Graphics2D g2 = (Graphics2D) g;
Paint paint = g2.getPaint();
GradientPaint gradient = new GradientPaint(0,0, darker, 0, getHeight(), brighter);
g2.setPaint(gradient);
g2.fillRect(0,0, getWidth(), getHeight());
g2.setPaint(paint); // restore
*/
Graphics2D g2 = (Graphics2D) g;
g2.setColor(darker);
g2.fillRect(0,0, getWidth(), getHeight());
int width = 5;
int height = 5;
BufferedImage image = new BufferedImage(width,height, BufferedImage.TYPE_INT_ARGB);
Graphics ig = image.createGraphics();
ig.setColor(darker);
ig.fillRect(0,0, width, height);
ig.setColor(new Color(1,1,1,0.5f));
ig.fillRect(2,2, 2, 2);
ig.setColor(new Color(0,0,0,0.2f));
ig.fillRect(1,1, 2, 2);
ig.dispose();
// Create a texture paint from the buffered image
Rectangle r = new Rectangle(0, 0, width, height);
TexturePaint tp = null;
if (tp == null){
tp = new TexturePaint(image, r);
}
Paint old = g2.getPaint();
g2.setPaint(tp);
g2.fillRect(0,0, getWidth(), height);
g2.setPaint(old);
//g2.setColor(hightLight);
//g2.fillRect(0,getHeight()-1, getWidth(), 1);
}
}
protected class Resizer extends JComponent {
Resizer(){
setPreferredSize(new Dimension(3,3));
setOpaque(true);
}
public void paintComponent(Graphics g){
if (isActive()){
g.setColor(activeCaptionColor);
} else {
g.setColor(inactiveCaptionColor);
}
g.fillRect(0,0, getWidth(), getHeight());
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/FloatingDockableContainer.java 0000644 0001750 0001750 00000001555 10573516344 030145 0 ustar twerner twerner package com.vlsolutions.swing.docking;
/** The interface describing a Floating window used to display one or more dockables
*
* Objects implementing this interface must be instances of JDialog , as the
* pack(), setVisible(), setLocation(), dispose() etc. are assumed.
*
* @author Lilian Chamontin, VLSolutions
*/
public interface FloatingDockableContainer {
/** This install method is invoked before adding the first dockable */
public void installDocking(DockingDesktop desktop);
/** adds the initial dockable to this top-level container */
public void setInitialDockable(Dockable dockable);
/** adds the initial tabbdeddockablecontainer to this top-level container.
* This will happen when drag-n-dropping a whole tab container from the desktop.
*/
public void setInitialTabbedDockableContainer(TabbedDockableContainer tdc);
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/MaximizedComponentReplacer.java 0000644 0001750 0001750 00000000565 10573516344 030402 0 ustar twerner twerner package com.vlsolutions.swing.docking;
import javax.swing.JComponent;
/** A component used to replace the maximized dockable in the dockable container hierarchy
*(as long as the dockable is maximized)
*
* @author Lilian Chamontin, VLSolutions
*/
class MaximizedComponentReplacer extends JComponent {
public MaximizedComponentReplacer() {
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/MaximizedDockView.java 0000644 0001750 0001750 00000011727 10573516350 026474 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import com.vlsolutions.swing.docking.event.DockEvent;
/** A dockView suitable for maximized dockables
*
* @author Lilian Chamontin, VLSolutions
* @update 2007/01/24 Lilian Chamontin : added DnD blocking (maximized components should't support
* drag/drop from floating windows)
*/
public class MaximizedDockView extends DockView {
public MaximizedDockView(Dockable dockable) {
super(dockable, true);
}
/** maximized dockable don't support drag and drop */
public void processDockableDrag(DockDragEvent event) { //2007/01/24
event.rejectDrag();
}
/** maximized dockable don't support drag and drop */
public void processDockableDrop(DockDropEvent event) {
event.rejectDrop();
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/MaximizedDockViewAsTab.java 0000644 0001750 0001750 00000005433 10573516344 027407 0 ustar twerner twerner package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import java.awt.Point;
import javax.swing.AbstractAction;
import javax.swing.UIManager;
/** A maximized view to use with the TabFactory.
*
* @author Lilian Chamontin, VLSolutions
* @see TabFactory
* @since 2.1.3
*/
public class MaximizedDockViewAsTab extends DockViewAsTab{
public MaximizedDockViewAsTab(Dockable dockable) {
super(dockable);
}
protected void configureMaximizeButton() {
if (isRestoreButtonDisplayed){
maximizeSmartIcon.setIcon(UIManager.getIcon("DockViewTitleBar.restore"));
maximizeSmartIcon.setPressedIcon(UIManager.getIcon("DockViewTitleBar.restore.pressed"));
maximizeSmartIcon.setRolloverIcon(UIManager.getIcon("DockViewTitleBar.restore.rollover"));
// add a tooltip
maximizeAction.putValue(AbstractAction.SHORT_DESCRIPTION,
UIManager.get("DockViewTitleBar.restoreButtonText"));
}
}
protected void configureFloatButton() {
isFloatButtonDisplayed = false;
}
protected void configureHideButton() {
isHideButtonDisplayed = false;
}
protected void configureCloseButton() {
isCloseButtonDisplayed = false;
}
protected TabHeader createTabHeader(){
return new MaximizedTabHeader();
}
public void processDockableDrag(DockDragEvent event) {
event.rejectDrag();
}
public void processDockableDrop(DockDropEvent event) {
event.rejectDrop();
}
protected class MaximizedTabHeader extends TabHeader {
/** {@inheritDoc} */
public boolean startDragComponent(Point p) {
// disable DnD for some cases :
// - child of a compound dockable, in hidden state
// - child of a maximized compund dockable
// - maximized dockable
Dockable target = getDockable();
int targetState = target.getDockKey().getDockableState();
if (targetState == DockableState.STATE_HIDDEN){
if (DockingUtilities.isChildOfCompoundDockable(target)){
// nested hidden dockables cannot be drag and dropped
return false;
}
} else if (targetState == DockableState.STATE_DOCKED){
boolean isChildOfMaximizedContainer = false;
if (desktop != null){
Dockable max = desktop.getMaximizedDockable();
if (max != null && max.getComponent().getParent().isAncestorOf(this)){
isChildOfMaximizedContainer = true;
}
}
if (isChildOfMaximizedContainer){
return false;
}
} else if (targetState == DockableState.STATE_MAXIMIZED){
return false;
}
return true;
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/RelativeDockablePosition.java 0000644 0001750 0001750 00000027757 10573516350 030050 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.awt.*;
/** This class is an immutable object used to remember the relative positionning
* of docked components.
*
*
*
* Objects of this class are used to reposition a Dockable on the desktop, based
* on lazy constraints : As the desktop is a mix of horizontal and vertical
* split panes ({@link SplitContainer}) it is not always possible to put a dockable
* exactly where you want given a set of x,y, w, and h constraints.
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* */
public class RelativeDockablePosition {
/** convenience field referencing the TOP border of the DockingDesktop */
public static final RelativeDockablePosition TOP = new RelativeDockablePosition(0,0,1, 0.2);
/** convenience field referencing the CENTER part of TOP border of the DockingDesktop */
public static final RelativeDockablePosition TOP_CENTER = new RelativeDockablePosition(0.4,0,0.2, 0.2);
/** convenience field referencing the TOP-RIGHT corner of the DockingDesktop */
public static final RelativeDockablePosition TOP_RIGHT= new RelativeDockablePosition(0,0,0.2, 0.2);
/** convenience field referencing the TOP-LEFT corner of the DockingDesktop */
public static final RelativeDockablePosition TOP_LEFT = new RelativeDockablePosition(0.8,0,0.2, 0.2);
/** convenience field referencing the RIGHT border of the DockingDesktop */
public static final RelativeDockablePosition RIGHT = new RelativeDockablePosition(0.8,0,0.2, 1);
/** convenience field referencing the CENTER part of the RIGHT border of the DockingDesktop */
public static final RelativeDockablePosition RIGHT_CENTER = new RelativeDockablePosition(0.8,0.4,0.2, 0.2);
/** convenience field referencing the TOP-RIGHT corner of the DockingDesktop */
public static final RelativeDockablePosition BOTTOM_RIGHT = new RelativeDockablePosition(0.8,0.8,0.2, 0.2);
/** convenience field referencing the BOTTOM border of the DockingDesktop */
public static final RelativeDockablePosition BOTTOM = new RelativeDockablePosition(0,0.8,1, 0.2);
/** convenience field referencing the CENTER part of the BOTTOM border of the DockingDesktop */
public static final RelativeDockablePosition BOTTOM_CENTER = new RelativeDockablePosition(0.4,0.8,0.2, 0.2);
/** convenience field referencing the TOP-RIGHT corner of the DockingDesktop */
public static final RelativeDockablePosition BOTTOM_LEFT = new RelativeDockablePosition(0,0.8,0.2, 0.2);
/** convenience field referencing the LEFT border of the DockingDesktop */
public static final RelativeDockablePosition LEFT = new RelativeDockablePosition(0,0,0.2, 1);
/** convenience field referencing the CENTER part of the LEFT border of the DockingDesktop */
public static final RelativeDockablePosition LEFT_CENTER = new RelativeDockablePosition(0,0.4,0.2, 0.2);
private double x, y, w; // relative positionning (0-1) of the component in the container
/** The container used for relative positioning (can be a top level DockingPanel
* or an intermediate CompoundDockingPanel) */
private Container relativeAncestorContainer;
private double h;
/** @see AnchorConstraints.ANCHOR_TOP (this field is an ORing of possible anchors) and contains
* 4 boolean values (TOP, LEFT, BOTTOM, RIGHT)
*/
private int anchors;
/** Construct a RelativeDockablePosition, assigning x, y, w, h values from the
* current position of a dockable in its desktop container.
*
* This constructor is a convenience for the framework, and should not be
* used by API users (thus is package protected visibility).
* */
RelativeDockablePosition(Container relativeAncestorContainer, Dockable dockable) {
/* (package protected) */
resetRelativePosition(relativeAncestorContainer, dockable);
}
/** Constructs an empty relative position (all fields are initialized with 0.0 values) */
public RelativeDockablePosition() {
}
/** Constructs a relative position with given location and size.
*
* Please remember that the values must be between 0 and 1, as they designate
* relative coordinates position/size.
*
* @throws IllegalArgumentException if values are not in the given bounds
* */
public RelativeDockablePosition(double x, double y, double w, double h) {
this (null, x, y, w, h);
}
/** Constructs a relative position with a given location and size, relative to a container */
public RelativeDockablePosition(Container relativeAncestorContainer, double x, double y, double w, double h) {
this.relativeAncestorContainer = relativeAncestorContainer;
if (x < 0 || x > 1){
throw new IllegalArgumentException("x is out of bounds [0.0 , 1.0] " + x);
}
if (y < 0 || y > 1){
throw new IllegalArgumentException("y is out of bounds [0.0 , 1.0] " + y);
}
if (w < 0 || w > 1){
throw new IllegalArgumentException("w is out of bounds [0.0 , 1.0] " + w);
}
if (h < 0 || h > 1){
throw new IllegalArgumentException("h is out of bounds [0.0 , 1.0] " + h);
}
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
/** Returns the relative x position of the dockable */
public double getX(){
return x;
}
/** Returns the relative y position of the dockable */
public double getY(){
return y;
}
/** Returns the relative width of the dockable */
public double getWidth(){
return w;
}
/** Returns the relative height of the dockable */
public double getHeight(){
return h;
}
/** Returns a meaningfull string representation of this RelativeDockablePosition */
public String toString(){
return "RelativePosition [" + x+", " + y +", " + w + ", " + h + ", anchors=" + anchors+"]";
}
/** Returns the ancestor container used as a reference for the relative potionning
* This can be a DockingPanel (top level ancestor) or CompoundDockingPanel (intermediate ancestor)
*/
public Container getRelativeAncestorContainer(){
return relativeAncestorContainer;
}
/** Returns an integer value representing the anchoring of the dockable relatively to
* its ancestor container.
*
* For example a dockable at the top left angle of an ancestor container will have an
* "anchors" value or : AnchorConstraints.ANCHOR_TOP|AnchorConstraints.ANCHOR_LEFT
* @see AnchorConstraints
*/
public int getAnchors(){
return anchors;
}
/** Updates the current relative ancestor container and anchor positionning */
public void resetRelativePosition(Container relativeAncestorContainer, Dockable dockable) {
this.relativeAncestorContainer = relativeAncestorContainer;
DockableContainer dockableContainer = DockingUtilities.findSingleDockableContainer(dockable);
if (dockableContainer != null && relativeAncestorContainer != null){
Component c = (Component) dockableContainer;
Rectangle converted = SwingUtilities.convertRectangle(c,
new Rectangle(0,0, c.getWidth(), c.getHeight()), relativeAncestorContainer);
x = converted.x / (float)relativeAncestorContainer.getWidth();
y = converted.y / (float)relativeAncestorContainer.getHeight();
w = converted.width / (float)relativeAncestorContainer.getWidth();
h = converted.height / (float)relativeAncestorContainer.getHeight();
// also set boolean anchors
this.anchors = RelativeDockingUtilities.findAnchors(dockable.getComponent(), relativeAncestorContainer);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/RelativeDockingUtilities.java 0000644 0001750 0001750 00000227344 10573516350 030063 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockingActionAddDockableEvent;
import com.vlsolutions.swing.docking.event.DockingActionEvent;
import com.vlsolutions.swing.docking.event.DockingActionSplitComponentEvent;
import java.awt.*;
import javax.swing.*;
/** This class provides an algorithm for finding (and then inserting) the most suitable place to
* show a dockable, based on a relative positionning.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @update 2005/10/10 Lilian Chamontin : improved heuristics of resizing (best matching of the appropriate SplitContainer)
* @update 2005/10/10 Lilian Chamontin : improved again heuristics of resizing
*/
class RelativeDockingUtilities {
/* package class */
/* This class is an extraction of DockingDesktop - we will enhance (and complexify)
* the algorithm later,
* and should not mess up with DockingDesktop source code.
*
*
*/
private RelativeDockingUtilities() {
}
/** try to find the best suitable SplitContainer from where insertion will
* be done.
* */
private static SplitContainer findBestContainer(Container ancestorContainer, RelativeDockablePosition position){
// convert relative positionning to current positionning (depending
// on the current size of dockingPanel)
int x = (int) (position.getX() * ancestorContainer.getWidth());
int y = (int) (position.getY() * ancestorContainer.getHeight());
int w = (int) (position.getWidth() * ancestorContainer.getWidth());
int h = (int) (position.getHeight() * ancestorContainer.getHeight());
int centerX = x + w / 2;
int centerY = y + h / 2;
Component centerComp = ancestorContainer.findComponentAt(centerX, centerY);
// find the splitcontainer containing centerComp,
// and ensure this split is linked to ancestorContainer by a hierarchy of split containers
// (to avoid selecting a split inside a sub-container)
Component splitComp = centerComp;
boolean found = false;
while (splitComp != null && splitComp != ancestorContainer && ! found){
splitComp = splitComp.getParent();
if (splitComp instanceof SplitContainer){
// ok we've found a split : now let's check if there's a direct split hierarchy
// between this one and the ancestor container
Component up = splitComp.getParent();
while (up instanceof SplitContainer){
up = up.getParent();
}
if (up == ancestorContainer){
found = true;
}
}
}
if (splitComp instanceof SplitContainer) { //2006/09/12
/* Try to find a larger splitcontainer that still fits well
* with the position.
* for example :
*
* [1|___2_____]
* [1|[3|[4|5]]]
*
* if we remove "2", what remains is [1|[3|[4|5]]]
* and on restoring, the selected split is [4|5], although [3|[4|5]] would be
* a much better choice.
*
* to do that, we try to find the parent with the best "width" and "height"
*
*/
float EPSILON = 0.05f;
found = true;
while (found && splitComp.getParent() instanceof SplitContainer){
found = false;
float widthRatio = splitComp.getWidth() / (float) w;
float heightRatio = splitComp.getHeight() / (float) h;
SplitContainer parentSplit = (SplitContainer) splitComp.getParent();
float pWidthRatio = parentSplit.getWidth() / (float) w;
float pHeightRatio = parentSplit.getHeight() / (float) h;
boolean sameOrientation = ((SplitContainer)splitComp).getOrientation() == parentSplit.getOrientation();
if (sameOrientation){
if (parentSplit.getOrientation() == SplitContainer.HORIZONTAL_SPLIT){
// two horizontal, which one has the best width ?
if (Math.abs(pWidthRatio-1) < Math.abs(widthRatio-1)){
//parents width is better : we upgrade splitcomp
splitComp = splitComp.getParent();
found = true; // loop again
}
} else {
// vertical == same width, is parent height better ?
if (Math.abs(pHeightRatio-1) < Math.abs(heightRatio-1)){
//height is better : we upgrade splitcomp
splitComp = splitComp.getParent();
found = true; // loop again
}
}
} else { // opposite orientation
if (parentSplit.getOrientation() == SplitContainer.HORIZONTAL_SPLIT){
// so split is V and parent is H
// has parent a better width ratio ?
if (Math.abs(pWidthRatio-1) < Math.abs(widthRatio-1)){
//parents width is better : we upgrade splitcomp
splitComp = splitComp.getParent();
found = true; // loop again
}
} else {
if (Math.abs(pHeightRatio-1) < Math.abs(heightRatio-1)){
//height is better : we upgrade splitcomp
splitComp = splitComp.getParent();
found = true; // loop again
}
}
}
}
}
/*while (splitComp != null && splitComp != ancestorContainer
&& ! (splitComp instanceof SplitContainer)) {
splitComp = splitComp.getParent();
}*/
if (splitComp instanceof SplitContainer) {
// try to enhance the selection when there are global anchors //2005/10/10
// we're now looking for a split container whose anchors would better match
// the ones of the dockable position
// boolean anchoredTop = Math.abs( y - dockingPanel.getY()) < 5;
// boolean anchoredLeft =Math.abs(x - dockingPanel.getX()) < 5;
// boolean anchoredBottom = Math.abs(y + h - dockingPanel.getY() - dockingPanel.getHeight()) < 5;
// boolean anchoredRight = Math.abs(x + w - dockingPanel.getX() - dockingPanel.getWidth()) < 5;
/*boolean anchoredTop = y < 5; //2005/11/08 enhanced !
boolean anchoredLeft = x < 5;
boolean anchoredBottom = Math.abs(y + h - ancestorContainer.getHeight()) < 5;
boolean anchoredRight = Math.abs(x + w - ancestorContainer.getWidth()) < 5;*/
int anchors = position.getAnchors();
boolean anchoredTop = (anchors & AnchorConstraints.ANCHOR_TOP)>0;
boolean anchoredLeft = (anchors & AnchorConstraints.ANCHOR_LEFT)>0;
boolean anchoredBottom = (anchors & AnchorConstraints.ANCHOR_BOTTOM)>0;
boolean anchoredRight = (anchors & AnchorConstraints.ANCHOR_RIGHT)>0;
return findBetterContainer((SplitContainer)splitComp, ancestorContainer, anchoredTop, anchoredLeft, anchoredBottom, anchoredRight);
} else {
return null;
}
}
/** try to find a SplitContainer up in the hierarchy, satisfying the global anchors */
private static SplitContainer findBetterContainer(SplitContainer split,
Container dockingPanel, boolean anchoredTop,
boolean anchoredLeft, boolean anchoredBottom, boolean anchoredRight){
// we already have found a splitContainer, but it can be subOptimal in some cases
// for instance when we want to anchor a component at the bottom of the container (full width),
// and there are two horizontal splits there, we might return the internal split (not full width),
// and not the external (full width) one.
// this method will try to find a splitcontainer upper in the hierarchy, with better anchors
/*System.out.println("global anchors " + anchoredTop + " "
+ anchoredLeft + " " + anchoredBottom + " " + anchoredRight);*/
boolean [] globalAnchors = {anchoredTop, anchoredLeft, anchoredBottom, anchoredRight};
int globalCount = 0; // number of anchors to be found (at least)
for (int i=0; i < 4; i++){
if (globalAnchors[i]){
globalCount++;
}
}
SplitContainer betterSplit = split;
boolean [] splitAnchors = new boolean[4];
while (true){
int contacts = findAnchors(split, dockingPanel);
splitAnchors[0] = (contacts & AnchorConstraints.ANCHOR_TOP) > 0;
splitAnchors[1] = (contacts & AnchorConstraints.ANCHOR_LEFT) > 0;
splitAnchors[2] = (contacts & AnchorConstraints.ANCHOR_BOTTOM) > 0;
splitAnchors[3] = (contacts & AnchorConstraints.ANCHOR_RIGHT) > 0;
int count = 0;
for (int i=0; i < 4; i++){
if (globalAnchors[i] && splitAnchors[i]){
count ++;
}
}
if (count >= globalCount){
return split;
} else {
if (split.getParent() instanceof SplitContainer){
split = (SplitContainer) split.getParent();
} else {
return split; // last split container
}
}
}
}
/** builds an array used to find anchors of a component relative to its ancestor container */
/* private static boolean [] findAnchors(Component comp, Container container){
Rectangle r = SwingUtilities.convertRectangle(comp,
new Rectangle(0, 0, comp.getWidth(), comp.getHeight()),
container);
int x = container.getX();
int y = container.getY();
int w = container.getWidth();
int h = container.getHeight();
boolean [] anchors = new boolean [4];
anchors[0] = Math.abs( y - r.y) < 5;
anchors[1] = Math.abs(x - r.x) < 5;
anchors[2] = Math.abs(y + h - r.y - r.height) < 30;
anchors[3] = Math.abs(x + w - r.x - r.width) < 5;
return anchors;
}
*/
/** Horizontally divide split and resize the new split
*
* @since 2004/04/24
* */
private static void hSplitAndResize(Component base,
Component left, Component right, double proportion){
Container parent = base.getParent();
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(parent, base, newSplit);
newSplit.setLeftComponent( left);
newSplit.setRightComponent(right);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportion));
}
/** Vertically divide split and resize the new split
*
* @since 2004/04/24
* */
private static void vSplitAndResize(Component base,
Component top, Component bottom, double proportion){
Container parent = base.getParent();
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(parent, base, newSplit);
newSplit.setTopComponent( top);
newSplit.setBottomComponent(bottom);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportion));
}
/** look up the split hierarchy to find which borders a component is touching
*
* @param base the component to find anchors for
* @param ancestorContainer the top level ancestor used to stop searching
*/
public static int findAnchors(Component base, Container ancestorContainer){
int contact = AnchorConstraints.ANCHOR_TOP|AnchorConstraints.ANCHOR_LEFT
|AnchorConstraints.ANCHOR_BOTTOM|AnchorConstraints.ANCHOR_RIGHT;
Component comp = base.getParent();
Component child = base;
while (comp != null && comp != ancestorContainer && contact != 0){
if (comp instanceof SplitContainer){
SplitContainer sc = (SplitContainer) comp;
if (sc.getOrientation() == JSplitPane.VERTICAL_SPLIT){
if (sc.getTopComponent() == child){
contact = contact & (~AnchorConstraints.ANCHOR_BOTTOM); // not at bottom
} else {
contact = contact & (~AnchorConstraints.ANCHOR_TOP); // not on top
}
} else {
if (sc.getLeftComponent() == child){
contact = contact & (~AnchorConstraints.ANCHOR_RIGHT); // not right
} else {
contact = contact & (~AnchorConstraints.ANCHOR_LEFT); // not left
}
}
}
child = comp;
comp = comp.getParent();
}
return contact;
}
/** Tries to find the best position to insert an hidden dockable, and insert it
* @deprecated use getInsertionDockingAction / applyDockingAction instead
*/
public static SingleDockableContainer insertDockable(Container relativeAncestorContainer,
Dockable dockable, RelativeDockablePosition position) {
if (position == null){
// for safety
position = new RelativeDockablePosition(0,0.8,0.5,0.2);
}
SingleDockableContainer dockableContainer = null;
if (relativeAncestorContainer.getComponentCount() == 0){ // empty docking panel
dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_DESKTOP);
// default central insertion
relativeAncestorContainer.add((Component)dockableContainer, BorderLayout.CENTER);
relativeAncestorContainer.invalidate(); // 2005/05/04
relativeAncestorContainer.validate();
relativeAncestorContainer.repaint();
} else {
dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
// convert relative positionning to current positionning (depending
// on the current size of dockingPanel)
int x = (int) (position.getX() * relativeAncestorContainer.getWidth());
int y = (int) (position.getY() * relativeAncestorContainer.getHeight());
int w = (int) (position.getWidth() * relativeAncestorContainer.getWidth());
int h = (int) (position.getHeight() * relativeAncestorContainer.getHeight());
int centerX = x + w / 2;
int centerY = y + h / 2;
SplitContainer split = findBestContainer(relativeAncestorContainer, position);
if (split != null){
// ok we've found one
/*Rectangle splitRect = SwingUtilities.convertRectangle(split,
new Rectangle(0, 0, split.getWidth(), split.getHeight()),
relativeAncestorContainer);*/
//int contacts = findAnchors(split, relativeAncestorContainer);
int contacts = position.getAnchors(); // we use the anchors that
// were computed on closing
// heuristics : try to find an anchor, and which component(left/right)
// is nearer of center
/*boolean anchoredTop = Math.abs( y - splitRect.y) < 5;
boolean anchoredLeft = Math.abs(x - splitRect.x) < 5;
boolean anchoredBottom = Math.abs(y + h - splitRect.y - splitRect.height) < 30;
boolean anchoredRight = Math.abs(x + w - splitRect.x - splitRect.width) < 5;*/
boolean anchoredTop = (contacts & AnchorConstraints.ANCHOR_TOP)>0;
boolean anchoredLeft =(contacts & AnchorConstraints.ANCHOR_LEFT)>0;
boolean anchoredBottom = (contacts & AnchorConstraints.ANCHOR_BOTTOM)>0;
boolean anchoredRight = (contacts & AnchorConstraints.ANCHOR_RIGHT)>0;
// System.out.println("anchors : " + anchoredTop + ", "+ anchoredLeft + ", "
// + anchoredBottom + ", " + anchoredRight);
Component left = split.getLeftComponent();
Component right = split.getRightComponent();
Point leftCenter = SwingUtilities.convertPoint(left,
left.getWidth() / 2,
left.getHeight() / 2, relativeAncestorContainer);
Point rightCenter = SwingUtilities.convertPoint(right,
right.getWidth() / 2,
right.getHeight() / 2, relativeAncestorContainer);
int leftDist = (leftCenter.x - x) * (leftCenter.x - x)
+ (leftCenter.y - y) * (leftCenter.y);
int rightDist = (rightCenter.x - x) * (rightCenter.x - x)
+ (rightCenter.y - y) * (rightCenter.y);
Point bestCenter;
Component bestComp;
if (leftDist < rightDist) {
bestCenter = leftCenter;
bestComp = left;
} else {
bestCenter = rightCenter;
bestComp = right;
}
//2006/09/12
/* If the split matches the size of the component, then
* we'll have to split it (and not split one of its children)
*/
float splitWidthRatio = Math.abs(1 - split.getWidth() / (float)w);
float splitHeightRatio = Math.abs(1 - split.getHeight() / (float)h);
/** this will happen only when anchors are not too strict (like top+right)
* for wider anchors (left-top-right) this ration is not used as
* superflous
*/
if (split.getOrientation() == JSplitPane.VERTICAL_SPLIT) {
Component top = split.getTopComponent();
Component bottom = split.getBottomComponent();
int topH = top.getHeight();
int bottomH = bottom.getHeight();
// proportions used when splitting a vertical split vertically
float proportionTopH = h / (float)topH;
float proportionBottomH = h / (float)bottomH;
if (proportionTopH >= 0.6f){ // not too big
proportionTopH = 0.6f;
}
if (proportionBottomH >= 0.6f){ // not too big
proportionBottomH = 0.6f;
}
// proportions used when splitting a vertical split horizontally
int splitW = split.getWidth();
float proportionW = w / (float) splitW;
if (proportionW >= 0.8f){ // not too big
proportionW = 0.8f;
}
if (anchoredTop) {
if (anchoredLeft) {
if (anchoredBottom) { // TLB = full left
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setLeftComponent( (Component) dockableContainer);
newSplit.setRightComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionW));
} else {
// Top + left
if (splitWidthRatio < 0.1f && split.getHeight() > h){//2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, top, newSplit);
newSplit.setLeftComponent( (Component) dockableContainer);
newSplit.setRightComponent(top);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionW));
}
}
} else if (anchoredRight) { // TR
if (anchoredBottom) { // TRB = full right
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setRightComponent( (Component) dockableContainer);
newSplit.setLeftComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionW));
} else {
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, top, newSplit);
newSplit.setLeftComponent(top);
newSplit.setRightComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionW));
}
}
} else {
// just anchored top
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, top, newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(top);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionTopH));
}
} else if (anchoredBottom) { // but not anchoredTop
if (anchoredLeft) { //BL
if (anchoredRight) { //BLR = full bottom
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bottom, newSplit);
newSplit.setTopComponent(bottom);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionBottomH));
} else {
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1- h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bottom, newSplit);
newSplit.setLeftComponent( (Component) dockableContainer);
newSplit.setRightComponent(bottom);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionW));
}
}
} else if (anchoredRight) { // BR
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1 - h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bottom, newSplit);
newSplit.setLeftComponent(bottom);
newSplit.setRightComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionW));
}
} else {
// just anchored bottom
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bottom, newSplit);
newSplit.setTopComponent(bottom);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionBottomH));
}
} else if (anchoredLeft) { // not anchored on top / bottom
if (anchoredRight){ //2005/10/10
// left + right on a vertical split, means we have to insert a new component
// in between
int yTop = y;
int yBottom = split.getHeight() - y - h;
int splitTop = top.getHeight();
int splitBottom = bottom.getHeight();
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestComp == top){
newSplit.setTopComponent(bestComp);
newSplit.setBottomComponent((Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(split,
(split.getHeight() - yBottom)/(float) split.getHeight()));
SwingUtilities.invokeLater(new SplitResizer(newSplit,
yTop/(float) split.getHeight()));
} else {
newSplit.setBottomComponent(bestComp);
newSplit.setTopComponent((Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(split, yTop/(float) split.getHeight()));
SwingUtilities.invokeLater(new SplitResizer(newSplit, h/(float) splitBottom));
}
} else {// only left
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
newSplit.setRightComponent(bestComp);
newSplit.setLeftComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionW));
}
} else if (anchoredRight) {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
newSplit.setLeftComponent(bestComp);
newSplit.setRightComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionW));
} else { // not anchored at all, split verticaly and add
// todo : check how it's done now for the split-h part and do the same here
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestCenter.y < centerY) {
newSplit.setTopComponent(bestComp);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionBottomH));
} else {
newSplit.setBottomComponent(bestComp);
newSplit.setTopComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionTopH));
}
}
} else {
// horizontal split
// proportions used when splitting a horizontal split horizontally
float proportionLeftW = w / (float)left.getWidth();
float proportionRightW = w / (float)right.getWidth();
if (proportionLeftW >= 0.8f){ // not too big
proportionLeftW = 0.8f;
}
if (proportionRightW >= 0.8f){ // not too big
proportionRightW = 0.8f;
}
// proportions used when splitting a horizontal split vertically
int splitH = split.getHeight();
float proportionH = h / (float) splitH;
if (proportionH >= 0.6f){ // not too big
proportionH = 0.6f;
}
if (anchoredTop) {
if (anchoredLeft) {
if (anchoredBottom) { // TLB = full left
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, left,
newSplit);
newSplit.setLeftComponent( (Component) dockableContainer);
newSplit.setRightComponent(left);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionLeftW));
} else if (anchoredRight){ // TLR = full top
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split, newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
} else { // just anchored top/left
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
// otherwise we just split vertically on the left side
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, left,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(left);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
}
}
} else if (anchoredRight) { // Top but not left
if (anchoredBottom) { // top + right + bottom == full right
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, right,
newSplit);
newSplit.setRightComponent( (Component) dockableContainer);
newSplit.setLeftComponent(right);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionRightW));
} else { // top + right
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, right, newSplit);
newSplit.setBottomComponent(right);
newSplit.setTopComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
}
}
} else if (anchoredBottom){ //2005/10/10
// top + bottom : create a horizontal split
// as we are inserting a vertical element into a horizontal split
// we have to adjust the width on both sides
int xLeft = x;
int xRight = split.getWidth() - x - w;
int splitLeft = left.getWidth();
int splitRight = right.getWidth();
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestComp == left){
newSplit.setLeftComponent(bestComp);
newSplit.setRightComponent((Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(split, (split.getWidth() - xRight)/(float) split.getWidth()));
SwingUtilities.invokeLater(new SplitResizer(newSplit, xLeft/(float) split.getWidth()));
} else {
newSplit.setRightComponent(bestComp);
newSplit.setLeftComponent((Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(split, xLeft/(float) split.getWidth()));
SwingUtilities.invokeLater(new SplitResizer(newSplit, w/(float) splitRight));
}
} else {
// just anchored top
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(bestComp);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
}
}
} else if (anchoredBottom) { // but not anchoredTop
if (anchoredLeft) {
if (anchoredRight) { // BLR == full bottom
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split, newSplit);
newSplit.setTopComponent(split);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionH));
} else { // bottom + left
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1 - h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, left, newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(left);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionH));
}
}
} else if (anchoredRight) { // bottom + right
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1- h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, right, newSplit);
newSplit.setTopComponent(right);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionH));
}
} else {
// just anchored bottom
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setBottomComponent( (Component) dockableContainer);
newSplit.setTopComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1- h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
newSplit.setTopComponent(bestComp);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionH));
}
}
} else if (anchoredLeft) { // not anchored on top / bottom
if (anchoredRight){
// left + right... we have to split vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split); // todo : check this case : why is the new component on top
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
} else {
// just left
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, left, newSplit);
newSplit.setRightComponent(left);
newSplit.setLeftComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionLeftW));
}
}
} else if (anchoredRight) {
if (splitWidthRatio < 0.1f && split.getHeight() > h){ // 2006/09/12
// almost the same width, but the split is taller : we split it
// vertically
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split.getParent(), split,
newSplit);
newSplit.setTopComponent( (Component) dockableContainer);
newSplit.setBottomComponent(split);
SwingUtilities.invokeLater(new SplitResizer(newSplit, h / (float)split.getHeight()));
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, right, newSplit);
newSplit.setLeftComponent(right);
newSplit.setRightComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionRightW));
}
} else { // not anchored at all
// this part can be improved :
// - we know we're into an horizontal split
// - we can guess if the component was horizontaly splitted or vertically,
// and on which side of the split if was (bestComp)
float widthIfSplitH = bestComp.getWidth()/2;
float heightIfSplitH = bestComp.getHeight();
float widthIfSplitV = bestComp.getWidth();
float heightIfSplitV = bestComp.getHeight()/2;
// now which case keeps the best proportions ?
float whH = widthIfSplitH / heightIfSplitH;
float whV = widthIfSplitV / heightIfSplitV;
float whBefore = w / (float)h;
if (Math.abs(whBefore - whV) < Math.abs(whBefore - whH)){
// nearer of V
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestCenter.y < centerY) {
newSplit.setTopComponent(bestComp);
newSplit.setBottomComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, 1-proportionH));
} else {
newSplit.setBottomComponent(bestComp);
newSplit.setTopComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionH));
}
} else {
SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestCenter.x < centerX) {
newSplit.setLeftComponent(bestComp);
newSplit.setRightComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionRightW));
} else {
newSplit.setRightComponent(bestComp);
newSplit.setLeftComponent( (Component) dockableContainer);
SwingUtilities.invokeLater(new SplitResizer(newSplit, proportionLeftW));
}
}
}
}
} else { // 2004/04/01 (this part was missing) ------------------------------
// one component, but not a split container
// heuristics : try to find an anchor
boolean anchoredTop = y < 5;
boolean anchoredLeft = x < 5;
boolean anchoredBottom = Math.abs(y + h - relativeAncestorContainer.getHeight()) < 5;
boolean anchoredRight = Math.abs(x + w - relativeAncestorContainer.getWidth()) < 5;
Component singleComp = relativeAncestorContainer.getComponent(0);
float proportionW = w / (float) relativeAncestorContainer.getWidth();
if (proportionW >= 0.8f){ // not too big
proportionW = 0.8f;
}
float proportionH = h / (float) relativeAncestorContainer.getHeight();
if (proportionH >= 0.6f){ // not too big
proportionH = 0.6f;
}
if (anchoredTop){
if (anchoredLeft){
if (anchoredBottom){
hSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionW);
} else if (anchoredRight){ // top + left + right == TOP
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
} else { // top + left... what should we do ?
if (w > h){
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
} else {
hSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionW);
}
}
} else if (anchoredRight){ // top + right (not left)
if (anchoredBottom){ // top + right + bottom == on the right
hSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionW);
} else { // top + right
if (w > h){ // on top
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
} else { // on the right
hSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionW);
}
}
} else { // top only
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
}
} else if (anchoredLeft){ //left (but not top)
if (anchoredBottom){ // left + bot
if (anchoredRight){ // == bottom
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
} else { // left + bottom
if (w > h){ // bottom
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
} else { // on the left
hSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionW);
}
}
} else if (anchoredRight){ // left + right, but not top/bottom...
if (centerY < relativeAncestorContainer.getHeight()/2){ // center is upper part
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
} else { // lower part
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
}
} else { // left only
hSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionW);
}
} else if (anchoredBottom){ // bottom, but not top/left
if (anchoredRight){
if (w > h){ // bottom
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
} else { // on the right
hSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionW);
}
} else { // just bottom
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
}
} else if (anchoredRight){ // just right
hSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionW);
} else { // no anchors
if (centerY < relativeAncestorContainer.getHeight()/2){ // center is upper part
vSplitAndResize(singleComp, (Component) dockableContainer, singleComp, proportionH);
} else {
vSplitAndResize(singleComp, singleComp, (Component) dockableContainer, 1-proportionH);
}
}
} // 2004/04/01 (end of missing part) ------------------------------
}
return dockableContainer;
//DockingActionEvent action = getInsertionDockingAction(relativeAncestorContainer, dockable, position);
//return applyDockingAction(dockable, action);
}
/** returns a docking action event corresponding to the insertion point and method
* of the dockable.
*/
public static DockingActionEvent getInsertionDockingAction(Container relativeAncestorContainer,
Dockable dockable, DockableState dockableState, DockableState newState){
RelativeDockablePosition position = dockableState.getPosition();
DockingDesktop desktop = dockableState.getDesktop();
int initialState = dockableState.getState();
int nextState = newState.getState();
if (position == null){
// for safety
position = new RelativeDockablePosition(0,0.8,0.5,0.2);
}
SingleDockableContainer dockableContainer = null;
if (relativeAncestorContainer.getComponentCount() == 0){ // empty docking panel
return new DockingActionAddDockableEvent(desktop, dockable,
initialState, nextState, relativeAncestorContainer);
} else {
// convert relative positionning to current positionning (depending
// on the current size of dockingPanel)
int x = (int) (position.getX() * relativeAncestorContainer.getWidth());
int y = (int) (position.getY() * relativeAncestorContainer.getHeight());
int w = (int) (position.getWidth() * relativeAncestorContainer.getWidth());
int h = (int) (position.getHeight() * relativeAncestorContainer.getHeight());
int centerX = x + w / 2;
int centerY = y + h / 2;
SplitContainer split = findBestContainer(relativeAncestorContainer, position);
if (split != null){
// ok we've found one
Rectangle splitRect = SwingUtilities.convertRectangle(split,
new Rectangle(0, 0, split.getWidth(), split.getHeight()),
relativeAncestorContainer);
// heuristics : try to find an anchor, and which component(left/right)
// is nearer of center
boolean anchoredTop = Math.abs( y - splitRect.y) < 5;
boolean anchoredLeft = Math.abs(x - splitRect.x) < 5;
boolean anchoredBottom = Math.abs(y + h - splitRect.y - splitRect.height) < 30/*5*/;
boolean anchoredRight = Math.abs(x + w - splitRect.x - splitRect.width) < 5;
Component left = split.getLeftComponent();
Component right = split.getRightComponent();
Point leftCenter = SwingUtilities.convertPoint(left,
left.getWidth() / 2,
left.getHeight() / 2, relativeAncestorContainer);
Point rightCenter = SwingUtilities.convertPoint(right,
right.getWidth() / 2,
right.getHeight() / 2, relativeAncestorContainer);
int leftDist = (leftCenter.x - x) * (leftCenter.x - x)
+ (leftCenter.y - y) * (leftCenter.y);
int rightDist = (rightCenter.x - x) * (rightCenter.x - x)
+ (rightCenter.y - y) * (rightCenter.y);
Point bestCenter;
Component bestComp;
if (leftDist < rightDist) {
bestCenter = leftCenter;
bestComp = left;
} else {
bestCenter = rightCenter;
bestComp = right;
}
if (split.getOrientation() == JSplitPane.VERTICAL_SPLIT) {
Component top = split.getTopComponent();
Component bottom = split.getBottomComponent();
int topH = top.getHeight();
int bottomH = bottom.getHeight();
// proportions used when splitting a vertical split vertically
float proportionTopH = h / (float)topH;
float proportionBottomH = h / (float)bottomH;
if (proportionTopH >= 0.6f){ // not too big
proportionTopH = 0.6f;
}
if (proportionBottomH >= 0.6f){ // not too big
proportionBottomH = 0.6f;
}
// proportions used when splitting a vertical split horizontally
int splitW = split.getWidth();
float proportionW = w / (float) splitW;
if (proportionW >= 0.8f){ // not too big
proportionW = 0.8f;
}
if (anchoredTop) {
if (anchoredLeft) {
if (anchoredBottom) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, split, DockingConstants.SPLIT_LEFT, proportionW);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, top, DockingConstants.SPLIT_LEFT, proportionW);
}
} else if (anchoredRight) {
if (anchoredBottom) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, split, DockingConstants.SPLIT_RIGHT, 1-proportionW);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, top, DockingConstants.SPLIT_RIGHT, 1-proportionW);
}
} else {
// just anchored top
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, top, DockingConstants.SPLIT_TOP, proportionTopH);
}
} else if (anchoredBottom) { // but not anchoredTop
if (anchoredLeft) {
if (anchoredRight) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bottom, DockingConstants.SPLIT_BOTTOM, 1-proportionBottomH);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bottom, DockingConstants.SPLIT_LEFT, proportionW);
}
} else if (anchoredRight) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bottom, DockingConstants.SPLIT_RIGHT, 1-proportionW);
} else {
// just anchored bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bottom, DockingConstants.SPLIT_BOTTOM, 1-proportionBottomH);
}
} else if (anchoredLeft) { // not anchored on top / bottom
if (anchoredRight){ //2005/10/10
// left + right on a vertical split, means we have to insert a new component
// in between
int yTop = y;
int yBottom = split.getHeight() - y - h;
int splitTop = top.getHeight();
int splitBottom = bottom.getHeight();
/*SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);*/
if (bestComp == top){
float hParent =( split.getHeight() - yBottom)/(float) split.getHeight() ;
float hChild = yTop/(float) split.getHeight();
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_BOTTOM, hChild, hParent);
} else {
float hChild = h/(float) splitBottom;
float hParent = yTop/(float) split.getHeight();
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_TOP, hChild, hParent);
}
} else {// only left
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_LEFT, proportionW);
}
} else if (anchoredRight) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_RIGHT, 1-proportionW);
} else { // not anchored at all, split verticaly and add
SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);
if (bestCenter.y < centerY) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_BOTTOM, 1-proportionBottomH);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_TOP, proportionTopH);
}
}
} else {
// horizontal split
// proportions used when splitting a horizontal split horizontally
float proportionLeftW = w / (float)left.getWidth();
float proportionRightW = w / (float)right.getWidth();
if (proportionLeftW >= 0.8f){ // not too big
proportionLeftW = 0.8f;
}
if (proportionRightW >= 0.8f){ // not too big
proportionRightW = 0.8f;
}
// proportions used when splitting a horizontal split vertically
int splitH = split.getHeight();
float proportionH = h / (float) splitH;
if (proportionH >= 0.6f){ // not too big
proportionH = 0.6f;
}
if (anchoredTop) {
if (anchoredLeft) {
if (anchoredBottom) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, left, DockingConstants.SPLIT_LEFT, proportionLeftW);
} else if (anchoredRight){
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, split, DockingConstants.SPLIT_TOP, proportionH);
} else { // just anchored top/left
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, left, DockingConstants.SPLIT_TOP, proportionH);
}
} else if (anchoredRight) {
if (anchoredBottom) { // top + right + bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, right, DockingConstants.SPLIT_RIGHT, 1-proportionRightW);
} else { // top + right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, right, DockingConstants.SPLIT_TOP, proportionH);
}
} else if (anchoredBottom){ //2005/10/10
// top + bottom : create a horizontal split
// as we are inserting a vertical element into a horizontal split
// we have to adjust the width on both sides
int xLeft = x;
int xRight = split.getWidth() - x - w;
int splitLeft = left.getWidth();
int splitRight = right.getWidth();
/*SplitContainer newSplit = new SplitContainer(JSplitPane.
HORIZONTAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);*/
if (bestComp == left){
float parentW = (split.getWidth() - xRight)/(float) split.getWidth();
float childW = xLeft/(float) split.getWidth();
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_RIGHT, childW, parentW);
} else {
float parentW = xLeft/(float) split.getWidth();
float childW = w/(float) splitRight;
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_LEFT, childW, parentW);
}
} else {
// just anchored top
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_TOP, proportionH);
}
} else if (anchoredBottom) { // but not anchoredTop
if (anchoredLeft) {
if (anchoredRight) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, split, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else { // bottom + left
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, left, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
}
} else if (anchoredRight) { // bottom + right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, right, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
}
} else if (anchoredLeft) { // not anchored on top / bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, left, DockingConstants.SPLIT_LEFT, proportionLeftW);
} else if (anchoredRight) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, right, DockingConstants.SPLIT_RIGHT, 1-proportionRightW);
} else { // not anchored at all, split verticaly and add
/*SplitContainer newSplit = new SplitContainer(JSplitPane.
VERTICAL_SPLIT);
DockingUtilities.replaceChild(split, bestComp, newSplit);*/
if (bestCenter.y < centerY) {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, bestComp, DockingConstants.SPLIT_TOP, proportionH);
}
}
}
} else { // 2004/04/01 (this part was missing) ------------------------------
// one component, but not a split container
// heuristics : try to find an anchor
boolean anchoredTop = y < 5;
boolean anchoredLeft = x < 5;
boolean anchoredBottom = Math.abs(y + h - relativeAncestorContainer.getHeight()) < 5;
boolean anchoredRight = Math.abs(x + w - relativeAncestorContainer.getWidth()) < 5;
Component singleComp = relativeAncestorContainer.getComponent(0);
float proportionW = w / (float) relativeAncestorContainer.getWidth();
if (proportionW >= 0.8f){ // not too big
proportionW = 0.8f;
}
float proportionH = h / (float) relativeAncestorContainer.getHeight();
if (proportionH >= 0.6f){ // not too big
proportionH = 0.6f;
}
if (anchoredTop){
if (anchoredLeft){
if (anchoredBottom){
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_LEFT, proportionW);
} else if (anchoredRight){ // top + left + right == TOP
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
} else { // top + left... what should we do ?
if (w > h){ // vsplit
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
} else { // hsplit
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_LEFT, proportionW);
}
}
} else if (anchoredRight){ // top + right (not left)
if (anchoredBottom){ // top + right + bottom == on the right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_RIGHT, 1-proportionW);
} else { // top + right
if (w > h){ // on top
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
} else { // on the right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_RIGHT, 1-proportionW);
}
}
} else { // top only
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
}
} else if (anchoredLeft){ //left (but not top)
if (anchoredBottom){ // left + bot
if (anchoredRight){ // == bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else { // left + bottom
if (w > h){ // bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else { // on the left
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_LEFT, proportionW);
}
}
} else if (anchoredRight){ // left + right, but not top/bottom...
if (centerY < relativeAncestorContainer.getHeight()/2){ // center is upper part
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
} else { // lower part
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
}
} else { // left only
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_LEFT, proportionW);
}
} else if (anchoredBottom){ // bottom, but not top/left
if (anchoredRight){
if (w > h){ // bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
} else { // on the right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_RIGHT, 1-proportionW);
}
} else { // just bottom
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
}
} else if (anchoredRight){ // just right
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_RIGHT, 1-proportionW);
} else { // no anchors
if (centerY < relativeAncestorContainer.getHeight()/2){ // center is upper part
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_TOP, proportionH);
} else {
return new DockingActionSplitComponentEvent(desktop, dockable,
initialState, nextState, singleComp, DockingConstants.SPLIT_BOTTOM, 1-proportionH);
}
}
}
}
}
public static SingleDockableContainer applyDockingAction(Dockable dockable, DockingActionEvent action){
SingleDockableContainer dockableContainer;
switch (action.getActionType()){
case DockingActionEvent.ACTION_ADD_DOCKABLE:
DockingActionAddDockableEvent addAction = (DockingActionAddDockableEvent) action;
dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_DESKTOP);
Container relativeAncestorContainer = addAction.getParentContainer();
// default central insertion
relativeAncestorContainer.add((Component)dockableContainer, BorderLayout.CENTER);
relativeAncestorContainer.invalidate(); // 2005/05/04
relativeAncestorContainer.validate();
relativeAncestorContainer.repaint();
return dockableContainer;
case DockingActionEvent.ACTION_SPLIT_COMPONENT:
dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
DockingActionSplitComponentEvent splitAction = (DockingActionSplitComponentEvent) action;
Component base = splitAction.getBase();
float div = splitAction.getDividorLocation();
DockingConstants.Split splitPosition = splitAction.getSplitPosition();
float parentDiv = splitAction.getParentDividorLocation();
switch (splitPosition.value()){
case DockingConstants.INT_SPLIT_TOP:
vSplitAndResize(base, (Container) dockableContainer, base, div);
break;
case DockingConstants.INT_SPLIT_LEFT:
hSplitAndResize(base, (Container) dockableContainer, base, div);
break;
case DockingConstants.INT_SPLIT_BOTTOM:
vSplitAndResize(base, base, (Container) dockableContainer, div);
break;
case DockingConstants.INT_SPLIT_RIGHT:
hSplitAndResize(base, base, (Container) dockableContainer, div);
break;
}
if (parentDiv != -1 && base.getParent() instanceof SplitContainer){
SplitContainer parent = (SplitContainer) base.getParent();
new SplitResizer(parent, parentDiv);
}
return dockableContainer;
default:
throw new IllegalArgumentException("Action type not managed : "+ action.getActionType());
}
}
} vldocking_2.1.4/src/com/vlsolutions/swing/docking/ShadowBorder.java 0000644 0001750 0001750 00000015733 10573516350 025475 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.border.*;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.*;
import javax.swing.*;
/** A border using a shadow on right-bottom sides.
*
*
* Two types of border can be drawn : full shadow border and half shadow border.
*
* The components is usually displayed with decorations
* (a title bar, docking state management buttons, a drop shadow, ...).
*
* This interface is meant for API Extenders in order to provide new kinds of
* SingleDockableContainers (if the default implementation,
* The split container should be used only by the DockingDesktop.
*
* It is a SplitPane with bug workarounds and a custom UI (in fact : no UI painting at all,
* by default).
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class SplitContainer extends JSplitPane implements DockDropReceiver {
// this is for debugging purpose and will be removed.
private static Color [] colors = {Color.RED, Color.BLUE, Color.CYAN, Color.GREEN,
Color.MAGENTA, Color.ORANGE, Color.PINK, Color.WHITE, Color.YELLOW};
private static int colorindex = -1;
private static final boolean DEBUG = false;
private static final String uiClassID = "DockingSplitPaneUI";
/** Constructs a vertically splitted SplitContainer */
public SplitContainer() {
this(VERTICAL_SPLIT);
}
/** Constructs a SplitContainer with the given JSplitPane orientation. */
public SplitContainer(int orientation) {
super(orientation);
setBorder(null);
if (DEBUG){
Color c = colors[ (++colorindex % colors.length)];
setBorder(BorderFactory.createLineBorder(c, 2));
}
}
/** Overriden for custom UI delegation */
public String getUIClassID() {
return uiClassID;
}
/** Returns a readable String representing this SplitContainer */
public String toString() {
if (getOrientation() == HORIZONTAL_SPLIT){
return "SplitContainer[HORIZONTAL, " + getTopComponent() + " / " + getBottomComponent() +
']';
} else {
return "SplitContainer[VERTICAL, " + getTopComponent() + " / " + getBottomComponent() +
']';
}
}
/** Returns a suitable name for when this container is the main child of a Tab (TabbedDockableContainer) */
public String getTabName(){
Component left = getLeftComponent();
if (left instanceof SingleDockableContainer){
return ((SingleDockableContainer)left).getDockable().getDockKey().getTabName();
} else if (left instanceof SplitContainer){
return ((SplitContainer)left).getTabName();
} else {
return null;
}
}
/** {@inheritDoc} */
public void processDockableDrag(DockDragEvent event) {
scanContainer(event, false);
}
/** {@inheritDoc} */
public void processDockableDrop(DockDropEvent event) {
scanContainer(event, true);
}
private void scanContainer(DockEvent event, boolean drop) {
// reject operation if the source is an ancestor of this view.
if (event.getDragSource().getDockableContainer().isAncestorOf(this)){
// this is possible for compound containers (as they contain sub-dockables)
// in that case, you cannnot drop a compound into one of its children // 2007/01/08
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
return;
}
/* Dock is available :
* - on borders of the two components
* - on the center of the 2 components (meaning : tab'em)
*/
Point p = event.getMouseEvent().getPoint();
Rectangle compBounds = getLeftComponent().getBounds();
if (compBounds.contains(p)){
scanComponent(getLeftComponent(), event, drop, p, compBounds);
}else {
getRightComponent().getBounds(compBounds);
if (compBounds.contains(p)){
scanComponent(getRightComponent(), event, drop, p, compBounds);
} else {
// we are elsewhere : reject
if (drop) {
( (DockDropEvent) event).rejectDrop();
} else {
( (DockDragEvent) event).rejectDrag();
}
}
}
}
// workaround bug #4276222
private boolean isPainted;
private boolean hasProportionalLocation;
private double proportionalLocation;
/** Overriden for a bug workaround*/
public void setDividerLocation(double proportionalLocation){
if (! isPainted){
hasProportionalLocation = true;
this.proportionalLocation = proportionalLocation;
} else {
if (proportionalLocation < 0 ){ // safety checks to avoid exceptions
proportionalLocation = 0;
} else if (proportionalLocation > 1){
proportionalLocation = 1;
} else {
super.setDividerLocation(proportionalLocation);
}
}
}
public void setDividerLocation(int location) {
super.setDividerLocation(location);
if (!DockingPreferences.isLightWeightUsageEnabled()){
// ugly repaint trick due to incorrect repaint on linux/mac systems
final Window w = SwingUtilities.getWindowAncestor(this);
if (w != null){
SwingUtilities.invokeLater(new Runnable(){
public void run(){
w.repaint();
}
});
}
}
}
/** overriden for a bug workaround reason */
public void paint(Graphics g){
if (! isPainted){
isPainted = true;
if (hasProportionalLocation){
setDividerLocation(proportionalLocation);
doLayout();
}
}
super.paint(g);
}
/** Resest recursively the left and right components to their preferred size
* if possible. (same contract as JSplitPane's).
*
* If contained components are SplitContainers, their are also reset to their
* preferredSize.
* */
public void resetToPreferredSizes(){
super.resetToPreferredSizes();
if (getLeftComponent() instanceof SplitContainer){
((SplitContainer)getLeftComponent()).resetToPreferredSizes();
}
if (getRightComponent() instanceof SplitContainer){
((SplitContainer)getRightComponent()).resetToPreferredSizes();
}
}
/** Replaces the child component by a sub-split pane.
* @param child one or the two components of this split pane
* @param newComp the new component to add
* @param position where to put comp / child (i.e if SPLIT_TOP,
* a vertical splitpane will be created and comp will be on top of it
* (and child at bottom).
*/
public void split(Component newComp, Component child, DockingConstants.Split position){
SplitContainer split;
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_BOTTOM){
split = new SplitContainer(JSplitPane.VERTICAL_SPLIT);
} else /*if (position == DockingConstants.SPLIT_LEFT
|| position == DockingConstants.SPLIT_RIGHT)*/ {
split = new SplitContainer(JSplitPane.HORIZONTAL_SPLIT);
}
if (getLeftComponent() == child){
remove(child);
setLeftComponent(split);
if (position == DockingConstants.SPLIT_TOP || position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent(newComp); // for splitpane, left == top
split.setRightComponent(child);
} else {
split.setLeftComponent(child); // for splitpane, left == top
split.setRightComponent(newComp);
}
} else {
remove(child);
setRightComponent(split);
if (position == DockingConstants.SPLIT_TOP || position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent(newComp); // for splitpane, left == top
split.setRightComponent(child);
} else {
split.setLeftComponent(child); // for splitpane, left == top
split.setRightComponent(newComp);
}
}
}
private void scanComponent(Component comp, DockEvent event, boolean drop,
Point p, Rectangle compBounds) {
int distTop = p.y - compBounds.y;
int distLeft = p.x - compBounds.x;
int min = Math.min(distTop, distLeft);
int distRight = compBounds.x + compBounds.width - p.x;
int distBottom = compBounds.y + compBounds.height - p.y;
int min2 = Math.min(distBottom, distRight);
min = Math.min(min, min2);
Dockable dockable = event.getDragSource().getDockable();
int splitState = DockingUtilities.getDockableStateFromHierarchy(this);
int dockableState = dockable.getDockKey().getDockableState();
if (min == distTop) {
// dock on top
if (drop) {
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_TOP, 0.5f));
( (DockDropEvent) event).acceptDrop();
event.getDesktop().splitComponent(comp, event.getDragSource().getDockable(),
DockingConstants.SPLIT_TOP);
} else {
Rectangle2D r2d = new Rectangle2D.Float(compBounds.x,
compBounds.y,
compBounds.width,
20);
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_TOP, 0.5f));
( (DockDragEvent) event).acceptDrag(r2d);
}
} else if (min == distLeft) {
if (drop) {
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_LEFT, 0.5f));
( (DockDropEvent) event).acceptDrop();
event.getDesktop().splitComponent(comp, event.getDragSource().getDockable(),
DockingConstants.SPLIT_LEFT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(compBounds.x,
compBounds.y,
20,
compBounds.height);
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_LEFT, 0.5f));
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockable.getDockKey().getDockableState(), splitState,
comp, DockingConstants.SPLIT_TOP, 0.5f));
( (DockDragEvent) event).acceptDrag(r2d);
}
} else if (min == distBottom) {
if (drop) {
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_BOTTOM, 0.5f));
( (DockDropEvent) event).acceptDrop();
event.getDesktop().splitComponent(comp, event.getDragSource().getDockable(),
DockingConstants.SPLIT_BOTTOM);
} else {
Rectangle2D r2d = new Rectangle2D.Float(compBounds.x,
compBounds.y + compBounds.height - 20,
compBounds.width,
20);
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_BOTTOM, 0.5f));
( (DockDragEvent) event).acceptDrag(r2d);
}
} else { // right
if (drop) {
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_RIGHT, 0.5f));
( (DockDropEvent) event).acceptDrop();
event.getDesktop().splitComponent(comp, event.getDragSource().getDockable(),
DockingConstants.SPLIT_RIGHT);
} else {
Rectangle2D r2d = new Rectangle2D.Float(
compBounds.x + compBounds.width - 20,
compBounds.y,
20,
compBounds.height);
event.setDockingAction(new DockingActionSplitComponentEvent(event.getDesktop(),
dockable, dockableState, splitState, comp, DockingConstants.SPLIT_RIGHT, 0.5f));
( (DockDragEvent) event).acceptDrag(r2d);
}
}
}
}
/* Utility class, resizes a splitcontainer after its size is known (needs an invokelater after
* having added it).
* allows us to avoid the nasty resizing of a splitpane when a component
* is added on the right/bottom (it will then take most of the split surface,
* which is not good when we add a small dockable to the right of a big dockable
*/
class SplitResizer implements Runnable {
SplitContainer split;
int location;
double doubleloc;
boolean isDouble;
SplitResizer(SplitContainer split, int location) {
this.split = split;
this.location = location;
isDouble = false;
}
SplitResizer(SplitContainer split, double location) {
this.split = split;
this.doubleloc = location;
isDouble = true;
}
public void run() {
// used as invokeLater, as the size of the splitpane is not known
// when split is first inserted.
if (isDouble){
split.setDividerLocation(doubleloc);
} else {
// clamp resizing to the half width/height of the splitpane
int maxWidth = split.getWidth() / 2;
int maxHeight = split.getHeight() / 2;
if (location < 0) { //meaning it's a resize of the opposite component
if (split.getOrientation() == JSplitPane.HORIZONTAL_SPLIT) {
location = Math.max(maxWidth, split.getWidth() + location);
} else {
location = Math.max(maxHeight, split.getHeight() + location);
}
} else {
if (split.getOrientation() == JSplitPane.HORIZONTAL_SPLIT) {
location = Math.min(maxWidth, location);
} else {
location = Math.min(maxHeight, location);
}
}
split.setDividerLocation(location);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/TabFactory.java 0000644 0001750 0001750 00000002150 10573516344 025140 0 ustar twerner twerner package com.vlsolutions.swing.docking;
/** A factory that replaces DockViews (with title headers) by tabbed panes with a single tab.
*
* This factory provides a unified GUI for single AND tabbed components (with the exception of
* auto-hide and single-floating that still use the standard title bars).
*
* It is still in an early stage and will be improved in future releases, depending on its
* adoption.
*
* @author Lilian Chamontin, VLSolutions
* @since 2.1.3
*
*/
public class TabFactory extends DefaultDockableContainerFactory {
public SingleDockableContainer createDockableContainer(Dockable dockable, int parentType) {
switch (parentType){
case PARENT_TABBED_CONTAINER:
return new TabbedDockView(dockable);
case PARENT_DESKTOP:
return new MaximizedDockViewAsTab(dockable);//MaximizedDockView(dockable);
case PARENT_SPLIT_CONTAINER:
return new DockViewAsTab(dockable);
case PARENT_DETACHED_WINDOW:
return new DetachedDockView(dockable);
default :
throw new RuntimeException("Wrong dockable container type");
}
}
} vldocking_2.1.4/src/com/vlsolutions/swing/docking/TabbedContainerActions.java 0000644 0001750 0001750 00000025405 10573516350 027454 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.KeyStroke;
import javax.swing.UIManager;
/** An utility class providing default implementation of usefull actions for pop-up
* menus in tab container selectors.
*
*
* @author Lilian Chamontin, VLSolutions
*
*@update 2005/10/07 Lilian Chamontin : added the attach action for floating tabs
*/
public class TabbedContainerActions {
// label resources taken from BasicInternalFrameUI...
private static final String CLOSE_TEXT = UIManager.getString("DockTabbedPane.closeButtonText");
private static final String ICONIFY_TEXT = UIManager.getString("DockTabbedPane.minimizeButtonText");
private static final String RESTORE_TEXT = UIManager.getString("DockTabbedPane.restoreButtonText");
private static final String MAXIMIZE_TEXT = UIManager.getString("DockTabbedPane.maximizeButtonText");
private static final String FLOAT_TEXT = UIManager.getString("DockTabbedPane.floatButtonText");
private static final String ATTACH_TEXT = UIManager.getString("DockTabbedPane.attachButtonText");
private static final Icon CLOSE_ICON = UIManager.getIcon("DockTabbedPane.menu.close");
private static final Icon CLOSE_ALL_ICON = UIManager.getIcon("DockTabbedPane.closeAll");
private static final Icon CLOSE_OTHER_ICON = UIManager.getIcon("DockTabbedPane.closeAllOther");
private static final Icon ICONIFY_ICON = UIManager.getIcon("DockTabbedPane.menu.hide");
private static final Icon MAXIMIZE_ICON = UIManager.getIcon("DockTabbedPane.menu.maximize");
private static final Icon FLOAT_ICON = UIManager.getIcon("DockTabbedPane.menu.float");
private static final Icon ATTACH_ICON = UIManager.getIcon("DockTabbedPane.menu.attach");
private TabbedContainerActions() {
}
/** returns an action suitable for closing a dockable contained in a tab.
*
* Action properties : The icon is provided, and also the standard localized "close" message.
*/
public static Action createCloseAction(final Dockable dockable, final DockingDesktop desktop){
AbstractAction action = new AbstractAction(CLOSE_TEXT){
public void actionPerformed(ActionEvent e){
desktop.close(dockable);
}
};
action.putValue(AbstractAction.SMALL_ICON, CLOSE_ICON);
KeyStroke ks = (KeyStroke)UIManager.get("DockingDesktop.closeActionAccelerator");
if (ks != null){
action.putValue(AbstractAction.ACCELERATOR_KEY, ks);
}
return action;
}
/** returns an action suitable for closing every dockable contained in a tab.
*
* Action properties : The icon is provided, and also an unlocalized "Close all documents" message.
*/
public static Action createCloseAllAction(final Dockable base, final DockingDesktop desktop){
AbstractAction action = new AbstractAction("Close all documents"){
public void actionPerformed(ActionEvent e){
desktop.closeAllDockablesInTab(base);
}
};
action.putValue(AbstractAction.SMALL_ICON, CLOSE_ALL_ICON);
return action;
}
/** returns an action suitable for closing every dockable contained in a tab excepted the current one.
*
* Action properties : The icon is provided, and also an unlocalized "Close all other documents" message.
*/
public static Action createCloseAllOtherAction(final Dockable exception, final DockingDesktop desktop){
AbstractAction action = new AbstractAction("Close all other documents"){
public void actionPerformed(ActionEvent e){
desktop.closeAllOtherDockablesInTab(exception);
}
};
action.putValue(AbstractAction.SMALL_ICON, CLOSE_OTHER_ICON);
return action;
}
/** returns an action suitable for maximizing a dockable contained in a tab.
*
* Action properties : The icon is provided, and also a localized "Maximize" message.
*/
public static Action createMaximizeTabAction(final Dockable dockable, final DockingDesktop desktop){
AbstractAction action = new AbstractAction(MAXIMIZE_TEXT){
public void actionPerformed(ActionEvent e){
desktop.maximize(dockable);
}
};
action.putValue(AbstractAction.SMALL_ICON, MAXIMIZE_ICON);
KeyStroke ks = (KeyStroke)UIManager.get("DockingDesktop.maximizeActionAccelerator");
if (ks != null){
action.putValue(AbstractAction.ACCELERATOR_KEY, ks);
}
return action;
}
/** returns an action suitable for hiding a dockable contained in a tab.
*
* Action properties : The icon is provided, and also a localized "Iconify" message.
*/
public static Action createHideTabAction(final Dockable dockable, final DockingDesktop desktop){
AbstractAction action = new AbstractAction(ICONIFY_TEXT){
public void actionPerformed(ActionEvent e){
desktop.setAutoHide(dockable, true);
}
};
action.putValue(AbstractAction.SMALL_ICON, ICONIFY_ICON);
KeyStroke ks = (KeyStroke)UIManager.get("DockingDesktop.dockActionAccelerator");
if (ks != null){
action.putValue(AbstractAction.ACCELERATOR_KEY, ks);
}
return action;
}
/** returns an action suitable for floating (detach) a dockable contained in a tab.
*
* Action properties : The icon is provided, and a default "Detach" message.
*/
public static Action createFloatTabAction(final Dockable dockable, final DockingDesktop desktop){
AbstractAction action = new AbstractAction(FLOAT_TEXT){
public void actionPerformed(ActionEvent e){
desktop.setFloating(dockable, true);
}
};
action.putValue(AbstractAction.SMALL_ICON, FLOAT_ICON);
KeyStroke ks = (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator");
if (ks != null){
action.putValue(AbstractAction.ACCELERATOR_KEY, ks);
}
return action;
}
/** returns an action suitable for attaching a dockable contained in a floating tab.
*
* Action properties : The icon is provided, and a default "Attach" message.
* @since 2.0.1
*/
public static Action createAttachTabAction(final Dockable dockable, final DockingDesktop desktop){
AbstractAction action = new AbstractAction(ATTACH_TEXT){
public void actionPerformed(ActionEvent e){
desktop.setFloating(dockable, false);
}
};
action.putValue(AbstractAction.SMALL_ICON, ATTACH_ICON);
KeyStroke ks = (KeyStroke)UIManager.get("DockingDesktop.floatActionAccelerator");
if (ks != null){
action.putValue(AbstractAction.ACCELERATOR_KEY, ks);
}
return action;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/TabbedDockView.java 0000644 0001750 0001750 00000013640 10573516350 025722 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import com.vlsolutions.swing.docking.event.DockDragEvent;
import com.vlsolutions.swing.docking.event.DockDropEvent;
import com.vlsolutions.swing.docking.event.DockEvent;
import java.awt.Component;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
/** A DockView that can be nested into a TabbedDockableContainer
*
* @author Lilian Chamontin, VLSolutions
*/
public class TabbedDockView extends DockView {
public TabbedDockView(Dockable dockable) {
super(dockable, false);
}
protected void scanDrop(DockEvent event, boolean drop){
int state = dockable.getDockKey().getDockableState();
if (state == DockableState.STATE_DOCKED) {
super.scanDrop(event, drop);
} else if (state == DockableState.STATE_FLOATING){
// don't allow drop for floating tabs : only when child of a compound dockable
if (DockingUtilities.isChildOfCompoundDockable(dockable)){
super.scanDrop(event, drop);
} else {
if (drop){
((DockDropEvent) event).rejectDrop();
} else {
((DockDragEvent) event).delegateDrag();
}
}
}
}
public void setVisible(boolean visible){
super.setVisible(visible);
if (visible){
if (UIManager.getBoolean("TabbedContainer.requestFocusOnTabSelection")){
// this is a workaround to get focus on a tab when it's selected
// obviously, this relies in the fact that the parent of this dockView is
// the tab container.
SwingUtilities.invokeLater(new Runnable(){
public void run(){
if (getDockable() != null){
Component comp = getDockable().getComponent();
if (comp != null){
comp.requestFocus();
}
}
}
});
}
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/TabbedDockableContainer.java 0000644 0001750 0001750 00000012613 10573516350 027555 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
/** Interface describing a container that can be used to display more than
* one Dockable in a Tabbed Pane fashion.
*
* This interface is meant for API Extenders in order to provide new kinds of
* TabbedDockableContainers (the default implementation is This javadoc directory represents the API documentation of the VL Docking Framework.
Original javadoc website is www.vlsolutions.com
For those who would like to extend the API, please read this javadoc and don't hesitate to
contact vlsolutions by email at
support@vlsolutions.com for explanations.
vldocking_2.1.4/src/com/vlsolutions/swing/docking/package.html 0000644 0001750 0001750 00000017756 10573516344 024542 0 ustar twerner twerner
This javadoc is targetted to :
You will find in this documentation references of those targets, indicating you if
you have to read such document or not, depending on your goals
(developping a "User Application" or extending the API).
The VL Docking Framework is a set of Swing Components that is used to enhance any
Swing Application by providing Docking capabilities to user components : A user component can be any Swing JComponent (usualy a JPanel or a JScrollPane). Docking functions are built upon the following classes :
There is usually only one DockingDesktop associated to a Window.
For developpers used to The desktop is composed of :
The central zone contains a If you already have a working application (without docking) and want to use
the docking framework, take your GUI major components, have them implement
the Dockable interface (only 2 methods) and you will be able to add them to
the docking desktop.
Alternatively, you can use DockablePanel which is a JPanel container
implementing Dockable.
A DockKey is used in 3 situations :
So keep in mind that each dockable must have a unique DockKey (it's a kind of
primary key) and that the key, as a javabean, is used to decorate the
dockable container.
Listeners : most DockKey properties are bound, and changing their value will have
an immediate effect on the DockingDesktop : for example, you can change the icon
property of a key and it will be propagated to the DockableContainer's title bar of
its dockable.
But of course, there's more in the docking framework than this.
For example you can also :
The subset of classes of this package needed to understand and use the Docking Framework is
limited to the following classes :
This API has been developed with extension in mind.
To Fully understand its principles, you will have to browse the entire javadoc and
read the API extension tutorial on www.vlsolutions.com.
vldocking_2.1.4/src/com/vlsolutions/swing/docking/restore16.gif 0000644 0001750 0001750 00000001532 10573516344 024563 0 ustar twerner twerner GIF89a ! , 7 H :< ąVǁ5flh1D)6Ȳe ; vldocking_2.1.4/src/com/vlsolutions/swing/docking/restore16pressed.gif 0000644 0001750 0001750 00000001576 10573516344 026161 0 ustar twerner twerner GIF89a BBB΄B! , [ H@ Dx@ B #B 4r8pdH O8q#K
cʜRK&EPȄ 3xbˉD)p ; vldocking_2.1.4/src/com/vlsolutions/swing/docking/restore16rollover.gif 0000644 0001750 0001750 00000001562 10573516344 026353 0 ustar twerner twerner GIF89a BBBB! , O H@ DxP@Bp8pņ
qcB bI
S\ycK '8RG-rØ7\I0 ; vldocking_2.1.4/src/com/vlsolutions/swing/docking/restore16v2.png 0000644 0001750 0001750 00000000503 10573516344 025047 0 ustar twerner twerner PNG
IHDR a bKGD pHYs tIME %s~ IDATxS;0 }YrkBre ٺ2 CP:m?O~fnAc,b0\ھ "ReE]M,"?McEށDyTOWVb3P pYL˒E
d<֧ιF۰?nOrsEJ&ny">a< ݀Xv& IENDB` vldocking_2.1.4/src/com/vlsolutions/swing/docking/restore16v2pressed.png 0000644 0001750 0001750 00000000531 10573516344 026436 0 ustar twerner twerner PNG
IHDR a bKGD pHYs tIME nm IDATxڥS
ExZضmw7w #~f4ބ ! If the icon is shared between containers, please provide at least one as
* this allows the icon to properly estimate its dimension.
*/
public void setIconForTabbedPane(JTabbedPane container){
this.container = container;
}
/** paints the icon (and the associated label and sub-icons) */
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g;
Object renderingValue = null;
if (this.antialiased){
renderingValue = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
if (icon != null){
icon.paintIcon(c, g, x, y);
}
Font f = UIManager.getFont("JTabbedPaneSmartIcon.font"); // 2006/01/23
if (f != null){
g.setFont(f);
}
// reevaluate the width with correct graphics object, in case something has changed
FontMetrics fm = g.getFontMetrics();
int iconsOffset = otherIconsOffset;
if (icon != null){
g.drawString(label, x+icon.getIconWidth() + textIconGap, y + height - fm.getDescent());
} else {
g.drawString(label, x, y + height - fm.getDescent());
}
if (otherIcons != null){ //2005/11/01
for (int i=0; i < otherIcons.length; i++){
otherIcons[i].paintIcon(c, g, x + iconsOffset, y + height / 2 - otherIcons[i].getIconHeight()/2);
iconsOffset += otherIcons[i].getIconWidth();
if (i < otherIcons.length-1){
iconsOffset+= inBetweenOtherIconsGap;
}
}
}
if (antialiased){
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, renderingValue);
}
}
private SmartIconJButton findButtonAt(Point p){
int start = otherIconsOffset;
if (otherIcons != null){ //2005/11/01
for (int i=0; i < otherIcons.length; i++){
SmartIconJButton btn = otherIcons[i];
if (p.x >= start && p.x < start + btn.getIconWidth()){
if (p.y >= height/2 - btn.getIconHeight() /2
&& p.y < height/2 + btn.getIconHeight() /2){
return btn;
} else {
return null;
}
}
start += btn.getIconWidth(); // bug corrected thanks to Emmanuel GAUVRIT 2005/11/08
if (i < otherIcons.length-1){
start += inBetweenOtherIconsGap;
}
}
}
return null;
}
/** Returns the width of this icon */
public int getIconWidth() {
if (width == -1){
if (container == null){
throw new NullPointerException("container for this smart icon not specified with setIconForTabbedPane()");
}
// reevaluate the width with correct graphics object, in case something has changed
//Font f = UIManager.getFont("DockTabbedPane.font"); // 2006/01/23
Font f = UIManager.getFont("JTabbedPaneSmartIcon.font"); // 2006/01/23
FontMetrics fm = container.getFontMetrics(f);
this.width = 0;
if (icon != null){
width = icon.getIconWidth();
}
width += textIconGap + fm.stringWidth(label) + otherIconsGap;
this.otherIconsOffset = width;
int iconsOffset = otherIconsOffset;
if (otherIcons != null){
for (int i=0; i < otherIcons.length; i++){
width += otherIcons[i].getIconWidth(); // additional width for icons
if (i < otherIcons.length-1){
width += inBetweenOtherIconsGap;
}
}
}
}
return width;
}
/** Returns the height of this icon */
public int getIconHeight() {
if (height == -1){
if (icon != null){
height = icon.getIconHeight();
} else {
height = 16; // standard height (as if there was an icon) : should be calculated instead of fixed
}
}
return height;
}
/** Process the mouse pressed event.
*
* Mouse coordinates are given relative to this icon
*/
public boolean onMousePressed(MouseEvent e){
// find the icon under the point
SmartIconJButton btn = findButtonAt(e.getPoint());
if (btn != null && btn.isEnabled()){
btn.setPressed(true);
pressedButton = btn;
return true;
}
return false;
}
/** Process the mouse released event.
*
* Mouse coordinates are given relative to this icon
*/
public boolean onMouseReleased(final MouseEvent e){
if (pressedButton != null && pressedButton.isEnabled()){
pressedButton.setPressed(false);
final SmartIconJButton btn = findButtonAt(e.getPoint());
if (btn == pressedButton){
btn.fireAction(new ActionEvent(e.getSource(),
ActionEvent.ACTION_PERFORMED, "" ));
return true;
}
}
return false;
}
/** Process the mouse exited event.
*
* Mouse coordinates are given relative to this icon
*/
public boolean onMouseExited(MouseEvent e){
// reset all rollover states
if (rolloverButton != null){
rolloverButton.setRollover(false);
rolloverButton = null;
localTooltipText = tooltipText;
return true;
}
rolloverButton = null;
return false;
}
/** Process the mouse moved event.
*
* Mouse coordinates are given relative to this icon
*/
public boolean onMouseMoved(MouseEvent e){
// check for a rollover effect
SmartIconJButton btn = findButtonAt(e.getPoint());
boolean shouldRepaint = false;
if (btn != null){
String tip = btn.getTooltipText();
if (tip != null){
if (!tip.equals(localTooltipText)){
this.localTooltipText = tip;
shouldRepaint = true;
}
} else if (localTooltipText != tooltipText){
this.localTooltipText = tooltipText;
shouldRepaint = true;
}
if (btn == rolloverButton){
// still on the same button
} else {
// another button
if (rolloverButton != null){
rolloverButton.setRollover(false);
}
rolloverButton = btn;
rolloverButton.setRollover(true);
shouldRepaint = true;
}
} else if (rolloverButton != null){
rolloverButton.setRollover(false);
rolloverButton = null;
localTooltipText = tooltipText;
shouldRepaint = true;
}
return shouldRepaint;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/tabbedpane/JTabbedPaneSmartIconManager.java 0000644 0001750 0001750 00000037461 10573516350 030775 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.tabbedpane;
import java.awt.Component;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.Icon;
import javax.swing.JTabbedPane;
import javax.swing.SwingUtilities;
/** This class is the interface between a JTabbedPane and a smart icon.
*
* As JTabbedPanes cannot use any JComponents as tab selectors (the access if protected and we just have
* a label, an icon and a tooltip), we have to rely on tricks to bypass them.
*
* This class is used (with a mouse listener) to forward events into the smart icon. which is responsible
* for faking an enhanced tab selector (including label and optional buttons).
*
*
* @author Lilian Chamontin, VLSolutions
*/
public class JTabbedPaneSmartIconManager implements MouseListener, MouseMotionListener {
private JTabbedPane tabbedPane;
private JTabbedPaneSmartIcon pressedIcon;
private int pressedTab; // the tab associated to the pressed icon
private JTabbedPaneSmartIcon movedIcon;
private int movedTab;
/** Constructs a new tabbedPane manager for a given JTabbedPane */
public JTabbedPaneSmartIconManager(JTabbedPane tabbedPane) {
this.tabbedPane = tabbedPane;
tabbedPane.addMouseListener(this);
tabbedPane.addMouseMotionListener(this);
}
/** MouseListener implementation, use to track mouse behaviour inside the tab selector bounds
* and forward them to the appropriate smart icon.
*/
public void mouseReleased(MouseEvent e) {
checkTabCount();
// forward the event to the pressed smart icon
if (pressedIcon != null){
Point p = e.getPoint();
final Rectangle r = tabbedPane.getBoundsAt(pressedTab);
Point iPoint = convertPointToIcon(r, p, pressedIcon);
final MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), e.getID(), e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
try {
if (pressedIcon.onMouseReleased(eSmart)){
tabbedPane.repaint(r.x, r.y, r.width, r.height); // no choice but trigger a repaint
}
} catch (Exception ignore){ // bug database : 5075526 this is to remove the stack trace
}
pressedIcon = null;
}
}
private Point convertPointToIcon(Rectangle r, Point p, Icon icon){
int x = p.x - (r.x + r.width/2 - icon.getIconWidth()/2) ;
int y = p.y - (r.y + r.height/2 - icon.getIconHeight()/2);
return new Point(x, y);
}
/** MouseListener implementation, use to track mouse behaviour inside the tab selector bounds
* and forward them to the appropriate smart icon.
*/
public void mousePressed(MouseEvent e) {
// where is the mouse pressed ?
Point p = e.getPoint();
this.pressedIcon = null; // reset the pressed state
int targetTab = findTabAt(p);
if (targetTab != -1){
Icon icon = tabbedPane.getIconAt(targetTab);
if (icon instanceof JTabbedPaneSmartIcon){
JTabbedPaneSmartIcon smartIcon = (JTabbedPaneSmartIcon) icon;
// convert point into smartIcon coordinates
// get the tab bounds
Rectangle r = tabbedPane.getBoundsAt(targetTab);
// as the icon is the only thing visible, we consider it centered in the tab
// (which is the default paint behaviour of BasicTabbedPaneUI, and should be okay
// with most look and feels.
int x = p.x - (r.x + r.width/2 - icon.getIconWidth()/2) ;
int y = p.y - (r.y + r.height/2 - icon.getIconHeight()/2);
if (x >=0 && y >= 0 && x < icon.getIconWidth() && y < icon.getIconHeight()){
// forward the event to the smart icon
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), e.getID(), e.getWhen(), e.getModifiers(),
x, y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (smartIcon.onMousePressed(eSmart)){
tabbedPane.repaint(r.x, r.y, r.width, r.height); // no choice but trigger a repaint
}
pressedIcon = smartIcon;
pressedTab = targetTab;
}
}
}
}
/** verify if the tab count hasn't changed.
*
* There is always the risk that the last tab has been removed (and movedTab will be
* out of bounds)
*
*/
private void checkTabCount(){
if (movedTab >= tabbedPane.getTabCount()){ // too late : tab has been removed
movedTab = -1;
movedIcon = null;
}
if (pressedTab >= tabbedPane.getTabCount()){
pressedTab = -1;
pressedIcon = null;
}
}
private int findTabAt(Point p){
int x= p.x;
int y = p.y;
for (int i=0; i < tabbedPane.getTabCount(); i++){
if (tabbedPane.getBoundsAt(i).contains(x, y)){
return i;
}
}
return -1;
}
/** MouseListener implementation, use to track mouse behaviour inside the tab selector bounds
* and forward them to the appropriate smart icon.
*/
public void mouseMoved(MouseEvent e) {
checkTabCount();
// where is the mouse moved ?
Point p = e.getPoint();
int targetTab = findTabAt(p);
if (targetTab != -1){
Icon icon = tabbedPane.getIconAt(targetTab);
if (icon instanceof JTabbedPaneSmartIcon){
JTabbedPaneSmartIcon smartIcon = (JTabbedPaneSmartIcon) icon;
if (movedIcon != null && movedIcon != smartIcon){
// trigger a mouseExit from the movedIcon
Rectangle prevRect = tabbedPane.getBoundsAt(movedTab);
Point iPoint = convertPointToIcon(prevRect, p, movedIcon);
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (movedIcon.onMouseExited(eSmart)){
String tip = movedIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(targetTab))){
tabbedPane.setToolTipTextAt(targetTab, tip);
}
// tabbedPane.repaint(prevRect.x, prevRect.y, prevRect.width, prevRect.height);
tabbedPane.revalidate();
tabbedPane.repaint();
}
movedIcon = null;
movedTab = -1;
}
// convert point into smartIcon coordinates
// get the tab bounds
Rectangle r = tabbedPane.getBoundsAt(targetTab);
Point iPoint = convertPointToIcon(r, p, icon);
if (iPoint.x >=0 && iPoint.y >= 0
&& iPoint.x < icon.getIconWidth()
&& iPoint.y < icon.getIconHeight()){
// forward the event to the smart icon
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), e.getID(), e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (smartIcon.onMouseMoved(eSmart)){
String tip = smartIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(targetTab))){
tabbedPane.setToolTipTextAt(targetTab, tip);
}
tabbedPane.revalidate();
tabbedPane.repaint();
// tabbedPane.repaint(r.x, r.y, r.width, r.height);
}
movedIcon = smartIcon;
movedTab = targetTab;
} else { // in tab, but not on icon
if (movedIcon != null){
// trigger a mouseExit from the movedIcon
Rectangle prevRect = tabbedPane.getBoundsAt(movedTab);
iPoint = convertPointToIcon(prevRect, p, movedIcon);
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (movedIcon.onMouseExited(eSmart)){
String tip = movedIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(targetTab))){
tabbedPane.setToolTipTextAt(targetTab, tip);
}
tabbedPane.revalidate();
tabbedPane.repaint();
// tabbedPane.repaint(prevRect.x, prevRect.y, prevRect.width, prevRect.height);
}
}
movedIcon = null;
movedTab = -1;
}
} else { // not a smart icon ?
if (movedIcon != null){
// trigger a mouseExit from the movedIcon
Rectangle prevRect = tabbedPane.getBoundsAt(movedTab);
Point iPoint = convertPointToIcon(prevRect, p, movedIcon);
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (movedIcon.onMouseExited(eSmart)){
String tip = movedIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(targetTab))){
tabbedPane.setToolTipTextAt(targetTab, tip);
}
tabbedPane.revalidate();
tabbedPane.repaint();
// tabbedPane.repaint(prevRect.x, prevRect.y, prevRect.width, prevRect.height);
}
movedIcon = null;
movedTab = -1;
}
}
} else { // not on a tab
if (movedIcon != null){
// trigger a mouseExit from the movedIcon
Rectangle prevRect = tabbedPane.getBoundsAt(movedTab);
Point iPoint = convertPointToIcon(prevRect, p, movedIcon);
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (movedIcon.onMouseExited(eSmart)){
String tip = movedIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(movedTab))){
tabbedPane.setToolTipTextAt(movedTab, tip);
}
tabbedPane.revalidate();
tabbedPane.repaint();
// tabbedPane.repaint(prevRect.x, prevRect.y, prevRect.width, prevRect.height);
}
movedIcon = null;
movedTab = -1;
}
}
}
/** MouseListener implementation, use to track mouse behaviour inside the tab selector bounds
* and forward them to the appropriate smart icon.
*/
public void mouseExited(MouseEvent e) {
checkTabCount();
if (movedIcon != null){
Point p = e.getPoint();
// trigger a mouseExit from the movedIcon
Rectangle prevRect = tabbedPane.getBoundsAt(movedTab);
Point iPoint = convertPointToIcon(prevRect, p, movedIcon);
MouseEvent eSmart = new MouseEvent(
(Component) e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(), e.getModifiers(),
iPoint.x, iPoint.y, e.getClickCount(), e.isPopupTrigger(), e.getButton());
if (movedIcon.onMouseExited(eSmart)){
String tip = movedIcon.getLocalTooltipText();
if (tip != null && ! tip.equals(tabbedPane.getToolTipTextAt(movedTab))){
tabbedPane.setToolTipTextAt(movedTab, tip);
}
tabbedPane.repaint(prevRect.x, prevRect.y, prevRect.width, prevRect.height);
}
movedIcon = null;
movedTab = -1;
}
}
/** MouseListener implementation, not used.
*/
public void mouseEntered(MouseEvent e) {
}
/** MouseMotionListener implementation, not used.
*/
public void mouseDragged(MouseEvent e) {
}
/** MouseListener implementation, not used.
*/
public void mouseClicked(MouseEvent e) {
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/tabbedpane/SmartIconJButton.java 0000644 0001750 0001750 00000025363 10573516350 026766 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.tabbedpane;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.GrayFilter;
import javax.swing.Icon;
import javax.swing.ImageIcon;
/** A sub component of JTabbedPaneSmartIcon, used to describe a button included in a tabbedpane.
*
* As JTabbedPanes cannot use any JComponents as tab selectors (the access if protected and we just have
* a label, an icon and a tooltip), we have to rely on tricks to bypass them.
*
* This trick, the SmartIconJButton is an icon faking the behaviour of a button. It uses an Action
* for reacting to clicks and manages a set of images (default, rollover, pressed, disabled) to
* behave like a rollover button.
*
* @author Lilian Chamontin, VLSolutions
*/
public class SmartIconJButton implements Icon, PropertyChangeListener {
/** The action triggered when the clicks on the icon */
protected Action action;
/** the default icon (enabled/visible)*/
protected Icon defaultIcon;
/** the icon for the rollover effect*/
protected Icon rolloverIcon;
/** the icno for the pressed effect */
protected Icon pressedIcon;
/** the icon for the disabled effect */
protected Icon disabledIcon;
/** the tooltip associated with the button */
protected String tooltipText;
/* internal state variables*/
private boolean isRollover, isPressed, isEnabled, isVisible;
/** Constructs a new button with an action.
*
* The button is enabled and visible.
*/
public SmartIconJButton(Action action) {
this.action = action;
defaultIcon = (Icon) action.getValue(AbstractAction.SMALL_ICON);
tooltipText = (String) action.getValue(AbstractAction.SHORT_DESCRIPTION);
isVisible = true;
isEnabled = action.isEnabled();
action.addPropertyChangeListener(this);
}
/** Update the default icon property */
public void setIcon(Icon icon){
this.defaultIcon = icon;
}
/** Returns the default icon */
public Icon getIcon(){
return defaultIcon;
}
/** Update the rollover icon property */
public void setRolloverIcon(Icon icon){
this.rolloverIcon = icon;
}
/** Returns the rollover icon */
public Icon getRolloverIcon(){
return rolloverIcon;
}
/** Update the pressed icon property */
public void setPressedIcon(Icon icon){
this.pressedIcon = icon;
}
/** Returns the pressed icon */
public Icon getPressedIcon(){
return pressedIcon;
}
/** Update the disabled icon property */
public void setDisabledIcon(Icon icon){
this.disabledIcon = icon;
}
/** Returns the disabled icon */
public Icon getDisabledIcon(){
return disabledIcon;
}
/** Update the rollover state */
public void setRollover(boolean isRollover){
this.isRollover = isRollover;
}
/** Update the enabled state */
public void setEnabled(boolean isEnabled){
this.isEnabled = isEnabled;
}
/** Update the visible state */
public void setVisible(boolean isVisible){
this.isVisible = isVisible;
}
/** Update the pressed state */
public void setPressed(boolean isPressed){
this.isPressed = isPressed;
}
/** Returns the rollover state*/
public boolean isRollover(){
return isRollover;
}
/** Returns the pressed state*/
public boolean isPressed(){
return isPressed;
}
/** Returns the enabled state*/
public boolean isEnabled(){
return isEnabled;
}
/** Returns the visible state*/
public boolean isVisible(){
return isVisible;
}
/** paints the appropriate icon according to its internal state (pressed, rollover...)
*/
public void paintIcon(java.awt.Component c, java.awt.Graphics g, int x, int y) {
if (! isVisible){
return;
} else if (isEnabled){
if (isPressed){
if (pressedIcon != null){
pressedIcon.paintIcon(c, g, x, y);
} else {
defaultIcon.paintIcon(c, g, x+1, y+1);
}
} else if (isRollover){
if (rolloverIcon != null){
rolloverIcon.paintIcon(c, g, x, y);
} else {
defaultIcon.paintIcon(c, g, x-1, y-1); // "push" effect
}
} else { // just the default
if (defaultIcon != null){
defaultIcon.paintIcon(c, g, x, y);
}
}
} else { // disabled
if (disabledIcon == null){
disabledIcon = createDisabledIcon();
}
disabledIcon.paintIcon(c,g, x, y);
}
}
private Icon createDisabledIcon(){
if (defaultIcon instanceof ImageIcon){
Image i = GrayFilter.createDisabledImage (((ImageIcon)defaultIcon).getImage());
return new ImageIcon(i);
} else {
BufferedImage bi = new BufferedImage(defaultIcon.getIconWidth(), defaultIcon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics g = bi.createGraphics();
g.setColor(new Color(0,0,0,0));
g.fillRect(0,0, defaultIcon.getIconWidth(), defaultIcon.getIconHeight());
defaultIcon.paintIcon(null, g, 0,0);
g.dispose();
Image i = GrayFilter.createDisabledImage(bi);
return new ImageIcon(i);
}
}
public int getIconWidth() {
int w = 0;
if (defaultIcon != null){
w = Math.max(w, defaultIcon.getIconWidth());
}
if (rolloverIcon != null){
w = Math.max(w, rolloverIcon.getIconWidth());
}
if (pressedIcon != null){
w = Math.max(w, pressedIcon.getIconWidth());
}
return w;
}
public int getIconHeight() {
int h = 0;
if (defaultIcon != null){
h = Math.max(h, defaultIcon.getIconHeight());
}
if (rolloverIcon != null){
h = Math.max(h, rolloverIcon.getIconHeight());
}
if (pressedIcon != null){
h = Math.max(h, pressedIcon.getIconHeight());
}
return h;
}
/** triggers the associated action */
public void fireAction(ActionEvent e){
action.actionPerformed(e);
}
public String getTooltipText(){
return tooltipText;
}
public void setTooltipText(String tooltip){
this.tooltipText = tooltip;
}
/** Do not call directly as it a side effect of listening to the action changes.
*/
public void propertyChange(PropertyChangeEvent evt) {
// track changes in the Action
String prop = evt.getPropertyName();
if (prop.equals(AbstractAction.SHORT_DESCRIPTION)){
setTooltipText((String)evt.getNewValue());
} else if (prop.equals(AbstractAction.SMALL_ICON)){
setIcon((Icon) evt.getNewValue());
} else if (prop.equals("enabled")){
setEnabled(((Boolean)evt.getNewValue()).booleanValue());
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/tabbedpane/package.html 0000644 0001750 0001750 00000000715 10573516344 025174 0 ustar twerner twerner
This package contains classes allowing to embed buttons into the tabs of a jtabbedpane.
Although it supports any number of tabs, the current implementation for the docking framework
only uses one : a close rollover button located on the right of the tab's label.
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ 0000755 0001750 0001750 00000000000 10573516350 022445 5 ustar twerner twerner vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/doc-files/ 0000755 0001750 0001750 00000000000 10573516344 024315 5 ustar twerner twerner vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/doc-files/overview.gif 0000644 0001750 0001750 00000011240 10573516344 026650 0 ustar twerner twerner GIF89a, !!))1 11BBBJ!JJRRZ)c1cckBkksJss{RcƄkƌsΔ֥֭ Ƶ!!))11BBJJRRcckk焄猌甔便ﭭﵵ! P , , H*\ȰÇ#JHŋ3jȱǏ C Iɓ(S\ɲ˗0cʜI͛8sɳϟ@
JѣH*]ʴӧPJJիX"$ׯ`Ê KٳhӪ]˶۷pʝKEZݛE) LÈ+^̸ǐ#KL˘3S"`CWM.P ^ͺװc˞M6 s뎍{oآLsjL eIF*sSVnTӸ_>9w=WŐCr iQ0G;t e''mWG$` G0 bWzT@
PA =pp"@ ( mD L7T;@
.HC) q > )q
>D8 ux@}%@G9HZREDEf@5М 9Еe(P'& B 0n/ ET<` iHqN%(E B )
ڪ Ci)
F`5p@G 6@%(BcdB mn_ &qY/ h ѫ+ RR j
FBM G`) C~"1Ă qP4I0 vKhD2{\G"B@` k/' @e:%h PH LD~䤏4FPe
CAeQ&
zWaiQ d+P @iH
LAk5IC%> ;uYl˾ۨCB
vKpgxCG@T}tZ NPWւC@^حI1i52n?pT2@B!+ Ҽ@n]zWU/ d hT M|I1
(ֱ00ؚ`q~
SB. U
! B"
rPrLrI{XD5U"| 9B¦̪ZȮz
FZձT@
9ZC 31ka$ySDp *Td"H !ZɌ5CRI
*Wްr7N#
XX1eC^2%d`4CbL2fJf84y̦6nz 8IrL:vt5
PRGzNgG9JI(GK"DQF*LB?F(JD
)N@Ţ"MMHjx*iK` v2Ip
.r:
jHMnBMQ?bҭTP *S[zӨZU$HQ5իz!]mV3֯ e(UzֶZ$
iAլvuX1^kA%aX$B},4RZֱSE${٘r|jg/ٵ.uBi5Ԣv5k;
Uvllي[ֶak
ׯ-jpRv=s
~u5u[VwVŮX ^v-W[Q7U{߫U
}O:%e_
x*-\XmN XK8 /| +v ~ tēݬ Fxn1u_ 8?Q 7 / }D(A&Y/K.{e OyU jy˷K143ќ.l^gjΙuƲk
* This icon uses a gray version of the provided image and paints it under the original one.
*
* @author Lilian Chamontin, VLSolutions
*/
public class RolloverIcon implements Icon{
private int shadowWidth = 1;
private int shadowHeight = 1;
private Icon icon, shadowIcon;
public RolloverIcon(Icon icon){
this.icon = icon;
shadowIcon = new ImageIcon(GrayFilter.createDisabledImage(((ImageIcon)icon).getImage()));
}
public int getIconHeight(){
return icon.getIconWidth();
}
public int getIconWidth(){
return icon.getIconHeight();
}
public void paintIcon(Component c, Graphics g, int x, int y){
Color highlight = UIManager.getColor("controlLtHighlight");
Color shadow = UIManager.getColor("controlShadow");
g.setColor(highlight);
g.fillRect(x, y, getIconWidth(), getIconHeight());
shadowIcon.paintIcon(c, g, x + shadowWidth-1, y + shadowHeight-1);
icon.paintIcon(c, g, x-1, y-1);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/RoundedBorder.java 0000644 0001750 0001750 00000011726 10573516350 026055 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** A simple rounded border.
*
* Can be used anywhere a rounded border is needed (no specific purpose).
*
* @author Lilian Chamontin, VLSolutions
*/
public class RoundedBorder implements Border {
private Insets insets = new Insets(2,2,2,2);
private Color shadow = UIManager.getColor("controlShadow");
public RoundedBorder() {
}
public boolean isBorderOpaque() {
return false;
}
public void paintBorder(Component component, Graphics graphics, int x,
int y, int w, int h) {
graphics.setColor(shadow);
graphics.drawRoundRect(x,y, w-1, h-1, 9, 9);
}
public Insets getBorderInsets(Component component) {
return insets;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarButtonBorder.java 0000644 0001750 0001750 00000015700 10573516350 027207 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import javax.swing.AbstractButton;
import javax.swing.ImageIcon;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** A border suitable for toolbar buttons.
*
* Paints a nice button effect with rounded corners.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* @since 2.0
*/
public class ToolBarButtonBorder implements Border {
private boolean pressed;
public ToolBarButtonBorder() {
}
private static Image borderImage = new ImageIcon(ToolBarButtonBorder.class.getResource("toolbarbuttonborder.png")).getImage();
private static Image pressedBorderImage = new ImageIcon(ToolBarButtonBorder.class.getResource("toolbarbuttonborder_pressed.png")).getImage();
static int borderWidth = borderImage.getWidth(null);
static int borderHeight = borderImage.getHeight(null);
private boolean paintTopLeft = true;
private Insets insets = new Insets(2, 2, 2, 2);
public boolean isBorderOpaque() {
return false;
}
public void paintBorder(Component component, Graphics graphics, int x,
int y, int w, int h) {
Image img;
if (pressed){
img = pressedBorderImage;
} else {
img = borderImage;
}
// top right corner
graphics.drawImage(img,
x+ w -5, y, x+w, y+5, borderWidth-5,0, borderWidth, 5, null);
// vertical right
graphics.drawImage(img,
x+ w -5, y+5, x+w, y+h-5, borderWidth-5,5, borderWidth, borderHeight-5, null);
// bottom-right corner
graphics.drawImage(img,
x+ w -5, y+h-5, x+w, y+h, borderWidth-5,borderHeight-5, borderWidth, borderHeight, null);
// horizontal bottom
graphics.drawImage(img,
x+5, y+h-5, x+w-5, y+h, 5,borderHeight-5, borderWidth-5, borderHeight, null);
// bottom left corner
graphics.drawImage(img,
x, y+h-5, x+5, y+h,
0, borderHeight-5, 5, borderHeight, null);
// horizontal top
graphics.drawImage(img,
x+5, y, x+w-5, y+5, 5,0, borderHeight-5, 5, null);
// vertical left
graphics.drawImage(img,
x, y+5, x+5, y+h-5, 0,5, 5, borderHeight-5, null);
// top left corner
graphics.drawImage(img,
x, y, x+5, y+5, 0,0, 5, 5, null);
}
public Insets getBorderInsets(Component component) {
if (component instanceof AbstractButton){
AbstractButton btn = (AbstractButton) component;
Insets i = btn.getMargin();
i.top+= insets.top;
i.left += insets.left;
i.right += insets.right;
i.bottom += insets.bottom;
return i;
} else {
return insets;
}
}
public boolean isPressed() {
return pressed;
}
public void setPressed(boolean pressed) {
this.pressed = pressed;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarConstraints.java 0000644 0001750 0001750 00000014202 10573516350 027101 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
/** Constraints to be used with the ToolBarLayout.
*
* Depending on the orientation of the layout, the two integers majorOrder and minorOrder
* express the opposite measures :
*
* Example : To layout two toolbars horizontally on an horizontal layout, use the following constraints
* (0,0) and (0,1) (the column is the minor order on an horizontal layout).
*
* to layout them in a row (one above the other), use the constraints (0,0) and (1,0) (the row
* is the major order on an horizontal layout).
*
* @author Lilian Chamontin, VLSolutions
*/
public class ToolBarConstraints {
/** The major order is the row index for horizontal toolbars, and the column index for
* vertical toolbars.
*/
public int majorOrder;
/** The minor order is the column index for horizontal toolbars, and the row index for
* vertical toolbars.
*/
public int minorOrder;
/** Set to -1/0/+1 during drag/drop phase to allow insertion between rows/columns.
* Do not use it outside drag and drop operations.
*/
/* package protected */ int majorOffset = 0;
/** Set to -1/0-31 during drag/drop phase to allow insertion between rows/columns
* Do not use it outside drag and drop operations.
*/
/* package protected */ int minorOffset = 0;
/** Constructs a new ToolBarConstraints at (0,0) */
public ToolBarConstraints() {
}
/** Constructs a new ToolBarConstraints at (majorOrder,minorOrder).
*
* the majorOrder is the ROW for an horizontal layout, and the columns for a vertical layout.
*/
public ToolBarConstraints(int majorOrder, int minorOrder) {
this.majorOrder = majorOrder;
this.minorOrder = minorOrder;
}
/** Returns a description of these constraints. */
public String toString(){
return "ToolBarConstraints[" + majorOrder + ", " + minorOrder + "]";
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarContainer.java 0000644 0001750 0001750 00000025500 10573516350 026517 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.BorderLayout;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Collections;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import java.awt.FlowLayout;
/** The container for toolbar panels.
*
* The layout used is BorderLayout and the CENTER component is dedicated to the user
* (the other 4 places (NORTH, EAST, WEST and SOUTH are used to display the toolbar panels)).
*
*
* Loading and saving toolbar configurations is done with the {@link ToolBarIO} utility class, and works if
* VLToolbars are registered (given a name and made know to their container by {@link #registerToolBar(VLToolBar)} ).
*
* @author Lilian Chamontin, VLSolutions
* @update 2006/09/09 Support for LTR/RTL orientation
*/
public class ToolBarContainer extends JPanel {
private Map componentsByContraints = new HashMap(); // this is private in borderlayout, so we need to keep a copy here
private Map contraintsByComponents = new HashMap();
private Map toolBarsByName = new HashMap();
public ToolBarContainer() {
setLayout(new BorderLayout());
}
/** Registers a new ToolBar.
*
* Registering is used when reading a xml configuration
*/
public void registerToolBar(VLToolBar toolbar){
if (toolbar.getName() == null){
throw new IllegalArgumentException("This toolbar hasn't got a name : cannot be registered");
}
toolBarsByName.put(toolbar.getName(), toolbar);
}
/** Unregisters a ToolBar.
*
* Registering is used when reading a xml configuration
*/
public void unregisterToolBar(VLToolBar toolbar){
if (toolbar.getName() == null){
return;
}
toolBarsByName.remove(toolbar.getName());
}
/** Returns the registered toolbar associated with the given name, or null if not found
*/
public VLToolBar getToolBarByName(String name){
return (VLToolBar)toolBarsByName.get(name);
}
/** Returns the list of currently registered toolbars.
*
* (eturns a new list at each invocation.)
*/
public List getRegisteredToolBars() {
return new ArrayList(toolBarsByName.values());
}
/** Overriden to track component constraints */
public void add(Component comp, Object constraints){
super.add(comp, constraints);
componentsByContraints.put(constraints, comp);
contraintsByComponents.put(comp, constraints);
if (comp instanceof ToolBarPanel){
ToolBarPanel panel = (ToolBarPanel) comp;
if (constraints.equals(BorderLayout.EAST) || constraints.equals(BorderLayout.WEST)){
panel.setOrientation(SwingConstants.VERTICAL);
}
// install the UI border
if (constraints.equals(BorderLayout.NORTH)){
panel.setBorder(UIManager.getBorder("ToolBarPanel.topBorder"));
} else if (constraints.equals(BorderLayout.WEST)){
panel.setBorder(UIManager.getBorder("ToolBarPanel.leftBorder"));
} else if (constraints.equals(BorderLayout.EAST)){
panel.setBorder(UIManager.getBorder("ToolBarPanel.rightBorder"));
} else if (constraints.equals(BorderLayout.SOUTH)){
panel.setBorder(UIManager.getBorder("ToolBarPanel.bottomBorder"));
}
}
}
/** Overriden to keep track of component constraints */
public void remove(Component comp){
super.remove(comp);
Object constraints = contraintsByComponents.remove(comp);
componentsByContraints.remove(constraints);
}
/** Overriden to keep track of component constraints */
public void remove(int index){
Component comp = getComponent(index);
super.remove(index);
Object constraints = contraintsByComponents.remove(comp);
componentsByContraints.remove(constraints);
}
/** Overriden to keep track of component constraints */
public void removeAll(){
super.removeAll();
componentsByContraints.clear();
contraintsByComponents.clear();
}
/** Returns the component for a given BorderLayout constraints */
public Component getComponentAt(Object constraints){
return (Component)componentsByContraints.get(constraints);
}
/** Returns the ToolBarPanel for a given BorderLayout constraints */
public ToolBarPanel getToolBarPanelAt(Object constraints){
return (ToolBarPanel) getComponentAt(constraints);
}
/** Returns the BorderLayout constraints of the given component */
public Object getConstraints(Component comp){
return contraintsByComponents.get(comp);
}
/** Creates a default ToolBarContainer with preinstalled toolbar panels on the borders with
* the LEADING alignment.
*
* The toolbarPanels are then accessible with getToolBarPanelAt(constraints) where constraints values
* are BorderLayout.NORTH, EAST, WEST and SOUTH.
*/
public static ToolBarContainer createDefaultContainer(boolean topToolbar, boolean leftToolBar,
boolean bottomToolBar, boolean rightToolBar){
return createDefaultContainer(topToolbar, leftToolBar, bottomToolBar, rightToolBar,
FlowLayout.LEADING);
}
/** Creates a default ToolBarContainer with preinstalled toolbar panels on the borders with
* the specified alignment
* The value of the alignment argument must be one of
*
* The toolbarPanels are then accessible with getToolBarPanelAt(constraints) where constraints values
* are BorderLayout.NORTH, EAST, WEST and SOUTH.
*
*@author KDMurthy, Marathon Project.
*/
public static ToolBarContainer createDefaultContainer(boolean topToolbar, boolean leftToolBar,
boolean bottomToolBar, boolean rightToolBar, int alignment){
ToolBarContainer container = new ToolBarContainer();
if (topToolbar){
ToolBarPanel panel = new ToolBarPanel(alignment);
panel.setVisible(false);
container.add(panel, BorderLayout.NORTH);
}
if (leftToolBar){
ToolBarPanel panel = new ToolBarPanel(alignment);
panel.setVisible(false);
container.add(panel, BorderLayout.WEST);
}
if (bottomToolBar){
ToolBarPanel panel = new ToolBarPanel(alignment);
panel.setVisible(false);
container.add(panel, BorderLayout.SOUTH);
}
if (rightToolBar){
ToolBarPanel panel = new ToolBarPanel(alignment);
panel.setVisible(false);
container.add(panel, BorderLayout.EAST);
}
return container;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarGripper.java 0000644 0001750 0001750 00000013766 10573516350 026220 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import javax.swing.JComponent;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
/** The component used to have a "grip" action on a toolbar (Drag and Drop support)
*
* @author Lilian Chamontin, VLSolutions
* @since 2.0
*/
public class ToolBarGripper extends JComponent {
private static final String uiClassID = "ToolBarGripperUI";
/** Id for the orientation property */
public static final String PROPERTY_ORIENTATION = "ORIENTATION";
private int orientation = SwingConstants.HORIZONTAL;
private boolean collapsible = true;
private boolean collapsed = false;
public ToolBarGripper() {
this(SwingConstants.HORIZONTAL);
}
public ToolBarGripper(int orientation) {
setOrientation(orientation);
updateUI();
}
public void setOrientation(int orientation){
int old = this.orientation;
this.orientation = orientation;
firePropertyChange(PROPERTY_ORIENTATION, old, orientation); // not used by the framwork, but might be usefull for someone
}
/** Returns the orientation of this gripper (SwingConstants.HORIZONTAL/VERTICAL) */
public int getOrientation(){
return this.orientation;
}
/**
* Resets the UI property to a value from the current look and feel.
*
* @see JComponent#updateUI
*/
public void updateUI() {
setUI(UIManager.getUI(this));
}
/** {@inheritDoc}
* @since 2.0
*/
public String getUIClassID() {
return uiClassID;
}
/** Return true is this toolbar can be collapsed (default is true)*/
public boolean isCollapsible() {
return collapsible;
}
public void setCollapsible(boolean collapsible) {
this.collapsible = collapsible;
}
/** Return true is this toolbar is currently collapsed */
public boolean isCollapsed() {
return collapsed;
}
public void setCollapsed(boolean collapsed) {
this.collapsed = collapsed;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarGripperUI.java 0000644 0001750 0001750 00000015003 10573516350 026440 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.SwingConstants;
import javax.swing.plaf.ComponentUI;
/** The default UI for the toolbar gripper.
*
* @author Lilian Chamontin, VLSolutions
*/
public class ToolBarGripperUI extends ComponentUI{
/** the "grip" (an alpha blended dot image, 3*3 pixels, hightlighted underneath ) */
protected static Image gripImage = new ImageIcon(ToolBarGripperUI.class.getResource("gripper.png")).getImage();
protected static Image gripExpandHImage = new ImageIcon(ToolBarGripperUI.class.getResource("grip_expand_h.png")).getImage();
protected static Image gripExpandVImage = new ImageIcon(ToolBarGripperUI.class.getResource("grip_expand_v.png")).getImage();
/** Constructs a new gripper UI */
public ToolBarGripperUI() {
}
public static ComponentUI createUI(JComponent c) {
return new ToolBarGripperUI();
}
/** installs the UI and sets the preferred size of the gripper */
public void installUI(JComponent comp){
super.installUI(comp);
comp.setPreferredSize(new Dimension(4,4));
}
/** Paints gripper dots */
public void paint(Graphics g, JComponent comp){
ToolBarGripper gripper = (ToolBarGripper)comp;
Insets insets = gripper.getInsets();
if (gripper.getOrientation() == SwingConstants.HORIZONTAL){
int dots = (gripper.getHeight())/4 -1;
int dotsSize = dots * 4;
int top = insets.top + gripper.getHeight()/2 - dotsSize/2;
int centerX = insets.left + (gripper.getWidth() - insets.left - insets.right) / 2;
for (int i=0; i < dots; i++){
g.drawImage(gripImage, centerX-1 , top+ i*4+1, null);
}
if (gripper.isCollapsed()){
int centerY = gripper.getHeight()/2;
g.drawImage(gripExpandHImage, 0, centerY - 4, null);
}
} else {
int dots = (gripper.getWidth())/4-1;
for (int i=0; i < dots; i++){
g.drawImage(gripImage, insets.left+ i*4+2,insets.top, null);
}
if (gripper.isCollapsed()){
int centerX = gripper.getWidth() / 2;
g.drawImage(gripExpandVImage, centerX - 4, 0, null);
}
}
super.paint(g, comp);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarIO.java 0000644 0001750 0001750 00000030151 10573516350 025102 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import com.vlsolutions.swing.docking.AutoHideButton;
import com.vlsolutions.swing.docking.AutoHideButtonPanel;
import com.vlsolutions.swing.docking.Dockable;
import com.vlsolutions.swing.docking.DockableState;
import com.vlsolutions.swing.docking.RelativeDockablePosition;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.util.Collection;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
/** A utility class used to save and restore toolbars to/from an XML configuration.
*
* @author Lilian Chamontin, VLSolutions
*/
public class ToolBarIO {
/** The main container */
private ToolBarContainer container;
/** Constructs a new ToolBarIO utility based on the given container */
public ToolBarIO(ToolBarContainer container) {
this.container = container;
}
/** Saves the current toolbar configuration into an XML stream.
*
* The stream is not closed at the end of the operation.
*
* @see #readXML(InputStream)
* */
public void writeXML(OutputStream stream) throws IOException {
PrintWriter out = new PrintWriter(stream);
out.println("");
out.println("
* When the method returns, the container is totally reconfigured with possibly different
* toolbars at different positions.
*
* Note : The Also note that the container must already contain its ToolBarPanels before reading
* the configuration.
*
*
* Dismisses all visible toolbars.
*
* The stream is not closed at the end of the operation.
* @see #writeXML(OutputStream)
* @see ToolBarContainer#registerToolBar(VLToolBar)
* @return a descriptor of the reading operation(useful for example to know the registered toolbars, that weren't
* loaded (missing) from the input file).
* */
public ToolBarIOReadInfo readXML(InputStream in) throws ParserConfigurationException, IOException, SAXException {
ToolBarIOReadInfo tri = new ToolBarIOReadInfo();
// first clear the toolbar panels
Component [] comps = container.getComponents();
for (int i=0; i < comps.length; i++){
Object constraints = container.getConstraints(comps[i]);
if (constraints.equals(BorderLayout.NORTH)){
((Container)comps[i]).removeAll();
} else if (constraints.equals(BorderLayout.WEST)){
((Container)comps[i]).removeAll();
} else if (constraints.equals(BorderLayout.SOUTH)){
((Container)comps[i]).removeAll();
} else if (constraints.equals(BorderLayout.EAST)){
((Container)comps[i]).removeAll();
}
}
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(in);
Element root = doc.getDocumentElement();
NodeList children = root.getChildNodes();
for (int i = 0, len = children.getLength(); i < len; i++) {
Node child = children.item(i);
xmlReadRootNode(child, tri);
}
tri.setRegisteredToolbars(container.getRegisteredToolBars());
tri.finishLoading();
container.revalidate();
return tri;
}
private void xmlReadRootNode(Node node, ToolBarIOReadInfo tri) throws SAXException{
if (node.getNodeType() == Node.ELEMENT_NODE){
Element elt = (Element) node;
String name = elt.getNodeName();
if (name.equals("Container")){
NodeList children = node.getChildNodes();
for (int i = 0, len = children.getLength(); i < len; i++) {
Node child = children.item(i);
xmlReadContainerNode(child, tri);
}
} else {
throw new SAXNotRecognizedException(name);
}
}
}
private void xmlReadContainerNode(Node node, ToolBarIOReadInfo tri) throws SAXException{
if (node.getNodeType() == Node.ELEMENT_NODE){
Element elt = (Element) node;
String name = elt.getNodeName();
if (name.equals("ToolBarPanel")){
String position = elt.getAttribute("position");
ToolBarPanel tp = null;
if (position.equals("top")){
tp = container.getToolBarPanelAt(BorderLayout.NORTH);
} else if (position.equals("left")){
tp = container.getToolBarPanelAt(BorderLayout.WEST);
} else if (position.equals("bottom")){
tp = container.getToolBarPanelAt(BorderLayout.SOUTH);
} else if (position.equals("right")){
tp = container.getToolBarPanelAt(BorderLayout.EAST);
}
NodeList children = elt.getElementsByTagName("ToolBar");
for (int i = 0, len = children.getLength(); i < len; i++) {
xmlReadToolBarPanelNode(tp, (Element)children.item(i), tri);
}
tp.revalidate();
} else {
throw new SAXNotRecognizedException(name);
}
}
}
private void xmlReadToolBarPanelNode(ToolBarPanel panel, Element toolbarElt, ToolBarIOReadInfo tri) {
String toolbarName = toolbarElt.getAttribute("name");
int major = Integer.parseInt(toolbarElt.getAttribute("major"));
int minor = Integer.parseInt(toolbarElt.getAttribute("minor"));
boolean collapsed = Boolean.valueOf(toolbarElt.getAttribute("collapsed")).booleanValue(); //2.0.6b
ToolBarConstraints tc = new ToolBarConstraints(major, minor);
VLToolBar tb = container.getToolBarByName(toolbarName);
if (tb != null) {
tb.setCollapsed(collapsed); // 2.0.6b
panel.add(tb, tc);
tri.notifyToolbarInstalled(tb);
} else {
// If the ToolBar is not registered ignore it
tri.notifyUnknownToolbarFound(toolbarName);
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarIOReadInfo.java 0000644 0001750 0001750 00000003320 10573516344 026513 0 ustar twerner twerner package com.vlsolutions.swing.toolbars;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/** Descriptor of the loading operation of toolbars.
*
* returns useful informations such as the toolbars registered and successfully loaded, and
* the ones not loaded.
*
* @author Lilian Chamontin, VLSolutions
*/
public class ToolBarIOReadInfo {
List notInstalledToolBarList;
List installedToolBarList = new ArrayList();
List unknownToolBarNames = new ArrayList();
List registeredToolbars;
public ToolBarIOReadInfo() {
}
/** returns the list of toolbars that were successfully loaded from the toolbarIO operation */
public List getInstalledToolbars(){
return installedToolBarList;
}
/** returns the list of toolbars that weren't loaded from the stream (but registered) */
public List getNotInstalledToolbars(){
return notInstalledToolBarList;
}
/** Return the list of toolbars names (String) found in the stream but not registered
* (these toolbars cannot be loaded, so the API can only report their name).
*/
public List getUnknownToolbarNames(){
return unknownToolBarNames;
}
void notifyToolbarInstalled(VLToolBar tb){
installedToolBarList.add(tb);
}
void setRegisteredToolbars(List registered) {
this.registeredToolbars = registered;
}
/** invoked on completion of loading */
void finishLoading(){
this.notInstalledToolBarList = new ArrayList(registeredToolbars);
notInstalledToolBarList.removeAll(installedToolBarList);
}
void notifyUnknownToolbarFound(String toolbarName) {
unknownToolBarNames.add(toolbarName);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarPanel.java 0000644 0001750 0001750 00000023061 10573516350 025634 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.JToolBar.Separator;
import javax.swing.SwingConstants;
/** The toolbar panel is able to receive multiple toolbars and arrange them in
* many columns or rows (depending on the horizontal/vertical orientation).
*
*
* The class uses the preferences framework of the java runtime, and installs a
* shutdown hook to save the toolbars state on application exit.
*
* Warning : this class cannot be run from a sandboxed (untrusted) environment
* (unsigned applet/ java web start) as it uses classes requiring a SecurityManager
* (Preferences API and Runtime shutdown hook).
*
* Call loadToolBarLayout() upon application startup, after registering all ToolBars.
*
* @author Michael Westergaard, revised by Lilian Chamontin.
*
* @see ToolBarIO
*/
public class ToolBarPersistence implements Runnable {
private final static String TOOLBAR_LAYOUT = "toolbar_layout"; //$NON-NLS-1$
private ToolBarContainer container;
private ToolBarIO io;
private Preferences prefs;
/**
* Construct a new set of persistent toolbars.
*
* @param mainClass the main class of the application. Will be used to
* generate a reasonable name for the preferences to store toolbar
* configuration
* @param container the toolbarcontainer to keep persistent
* @throws SecurityException if this class is invoked from an untrusted environment
*/
public ToolBarPersistence(Object mainClass, ToolBarContainer container) {
this.container = container;
this.io = new ToolBarIO(container);
String nodeName = mainClass.getClass().getName().replaceFirst(mainClass.getClass().getPackage().getName() + ".", ""); //$NON-NLS-1$ //$NON-NLS-2$
prefs = Preferences.userNodeForPackage(mainClass.getClass()).node(nodeName);
Runtime.getRuntime().addShutdownHook(new Thread(this));
}
protected void handleUnloadedToolBar(VLToolBar toolbar) {
ToolBarPanel panel =
container.getToolBarPanelAt(BorderLayout.NORTH);
if (panel != null)
panel.add(toolbar, new ToolBarConstraints());
}
/**
* Load the toolbar configuration.
*
* @throws IOException
* @throws ParserConfigurationException
* @throws SAXException
*/
public void loadToolBarLayout() throws IOException, ParserConfigurationException, SAXException {
byte data[] = prefs.getByteArray(TOOLBAR_LAYOUT, null);
if (data != null) {
InputStream in = new ByteArrayInputStream(data);
ToolBarIOReadInfo tri = io.readXML(in);
Collection unloadedToolBars = tri.getNotInstalledToolbars();
in.close();
for (Iterator i = unloadedToolBars.iterator(); i.hasNext(); ) {
VLToolBar toolbar = (VLToolBar) i.next();
handleUnloadedToolBar(toolbar);
}
}
}
/**
* Save the toolbar configuration.
* Masks all errors.
* don't call this method directly : it is used by the shudown hook.
*
* @see java.lang.Runnable#run()
*/
public void run() {
try {
saveToolBarLayout();
} catch (Exception exception) {
// Mask error as we are quitting anyway
}
}
/**
* Save the toolbar configuration.
*
* @throws IOException
*/
public void saveToolBarLayout() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
io.writeXML(out);
out.close();
prefs.putByteArray(TOOLBAR_LAYOUT, out.toByteArray());
}
} vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/VLButtonUI.java 0000644 0001750 0001750 00000013040 10573516350 025261 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.AbstractButton;
import javax.swing.JComponent;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.basic.BasicToggleButtonUI;
/** A UI for toolbar buttons : replaces the look and feel default UI to
* have a unified toolbar rendering.
*
* @author Lilian Chamontin, VLSolutions
*/
public class VLButtonUI extends BasicToggleButtonUI {
private Color highlight = UIManager.getColor("controlLtHighlight");
public VLButtonUI() {
}
public void paint(Graphics g, JComponent comp){
AbstractButton btn = (AbstractButton) comp;
boolean rollover = btn.getModel().isRollover();
boolean selected = btn.getModel().isSelected();
boolean armed = btn.getModel().isArmed();
btn.setBorderPainted(selected || rollover);
if (rollover || selected){
if (armed){
g.translate(1,1);
} else {
Insets i = btn.getInsets();
if (! selected){ // avoid too much effects
g.setColor(highlight);
g.fillRect(1,1, btn.getWidth() - 2, btn.getHeight() - 2);
}
}
}
Border b = comp.getBorder();
if (b instanceof ToolBarButtonBorder){
((ToolBarButtonBorder)b).setPressed(selected || armed);
}
super.paint(g, comp);
}
} vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/VLToolBar.java 0000644 0001750 0001750 00000052763 10573516350 025131 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import com.vlsolutions.swing.docking.animation.AnimationEvent;
import com.vlsolutions.swing.docking.animation.AnimationListener;
import com.vlsolutions.swing.docking.animation.ComponentAnimator;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.AbstractButton;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.JToolBar;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** A JToolbar suitable for drag and drop purposes.
*
* To use the toolbar feature, you must follow this pattern :
*
* Loading and saving toolbar configurations is done with the {@link ToolBarIO} utility class.
*
* Toolbars can now be collapsed (to gain space on screen). this property is disabled by default to
* keep compatibility with previous releases. For a better usage of collapsing it is better to
* set a tooltip text on the toolbar (it will be propagated to the gripper, which will be the only
* one component visible when collapsed).
*
* @author Lilian Chamontin, VLSolutions
* @update 2006/02/20 Lilian Chamontin : added support for collapsible toolbars
* @update 2006/03/16 Lilian Chamontin : added animation effect when collapsing toolbars
* @update 2006/12/01 Lilian Chamontin : added protection againt class cast when dragging
*/
public class VLToolBar extends JPanel{
private ToolBarGripper gripper = new ToolBarGripper();
private boolean rolloverBorderPainted = true;
private boolean rolloverContentAreaFilled = false;
private boolean useCustomUI = true;
private int orientation = SwingConstants.HORIZONTAL;
private MouseListener buttonMouseHandler = new MouseAdapter(){
public void mouseEntered(MouseEvent e){
AbstractButton btn = (AbstractButton) e.getSource();
if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) == 0){
if (rolloverBorderPainted){
btn.setBorderPainted(true);
}
if (rolloverContentAreaFilled){
btn.setContentAreaFilled(true);
}
}
}
public void mouseExited(MouseEvent e){
AbstractButton btn = (AbstractButton) e.getSource();
btn.setBorderPainted(false);
}
};
/** The mouse listener in charge for toolbar drag and drop */
private GripperHandler gripperListener = new GripperHandler();
/** The border used during DnD to show that the toolbar is selected */
private Border draggedBorder = new ToolBarButtonBorder();
private VLToolBarLayout horizontalLayout = new VLToolBarLayout(true, 0);
private VLToolBarLayout verticalLayout = new VLToolBarLayout(false, 0);
/** Constructs a toolbar with a null name (this toolbar will not be
* able to write its structure in a XML encoder, unless you call setName(String)
* with a non null name before saving).
* ).
*/
public VLToolBar() {
this(null);
}
/** Constructs a toolbar with the given name.
*
* The name is used when reading/writing XML configuration. It must not be null if
* you use this feature.
*/
public VLToolBar(String name) {
setName(name);
setLayout(horizontalLayout);
gripper.addMouseMotionListener(gripperListener);
gripper.addMouseListener(gripperListener);
gripper.setPreferredSize(new Dimension(4, 20));
//gripper.setMinimumSize(new Dimension(4, 4));
add(gripper);
setBorder(BorderFactory.createEmptyBorder(2,2,2,2));
gripper.setToolTipText(name);
}
/** Adds a new separator to this toolbar */
public void addSeparator(){
Dimension size = (Dimension)(UIManager.get("ToolBar.separatorSize"));
JToolBar.Separator sep = new JToolBar.Separator();
sep.setOrientation(orientation);
if (orientation == SwingConstants.HORIZONTAL){
sep.setOrientation(SwingConstants.VERTICAL);
sep.setPreferredSize(size);
add(sep);
} else {
sep.setOrientation(SwingConstants.HORIZONTAL);
sep.setPreferredSize(size);
add(sep);
}
}
/** Overriden to track AbstractButton added */
public Component add(Component comp){
if (comp instanceof AbstractButton){
return add((AbstractButton) comp);
} else {
if (!(comp instanceof ToolBarGripper)) {
comp.setVisible(!gripper.isCollapsed());
}
return super.add(comp);
}
}
/** Adds a new button to this toolbar */
public Component add(AbstractButton button){
if (useCustomUI){
installButtonUI(button);
}
button.setVisible(!gripper.isCollapsed());
super.add(button);
configureButton(button);
installMouseHandler(button);
return button;
}
/** Adds a new button to this toolbar */
public Component add(JButton button){
// this method is here to maintain backward compatibility
return add((AbstractButton) button);
}
/** Install custom UI for this button : a light rollover effet and a custom rounded/shaded border.
*
* This method can be overriden to replace the provided "look and feel" which uses the follwing configuration :
*
* Can be overriden to implement custom event handling.
*/
public void installMouseHandler(AbstractButton button){
button.addMouseListener(buttonMouseHandler);
}
/** This method is invoked upon adding a button to the toolbar. It can be
* overriden to provide another look or feel.
*
* Default settings are :
*
* If true, when one of the toolbar buttons is rolled-over, its border will be shown.
*
* DefaultValue is true
*/
public void setRolloverBorderPainted(boolean painted){
this.rolloverBorderPainted = painted;
}
/** Returns the state of the rolloverBorderPainted property */
public boolean isRolloverBorderPainter(){
return rolloverBorderPainted;
}
/** Updates the rolloverContentAreaFilled property.
*
* If true, when one of the toolbar buttons is rolled-over, its content will be filled.
*
* Default value is false to accomodate with VLButtonUI which paints itself the button
* interiors.
*
*/
public void setRolloverContentAreaFilled(boolean filled){
this.rolloverContentAreaFilled = filled;
}
/** Returns the value of the rolloverContentAreaFilled property */
public boolean isRolloverContentAreaFilled(){
return rolloverContentAreaFilled;
}
/** Updates the useCustomUI property.
*
* Default value is true.
*
* When set to true the installButtonUI() method will be called when a button is added to this
* toolbar.
*/
public void setUseCustomUI(boolean useCustomUI){
this.useCustomUI = useCustomUI;
}
/** Return the value of the useCustomUI property */
public boolean isUseCustomUI(){
return useCustomUI;
}
/** Changes the border used during drag and drop of the toolbar.
*
* For a better user experience, please note to install an empty border of the
* same Insets than this one (otherwise, there will be a size change of the toolbar at the beginning
* of the drag and after the drop).
*/
public void setDraggedBorder(Border border){
this.draggedBorder = border;
}
/** Returns the border used during drag and drop or the toolbar */
public Border getDraggedBorder(){
return this.draggedBorder;
}
private void gripperDragged(MouseEvent e){
// where are we ?
Component gripper = e.getComponent();
ToolBarPanel panel = (ToolBarPanel) this.getParent();
if (!(panel.getParent() instanceof ToolBarContainer)){ //2006/12/01
// this is a safety for users willing to include toolbar panels outside
// a toolbar container (in that case, these toolbars aren't draggable).
return;
}
ToolBarContainer container = (ToolBarContainer) panel.getParent();
Point tbPanelPoint = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), panel);
if (panel.contains(tbPanelPoint)){
// we're dragging inside the same ToolbarPanel
ToolBarPanelLayout layout = (ToolBarPanelLayout) panel.getLayout();
ToolBarConstraints constraints = layout.getInsertionContraintsAt(this, tbPanelPoint);
if (constraints != null){
panel.remove(this);
panel.add(this, constraints);
panel.revalidate();
}
} else {
// we're outside this toolbar panel, check if we're above another toolbar
// or near an empty one
Rectangle containerBounds = container.getBounds();
Rectangle invisiblePanelBounds = new Rectangle(containerBounds);
ToolBarPanel topPanel = (ToolBarPanel)container.getComponentAt(BorderLayout.NORTH);
invisiblePanelBounds.height = 10;
if (checkGripperOnOtherPanel(topPanel, e, invisiblePanelBounds)){
return;
}
invisiblePanelBounds.y = containerBounds.y + containerBounds.height - 10;
ToolBarPanel bottomPanel = (ToolBarPanel)container.getComponentAt(BorderLayout.SOUTH);
if (checkGripperOnOtherPanel(bottomPanel, e, invisiblePanelBounds)){
return;
}
invisiblePanelBounds.y = containerBounds.y;
invisiblePanelBounds.height = containerBounds.height;
invisiblePanelBounds.width = 10;
ToolBarPanel leftPanel = (ToolBarPanel)container.getComponentAt(BorderLayout.WEST);
if (checkGripperOnOtherPanel(leftPanel, e, invisiblePanelBounds)){
return;
}
invisiblePanelBounds.x = containerBounds.x + containerBounds.width - 10;
ToolBarPanel rightPanel = (ToolBarPanel)container.getComponentAt(BorderLayout.EAST);
if (checkGripperOnOtherPanel(rightPanel, e, invisiblePanelBounds)){
return;
}
}
}
private boolean checkGripperOnOtherPanel(ToolBarPanel panel, MouseEvent e, Rectangle invisibleBounds){
if (panel != null && panel != getParent()){
if(panel.isVisible()){
Point panelPoint = SwingUtilities.convertPoint(this, e.getPoint(), panel);
if (panel.contains(panelPoint)){
gripperDraggedOnOtherVisiblePanel(panel, panelPoint);
return true;
}
} else { // not visible
Point containerPoint = SwingUtilities.convertPoint(this, e.getPoint(), panel.getParent());
if (invisibleBounds.contains(containerPoint)){
ToolBarPanel parent = (ToolBarPanel)getParent();
parent.remove(this);
panel.add(this, new ToolBarConstraints(0,0)); // the panel is not visible == empty
panel.revalidate();
if (parent.getComponentCount() == 0){
parent.setVisible(false); // last toolbar : hideit
}
return true;
}
}
}
return false;
}
private void gripperDraggedOnOtherVisiblePanel(ToolBarPanel panel, Point point){
// we're dragging inside another ToolbarPanel
ToolBarPanelLayout layout = (ToolBarPanelLayout) panel.getLayout();
ToolBarConstraints constraints = layout.getInsertionContraintsAt(this, point);
if (constraints != null){
ToolBarPanel parent = (ToolBarPanel)getParent();
parent.remove(this);
panel.add(this, constraints);
panel.revalidate();
}
}
public String toString(){
return "VLToolBar " + getName();
}
/** Updates the orientation of this toolbar.
*
* This method is called directly by the framework on toolbar installation or
* during drag and drop.
*/
public void setOrientation(int orientation){
if (this.orientation != orientation){
this.orientation = orientation;
gripper.setOrientation(orientation);
Component [] comps = getComponents();
removeAll();
if (orientation == SwingConstants.HORIZONTAL){
gripper.setPreferredSize(new Dimension(4, 20));
setLayout(horizontalLayout);
for (int i=0; i < comps.length; i++){
if (comps[i] instanceof JToolBar.Separator){
JToolBar.Separator sep = (JToolBar.Separator) comps[i];
sep.setOrientation(SwingConstants.VERTICAL);
}
add(comps[i]);
}
} else {
gripper.setPreferredSize(new Dimension(20,4));
setLayout(verticalLayout);
// gripper.setIcon(vGripIcon);
for (int i=0; i < comps.length; i++){
if (comps[i] instanceof JSeparator){
JSeparator sep = (JSeparator) comps[i];
sep.setOrientation(SwingConstants.HORIZONTAL);
}
add(comps[i]);
}
}
revalidate();
}
}
/** Updates the tooltip of the toolbar, and propagates it to the toolbar gripper. */
public void setToolTipText(String tooltip){
super.setToolTipText(tooltip);
gripper.setToolTipText(tooltip);
}
boolean isInAnimationCycle = false;
private void gripperClicked(MouseEvent e){
if (isCollapsible() && ! isInAnimationCycle){
setCollapsed(!gripper.isCollapsed());
}
}
/** Hides the toolbar (just showing the gripper) */
public void setCollapsed(final boolean collapsed) {
if (collapsed){
// added a subtle animation effect to give more polish to the collapsing //2006/03/16
Rectangle bounds = getBounds();
Rectangle newBounds;
float animSpeed ;
if (orientation == SwingConstants.HORIZONTAL){
newBounds = new Rectangle(bounds.x,bounds.y, 20, getHeight());
animSpeed = getWidth() / 800f; // pix / sec
} else {
newBounds = new Rectangle(bounds.x,bounds.y, getWidth(), 20);
animSpeed = getHeight()/ 800f; // pix / sec
}
ComponentAnimator canim = new ComponentAnimator(this, bounds, newBounds, animSpeed);
canim.addAnimationListener(new AnimationListener() {
public void animation(AnimationEvent e) {
if (e.getState() == AnimationEvent.ANIMATION_END){
gripperListener.resetBorder();
finishAnimation(collapsed);
}
}
});
gripperListener.installDragBorder();
canim.start();
} else {
// no animation when expanding
finishAnimation(collapsed);
}
}
private void finishAnimation(boolean collapsed){
gripper.setCollapsed(collapsed);
int maxSize = 20; //2.0.6b
Component [] comps = getComponents();
for (int i=0; i < comps.length; i++){
if (!(comps[i] instanceof ToolBarGripper)) {
if (orientation == SwingConstants.HORIZONTAL){
maxSize = Math.max(maxSize, comps[i].getHeight());
} else {
maxSize = Math.max(maxSize, comps[i].getWidth());
}
comps[i].setVisible(!collapsed);
}
}
if (collapsed){
if (orientation == SwingConstants.HORIZONTAL){
gripper.setPreferredSize(new Dimension(6, maxSize));
} else {
gripper.setPreferredSize(new Dimension(maxSize, 6));
}
}
revalidate();
}
/** Returns true if this toolbar is currently collapsed */
public boolean isCollapsed() {
return gripper.isCollapsed();
}
public boolean isCollapsible() {
return gripper.isCollapsible();
}
public void setCollapsible(boolean collapsible) {
gripper.setCollapsible(collapsible);
}
private class GripperHandler implements MouseListener, MouseMotionListener {
Border oldBorder;
public void mouseDragged(MouseEvent e){
gripperDragged(e);
}
public void mouseReleased(MouseEvent mouseEvent) {
resetBorder();
}
/** puts back the old border (the one when not selected) */
public void resetBorder(){
setBorder(oldBorder);
}
public void installDragBorder(){
oldBorder = getBorder();
setBorder(draggedBorder);
}
public void mousePressed(MouseEvent mouseEvent) {
installDragBorder();
}
public void mouseMoved(MouseEvent mouseEvent) { }
public void mouseExited(MouseEvent mouseEvent) { }
public void mouseEntered(MouseEvent mouseEvent) { }
public void mouseClicked(MouseEvent mouseEvent) {
gripperClicked(mouseEvent);
}
}
} vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/VLToolBarLayout.java 0000644 0001750 0001750 00000023465 10573516350 026324 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.util.ArrayList;
/** The layout for VLToolBar (supports horizontal and vertical orientation).
*
* When used in horizontal orientation, this layout respects the preferred width of
* the contained components, and forces the height to the maximum of all the preferred heights.
* (so components are vertically streched to have the same height).
*
* When used in vertical orientation, this layout respects the preferred height of
* the contained components, and forces the width to the maximum of all the preferred widths.
* (so components are horizontally streched to have the same width).
*
* @author Lilian Chamontin, VLSolutions
* @update 2006/09/09 Support for LTR and RTL component orientation
*/
public class VLToolBarLayout implements LayoutManager2{
private ArrayList components = new ArrayList();
private boolean isHorizontal;
private int gap; // gap in pixels between components
public VLToolBarLayout() {
this(true, 0);
}
/** Constructs a new Layout.
*
* @param isHorizontal indicates if the layout will be horizontal or vertical.
*
* */
public VLToolBarLayout(boolean isHorizontal) {
this(isHorizontal, 0);
}
/** Constructs a new Layout.
* @param isHorizontal indicates if the layout will be horizontal or vertical.
* @param gap gap in pixels between components
* */
public VLToolBarLayout(boolean isHorizontal, int gap) {
this.isHorizontal = isHorizontal;
this.gap = gap;
}
public float getLayoutAlignmentX(Container target) {
return 0.5F;
}
public float getLayoutAlignmentY(Container target) {
return 0.5F;
}
public void invalidateLayout(Container target) {
}
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints == null){
components.add(comp);
} else {
Integer i = (Integer) constraints;
components.add(i.intValue(), comp);
}
}
public void removeLayoutComponent(Component comp) {
components.remove(comp);
}
public void addLayoutComponent(String name, Component comp) {
}
public Dimension minimumLayoutSize(Container parent) {
synchronized (parent.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int visible = 0;
for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
Dimension d = comp.getPreferredSize();
if (comp.isVisible()){
visible ++;
if (isHorizontal) {
dim.width += d.width;
dim.height = Math.max(dim.height, d.height);
} else {
dim.width = Math.max(dim.width, d.width);
dim.height += d.height;
}
}
}
// add the gap between components
if (isHorizontal) {
dim.width += (visible - 1) * gap;
} else {
dim.height += (visible - 1) * gap;
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
public Dimension preferredLayoutSize(Container parent) {
return minimumLayoutSize(parent);
}
/** overridden to adjust position (x(top) = width(left), y(left) = height(top)
*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Dimension toolbarDim = preferredLayoutSize(target);
Insets insets = target.getInsets();
if (isHorizontal){
int left = insets.left;
/*for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, insets.top, d.width, toolbarDim.height - insets.top - insets.bottom);
left += d.width + gap;
}
}*/
if (target.getComponentOrientation().isLeftToRight()) {
for (int i = 0; i < components.size(); i++) {
left = layoutHorizComponent((Component)components.get(i), toolbarDim, insets, left);
}
} else {
// Right to left
Component firstComp = components.size() == 0 ? null : (Component)components.get(0);
int endWith = 0 ;
if (firstComp != null && firstComp instanceof ToolBarGripper) {
left = layoutHorizComponent(firstComp, toolbarDim, insets, left);
endWith = 1;
}
for (int i = components.size() - 1; i >= endWith; i--) {
left = layoutHorizComponent((Component)components.get(i), toolbarDim, insets, left);
}
}
} else { //vertical
int centerX = insets.left + (toolbarDim.width - insets.left - insets.right)/2;
int top = insets.top;
for (int i = 0; i < components.size(); i++) {
Component comp = (Component) components.get(i);
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(insets.left, top, toolbarDim.width - insets.left - insets.right, d.height);
top += d.height + gap;
}
}
}
}
}
/* 2006/09/09 */
private int layoutHorizComponent(Component comp, Dimension toolbarDim, Insets insets, int left) {
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, insets.top, d.width, toolbarDim.height - insets.top - insets.bottom);
left += d.width + gap;
}
return left;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/grip_expand_h.png 0000644 0001750 0001750 00000000370 10573516344 025765 0 ustar twerner twerner PNG
IHDR bKGD C pHYs tIME
.*i tEXtComment Copyright VLSolutions
dD \IDATx}1@PE>)ve
[e(g`d5#ex" @k)QYo`D| I' IENDB` vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/grip_expand_v.png 0000644 0001750 0001750 00000000355 10573516344 026006 0 ustar twerner twerner PNG
IHDR bKGD C pHYs tIME
/, tEXtComment Copyright VLSolutions
dD QIDATxڭ͡P w3IQT6.ڽv Fx',moI>X>f\SN: IENDB` vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/gripper.png 0000644 0001750 0001750 00000000276 10573516344 024633 0 ustar twerner twerner PNG
IHDR V( bKGD pHYs tIME 5 Z tEXtComment Copyright VLSolutions
dD "IDATx
!4o/w\<8Udpn IENDB` vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/package.html 0000644 0001750 0001750 00000002076 10573516344 024736 0 ustar twerner twerner
This packages contains an independant set of components allowing multiple draggable toolbars
to be positionned around a central component.
Getting started is easy :
B-*S װf' A$O%Чȥ"x8#B]%- @
KPJY`V }(~ WW-b42d[_\=-]o R}tq${3- gsB&C*n*3Ve8\ \\1 * X6!J'c{M@)m,(njtN9-L .> 6"첏8|kH}1vm ;`Ju
6 R(N(5 IT(*ԁJ8-CP
T*8McbUV[J;{vt~<'ˌ3,Nܳ츝yVn3yJrbD(E% v@xD E ò-wR/6n fB뾎K1WϟLS^n^;Mf,5LR떂-3zoAhz1zzi/>
v vH(i 4$&> ;mdcj!;DwTY5{ƽ F0V͚31Z V'|m꒵~o+_)[B- %k /яȟݏɧ(-ĸ` >
stream
HyTSwoɞc
[5la QIBHADED2mtFOE.c}088GNg 9w߽ '0 ֠Jb
2y.-;!KZ ^i"L0-
@8(r;q7Ly&Qq4j|9
V)gB0iW8#8wթ8_٥ʨQQj@&A)/g>'K t;\
ӥ$պFZUn (4T%)뫔0C&Zi8bxEB ;Pӓ̹A om?W=
x- [ 0 }y)7ta>jT7@tܛ`q2ʀ&6ZLĄ? _ yxg)˔zçLU*uSkSeO4?c. R
߁-25 S>ӣVd`rn~Y&+`;A4 A9 =- t l`;~p Gp | [`L`< "A YA+Cb(R, *T2B-
ꇆ nQt}MA0a lS x k&^>0|>_',G !"F$H:R!zFQd?r 9\A&G rQ hE]a4zBgE#H *B=0HIpp0MxJ$D1D, VĭKĻYdE"EI2EBGt4MzN r!YK ?%_&#(0J:EAiQ(()ӔWT6U@P+!~mD eԴ!hӦh/ ']B/ ҏӿ?a0nhF!X8܌kc&5S 6lIa2cKMA!E#ƒdV(kel
}}Cq9
N')].uJr
wG xR^[oƜc hg`>b$ *~ :Eb~,m,-ݖ,Y¬*6X[ݱF=3뭷Y~dó t i zf6~`{v.Ng#{}} j c1X6f m ; ' _9 r:8q:˜O:ϸ8uJqnv=MmR 4
n3ܣkGݯz= [==<=GTB(/S,]6*-W:#7 *e^YDY}UjAyT`#D="b{ų+ʯ:!kJ4G mt}uC%K7YVfFY .=b?SƕƩȺy
چ k5%4m7lqlioZlG+Zzmzy]?uuw|"űNwW&e֥ﺱ*|j5kyݭǯg^ykEklD_p߶7Dmo꿻1ml{Mś
nLl<9O [$h՛B dҞ@ iءG&vVǥ8nRĩ7 u\ЭD- u`ֲK³8%yhYѹJº;.!
zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖ ޢ)߯6DScs
2F[p(@Xr4Pm8Ww)Km
endstream
endobj
512 0 obj
<< /Length 127 /Filter /FlateDecode >>
stream
Hb``PPP000ppp 2'1qAAAnժʶwNs`s [~ʍgC?Ƿ ߿ˏaA HX<
endstream
endobj
513 0 obj
<< /Type /XObject /Subtype /Image /Width 167 /Height 46 /BitsPerComponent 8
/ColorSpace 484 0 R /Length 1331 /Filter /FlateDecode >>
stream
Hܗr:E`* b?9-pH*뚚"?a{9?ݍ=Ӿ![FO c*H%Oa*`оb2^cP}_hbtR*nA|Q9@r-]D M6p3=5\o?ic>Z_+i9"?-e\7fㆇgmF58Q'Rbx )HZF qd:, hIEl.{y?}Ch"'J1]#fIE9J4!Sn^FI)TP* ׅv˔}wYVq3dERjfwId|Ed|`rēW\Z!GKƏYAFK=ZQ D&6%P*8˴dB#Ĭ^ab>YĦ0
̓ߨκo{ˍ1=#@!UhgV,B3^c+Ny-%6cK I"+`}ʐTW&c&-!"h. owj9GJU9c?*d.IYɨ Fj2]FĘsy
S ,Q|UgQ C3&ܱQJ,5
"GF ' jGhbBJN[af D`gwN3֝@ی)+7#s[ J X&@Rb:+8j[v$Mv$!!U;MPRpWgs01 Cri`S*
4}ݲt{^jzyS* wE\5:Yԉnq f0!&vf %\,^jdM"ڥZL.$Vsꄘ4n(,QIƃZƻ ̱(b1Yv۠O}5;B@uHUr|dAGy^)V$4ƄSZbJ ^E4uDy =m3K(: #* WMeQ : T kdL7Ash;m`n nvCAV~lzTNS+(+ t Dn:(:hnկIôX2-< ąoy 103˳;e<pxj, RwӇJ CلȝC
* than your corresponding WSDockKey will be wsdk = new WSDockKey("testDockable");
* Dockable's DockKey, with a custom look and feel.
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class AutoHideButton extends JLabel {
/** property name associated to the "zone" (border) property */
public static final String PROPERTY_ZONE = "autohide.zone";
public static final String uiClassID = "AutoHideButtonUI";
private boolean selected = false;
private DockKey key;
private Dockable dockable;
private int zone; // the border used
private boolean isNotification = false;
private Timer notificationTimer; // blinking timer
private int blinkCount = 0;
private int MAX_BLINKS = UIManager.getInt("DockingDesktop.notificationBlinkCount");
private PropertyChangeListener keyListener = new PropertyChangeListener(){
// this is a DockKey listener, not a KeyEvent listener...
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals(DockKey.PROPERTY_NAME)){
setText((String)e.getNewValue());
} else if (e.getPropertyName().equals(DockKey.PROPERTY_TOOLTIP)){
setToolTipText((String)e.getNewValue());
} else if (e.getPropertyName().equals(DockKey.PROPERTY_ICON)){
setIcon((Icon) e.getNewValue());
} else if (e.getPropertyName().equals(DockKey.PROPERTY_NOTIFICATION)){
boolean isOn = ((Boolean)e.getNewValue()).booleanValue();
if (isOn){
if (notificationTimer == null){
notificationTimer = new Timer(1000,
new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
setNotification(!isNotification);
if (!isNotification){
blinkCount ++;
if (blinkCount >= MAX_BLINKS){
blinkCount = 0;
notificationTimer.stop(); // enough blinking
}
}
repaint();
}
});
}
setNotification(true);
notificationTimer.restart();
} else {
if (notificationTimer != null){
notificationTimer.stop();
blinkCount = 0;
}
setNotification(false);
}
}
}
};
public AutoHideButton() {
}
/** Sets the background color according to the notification boolean */
private void setNotification(boolean notification){
this.isNotification = notification;
if (notification){
setBackground(UIManager.getColor("DockingDesktop.notificationColor"));
setOpaque(true);
} else {
setOpaque(false);
}
repaint();
}
/** Returns the dockable this button is for */
public Dockable getDockable(){
return dockable;
}
/** Returns the key of the dockable */
public DockKey getKey(){
return key;
}
/** Initialize the button for a Dockable and a border zone */
public void init(Dockable dockable, int zone){
DockKey key = dockable.getDockKey();
this.dockable = dockable;
this.key = key;
int oldZone = this.zone;
this.zone = zone;
firePropertyChange("autohide.zone", oldZone, zone);
key.addPropertyChangeListener(keyListener);
setText(key.getName());
setToolTipText(key.getTooltip());
if (key.getIcon() != null) {
setIcon(key.getIcon());
}
setFocusable(true);
setOpaque(false);
setIconTextGap(4);
setAlignmentY(1);
}
public Dimension getPreferredSize() {
if (zone == DockingConstants.INT_HIDE_TOP
|| zone == DockingConstants.INT_HIDE_BOTTOM) {
return super.getPreferredSize();
} else {
Dimension d = super.getPreferredSize();
Insets i = getInsets();
return new Dimension(d.height - i.top - i.bottom + i.left + i.right,
d.width - i.left - i.right + i.top + i.bottom); // rotate the shape
}
}
public Dimension getMaximumSize() {
if (zone == DockingConstants.INT_HIDE_TOP
|| zone == DockingConstants.INT_HIDE_BOTTOM) {
return super.getMaximumSize();
} else {
Insets i = getInsets();
Dimension d = super.getMaximumSize();
return new Dimension(d.height - i.top - i.bottom + i.left + i.right,
d.width - i.left - i.right + i.top + i.bottom); // rotate the shape
}
}
public Dimension getMinimumSize() {
if (zone == DockingConstants.INT_HIDE_TOP
|| zone == DockingConstants.INT_HIDE_BOTTOM) {
return super.getMinimumSize();
} else {
Insets i = getInsets();
Dimension d = super.getMinimumSize();
return new Dimension(d.height - i.top - i.bottom + i.left + i.right,
d.width - i.left - i.right + i.top + i.bottom); // rotate the shape
}
}
/** Returns the border zone of this button*/
public int getZone(){
return zone;
}
/** True when the button is currently selected. */
public boolean isSelected(){
return selected;
}
/** Selects or unselects the button */
public void setSelected(boolean selected){
this.selected = selected;
setOpaque(selected);
repaint();
if (selected){
key.setNotification(false); // in case we were in notification mode
}
}
public String getUIClassID() {
return uiClassID;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/AutoHideButtonPanel.java 0000644 0001750 0001750 00000016274 10573516346 026776 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
/** A Swing panel used as a toolbar for autohide buttons.
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* */
public class AutoHideButtonPanel extends JPanel {
/** The property name associated with the "border" property */
public static final String PROPERTY_BORDERZONE = "borderzone";
public static final String uiClassID = "AutoHideButtonPanelUI";
/** <=> Zone */
private int border;
/** highlight effect (rollover) on the contained buttons */
private ButtonHighlighter buttonHighlighter = new ButtonHighlighter();
/** expansion management */
private AutoHideExpandPanel expandPanel;
/** Constructs a new AutoHideButtonPanel, with a shared expandPanel, and for
* a specified border zone.
*
* @param border constant taken from AutoHideButtonPanel.TOP, AutoHideButtonPanel.LEFT,
* AutoHideButtonPanel.BOTTOM, AutoHideButtonPanel.RIGHT
* */
public AutoHideButtonPanel(AutoHideExpandPanel expandPanel, int border) {
this.border = border;
this.expandPanel = expandPanel;
boolean isHorizontal = (border == DockingConstants.INT_HIDE_TOP)
|| (border == DockingConstants.INT_HIDE_BOTTOM);
setLayout(new AutoHideBorderLayout(isHorizontal));
firePropertyChange("borderzone", -1, border);
}
/** Returns the number of buttons currently displayed by this panel.
*/
public int getVisibleButtonCount(){
Component [] comps = getComponents();
int count = 0;
for (int i=0; i < comps.length; i++){
if (comps[i].isVisible()){
count ++;
}
}
return count;
}
/** Returns the border this panel is for.
*
*
*
*
* DockingDesktop desk = ...
* desk.addDockable(dockable1);
* desk.split(dockable1, dockable2, DockingConstants.SPLIT_RIGHT);
* // now let's add a compound dockable
* CompoundDockable compound = new CompoundDockable(new DockKey("Compound!"));
* desk.split(dockable1, compound);
* // and add a tab into it
* desk.addDockable(compound, dockable3); // initial nesting : new API call
* desk.createTab(dockable3, dockable4, 1); // a tab, using standard API
*
* DockView as a SingleDockableContainer,
* and DockTabbedPane as a TabbedDockableContainer
*
*
*
*@see DockView
*@see TabbedDockView
*@see MaximizedDockView
*@see DetachedDockView
*/
public SingleDockableContainer createDockableContainer(Dockable dockable, int parentType) {
switch (parentType){
case PARENT_TABBED_CONTAINER:
return new TabbedDockView(dockable);
case PARENT_DESKTOP:
return new MaximizedDockView(dockable);
case PARENT_SPLIT_CONTAINER:
return new DockView(dockable);
case PARENT_DETACHED_WINDOW:
return new DetachedDockView(dockable);
default :
throw new RuntimeException("Wrong dockable container type");
}
}
/** Returns the container used for tabbed docking.
*Dockable.
*
*
*
*
*
*
* 
.
*
*
*
*
* function Version 1.1 Version 2.0 maximize 
restore 
hide 
dock 
close 
float (detach) n/a 
attach n/a 
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
* */
public interface Dockable {
/** returns the unique key identifying the docked element */
public DockKey getDockKey();
/** returns the component wrapped.
*
* */
public Component getComponent();
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableActionCustomizer.java 0000644 0001750 0001750 00000017371 10573516350 030041 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.JPopupMenu;
/** An objet that can provide actions relative to a dockable.
*
* class MyComponent extends JPanel implements Dockable {
* // unique key for the docking desktop
* DockKey key = new DockKey("MyComponent");
*
* public MyComponent(){
* // build your user component here
* add(new JButton("Button"));
* add(new JTextField("Field"));
*
* // initialize docking properties
* key.setName("My Component");
* key.setIcon(...);
* key.setCloseEnabled(false);
* }
* public DockKey getDockKey(){
* return key;
* }
* public Component getComponent(){
* // this component is the dockable
* return this;
* }
* }
*
*
* DockableActionCustomizer customizer = new DockableActionCustomizer(){
* public void visitSingleDockableTitleBarPopUp(JPopupMenu popUpMenu, Dockable dockable){
* popUpMenu.add(new JMenuItem("test")); // a menu for SingleDockableContainers
* }
* public void visitTabSelectorPopUp(JPopupMenu popUpMenu, Dockable dockable){
* popUpMenu.add(new JMenuItem(closeAllInTab)); // two menus when contained in a tabbed container
* popUpMenu.add(new JMenuItem(closeAllOtherInTab));
* }
* };
* customizer.setSingleDockableTitleBarPopUpCustomizer(true); // enable single
* customizer.setTabSelectorPopUpCustomizer(true); // enable tabbed
* DockKey key = ...
* key.setActioncustomizer(customizer); // assoiate it with one or more DockKeys
*
* Dockable components.
* DockableDragSources
* in order to achieve drag and drop operations.
* installDocking().
* */
public void uninstallDocking(DockingDesktop desktop);
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableContainerFactory.java 0000644 0001750 0001750 00000016521 10573516350 030005 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.awt.Window;
/** An abstract factory used by the DockingDesktop to create instance
* of Dockable containers.
* Dockable, responsible
* for drag gesture recognition. There can be more than one DockableDragSource per
* Dockable.
* false) or to wrong mouse position .
*
* @return true if drag operation is accepted (i.e the zone pointed by p refers to
* a draggable component), false otherwise.
* */
public boolean startDragComponent(Point p);
/** Returns the Dockable component this source is for */
public Dockable getDockable();
/** returns the DockableContainer responsible for displaying the associated dockable */
public Container getDockableContainer();
/** notifies the source when the drag operation has ended (by a drop or cancelled)
* @since 2.1.3
*/
public void endDragComponent(boolean dropped);
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockablePanel.java 0000644 0001750 0001750 00000012526 10573516350 025573 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import javax.swing.*;
import java.awt.*;
/** A basic implementation of Dockable.
* comp on the center area of the BorderLayout.
* */
public void setComponent(Component comp) {
removeAll();
add(comp, BorderLayout.CENTER);
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/DockableResolver.java 0000644 0001750 0001750 00000001071 10573516344 026331 0 ustar twerner twerner package com.vlsolutions.swing.docking;
/** An interface used to find a dockable (when read from an input stream like XML)
* when the only information given is its DockKey id.
*
* DockKeys of the stream must be registered with
* the {@link #registerDockable(Dockable) registerDockable} method,
* prior readXML.
*
* This is the case if the desktop is already open and dockables
* laid out, but might not be the case if this method is used at application startup
* to populate an empty desktop.
*
*
*
*
* @author Lilian Chamontin, VLSolutions.
* @version 2.0
*
* @update 2005/10/06 Lilian Chamontin : added support for dnd to floatables
* @update 2005/10/07 Lilian Chamontin : cancel drag operation with ESCAPE key
* @update 2005/11/08 Lilian Chamontin : added support for global width/height drop (in split method)
* @update 2005/11/14 Lilian Chamontin : reworked setFloating methods.
* @update 2005/12/08 Lilian Chamontin : fixed a bug related to multiple desktop usage (when moving a window after
* the desktop has been removed from hierarchy, the listeners were still invoked and caused a NPE in moveFloatingWindows).
*
* @update 2006/12/01 Lilian Chamontin : fixed a NPE when closing a window with some floating children remaining
* @update 2006/12/19 Lilian Chamontin : fixed a memory leak issue due to keyboard focus manager handling
*/
public class DockingDesktop extends JLayeredPane {
private static final String CURRENT_VERSION_NUMBER = "2.1.4";
private static final String BUILD_DATE = "2007/03/07";
static {
// install UI settings if not already done
DockingUISettings.getInstance().installUI();
}
/** contextual data that can be shared by multiple desktops */
private DockingContext context;
/** panel containing autohidepanels on borders and dockingpanel at center */
private JPanel contentPane = new JPanel(new DockingBorderLayout());
/** main central container for dockables */
protected DockingPanel dockingPanel = new DockingPanel();
/** container responsible for auto-hidden components expansion */
protected AutoHideExpandPanel expandPanel = createAutoHideExpandPanel();
/** panel used to display autohide buttons */
protected AutoHideButtonPanel topBorderPane= new AutoHideButtonPanel(expandPanel, DockingConstants.INT_HIDE_TOP);
/** panel used to display autohide buttons */
protected AutoHideButtonPanel leftBorderPane = new AutoHideButtonPanel(expandPanel, DockingConstants.INT_HIDE_LEFT);
/** panel used to display autohide buttons */
protected AutoHideButtonPanel bottomBorderPane = new AutoHideButtonPanel(expandPanel, DockingConstants.INT_HIDE_BOTTOM);
/** panel used to display autohide buttons */
protected AutoHideButtonPanel rightBorderPane = new AutoHideButtonPanel(expandPanel, DockingConstants.INT_HIDE_RIGHT);
/** array containing the border panes */
protected AutoHideButtonPanel[] borderPanes = {topBorderPane,
leftBorderPane, bottomBorderPane, rightBorderPane};
private HashMap autoHideButtons = new HashMap(); // key : DockKey / value : AutoHideButton
private DragControler dragControler;
/** a component used to track position of the current maximized component */
private MaximizedComponentReplacer dummyMaximedReplacer = new MaximizedComponentReplacer();// 2007/01/18
//new JLabel();
/** the current maximized component */
private Component maximizedComponent;
/** a flag set when adding a maximized component : true is this one is heavyweight
* Only used with heavyweight support AND singleHeavyWeightComponent
*/
private boolean currentMaximizedComponentIsHeavyWeight = false;
private JComponent mouseMotionGrabber = new JComponent() {
// component used to grab mouse events under the expansion panel
// only visible (and active) when expansion panel is visible
};
/** this timer is only used when the java version is < 1.5 (version>=1.5 uses the MouseInfo component)*/
private javax.swing.Timer mouseOutOfExpandedPanelTimer
= new javax.swing.Timer(1000, new ActionListener() {
// timer used to hide the expanded panel when mouse is out too long
public void actionPerformed(ActionEvent actionEvent) {
if (!expandPanel.isActive() && expandPanel.shouldCollapse()) {
// do not hide it if it has got the focus
// or if a non-collapsible operation is occuring
expandPanel.collapse();
}
}
});
/** groups of tabs (used to re-tab autohidden dockable)*/
protected HashMap tabbedGroups = new HashMap(); // base.
* if base is not already child of a tabbedpane, a new tabbedpane will be created and inserted
* at base's location.
* @param order the tab order of view in its tabbed pane.
*
*/
public void createTab(Dockable base, Dockable dockable, int order){
createTab(base, dockable, order, false);
}
/** Add a view in a tab, or create it if it doesn't exist.
* dockable.
*
* */
public void splitComponent(Component base, Dockable dockable, DockingConstants.Split position){
/* splitComponent() is called from SplitContainer and BorderSplitter
* BorderSplitter is used by :
* - DockView (not floating, as the DetachedDockView child overrides the scanDrop method and doesn't use the BorderSplitter
* - DockTabbedPane (only when not floating)
* SplitContainer is used for DnD operations that can occur from Hide/Docked/Floating elements
*
*=> The future state will be DOCKED, but we cannot guess the current state (HIDE/FLOAT/DOCKED)
*=> as of 2.1 : the future state can be DOCKED or FLOATING (with the help of compound dockable)
*/
if (base == null) throw new NullPointerException("base");
if (dockable == null) throw new NullPointerException("dockable");
context.registerDockable(dockable);
//int futureState = DockableState.STATE_DOCKED;
int futureState = DockingUtilities.getDockableStateFromHierarchy(base);
/*if (!dockingPanel.isAncestorOf(base)){
futureState = DockableState.STATE_FLOATING;
}*/
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
boolean stateChange = false;
if (currentState == null){
stateChange = true;
} else if (currentState.getState() != futureState){
stateChange = true;
}
DockableState newState = new DockableState(this, dockable, futureState);
// DockableState.STATE_DOCKED);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(
currentState, newState);
DockingActionEvent dae = new DockingActionSplitComponentEvent(this, dockable, currentStateAsInt,
newState.getState(), base, position, 0.5f);
if (!isDockingActionAccepted(dae, dswe)) {
return; // vetoed
}
if (stateChange){
if (currentState.isFloating()){
removePreviousFloatingState(dockable); // clear reference of the previous state
}
}
Container oldContainer = (Container)DockingUtilities.findSingleDockableContainer(
dockable);
int oldWidth = 0;
int oldHeight = 0;
if (oldContainer != null){
oldWidth = oldContainer.getWidth();
oldHeight = oldContainer.getHeight();
} else {
oldWidth = base.getWidth() / 2;
oldHeight = base.getHeight()/2;
}
DockableContainer dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_SPLIT_CONTAINER);
dockableContainer.installDocking(this);
// create a new splitcontainer that will replace baseDockable's container
SplitContainer split;
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_BOTTOM){
split = new SplitContainer(JSplitPane.VERTICAL_SPLIT);
} else /*if (position == DockingConstants.SPLIT_LEFT
|| position == DockingConstants.SPLIT_RIGHT)*/{
split = new SplitContainer(JSplitPane.HORIZONTAL_SPLIT);
}
if (base != dockingPanel){ // 2005/11/08 support for splitting from dockingPanel
DockingUtilities.replaceChild(base.getParent(), base, split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent((Component)dockableContainer);
split.setRightComponent(base);
} else {
split.setRightComponent((Component)dockableContainer);
split.setLeftComponent(base);
}
} else {
// docking panel must remain the top level ancestor
if (dockingPanel.getComponentCount() != 0){
Component dockingPanelChild = dockingPanel.getComponent(0);
DockingUtilities.replaceChild(dockingPanel, dockingPanelChild, split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent((Component)dockableContainer);
split.setRightComponent(dockingPanelChild);
} else {
split.setRightComponent((Component)dockableContainer);
split.setLeftComponent(dockingPanelChild);
}
} else { // dockingpanel is empty
dockingPanel.add((Component) dockableContainer);
}
}
// if (oldContainer != null){
// now try to keep same size as before the drop
// we do this in invokelater because split.getWidth()/getHeight() returns 0 at this time
// and we need this value to do a correct setDividerLocation.
if (position == DockingConstants.SPLIT_TOP) {
SwingUtilities.invokeLater(new SplitResizer(split, oldHeight));
} else if (position == DockingConstants.SPLIT_BOTTOM) {
SwingUtilities.invokeLater(new SplitResizer(split, -oldHeight));
} else if (position == DockingConstants.SPLIT_LEFT) {
SwingUtilities.invokeLater(new SplitResizer(split, oldWidth));
} else if (position == DockingConstants.SPLIT_RIGHT) {
SwingUtilities.invokeLater(new SplitResizer(split, -oldWidth));
}
// }
context.setDockableState(dockable, newState);
if (stateChange){
if (futureState == DockableState.STATE_FLOATING ){
// splitting from ? (should be Docked) to floating
// we have to store a return state.
storePreviousFloatingState(dockable, currentState);
}
}
dockable.getDockKey().setDockableState(futureState);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
removeFromTabbedGroup(dockable); //2005/10/10
DockingUtilities.updateResizeWeights(dockingPanel);
}
/** Replaces the base component by a split pane oriented according to position,
* and put the dockablesContainer at position.
* dockable.
*
* */
public void splitComponent(Component base, Container dockablesContainer, DockingConstants.Split position){
if (dockablesContainer instanceof SingleDockableContainer){
splitComponent(base, ((SingleDockableContainer)dockablesContainer).getDockable(), position);
} else if (dockablesContainer instanceof TabbedDockableContainer){
splitTab(base, (TabbedDockableContainer)dockablesContainer, position);
} else {
System.err.println("unknow split request !" + dockablesContainer );
}
}
private void splitTab(Component base, TabbedDockableContainer tdc, DockingConstants.Split position){
// should be used only when drag and dropping
if (base == null) throw new NullPointerException("base");
Dockable firstDockable = tdc.getDockableAt(0);
DockableState currentState = getDockableState(firstDockable);
boolean stateChange = false;
if (currentState.isFloating()){
removePreviousFloatingStates(tdc); // clear reference of the previous state
stateChange = true;
}
Container oldContainer = (Container)tdc;
int oldWidth = 0;
int oldHeight = 0;
if (oldContainer != null){
oldWidth = oldContainer.getWidth();
oldHeight = oldContainer.getHeight();
} else {
oldWidth = base.getWidth() / 2;
oldHeight = base.getHeight()/2;
}
DockableContainer dockableContainer = tdc;
// create a new splitcontainer that will replace baseDockable's container
SplitContainer split;
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_BOTTOM){
split = new SplitContainer(JSplitPane.VERTICAL_SPLIT);
} else /*if (position == DockingConstants.SPLIT_LEFT
|| position == DockingConstants.SPLIT_RIGHT)*/{
split = new SplitContainer(JSplitPane.HORIZONTAL_SPLIT);
}
if (base != dockingPanel){ // 2005/11/08 support for splitting from dockingPanel
DockingUtilities.replaceChild(base.getParent(), base, split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent((Component)dockableContainer);
split.setRightComponent(base);
} else {
split.setRightComponent((Component)dockableContainer);
split.setLeftComponent(base);
}
} else {
// docking panel must remain the top level ancestor
if (dockingPanel.getComponentCount() != 0){
Component dockingPanelChild = dockingPanel.getComponent(0);
DockingUtilities.replaceChild(dockingPanel, dockingPanelChild, split);
if (position == DockingConstants.SPLIT_TOP
|| position == DockingConstants.SPLIT_LEFT){
split.setLeftComponent((Component)dockableContainer);
split.setRightComponent(dockingPanelChild);
} else {
split.setRightComponent((Component)dockableContainer);
split.setLeftComponent(dockingPanelChild);
}
} else { // dockingpanel is empty
dockingPanel.add((Component) dockableContainer);
}
}
//if (oldContainer != null){
// now try to keep same size as before the drop
// we do this in invokelater because split.getWidth()/getHeight() returns 0 at this time
// and we need this value to do a correct setDividerLocation.
if (position == DockingConstants.SPLIT_TOP) {
SwingUtilities.invokeLater(new SplitResizer(split, oldHeight));
} else if (position == DockingConstants.SPLIT_BOTTOM) {
SwingUtilities.invokeLater(new SplitResizer(split, -oldHeight));
} else if (position == DockingConstants.SPLIT_LEFT) {
SwingUtilities.invokeLater(new SplitResizer(split, oldWidth));
} else if (position == DockingConstants.SPLIT_RIGHT) {
SwingUtilities.invokeLater(new SplitResizer(split, -oldWidth));
}
//}
if (stateChange){
// this part is tricky : we assume the caller is DragContoller (it's the only
// legal way to invoke this method). DragController triggers event change
for (int i=0; i < tdc.getTabCount(); i++){
Dockable d = tdc.getDockableAt(i);
DockableState newState = new DockableState(this, d, DockableState.STATE_DOCKED);
context.setDockableState(d, newState);
}
}
// registerDockable(dockable);
// dockableStates.put(dockable, newState);
// if (stateChange){
// dockable.getDockKey().setDockableState(DockableState.STATE_DOCKED);
// fireDockableStateChange(new DockableStateChangeEvent(currentState, newState));
// }
//
// removeFromTabbedGroup(dockable); //2005/10/10
// DockingUtilities.updateResizeWeights(dockingPanel);
}
/** Moves a dockable to another position (relative to a destination dockable)
*
*
* @param dockable must be a registered Dockable
* @param base must be a visible Dockable
* @param position relative positionning
*/
public void move(Dockable base, Dockable dockable, DockingConstants.Split position){
if (base == null) throw new NullPointerException("base must not be null");
if (dockable == null) throw new NullPointerException("dockable must not be null");
if (dockable == base) return;
remove(dockable);
removeFromTabbedGroup(dockable); // 2005/07/13
split(base, dockable, position);
}
/** Shows again a dockable (if previously hidden, floating or closed).
* source. These listeners
* are used to perform start-dragging-docking actions over the source component */
public void installDockableDragSource(DockableDragSource source) {
((Component)source).addMouseListener(dragControler);
((Component)source).addMouseMotionListener(dragControler);
}
/** This method is used by DockableContainers in order to unregister their
* DockableDragSource(s) to the DragControler.
* DockKeys of the stream must be registered with
* the {@link #registerDockable(Dockable) registerDockable} method,
* prior readXML.
* This is the case if the desktop is already open and dockables
* laid out, but might not be the case if this method is used at application startup
* to populate an empty desktop.
*
*
*
*/
public void addDockable(Dockable dockable) {
/* addDockable isn't called internally by the API : just for user applications */
addDockable(dockable, new RelativeDockablePosition(0,0.8,0.5,0.2));
}
/** Adds a dockable in the docking desktop, and tries to respect the relative
* positionning provided.
*
*
*
* @param dockable the dockable to add (must not be already visible)
* @param position relative position of the dockable
*
* @throws IllegalArgumentException if the dockable already belongs to the desktop containment
* hierarchy.
*/
public void addDockable(Dockable dockable, RelativeDockablePosition position){
/* addDockable isn't called internally by the API : just for user applications */
if (this.isAncestorOf(dockable.getComponent())){
throw new IllegalArgumentException("Dockable is already contained in the desktop");
}
registerDockable(dockable);
if (DockingUtilities.findSingleDockableContainer(dockable) != null){
remove(dockable);
}
DockableState newState = new DockableState(this, dockable, DockableState.STATE_DOCKED, position);
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
DockingActionEvent dae = new DockingActionAddDockableEvent(this, dockable, currentStateAsInt, newState.getState(), dockingPanel);
if (isDockingActionAccepted(dae, dswe)){
SingleDockableContainer sdc = RelativeDockingUtilities.insertDockable(
dockingPanel, dockable, position);
sdc.installDocking(this);
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_DOCKED);
DockableStateChangeEvent dse = new DockableStateChangeEvent(currentState, newState);
fireDockingAction(dae, dse);
DockingUtilities.updateResizeWeights(dockingPanel);
}
}
/** Replaces a dockable by another one.
*
*
* @since 2.1
*/
public void addDockable(CompoundDockable base, Dockable dockable) {
registerDockable(dockable);
DockableState currentState = getDockableState(dockable);
int currentStateAsInt = getStateAsInt(currentState);
DockableState newState = new DockableState(this, dockable, DockableState.STATE_DOCKED);
DockableStateWillChangeEvent dswe = new DockableStateWillChangeEvent(currentState, newState);
CompoundDockingPanel panel = (CompoundDockingPanel) base.getComponent();
DockingActionEvent dae = new DockingActionAddDockableEvent(this, dockable,
currentStateAsInt, newState.getState(), panel);
if (isDockingActionAccepted(dae, dswe)){
DockableContainer dockableContainer = DockableContainerFactory.getFactory().
createDockableContainer(dockable, DockableContainerFactory.PARENT_DESKTOP);
dockableContainer.installDocking(this);
//TODO : check and raise exception if not empty
panel.add((JComponent)dockableContainer, BorderLayout.CENTER);
context.setDockableState(dockable, newState);
dockable.getDockKey().setDockableState(DockableState.STATE_DOCKED);
fireDockingAction(dae, new DockableStateChangeEvent(currentState, newState));
}
}
/** Evaluates and returns the preferred size of the desktop, according to
* its contents and auto-hide borders.*/
public Dimension getPreferredSize(){
Insets i = getDockingPanelInsets();
Dimension dim = dockingPanel.getPreferredSize();
dim.width += i.left + i.right;
dim.height += i.top + i.bottom;
return dim;
}
/** Adds a new DockableStateChangeListener to this desktop.
*
* ToolTipManager.sharedInstance().setLightWeightPopupEnabled(false);
* JPopupMenu.setDefaultLightWeightPopupEnabled(false);
*
*
* ToolTipManager.sharedInstance().setLightWeightPopupEnabled(false);
* JPopupMenu.setDefaultLightWeightPopupEnabled(false);
* setLightweigthComponentEnabled(false);
* getAutoHidePolicy().setExpansionDuration(0);
*
*/
public static void initHeavyWeightUsage(){
// for now, there are only two methods used.
ToolTipManager.sharedInstance().setLightWeightPopupEnabled(false);
JPopupMenu.setDefaultLightWeightPopupEnabled(false);
setLightweigthComponentEnabled(false);
getAutoHidePolicy().setExpansionDuration(0);
}
/** Facade method used to allow mixing of lightweight and heavyweight components in the
* desktop.
*/
public static void initHeavyWeightUsage(boolean isSingleHeavyWeightComponent){
initHeavyWeightUsage();
setSingleHeavyWeightComponent(isSingleHeavyWeightComponent);
}
/** Convenience method to use the VLDocking 1.0 layout and border style (with shadows around dockables) */
public static void setShadowDesktopStyle(){
DockingUISettings.getInstance().installUI();
UIManager.put("DockView.singleDockableBorder", new ShadowBorder());
UIManager.put("DockView.tabbedDockableBorder", new ShadowBorder(false));
UIManager.put("TabbedDockableContainer.tabPlacement", new Integer(SwingConstants.BOTTOM));
}
/** Convenience method to use the VLDocking 2.0 layout and border style.
*
* Frame f = ... // frame containing the docking panel
* DockingPanel dockingPanel = ...
* DockingSelectorDialog dlg = new DockingSelectorDialog(f);
* dlg.setDockingPanel(dockingPanel);
* dlg.pack();
* dlg.setLocationRelativeTo(f);
* dlg.setVisible(true); // modal
*
* // optional
* if (dlg.getClosingState() == DockingSelectorDialog.CONFIRM){
* // do something more
* }
*
*
* @see DockingPanel
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class DockingSelectorDialog extends JDialog {
/** Closing state of the dialog when the user has selected the confirm option
* @see #getClosingState() */
public static final int CONFIRM = 0;
/** Closing state of the dialog when the user has selected the cancel option
* @see #getClosingState() */
public static final int CANCEL = 1;
private DockablesTableModel model;
private DockingDesktop desktop;
private static final String TITLE = "Docking Configuration";
private JButton confirmButton = new JButton("Ok");
private JButton cancelButton = new JButton("Cancel");
private JTable table = new JTable();
JLabel wizardLabel = new JLabel() {
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Paint p = g2.getPaint();
g2.setPaint(new GradientPaint(0, 0, Color.WHITE, getWidth(), 0,
getBackground()));
g2.fillRect(0, 0, getWidth(), getHeight());
g2.setPaint(p);
super.paintComponent(g);
}
};
private String wizardLabelText =
"x, y, w, h fields are expressed with double values
* varying from 0 to 1.
*
*
*
*
*
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public class ShadowBorder implements Border {
private static Insets INSETS_FULL = new Insets(3, 2, 5, 5);
private static Insets INSETS_HALF = new Insets(1, 1, 5, 5);
private static Image shadowImage = new ImageIcon(ShadowBorder.class.getResource("shadow.png")).getImage();
static int shadowW = shadowImage.getWidth(null);
static int shadowH = shadowImage.getHeight(null);
private Color highlight = UIManager.getColor("controlLtHighlight");
private Color shadow = UIManager.getColor("controlShadow");
private boolean paintTopLeft = true;
private Insets insets;
/* Constructs a full shadow border */
public ShadowBorder() {
this(true);
}
/** Constructs a full shadow border (if paintTopLeft is true) or a half shadow border
* (is false).
* */
public ShadowBorder(boolean paintTopLeft) {
this.paintTopLeft = paintTopLeft;
insets = paintTopLeft? INSETS_FULL : INSETS_HALF;
}
public boolean isBorderOpaque() {
return false;
}
public void paintBorder(Component component, Graphics graphics, int x,
int y, int w, int h) {
// top corner
graphics.drawImage(shadowImage,
x+ w -5, y, x+w, y+5, shadowW-5,0, shadowW, 5, null);
// vertical
graphics.drawImage(shadowImage,
x+ w -5, y+5, x+w, y+h-5, shadowW-5,5, shadowW, shadowH-5, null);
// bottom-right corner
graphics.drawImage(shadowImage,
x+ w -5, y+h-5, x+w, y+h, shadowW-5,shadowH-5, shadowW, shadowH, null);
// horizontal
graphics.drawImage(shadowImage,
x+5, y+h-5, x+w-5, y+h, 5,shadowH-5, shadowW-5, shadowH, null);
// bottom left corner
graphics.drawImage(shadowImage,
x, y+h-5, x+5, y+h,
0, shadowH-5, 5, shadowH, null);
if (paintTopLeft){
graphics.setColor(highlight);
graphics.drawRect(x + 1, y + 2, w - 7, 1);
// graphics.drawRect(x + 1, y + 2, 1, h - 7);
graphics.drawLine(x + 1, y + 2, x+1, y + h - 5);
graphics.setColor(shadow);
graphics.drawRect(x, y + 1, w - 5, h - 6);
}
}
public Insets getBorderInsets(Component component) {
return insets;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/SingleDockableContainer.java 0000644 0001750 0001750 00000011557 10573516350 027623 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
/** A SingleDockableContainer is a DockableContainer that can display
* a single Dockable component.
* DockView hasn't
* got enough features or to provide a different look and feel).
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public interface SingleDockableContainer extends DockableContainer {
/** Returns the dockable this container is displaying */
public Dockable getDockable();
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/SplitContainer.java 0000644 0001750 0001750 00000043353 10573516350 026047 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.docking;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.event.ComponentEvent;
import java.awt.geom.*;
import com.vlsolutions.swing.docking.event.*;
/** A Specialized JSplitPane which accepts drag and drop of DockableContainer.
*DockTabbedPane).
*
* @author Lilian Chamontin, vlsolutions.
* @version 1.0
*/
public interface TabbedDockableContainer extends DockableContainer {
/** Returns the currently selected (front) dockable */
public Dockable getSelectedDockable();
/** Change the tab selection to display this dockable */
public void setSelectedDockable(Dockable dockable);
/** Returs the current tab count (which is also the current dockable count) */
public int getTabCount();
/** Returns the dockable at the index tab */
public Dockable getDockableAt(int index);
/** Adds a dockable to the given index tab. */
public void addDockable(Dockable dockable, int index);
/** Removes a dockable from the tabs */
public void removeDockable(Dockable dockable);
/** Remove the dockable at specified index tab */
public void removeDockable(int index);
/** Returns the index of the given dockable */
public int indexOfDockable(Dockable dockable);
}
vldocking_2.1.4/src/com/vlsolutions/swing/docking/attach16v2.png 0000644 0001750 0001750 00000000475 10573516344 024640 0 ustar twerner twerner PNG
IHDR a bKGD pHYs tIME
+) IDATxc`hTOɓ5"Y` }5_ IENDB` vldocking_2.1.4/src/com/vlsolutions/swing/docking/attach16v2rollover.png 0000644 0001750 0001750 00000000516 10573516344 026421 0 ustar twerner twerner PNG
IHDR a bKGD pHYs tIME
T IDATxڝS+0}pj[[Q#~/ܢATW t!Ulg7I R#7{ ?qts+$treyAC4*Z/!Q݊ H VLSolutions Docking Framework.
Getting Started
To fully understand the principles of docking please read the following documents :
The VL Docking Framework for JFC "Swing" applications.
Goals.
The VLSolutions Docking Framework provides a means to add docking capabilities into a Swing
application with minor modification of the components hierarchy (only decoration of
existing components and containers and adding of a new root container).
Audience.
For API Users
Basic Description
DockingDesktop : the root container of a docking-enabled application
Dockable : an interface implemented (usually) by components that need
docking capabilities.
DockableContainers : specialized containers with drag and drop extensions
(come in two flavors, SingleDockableContainer and TabbedDockabeContainer).
DockKey : a JavaBeans object fully describing the dockable (use for save/load, and for
DockableContainers customization) : name, icon, tooltip, docking features.
The
DockingDesktop class. JInternalFrame API, the DockingDesktop is equivalent
to the JDesktopPane : a layered pane capable of managing and displaying
multiple components, with overlapping when needed.
Dockable.
DockableContainer that can be
recursively splitted in two (horizontally or vertically) to add
more DockableContainers. Each split acts
as a JSplitPane, and can be resized by the end-user or with the API.
The
The Dockable interface Dockable is implemented by dockable component providers or, simply
by components that want to benefit of the docking features.
The
These interfaces are implemented by containers of Dockables. Usually you will not
interact with them (except if you want to extend the framework).
DockableContainer, SingleDockableContainer and
TabbedDockableContainer interfaces. The
This one is important because it fully describes the Docking presentation of
your dockables, and their behaviour.
DockKey class
DockingDesktop needs a unique key to identify a dockable
(for read/write operations)
DockableContainer displaying a Dockable wants
information about the dockable : a name, an icon, ...
Getting Started
It's easy, just follow the steps below, or have a look at the tutorial on
www.vlsolutions.com/en/documention/docking/tutorial.
Creating a small sample application :
import com.vlsolutions.swing.docking.*;
import javax.swing.*;
import java.awt.*;
public class DemoFrame extends JFrame {
// our docking desktop
DockingDesktop desk = new DockingDesktop();
public DemoFrame(){
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
getContentPane().add(desk);
// first, create 4 dockable buttons (inner class below)
DockableButton button1 = new DockableButton("Dockable 1");
DockableButton button2 = new DockableButton("Dockable 2");
DockableButton button3 = new DockableButton("Dockable 3");
DockableButton button4 = new DockableButton("Dockable 4");
// first button at center
desk.addDockable(button1);
// second and third button splitted vertically on the left of center
// first parameter is the "reference", second is the added dockable
desk.split(button1, button2, DockingConstants.SPLIT_LEFT);
desk.split(button2, button3, DockingConstants.SPLIT_BOTTOM);
// add the fourth button as a tab on the 3rd :
desk.createTab(button3, button4, 1);
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
setSize(800,600);
validate();
setVisible(true); // realize on the event dispatch thread
}
});
}
public static void main(String [] args){
new DemoFrame();
}
// our basic dockable object
class DockableButton extends JButton implements Dockable {
DockKey key;
public DockableButton(String label){
super(label);
this.key = new DockKey(label); // most simple dockkey constructor
setPreferredSize(new Dimension(200,200));
}
public DockKey getDockKey() {
return key;
}
public Component getComponent() {
return this;
}
}
}
You can read more about these features in the tutorial on
www.vlsolutions.com/en/documention/docking/tutorial.
Browsing the API
Extending the API
*
*
* The ToolBarContainer is a JPanel with a BorderLayout, containing a user component and a maximum of four
* ToolBarPanels.
* FlowLayout.LEFT, FlowLayout.RIGHT,
* FlowLayout.CENTER, FlowLayout.LEADING, or
* FlowLayout.TRAILING.
*VLToolBars of the stream must be registered with
* the {@link ToolBarContainer#registerToolBar(VLToolBar) registerToolBar} method,
* prior readXML.
*
* The ToolBarPanel is a JPanel with a ToolBarPanelLayout. It support horizontal and vertical orientation,
* and can contain one or more VLToolbars (with given ToolBarContraints for positionning).
* ToolBarPanel with the specified
* alignment.
* @param align the alignment value
* The value of the alignment argument must be one of
* FlowLayout.LEFT, FlowLayout.RIGHT,
* FlowLayout.CENTER, FlowLayout.LEADING, or
* FlowLayout.TRAILING.
*
*/
public ToolBarPanel(int align) {
this(align, null);
}
/**
* Constructs a new ToolBarPanel with the specified
* alignment and background painter.
* @param align the alignment value
* The value of the alignment argument must be one of
* FlowLayout.LEFT, FlowLayout.RIGHT,
* FlowLayout.CENTER, FlowLayout.LEADING, or
* FlowLayout.TRAILING.
* @param painter the background painter.
* @since 2.1.4
*/
public ToolBarPanel(int align, BackgroundPainter painter) {
setLayout(new ToolBarPanelLayout(this, align));
this.painter = painter;
}
/** Adds a new toolbar respecting the given positionning constraints.
*/
public void add(JToolBar toolbar){
add(toolbar, 0);
setVisible(true);
}
/** Adds a new JToolBar to the Panel at the given row. Multiple VLToolBars
* are constructed using Separators in the original JToolBar
*/
public void add(JToolBar toolbar, int major){
toolbar.setOrientation(orientation);
VLToolBar[] bars = getVLToolBarsFromJToolBar(toolbar);
for (int i = 0; i < bars.length; i++) {
ToolBarConstraints toolBarConstraints = new ToolBarConstraints(major, i);
add(bars[i], toolBarConstraints) ;
}
}
/**
* Helper function to convert a JToolBar into multiple VLToolBar objects. The JToolBar
* is split at the separator boundary to create VLToolbars
* @param bar, the JToolBar object
* @return array of VLToolBar objects
*/
private VLToolBar[] getVLToolBarsFromJToolBar(JToolBar bar) {
ArrayList vlBars = new ArrayList();
Component[] components = bar.getComponents();
VLToolBar current = new VLToolBar();
for (int i = 0; i < components.length; i++) {
if (components[i] instanceof JButton) {
JButton button = (JButton) components[i];
if (button.getIcon() != null)
button.setText(null);
current.add(button);
} else if (components[i] instanceof Separator) {
vlBars.add(current);
current = new VLToolBar();
} else {
System.err.println("Don't know how to handle this component " + components[i].getClass());
}
}
vlBars.add(current);
return (VLToolBar[]) vlBars.toArray(new VLToolBar[vlBars.size()]);
}
/** Adds a new toolbar respecting the given positionning constraints.
*/
public void add(VLToolBar toolbar, ToolBarConstraints constraints){
toolbar.setOrientation(orientation);
super.add(toolbar, constraints);
setVisible(true);
}
public void remove(Component comp){
super.remove(comp);
if (getComponentCount() == 0){
setVisible(false);
}
}
/* Updates the orientation of this toolbar. Valid values are SwingConstants.HORIZONTAL and VERTICAL*/
public void setOrientation(int orientation){
if (this.orientation != orientation){
this.orientation = orientation;
updateOrientation();
revalidate();
}
}
/** Returns the orientation of this toolbarpanel */
public int getOrientation(){
return this.orientation;
}
/** Propagates the orientation to the contained toolbars */
private void updateOrientation(){
for (int i=0; i < getComponentCount(); i++){
VLToolBar tb = (VLToolBar) getComponent(i);
tb.setOrientation(orientation);
}
}
/** Overriden for optional background painting */
public void paintComponent(Graphics g){
if (painter != null){
painter.paintBackground(this, g);
}
super.paintComponent(g);
}
/** Returns the optional background painter for this toolbar panel (may be null)
*@since 2.1.4
*/
public BackgroundPainter getBackgroundPainter() {
return painter;
}
/** Updates the optional background painter for this toolbar panel
* @param painter the new painer (may be null)
* @since 2.1.4
*/
public void setPainter(BackgroundPainter painter) {
this.painter = painter;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarPanelBorder.java 0000644 0001750 0001750 00000017637 10573516350 027006 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import javax.swing.ImageIcon;
import javax.swing.UIManager;
import javax.swing.border.Border;
/** This is an optional class that can be used as a border for toolbar panels.
*
* @author Lilian Chamontin, VLSolutions
*/
public class ToolBarPanelBorder implements Border {
public static final int TOP_PANEL = 0;
public static final int LEFT_PANEL = 1;
public static final int BOTTOM_PANEL = 2;
public static final int RIGHT_PANEL = 3;
private static Image borderImage = new ImageIcon(ToolBarButtonBorder.class.getResource("toolbarpanelborder.png")).getImage();
static int borderWidth = borderImage.getWidth(null);
static int borderHeight = borderImage.getHeight(null);
private Insets insets;
private int panelPosition;
public ToolBarPanelBorder() {
this(TOP_PANEL);
}
public ToolBarPanelBorder(int panelPosition) {
this.panelPosition = panelPosition;
switch(panelPosition){
case TOP_PANEL:
insets = new Insets(1, 1, 4, 1);
break;
case LEFT_PANEL:
insets = new Insets(1, 1, 1, 4);
break;
case BOTTOM_PANEL:
insets = new Insets(4, 1, 1, 1);
break;
case RIGHT_PANEL:
insets = new Insets(1, 4, 1, 1);
break;
}
}
public boolean isBorderOpaque() {
return false;
}
public void paintBorder(Component component, Graphics graphics, int x,
int y, int w, int h) {
switch (panelPosition){
case TOP_PANEL:
// horizontal bottom
graphics.drawImage(borderImage,
x, y+h-5, x+w, y+h, 5,borderHeight-5, borderWidth-5, borderHeight, null);
// bottom-right corner
/* graphics.drawImage(borderImage,
x+ w -SIDE, y+h-SIDE, x+w, y+h, borderWidth-SIDE,borderHeight-SIDE, borderWidth, borderWidth, null);
// bottom left
graphics.drawImage(borderImage,
x, y+h-SIDE, x+SIDE, y+h, 0, borderHeight-SIDE, SIDE, borderHeight, null);*/
break;
case LEFT_PANEL:
// vertical right
graphics.drawImage(borderImage,
x+ w -5, y, x+w, y+h, borderWidth-5,5, borderWidth, borderHeight-5, null);
break;
case BOTTOM_PANEL:
// horizontal top
graphics.drawImage(borderImage,
x, y, x+w, y+5, 5,0, borderHeight-5, 5, null);
break;
case RIGHT_PANEL:
// vertical left
graphics.drawImage(borderImage,
x, y, x+5, y+h, 0,5, 5, borderHeight-5, null);
break;
}
/*
// top right corner
graphics.drawImage(borderImage,
x+ w -5, y, x+w, y+5, borderWidth-5,0, borderWidth, 5, null);
// vertical right
graphics.drawImage(borderImage,
x+ w -5, y+5, x+w, y+h-5, borderWidth-5,5, borderWidth, borderHeight-5, null);
// bottom-right corner
graphics.drawImage(borderImage,
x+ w -5, y+h-5, x+w, y+h, borderHeight-5,borderWidth-5, borderWidth, borderHeight, null);
// horizontal bottom
graphics.drawImage(borderImage,
x+5, y+h-5, x+w-5, y+h, 5,borderHeight-5, borderWidth-5, borderHeight, null);
// bottom left corner
graphics.drawImage(borderImage,
x, y+h-5, x+5, y+h,
0, borderHeight-5, 5, borderHeight, null);
// horizontal top
graphics.drawImage(borderImage,
x+5, y, x+w-5, y+5, 5,0, borderHeight-5, 5, null);
// vertical left
graphics.drawImage(borderImage,
x, y+5, x+5, y+h-5, 0,5, 5, borderHeight-5, null);
// top left corner
graphics.drawImage(borderImage,
x, y, x+5, y+5, 0,0, 5, 5, null);
*/
}
public Insets getBorderInsets(Component component) {
return insets;
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarPanelLayout.java 0000644 0001750 0001750 00000056406 10573516350 027043 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Collections;
import javax.swing.SwingConstants;
/** The layout of a VLToolBarPanel
*
* @author Lilian Chamontin, VLSolutions
* @update 2006/09/09 Support for LTR and RTL component orientation
*/
public class ToolBarPanelLayout implements LayoutManager2{
private ToolBarPanel panel;
private ArrayList componentInfos = new ArrayList();
private int gap = 3; // gap in pixels between components
private int align = FlowLayout.LEADING ;
public ToolBarPanelLayout(ToolBarPanel panel, int align) {
this.panel = panel ;
this.align = align ;
}
public ToolBarPanelLayout(ToolBarPanel panel) {
this(panel, FlowLayout.LEADING);
}
/** Returns the alignment of this layout (FlowLayout.LEADING, TRAILING...)
*/
public int getAlign() {
return align;
}
public void setAlign(int align) {
this.align = align;
}
private int getAlignedX(Container target) {
int left = 0 ;
boolean ltr = target.getComponentOrientation().isLeftToRight() ;
int width = preferredLayoutSize(target).width ;
switch (align) {
case FlowLayout.LEFT:
left += ltr ? 0 : target.getSize().width - width ;
break ;
case FlowLayout.CENTER:
left += (target.getSize().width - width)/2 ;
break ;
case FlowLayout.RIGHT:
left += ltr ? target.getSize().width - width : 0 ;
break ;
case FlowLayout.LEADING:
break ;
case FlowLayout.TRAILING:
left += target.getSize().width - width ;
break ;
}
return left ;
}
public float getLayoutAlignmentX(Container target) {
return 0.5F;
}
public float getLayoutAlignmentY(Container target) {
return 0.5F;
}
public void invalidateLayout(Container target) {
}
public Dimension maximumLayoutSize(Container target) {
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints == null){
throw new NullPointerException();
} else {
ToolBarConstraints tc = (ToolBarConstraints) constraints;
componentInfos.add(new ComponentInfo(comp, tc));
reorderComponents();
}
}
public ToolBarConstraints getConstraints(Component comp){
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo) componentInfos.get(i);
if (ci.comp == comp){
return ci.constraints;
}
}
return null;
}
public void removeLayoutComponent(Component comp) {
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo) componentInfos.get(i);
if (ci.comp == comp){
componentInfos.remove(i);
return ;
}
}
}
public void addLayoutComponent(String name, Component comp) {
}
public Dimension minimumLayoutSize(Container parent) {
ToolBarPanel panel = (ToolBarPanel) parent;
boolean isHorizontal = panel.getOrientation() == SwingConstants.HORIZONTAL;
synchronized (parent.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int majorCount = getMajorCount();
for (int i=0; i < majorCount; i++){
Dimension minorDim = new Dimension(0,0);
ArrayList minorList = getMinorComponents(i);
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Dimension d = ci.comp.getPreferredSize();
if (ci.comp.isVisible()){
if (isHorizontal) {
minorDim.width += d.width;
minorDim.height = Math.max(minorDim.height, d.height);
if (j > 0){
minorDim.width += gap;
}
} else {
minorDim.width = Math.max(minorDim.width, d.width);
minorDim.height += d.height;
if (j > 0){
minorDim.height += gap;
}
}
}
}
if (isHorizontal){
dim.width = Math.max(dim.width, minorDim.width);
dim.height += minorDim.height;
} else {
dim.width += minorDim.width;
dim.height = Math.max(dim.height, minorDim.height);
}
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
public Dimension preferredLayoutSize(Container parent) {
return minimumLayoutSize(parent);
}
/** Returns and ordered array of the contained components */
public Component [] getComponents(){
Component [] comps = new Component[componentInfos.size()];
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
comps[i] = ci.comp;
}
return comps;
}
public void layoutContainer(Container target) {
ToolBarPanel panel = (ToolBarPanel) target;
boolean isHorizontal = panel.getOrientation() == SwingConstants.HORIZONTAL;
boolean ltr = target.getComponentOrientation().isLeftToRight();
synchronized (target.getTreeLock()) {
Collections.sort(componentInfos);
Insets insets = target.getInsets();
if (isHorizontal){
int top = insets.top;
int majorCount = getMajorCount();
for (int i=0; i < majorCount; i++){
int left = insets.left + getAlignedX(target);
int maxHeight = 0;
ArrayList minorList = getMinorComponents(i);
/*for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Component comp = ci.comp;
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
left += d.width + gap;
maxHeight = Math.max(maxHeight, d.height);
}
}*/
if (ltr) {
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Dimension d = layoutHorizMinor(ci, left, top);
if (d != null) {
left += d.width + gap ;
maxHeight = Math.max(maxHeight, d.height);
}
}
} else {
for (int j=minorList.size()-1; j >= 0; j--){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Dimension d = layoutHorizMinor(ci, left, top);
if (d != null) {
left += d.width + gap ;
maxHeight = Math.max(maxHeight, d.height);
}
}
}
top += maxHeight;
}
} else {
int majorCount = getMajorCount();
/*int left = insets.left;
for (int i=0; i < majorCount; i++){
int top = insets.top;
int maxWidth = 0;
ArrayList minorList = getMinorComponents(i);
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Component comp = ci.comp;
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
top += d.height + gap;
maxWidth = Math.max(maxWidth, d.width);
}
}
left += maxWidth;*/
int left = insets.left;
if (ltr) {
for (int i=0; i < majorCount; i++){
int maxWidth = layoutVertMajor(insets, left, i);
left += maxWidth;
}
} else {
for (int i=majorCount-1; i >= 0; i--){
int maxWidth = layoutVertMajor(insets, left, i);
left += maxWidth;
}
}
}
}
}
private Dimension layoutHorizMinor(ComponentInfo ci, int left, int top) {
Component comp = ci.comp ;
if (comp.isVisible()) {
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
return d ;
}
return null ;
}
private int layoutVertMajor(Insets insets, int left, int i) {
int top = insets.top;
int maxWidth = 0;
ArrayList minorList = getMinorComponents(i);
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Component comp = ci.comp;
if (comp.isVisible()){
Dimension d = comp.getPreferredSize();
comp.setBounds(left, top, d.width, d.height);
top += d.height + gap;
maxWidth = Math.max(maxWidth, d.width);
}
}
return maxWidth;
}
private void reorderComponents(){
Collections.sort(componentInfos);
/* Usefull state dumps : I'll let them here for some time.
System.out.println("---------------------------------------------------");
System.out.println("List of components : ----BEFORE ------");
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
System.out.println(ci.constraints + " = " + ci.comp);
}
//*/
// first, insert new major orders
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
if (ci.constraints.majorOffset < 0){
ci.constraints.majorOffset = 0;
for (int j=i+1; j < componentInfos.size(); j++){
ComponentInfo next = (ComponentInfo)componentInfos.get(j);
next.constraints.majorOrder ++;
}
} else if (ci.constraints.majorOffset > 0){
ci.constraints.majorOffset = 0;
for (int j=i; j < componentInfos.size(); j++){ // also increase the current one
ComponentInfo next = (ComponentInfo)componentInfos.get(j);
next.constraints.majorOrder ++;
}
}
}
// next, insert new minor orders
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
if (ci.constraints.minorOffset < 0){
ci.constraints.minorOffset = 0;
for (int j=i+1; j < componentInfos.size(); j++){
ComponentInfo next = (ComponentInfo)componentInfos.get(j);
if (next.constraints.majorOrder == ci.constraints.majorOrder){
next.constraints.minorOrder ++;
}
}
} else if (ci.constraints.minorOffset > 0){
ci.constraints.minorOffset = 0;
for (int j=i; j < componentInfos.size(); j++){ // also increase the current one
ComponentInfo next = (ComponentInfo)componentInfos.get(j);
if (next.constraints.majorOrder == ci.constraints.majorOrder){
next.constraints.minorOrder ++;
}
}
}
}
/* System.out.println("List of components : after offsets");
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
System.out.println(ci.constraints + " = " + ci.comp);
}*/
// next, let all major and minor order be consecutive
int order = 0;
int minorOrder = 0;
int lastMajorOrder = -1;
int lastMinorOrder = -1;
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
if (lastMajorOrder == -1){
lastMajorOrder = ci.constraints.majorOrder;
lastMinorOrder = ci.constraints.minorOrder;
}
if (ci.constraints.majorOrder == lastMajorOrder){
ci.constraints.majorOrder = order;
if (ci.constraints.minorOrder == lastMinorOrder){
ci.constraints.minorOrder = minorOrder;
} else {
minorOrder ++;
lastMinorOrder = ci.constraints.minorOrder;
ci.constraints.minorOrder = minorOrder;
}
} else { // beginning of a new major
order ++;
minorOrder = 0;
lastMajorOrder = ci.constraints.majorOrder;
lastMinorOrder = ci.constraints.minorOrder;
ci.constraints.majorOrder = order;
ci.constraints.minorOrder = minorOrder;
}
}
/* System.out.println("List of components : ------AFTER ----");
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo)componentInfos.get(i);
System.out.println(ci.constraints + " = " + ci.comp);
}
*/
}
private ToolBarConstraints getHorizontalInsertionContraintsAt(Component draggedComponent, Point p){
ToolBarConstraints tc = new ToolBarConstraints();
int majorCount = getMajorCount();
for (int i=0; i < majorCount; i++){
Rectangle bounds = getMinorBounds(i);
if (p.y < bounds.y){ // insert before first
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = -1;
return tc;
} else if (p.y < bounds.y + 5){ // insert before current row
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = -1;
return tc;
} else if (p.y > bounds.y + bounds.height){ // insert after.. ignore (will be tested on next loop)
} else if (p.y > bounds.y + bounds.height - 5){ // insert a new major as we are just below the lower part
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = +1;
return tc;
} else if (p.x < bounds.x + bounds.width){ // insert inside
ArrayList minorList = getMinorComponents(i);
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Component comp = ci.comp;
if (comp.isVisible()){
if (p.x < comp.getX() + comp.getWidth()){
if (comp == draggedComponent){
return null;
} else if (p.x < comp.getX() + 10){ // at the beginning of the component
tc.majorOrder = i;
tc.minorOrder = j;
tc.minorOffset = -1;
return tc;
} else { // on the component but not at the beginning
if (j < minorList.size()-1){
ComponentInfo next = (ComponentInfo)minorList.get(j+1);
if (next.comp == draggedComponent){
return null;
}
}
tc.majorOrder = i;
tc.minorOrder = j;
tc.minorOffset = +1;
return tc;
}
}
}
}
// not possible to reach this point
} else { // after last of the row
ArrayList minorList = getMinorComponents(i);
tc.majorOrder = i;
tc.minorOrder = minorList.size();
return tc;
}
}
// not found... so it's after the last
tc.majorOrder = majorCount;
tc.minorOrder = 0;
return tc;
}
private ToolBarConstraints getVerticalInsertionContraintsAt(Component draggedComponent, Point p){
ToolBarConstraints tc = new ToolBarConstraints();
int majorCount = getMajorCount();
for (int i=0; i < majorCount; i++){
Rectangle bounds = getMinorBounds(i);
if (p.x < bounds.x){ // insert before first
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = -1;
return tc;
} else if (p.x < bounds.x + 3){ // insert before current row
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = -1;
return tc;
} else if (p.x > bounds.x + bounds.width){ // insert after.. ignore (will be tested on next loop)
} else if (p.x > bounds.x + bounds.width - 3){ // insert a new major as we are just below the lower part
tc.majorOrder = i;
tc.minorOrder = 0;
tc.majorOffset = +1;
return tc;
} else if (p.y < bounds.y + bounds.height){ // insert inside
ArrayList minorList = getMinorComponents(i);
for (int j=0; j < minorList.size(); j++){
ComponentInfo ci = (ComponentInfo) minorList.get(j);
Component comp = ci.comp;
if (comp.isVisible()){
if (p.y < comp.getY() + comp.getHeight()){
if (comp == draggedComponent){
return null;
} else if (p.y < comp.getY() + 10){ // at the beginning of the component
tc.majorOrder = i;
tc.minorOrder = j;
tc.minorOffset = -1;
return tc;
} else { // on the component but not at the beginning
if (j < minorList.size()-1){
ComponentInfo next = (ComponentInfo)minorList.get(j+1);
if (next.comp == draggedComponent){
return null;
}
}
tc.majorOrder = i;
tc.minorOrder = j;
tc.minorOffset = +1;
return tc;
}
}
}
}
// not possible to reach this point
} else { // after last of the row
ArrayList minorList = getMinorComponents(i);
tc.majorOrder = i;
tc.minorOrder = minorList.size();
return tc;
}
}
// not found... so it's after the last
tc.majorOrder = majorCount;
tc.minorOrder = 0;
return tc;
}
/** Returns a proposed TooBarContraints for a given insertion point */
public ToolBarConstraints getInsertionContraintsAt(Component draggedComponent, Point p){
boolean isHorizontal = panel.getOrientation() == SwingConstants.HORIZONTAL;
if (isHorizontal){
return getHorizontalInsertionContraintsAt(draggedComponent, p);
} else { // vertical
return getVerticalInsertionContraintsAt(draggedComponent, p);
}
}
private int getMajorCount(){
int max = 0;
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo) componentInfos.get(i);
ToolBarConstraints tc = ci.constraints;
if (tc.majorOrder > max){
max = tc.majorOrder;
}
}
return max+1;
}
private Rectangle getMinorBounds(int majorOrder){
Rectangle r = new Rectangle();
Rectangle temp = null;
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo) componentInfos.get(i);
if (ci.constraints.majorOrder == majorOrder){
temp = ci.comp.getBounds(temp);
r = r.union(temp);
}
}
return r;
}
private ArrayList getMinorComponents(int majorOrder){
ArrayList list = new ArrayList();
for (int i=0; i < componentInfos.size(); i++){
ComponentInfo ci = (ComponentInfo) componentInfos.get(i);
if (ci.constraints.majorOrder == majorOrder){
list.add(ci);
}
}
return list;
}
private class ComponentInfo implements Comparable{
Component comp;
ToolBarConstraints constraints;
ComponentInfo(Component comp, ToolBarConstraints constraints){
this.comp = comp;
this.constraints = constraints;
}
private int getCompareOrder(){
int order = constraints.majorOrder * 100000 + constraints.majorOffset * 10000
+ constraints.minorOrder * 100 + constraints.minorOffset;
return order;
}
public int compareTo(Object obj) {
ComponentInfo ci = (ComponentInfo) obj;
return getCompareOrder() - ci.getCompareOrder();
}
}
}
vldocking_2.1.4/src/com/vlsolutions/swing/toolbars/ToolBarPersistence.java 0000644 0001750 0001750 00000017224 10573516350 027065 0 ustar twerner twerner /*
VLDocking Framework 2.1
Copyright VLSOLUTIONS, 2004-2006
email : info@vlsolutions.com
------------------------------------------------------------------------
This software is distributed under the CeCILL license, a GNU GPL-compatible
license adapted to french law.
French and English license headers are provided at the begining of
the source files of this software application.
------------------------------------------------------------------------
LICENCE CeCILL (FRENCH VERSION).
------------------------------------------------------------------------
Ce logiciel est un programme informatique servant amliorer les interfaces
homme-machine d'applications Java bases sur Swing, en leur apportant un
ensemble de fonctions relatives au dockage des composants.
Ce logiciel est rgi par la licence CeCILL soumise au droit franais et
respectant les principes de diffusion des logiciels libres. Vous pouvez
utiliser, modifier et/ou redistribuer ce programme sous les conditions
de la licence CeCILL telle que diffuse par le CEA, le CNRS et l'INRIA
sur le site "http://www.cecill.info".
En contrepartie de l'accessibilit au code source et des droits de copie,
de modification et de redistribution accords par cette licence, il n'est
offert aux utilisateurs qu'une garantie limite. Pour les mmes raisons,
seule une responsabilit restreinte pse sur l'auteur du programme, le
titulaire des droits patrimoniaux et les concdants successifs.
A cet gard l'attention de l'utilisateur est attire sur les risques
associs au chargement, l'utilisation, la modification et/ou au
dveloppement et la reproduction du logiciel par l'utilisateur tant
donn sa spcificit de logiciel libre, qui peut le rendre complexe
manipuler et qui le rserve donc des dveloppeurs et des professionnels
avertis possdant des connaissances informatiques approfondies. Les
utilisateurs sont donc invits charger et tester l'adquation du
logiciel leurs besoins dans des conditions permettant d'assurer la
scurit de leurs systmes et ou de leurs donnes et, plus gnralement,
l'utiliser et l'exploiter dans les mmes conditions de scurit.
Le fait que vous puissiez accder cet en-tte signifie que vous avez
pris connaissance de la licence CeCILL, et que vous en avez accept les
termes.
------------------------------------------------------------------------
CeCILL License (ENGLISH VERSION)
------------------------------------------------------------------------
This software is a computer program whose purpose is to enhance Human-Computer
Interfaces written in Java with the Swing framework, providing them a set of
functions related to component docking.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
*/
package com.vlsolutions.swing.toolbars;
import java.awt.BorderLayout;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Iterator;
import java.util.prefs.Preferences;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
/**
* This class contains methods to keep a set of toolbars persistent.
*
*
*
*
* The VLToolBar contains buttons and other components, and is included in a ToolBarPanel of a ToolBarContainer .
*
*
*/
public void installButtonUI(AbstractButton button){
button.setMargin(new Insets(2,2,2,2));
button.setUI(new VLButtonUI());
button.setBorder(new ToolBarButtonBorder());
}
/** Used internally to add a mouse listener to the button.
*
*/
public void configureButton(AbstractButton button){
button.setRolloverEnabled(true);
button.setContentAreaFilled(false);
button.setOpaque(false);
button.setBorderPainted(false);
}
/** Updates the rolloverBorderPainted property.
* The VLToolBars.
Getting Started
An overview of the components used.
_re%C\V&'Ý%i8UD8Ib4/yA( EPJ
JosXyP; -F Dc txZ:LQT)*$(W(ZeCcGW $Rll4H$?OP X^ͬ 'y(B\c s+Gvz~OkyklA97fdSw z)kJ +UМ_{:0+1!gvڍon-9lq|1;"Nc3Y(_K #Θ˟бӹht~Іx3 ~;v>[:Ӡ
D]7f R> \p -x|СgBHk
W ʱC z~"婔fF) )Mw:W4:4 )_`/B*& W: l$ӒA
Eӎha$
Tl䗎*; xφ+!p@he}vx7:] a̫S [/_i{ݗk[ ehHyۦBYU:h ]]20 .24\}&ǓyW2h'V!5FrY;s.Zݙ% nQ)jb-
> O@)iQw7a&7sLTs鶏=Yݸq,+Z FHZf1,:dJbBJ v\R%R yPq " [CVVXxތ5
:H| ;K
gj^KDT]s['_nm
X}ca??iLI 1~
y`E Q-Z<ṽuGT~ކ4cT{$e^JHߞ.i" n2(C9j2Q$( ;&h*[Zv`|B ea(0 6nJEըͿjG `zE'ƕ $̱O};-LK n+WU *J-
6{;1-N_SBb ?]Ӟ?iam̛t7w.Tʕ.83`V
Ѽ@>y
ta3toh'7̊ T:n!I OL>E(GM*J{~D4/ț
J?ٲnXhZDqZcCi,+uJ - vN.]ߎ͗VNTpNmo}.x)e
2 ν
Yz NۇBۿ;.xYs3a/ܡ5Oލ.!|ϒr_QUW{ T S2HV!$
&HKT*2$,چ4IЄ5
h e4VGf w{o}a ?/{:s 䚈S^H ~c߄UۖƔ R$2*Ze4IR,%/vIMd-rC1 Q11
?CNQ)5JZ~WU`~:kl3cKg'_H`0htdR B͚pMx*
(̜_yf1"5RbRT\?98hUtSٜˈvs 4TW۔H
Vg(u2w@]i贪yU+*ڧ.ԅϗԪe% i,PEV}jF"VHt*$u^GЖN
t?>cJC#S"2|9- \Gy>rjpOjaa#F_;LoeRjRm] m2Iz m[!h ,ʀIn- (am/HI)t^f`z EEE'% 1{^-6shF菠~ tG!(o@,
t&T=NmDإǝ)<:)iOړkD.CBY\` 9GZ.s? 3ĊӅ,Hp*IC:c?o+a <1E JhgcM-:fL=/if4n ]?8?M38@wa{1ه =FSYcG:W
SMn_YsƁǤ^ L ;"u( "!!$ dlm4
wMMO4ą&MK#ѠqeL孓# VLl
w
i>x2ܚFG.:^EމsE]BÏ xnVU_=fOC3=4O43J܌buZx(
F=2m~yZWz8:Dhoc_f_[a!Z#߶kv=w|tO/-H|tAЅox~26 \*/A'm8⭚'SƂQKyFNJo$qhU ~s&'a y{]$z\bA)$P"[#Ifa"ܲ7!)Vq,ot
b@Q dMاw&
rKst ¶3K.et6!T٬3ALP 1. ke@Af=eڠ \,^- ?R 6I~+uGslLy㞞ޏ np{
endstream
endobj
332 0 obj
<< /Filter /FlateDecode /Length 12182 /Length1 24848 >>
stream
֫}$5po!I)=%ϊA}5t⒌ 44Ln} h?>
tH w4CQ7
^4ӄ,їӝV!imK
N{@-0[}
^~|xTע苶bc'uFʼ_$Yv T͔8F66RG&6x999 Z|];G maӧ;S,/}0>|; G) ',BUMj73QP^P{$ӦLRk.Cj6
"CkGB
@Brd9(U Z ( b/,sc툆 Aw998
*O0 A5/MXx 7B|#Cٔ(GJ&}C Zt R&)9IhT&Eq@71k 49BzJR5~aO5