/********************************************************************************
* *
* (c) Copyright 2010 Verizon Communications USA and The Open University UK *
* *
* This software is freely distributed in accordance with *
* the GNU Lesser General Public (LGPL) license, version 3 or later *
* as published by the Free Software Foundation. *
* For details see LGPL: http://www.fsf.org/licensing/licenses/lgpl.html *
* and GPL: http://www.fsf.org/licensing/licenses/gpl-3.0.html *
* *
* This software is provided by the copyright holders and contributors "as is" *
* and any express or implied warranties, including, but not limited to, the *
* implied warranties of merchantability and fitness for a particular purpose *
* are disclaimed. In no event shall the copyright owner or contributors be *
* liable for any direct, indirect, incidental, special, exemplary, or *
* consequential damages (including, but not limited to, procurement of *
* substitute goods or services; loss of use, data, or profits; or business *
* interruption) however caused and on any theory of liability, whether in *
* contract, strict liability, or tort (including negligence or otherwise) *
* arising in any way out of the use of this software, even if advised of the *
* possibility of such damage. *
* *
********************************************************************************/
package com.compendium.ui.toolbars;
import java.awt.BorderLayout;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Vector;
import javax.help.HelpBroker;
import javax.swing.JFrame;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.undo.UndoManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.compendium.ProjectCompendium;
import com.compendium.core.ICoreConstants;
import com.compendium.core.datamodel.View;
import com.compendium.io.xml.XMLReader;
import com.compendium.ui.IUIConstants;
import com.compendium.ui.ProjectCompendiumFrame;
import com.compendium.ui.menus.UIMenuManager;
import com.compendium.ui.toolbars.system.IUIToolBarManager;
import com.compendium.ui.toolbars.system.UIToolBar;
import com.compendium.ui.toolbars.system.UIToolBarController;
import com.compendium.ui.toolbars.system.UIToolBarFloater;
/**
* This class manages all the toolbars
*
* @author Michelle Bachler
* @version 1.0
*/
public class UIToolBarManager implements IUIConstants, ICoreConstants, IUIToolBarManager {
/** logger for ProjectCompendiumFrame.class */
final Logger log = LoggerFactory.getLogger(this.getClass());
/** A reference to the main toolbar.*/
public final static int MAIN_TOOLBAR = 0;
/** A reference to the node toolbar.*/
public final static int NODE_TOOLBAR = 1;
/** A reference to the tags toolbar.*/
public final static int TAGS_TOOLBAR = 2;
/** A reference to the zoom toolbar.*/
public final static int ZOOM_TOOLBAR = 3;
/** A reference to the drawing toolbar.*/
public final static int DRAW_TOOLBAR = 4;
/** A reference to the data source mode swap toolbar.*/
public final static int DATA_TOOLBAR = 5;
/** A reference to the meeting toolbar.*/
public final static int MEETING_TOOLBAR = 6;
/** A reference to the label formatter toolbar.*/
public final static int FORMAT_TOOLBAR = 7;
/** A reference to the node formatter toolbar.*/
public final static int NODE_FORMAT_TOOLBAR = 8;
/** A reference to the link formatter toolbar.*/
public final static int LINK_FORMAT_TOOLBAR = 9;
/** The parent frame for this class.*/
private ProjectCompendiumFrame oParent = null;
/** The HelpBroker to use for toolbar help.*/
private HelpBroker mainHB = null;
/** The top toolbar controller panel.*/
private UIToolBarController oTopToolBarManager = null;
/** The bottom toolbar controller panel.*/
private UIToolBarController oBottomToolBarManager= null;
/** The left toolbar controller panel.*/
private UIToolBarController oLeftToolBarManager = null;
/** the right toolbar controller panel.*/
private UIToolBarController oRightToolBarManager= null;
/** The main toolbar manager class.*/
private UIToolBarMain oMainToolBar = null;
/** The node toolbar manager class.*/
private UIToolBarNode oNodeToolBar = null;
/** The Toolbar manager for the Zoom toolbar.*/
private UIToolBarZoom oZoomToolBar = null;
/** The Toolbar manager for the Scrible toolbar.*/
private UIToolBarScribble oScribbleToolBar = null;
/** The Toolbar manager for the data source toolbar.*/
private UIToolBarData oDataToolBar = null;
/** The label format toolbar manager.*/
private UIToolBarFormat oFormatToolBar = null;
/** The node format toolbar manager.*/
private UIToolBarFormatNode oNodeFormatToolBar = null;
/** The link format toolbar manager.*/
private UIToolBarFormatLink oLinkFormatToolBar = null;
/** The Toolbar manager for the tags toolbar.*/
private UIToolBarTags oTagsToolBar = null;
/**Indicates whether this menu is draw as a Simple interface or a advance user inteerface.*/
private boolean bSimpleInterface = false;
/**
* Constructor. Create a new instance of UIToolBarManager, with the given proerties.
* @param parent the parent frame for the application.
* @param hb the HelpBroker to use.
* @param isSimple indicates if the toolbars should be draw for a simple user interface, false for a complex one.
*/
public UIToolBarManager(ProjectCompendiumFrame parent,HelpBroker hb, boolean isSimple) {
oParent = parent;
mainHB = hb;
bSimpleInterface = isSimple;
}
/**
* Update the look and feel of all the toolbars
*/
public void updateLAF() {
if (oMainToolBar != null) {
oMainToolBar.updateLAF();
}
if (oScribbleToolBar != null) {
oScribbleToolBar.updateLAF();
}
if (oZoomToolBar != null) {
oZoomToolBar.updateLAF();
}
if (oFormatToolBar != null) {
oFormatToolBar.updateLAF();
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.updateLAF();
}
if (oLinkFormatToolBar != null) {
oLinkFormatToolBar.updateLAF();
}
if (oNodeToolBar != null) {
oNodeToolBar.updateLAF();
}
if (oDataToolBar != null) {
oDataToolBar.updateLAF();
}
if (oTagsToolBar != null) {
oTagsToolBar.updateLAF();
}
SwingUtilities.updateComponentTreeUI(oTopToolBarManager);
SwingUtilities.updateComponentTreeUI(oBottomToolBarManager);
SwingUtilities.updateComponentTreeUI(oLeftToolBarManager);
SwingUtilities.updateComponentTreeUI(oRightToolBarManager);
}
/**
* Create the toolbar controllers and load the toolbar data from the XML file where it has been save.
* If no data has been saved, set up the toolbars in thier default positions.
*/
public void createToolbars() {
try {
//load toolbar data
XMLReader reader = new XMLReader();
Document document = reader.read("System"+ProjectCompendium.sFS+"resources"+ProjectCompendium.sFS+"toolbars.xml", true);
if (document == null)
throw new Exception("Toolbar data could not be loaded");
NamedNodeMap attrs = null;
NodeList controllers = document.getElementsByTagName("controller");
if (controllers == null || controllers.getLength() == 0)
throw new Exception("Toolbar data could not be loaded");
int count = controllers.getLength();
for (int i=0; i< count; i++) {
Node controller = controllers.item(i);
attrs = controller.getAttributes();
Attr position = (Attr)attrs.getNamedItem("position");
int nPosition = new Integer(position.getValue()).intValue();
Attr oClosed = (Attr)attrs.getNamedItem("isClosed");
boolean isClosed = new Boolean(oClosed.getValue()).booleanValue();
loadToolBars(controller, isClosed, nPosition);
}
// PARANOIA
if (oTopToolBarManager == null || oBottomToolBarManager == null
|| oLeftToolBarManager == null || oRightToolBarManager == null) {
throw new Exception("Toolbars could not be created");
}
// ADD ANY FLOATING TOOLBARS
NodeList floaters = document.getElementsByTagName("floater");
createFloatingToolBars(floaters);
if (oMainToolBar == null) {
oMainToolBar = new UIToolBarMain(this, oParent, MAIN_TOOLBAR, bSimpleInterface);
oTopToolBarManager.addToolBar(oMainToolBar.getToolBar(), MAIN_TOOLBAR, true, true, oMainToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(MAIN_TOOLBAR, oMainToolBar.getDefaultActiveState());
}
if (oNodeToolBar == null) {
oNodeToolBar = new UIToolBarNode(this, oParent, NODE_TOOLBAR);
oLeftToolBarManager.addToolBar(oNodeToolBar.getToolBar(), NODE_TOOLBAR, true, true, oNodeToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(NODE_TOOLBAR, oNodeToolBar.getDefaultActiveState());
}
if (oZoomToolBar == null) {
oZoomToolBar = new UIToolBarZoom(this, oParent, ZOOM_TOOLBAR);
oTopToolBarManager.addToolBar(oZoomToolBar.getToolBar(), ZOOM_TOOLBAR, true, true, oZoomToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(ZOOM_TOOLBAR, oZoomToolBar.getDefaultActiveState());
}
if (oTagsToolBar == null) {
oTagsToolBar = new UIToolBarTags(this, oParent, TAGS_TOOLBAR);
oTopToolBarManager.addToolBar(oTagsToolBar.getToolBar(), TAGS_TOOLBAR, true, true, oTagsToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(TAGS_TOOLBAR, oTagsToolBar.getDefaultActiveState());
}
if (oScribbleToolBar == null) {
oScribbleToolBar = new UIToolBarScribble(this, oParent, DRAW_TOOLBAR);
oBottomToolBarManager.addToolBar(oScribbleToolBar.getToolBar(), DRAW_TOOLBAR, true, true, oScribbleToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(DRAW_TOOLBAR, oScribbleToolBar.getDefaultActiveState());
}
if (oDataToolBar == null) {
oDataToolBar = new UIToolBarData(this, oParent, DATA_TOOLBAR);
oBottomToolBarManager.addToolBar(oDataToolBar.getToolBar(), DATA_TOOLBAR, true, true, oDataToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(DATA_TOOLBAR, oDataToolBar.getDefaultActiveState());
}
if (oFormatToolBar == null) {
oFormatToolBar = new UIToolBarFormat(this, oParent, FORMAT_TOOLBAR);
oTopToolBarManager.addToolBar(oFormatToolBar.getToolBar(), FORMAT_TOOLBAR, true, true, oFormatToolBar.getDefaultActiveState(), 1);
updateToolbarMenu(FORMAT_TOOLBAR, oFormatToolBar.getDefaultActiveState());
}
if (oNodeFormatToolBar == null) {
oNodeFormatToolBar = new UIToolBarFormatNode(this, oParent, NODE_FORMAT_TOOLBAR);
oTopToolBarManager.addToolBar(oNodeFormatToolBar.getToolBar(), NODE_FORMAT_TOOLBAR, true, true, oNodeFormatToolBar.getDefaultActiveState(), 1);
updateToolbarMenu(NODE_FORMAT_TOOLBAR, oNodeFormatToolBar.getDefaultActiveState());
}
if (oLinkFormatToolBar == null) {
oLinkFormatToolBar = new UIToolBarFormatLink(this, oParent, LINK_FORMAT_TOOLBAR);
oTopToolBarManager.addToolBar(oLinkFormatToolBar.getToolBar(), LINK_FORMAT_TOOLBAR, true, true, oLinkFormatToolBar.getDefaultActiveState(), 1);
updateToolbarMenu(LINK_FORMAT_TOOLBAR, oLinkFormatToolBar.getDefaultActiveState());
}
}
catch(Exception ex) {
log.error("Error...", ex);
// IF THERE IS NO STORED DATA OR SOMETHING WENT WRONG, RESET THE TOOLBAR TO THEIR DEFAULTS
oTopToolBarManager = new UIToolBarController(this, UIToolBarController.TOP, false);
oParent.getMainPanel().add(oTopToolBarManager, BorderLayout.NORTH);
oBottomToolBarManager = new UIToolBarController(this, UIToolBarController.BOTTOM, false);
oParent.getMainPanel().add(oBottomToolBarManager, BorderLayout.SOUTH);
oLeftToolBarManager = new UIToolBarController(this, UIToolBarController.LEFT, false);
oParent.getMainPanel().add(oLeftToolBarManager, BorderLayout.WEST);
oRightToolBarManager = new UIToolBarController(this, UIToolBarController.RIGHT, false);
oParent.getMainPanel().add(oRightToolBarManager, BorderLayout.EAST);
onResetToolBars();
}
if (oMainToolBar != null)
oMainToolBar.getToolBar().addKeyListener(oParent);
if (oNodeToolBar != null)
oNodeToolBar.getToolBar().addKeyListener(oParent);
if (oTagsToolBar != null)
oTagsToolBar.getToolBar().addKeyListener(oParent);
if (oZoomToolBar != null)
oZoomToolBar.getToolBar().addKeyListener(oParent);
if (oScribbleToolBar != null)
oScribbleToolBar.getToolBar().addKeyListener(oParent);
if (oDataToolBar != null)
oDataToolBar.getToolBar().addKeyListener(oParent);
//if (tbrMeetingToolBar != null)
// tbrMeetingToolBar.getToolBar().addKeyListener(oParent);
if (oFormatToolBar != null) {
oFormatToolBar.getToolBar().addKeyListener(oParent);
oFormatToolBar.getToolBar().setEnabled(false);
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.getToolBar().addKeyListener(oParent);
oNodeFormatToolBar.getToolBar().setEnabled(false);
}
if (oLinkFormatToolBar != null) {
oLinkFormatToolBar.getToolBar().addKeyListener(oParent);
oLinkFormatToolBar.getToolBar().setEnabled(false);
}
}
/**
* Store the interface mode, true for simple, false for advanced
* and call <code>onResetToolBars</code> to redraw the correct default toolbar layout for the mode.
* @param isSimple
*/
public void setIsSimple(boolean isSimple) {
bSimpleInterface = isSimple;
onResetToolBars();
}
/**
* Reset the toolbar layouts to their default positions.
*/
public void onResetToolBars() {
// CLEAR FILE
try {
FileWriter fileWriter = new FileWriter("System"+ProjectCompendium.sFS+"resources"+ProjectCompendium.sFS+"toolbars.xml");
fileWriter.write("");
fileWriter.close();
}
catch (IOException e) {
ProjectCompendium.APP.displayError("Exception:" + e.getMessage());
}
disposeFloatingToolBars();
oTopToolBarManager.clear();
oBottomToolBarManager.clear();
oLeftToolBarManager.clear();
oRightToolBarManager.clear();
oTopToolBarManager.setVisible(false);
oBottomToolBarManager.setVisible(false);
oLeftToolBarManager.setVisible(false);
oRightToolBarManager.setVisible(false);
oMainToolBar = new UIToolBarMain(this, oParent, MAIN_TOOLBAR, bSimpleInterface);
oTagsToolBar = new UIToolBarTags(this, oParent, TAGS_TOOLBAR);
oNodeToolBar = new UIToolBarNode(this, oParent, NODE_TOOLBAR);
oZoomToolBar = new UIToolBarZoom(this, oParent, ZOOM_TOOLBAR);
oFormatToolBar = new UIToolBarFormat(this, oParent, FORMAT_TOOLBAR);
oNodeFormatToolBar = new UIToolBarFormatNode(this, oParent, NODE_FORMAT_TOOLBAR);
oLinkFormatToolBar = new UIToolBarFormatLink(this, oParent, LINK_FORMAT_TOOLBAR);
oScribbleToolBar = new UIToolBarScribble(this, oParent, DRAW_TOOLBAR);
oDataToolBar = new UIToolBarData(this, oParent, DATA_TOOLBAR);
//oMeetingToolBar = new UIToolBarFormat(this, oParent, MEETING_TOOLBAR);
oTopToolBarManager.addToolBar( oMainToolBar.getToolBar(), MAIN_TOOLBAR, true, true, oMainToolBar.getDefaultActiveState(), 0);
oTopToolBarManager.addToolBar( oZoomToolBar.getToolBar(), ZOOM_TOOLBAR, true, true, oZoomToolBar.getDefaultActiveState(), 0);
oTopToolBarManager.addToolBar( oTagsToolBar.getToolBar(), TAGS_TOOLBAR, true, true, oTagsToolBar.getDefaultActiveState(), 0);
oLeftToolBarManager.addToolBar( oNodeToolBar.getToolBar(), NODE_TOOLBAR, true, true, oNodeToolBar.getDefaultActiveState(), 0);
try {
oTopToolBarManager.addToolBar( oFormatToolBar.getToolBar(), FORMAT_TOOLBAR, true, true, oFormatToolBar.getDefaultActiveState(), 1);
oTopToolBarManager.addToolBar( oNodeFormatToolBar.getToolBar(), NODE_FORMAT_TOOLBAR, true, true, oNodeFormatToolBar.getDefaultActiveState(), 1);
oTopToolBarManager.addToolBar( oLinkFormatToolBar.getToolBar(), LINK_FORMAT_TOOLBAR, true, true, oLinkFormatToolBar.getDefaultActiveState(), 1);
} catch (Exception e) {
log.error("Error...", e);
}
oBottomToolBarManager.addToolBar( oScribbleToolBar.getToolBar(), DRAW_TOOLBAR, true, true, oScribbleToolBar.getDefaultActiveState(), 0);
oBottomToolBarManager.addToolBar( oDataToolBar.getToolBar(), DATA_TOOLBAR, true, true, oDataToolBar.getDefaultActiveState(), 0);
updateToolbarMenu(DRAW_TOOLBAR, oScribbleToolBar.getDefaultActiveState());
updateToolbarMenu(DATA_TOOLBAR, oDataToolBar.getDefaultActiveState());
updateToolbarMenu(MAIN_TOOLBAR, oMainToolBar.getDefaultActiveState());
updateToolbarMenu(NODE_TOOLBAR, oNodeToolBar.getDefaultActiveState());
updateToolbarMenu(TAGS_TOOLBAR, oTagsToolBar.getDefaultActiveState());
updateToolbarMenu(ZOOM_TOOLBAR, oZoomToolBar.getDefaultActiveState());
updateToolbarMenu(FORMAT_TOOLBAR, oFormatToolBar.getDefaultActiveState());
updateToolbarMenu(NODE_FORMAT_TOOLBAR, oNodeFormatToolBar.getDefaultActiveState());
updateToolbarMenu(LINK_FORMAT_TOOLBAR, oLinkFormatToolBar.getDefaultActiveState());
//updateToolbarMenu(oMeetingToolBar.getDefaultActiveState());
oTagsToolBar.updateCodeChoiceBoxData();
oParent.validate();
oParent.repaint();
}
/**
* Create any individual floating toolbars.
* @param floaters, the XML node with the saved information for which toolbars were floating.
*/
private void createFloatingToolBars(NodeList floaters) {
// SIMPLE INTERFACE DOES NOT HAVE FLOATING TOOLBARS.
if (floaters != null) {
int jcount = floaters.getLength();
NamedNodeMap attrs = null;
for (int j=0; j<jcount; j++) {
Node controller = floaters.item(j);
attrs = controller.getAttributes();
Attr oType = (Attr)attrs.getNamedItem("type");
int nType = new Integer(oType.getValue()).intValue();
//Attr oVisible = (Attr)attrs.getNamedItem("isVisible");
//boolean isVisible = new Boolean(oVisible.getValue()).booleanValue();
//Attr oWasVisible = (Attr)attrs.getNamedItem("wasVisible");
//boolean wasVisible = new Boolean(oWasVisible.getValue()).booleanValue();
Attr oXPos = (Attr)attrs.getNamedItem("xPos");
int nXPos = new Integer(oXPos.getValue()).intValue();
Attr oYPos = (Attr)attrs.getNamedItem("yPos");
int nYPos = new Integer(oYPos.getValue()).intValue();
Attr oRow = (Attr)attrs.getNamedItem("row");
int row = 0;
if (oRow != null) {
row = new Integer(oRow.getValue()).intValue();
}
UIToolBar bar = createToolBar(nType);
updateToolbarMenu(nType, true);
if (bar != null) {
UIToolBarFloater oFloater = new UIToolBarFloater(this, bar, nType, row);
oFloater.setLocation(nXPos, nYPos);
}
}
}
}
/**
* Create a toolbar controller, and load any toolbars that it should be displaying.
*/
private void loadToolBars(Node node, boolean isClosed, int nPosition) {
switch(nPosition) {
case (UIToolBarController.TOP): {
oTopToolBarManager = new UIToolBarController(this, nPosition, isClosed);
oParent.getMainPanel().add(oTopToolBarManager, BorderLayout.NORTH);
break;
}
case (UIToolBarController.BOTTOM): {
oBottomToolBarManager = new UIToolBarController(this, nPosition, isClosed);
oParent.getMainPanel().add(oBottomToolBarManager, BorderLayout.SOUTH);
break;
}
case (UIToolBarController.LEFT): {
oLeftToolBarManager = new UIToolBarController(this, nPosition, isClosed);
oParent.getMainPanel().add(oLeftToolBarManager, BorderLayout.WEST);
break;
}
case (UIToolBarController.RIGHT): {
oRightToolBarManager = new UIToolBarController(this, nPosition, isClosed);
oParent.getMainPanel().add(oRightToolBarManager, BorderLayout.EAST);
break;
}
}
if (node.hasChildNodes()) {
Node top = XMLReader.getFirstChildWithTagName(node, "toolbars");
if (top != null) {
Vector toolbars = XMLReader.getChildrenWithTagName(top, "toolbar");
NamedNodeMap attrs = null;
int count = toolbars.size();
for (int i=0; i< count; i++) {
Node toolbar = (Node)toolbars.elementAt(i);
attrs = toolbar.getAttributes();
Attr oType = (Attr)attrs.getNamedItem("type");
int nType = new Integer(oType.getValue()).intValue();
Attr oRow = (Attr)attrs.getNamedItem("row");
int row = 0;
if (oRow != null) {
row = new Integer(oRow.getValue()).intValue();
}
Attr oVisible = (Attr)attrs.getNamedItem("isVisible");
boolean isVisible = new Boolean(oVisible.getValue()).booleanValue();
Attr oWasVisible = (Attr)attrs.getNamedItem("wasVisible");
boolean wasVisible = new Boolean(oWasVisible.getValue()).booleanValue();
Attr oSwitchedOn = (Attr)attrs.getNamedItem("isOn");
boolean bIsOn = true;
if (oSwitchedOn != null) {
bIsOn = new Boolean(oSwitchedOn.getValue()).booleanValue();
}
switch(nPosition) {
case (UIToolBarController.TOP): {
UIToolBar oToolbar = createToolBar(nType, SwingConstants.HORIZONTAL);
if (oToolbar != null) {
oTopToolBarManager.addToolBar(oToolbar, nType, isVisible, wasVisible, bIsOn, row);
updateToolbarMenu(nType, bIsOn);
}
break;
}
case (UIToolBarController.BOTTOM): {
UIToolBar oToolbar = createToolBar(nType, SwingConstants.HORIZONTAL);
if (oToolbar != null) {
oBottomToolBarManager.addToolBar(oToolbar, nType, isVisible, wasVisible, bIsOn, row);
updateToolbarMenu(nType, bIsOn);
}
break;
}
case (UIToolBarController.LEFT): {
UIToolBar oToolbar = createToolBar(nType, SwingConstants.VERTICAL);
if (oToolbar != null) {
oLeftToolBarManager.addToolBar(oToolbar, nType, isVisible, wasVisible, bIsOn, row);
updateToolbarMenu(nType, bIsOn);
}
break;
}
case (UIToolBarController.RIGHT): {
UIToolBar oToolBar = createToolBar(nType, SwingConstants.VERTICAL);
if (oToolBar != null) {
oRightToolBarManager.addToolBar(oToolBar, nType, isVisible, wasVisible, bIsOn, row);
updateToolbarMenu(nType, bIsOn);
}
break;
}
}
}
}
}
}
/**
* Return the help broker
* @return the help broker
*/
public HelpBroker getHelpBroker() {
return mainHB;
}
/**
* Creates and return the toolbar for the given type for its default orientation.
*
* @param nType the type of the toolbar to create.
* @return UIToolBar the toolbar for the given type, or null if type unknown or the bar already exists
*/
private UIToolBar createToolBar(int nType) {
return createToolBar(nType, -1);
}
/**
* Creates and return the toolbar for the given type.
*
* @param nType the type of the toolbar to create.
* @param nOrientation the orientation to create the toolbar for. -1 means use the bar's default orientation.
* @return UIToolBar the toolbar for the given type, or null if type unknown or the bar already exists
*/
private UIToolBar createToolBar(int nType, int nOrientation) {
if (nType == MAIN_TOOLBAR) {
if (oMainToolBar == null) {
if (nOrientation == -1) {
oMainToolBar = new UIToolBarMain(this, oParent, nType, bSimpleInterface);
} else {
oMainToolBar = new UIToolBarMain(this, oParent, nType, nOrientation, bSimpleInterface);
}
return oMainToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == TAGS_TOOLBAR) {
if (oTagsToolBar == null) {
if (nOrientation == -1) {
oTagsToolBar = new UIToolBarTags(this, oParent, nType);
} else {
oTagsToolBar = new UIToolBarTags(this, oParent, nType, nOrientation);
}
return oTagsToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == NODE_TOOLBAR) {
if (oNodeToolBar == null) {
if (nOrientation == -1) {
oNodeToolBar = new UIToolBarNode(this, oParent, nType);
} else {
oNodeToolBar = new UIToolBarNode(this, oParent, nType, nOrientation);
}
return oNodeToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == ZOOM_TOOLBAR) {
if (oZoomToolBar == null) {
if (nOrientation == -1) {
oZoomToolBar = new UIToolBarZoom(this, oParent, nType);
} else {
oZoomToolBar = new UIToolBarZoom(this, oParent, nType, nOrientation);
}
return oZoomToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == DRAW_TOOLBAR) {
if (oScribbleToolBar == null) {
if (nOrientation == -1) {
oScribbleToolBar = new UIToolBarScribble(this, oParent, nType);
} else {
oScribbleToolBar = new UIToolBarScribble(this, oParent, nType, nOrientation);
}
return oScribbleToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == DATA_TOOLBAR) {
if (oDataToolBar == null) {
if (nOrientation == -1) {
oDataToolBar = new UIToolBarData(this, oParent, nType);
} else {
oDataToolBar = new UIToolBarData(this, oParent, nType, nOrientation);
}
return oDataToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == FORMAT_TOOLBAR) {
if (oFormatToolBar == null) {
oFormatToolBar = new UIToolBarFormat(this, oParent, nType);
return oFormatToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == NODE_FORMAT_TOOLBAR) {
if (oNodeFormatToolBar == null) {
oNodeFormatToolBar = new UIToolBarFormatNode(this, oParent, nType);
return oNodeFormatToolBar.getToolBar();
} else {
return null;
}
}
else if (nType == LINK_FORMAT_TOOLBAR) {
if (oLinkFormatToolBar == null) {
oLinkFormatToolBar = new UIToolBarFormatLink(this, oParent, nType);
return oLinkFormatToolBar.getToolBar();
} else {
return null;
}
}
return null;
}
/**
* Update the toolbar menu as to whether a given toolbar is on or not.
*
* @param nType, the type of the toolbar.
* @param bIsOn, if the toolbar is switched on or not.
*/
private void updateToolbarMenu(int nType, boolean bIsOn) {
UIMenuManager oMenuManager = oParent.getMenuManager();
oMenuManager.setToolbar(nType, bIsOn);
}
/**
* Hide/Show the given toolbar depending on the given selected state.
*
* @param boolean switchOn, whether to switch the given toolbar type on or off.
* @param int, the toolbar to switch On/Off.
*/
public void toggleToolBar(boolean switchOn, int nToolbarType) {
UIToolBar oToolBar = null;
switch(nToolbarType) {
case(MAIN_TOOLBAR) :
if (oMainToolBar != null) {
oToolBar = oMainToolBar.getToolBar();
}
break;
case(NODE_TOOLBAR) :
if (oNodeToolBar != null) {
oToolBar = oNodeToolBar.getToolBar();
}
break;
case(TAGS_TOOLBAR) :
if (oTagsToolBar != null ) {
oToolBar = oTagsToolBar.getToolBar();
}
break;
case(ZOOM_TOOLBAR) :
if (oZoomToolBar != null) {
oToolBar = oZoomToolBar.getToolBar();
}
break;
case(DRAW_TOOLBAR) :
if (oScribbleToolBar != null) {
oToolBar = oScribbleToolBar.getToolBar();
}
break;
case(DATA_TOOLBAR) :
if (oDataToolBar != null) {
oToolBar = oDataToolBar.getToolBar();
}
break;
case(FORMAT_TOOLBAR) :
if (oFormatToolBar != null) {
oToolBar = oFormatToolBar.getToolBar();
}
break;
case(NODE_FORMAT_TOOLBAR) :
if (oNodeFormatToolBar != null) {
oToolBar = oNodeFormatToolBar.getToolBar();
}
break;
case(LINK_FORMAT_TOOLBAR) :
if (oLinkFormatToolBar != null) {
oToolBar = oLinkFormatToolBar.getToolBar();
}
break;
case(MEETING_TOOLBAR) :
break;
}
if (oToolBar == null) {
oToolBar = createToolBar(nToolbarType, SwingConstants.HORIZONTAL);
}
if (oToolBar != null) {
if (!oTopToolBarManager.toggleToolBar(oToolBar, switchOn)) {
if (!oBottomToolBarManager.toggleToolBar(oToolBar, switchOn)) {
if (!oLeftToolBarManager.toggleToolBar(oToolBar, switchOn)) {
if (!oRightToolBarManager.toggleToolBar(oToolBar, switchOn)) {
// SHOULD NEVER GET HERE!
if (nToolbarType == MAIN_TOOLBAR || nToolbarType == NODE_TOOLBAR ||
nToolbarType == TAGS_TOOLBAR || nToolbarType == ZOOM_TOOLBAR) {
oTopToolBarManager.addToolBar(oToolBar, nToolbarType, true, true, switchOn, 0);
} else if (nToolbarType == FORMAT_TOOLBAR) {
oTopToolBarManager.addToolBar(oToolBar, nToolbarType, true, true, switchOn, 1);
} else {
oTopToolBarManager.addToolBar(oToolBar, nToolbarType, true, true, switchOn, 0);
}
}
}
}
}
}
}
/**
* Updates the menu when a new database project is opened.
*/
public void onDatabaseOpen() {
if (oMainToolBar != null) {
oMainToolBar.onDatabaseOpen();
}
if (oNodeToolBar != null) {
oNodeToolBar.onDatabaseOpen();
}
if (oZoomToolBar != null) {
oZoomToolBar.onDatabaseOpen();
}
if (oFormatToolBar != null) {
oFormatToolBar.onDatabaseOpen();
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.onDatabaseOpen();
}
if (oLinkFormatToolBar != null) {
oLinkFormatToolBar.onDatabaseOpen();
}
if (oDataToolBar != null) {
oDataToolBar.onDatabaseOpen();
}
if (oTagsToolBar != null) {
oTagsToolBar.onDatabaseOpen();
}
//Note: DRAW TOOLBAR TURNED ON BY CODE ELSEWHERE
}
/**
* Updates the menu when the current database project is closed.
*/
public void onDatabaseClose() {
if (oMainToolBar != null) {
oMainToolBar.onDatabaseClose();
}
if (oFormatToolBar != null) {
oFormatToolBar.onDatabaseClose();
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.onDatabaseClose();
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.onDatabaseClose();
}
if (oNodeToolBar != null) {
oNodeToolBar.onDatabaseClose();
}
if (oZoomToolBar != null) {
oZoomToolBar.onDatabaseClose();
}
if (oScribbleToolBar != null) {
oScribbleToolBar.onDatabaseClose();
}
if (oDataToolBar != null) {
oDataToolBar.onDatabaseClose();
}
if (oTagsToolBar != null) {
oTagsToolBar.onDatabaseClose();
}
}
/**
* Enable the codes toobar icon.
* @param selected, true to enalbe, false to disable.
*/
public void setNodeSelected(boolean selected) {
if (oMainToolBar != null) {
oMainToolBar.setNodeSelected(selected);
}
if (oFormatToolBar != null) {
oFormatToolBar.setNodeSelected(selected);
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.setNodeSelected(selected);
}
if (oLinkFormatToolBar != null) {
oLinkFormatToolBar.setNodeSelected(selected);
}
if (oNodeToolBar != null) {
oNodeToolBar.setNodeSelected(selected);
}
if (oZoomToolBar != null) {
oZoomToolBar.setNodeSelected(selected);
}
if (oScribbleToolBar != null) {
oScribbleToolBar.setNodeSelected(selected);
}
if (oDataToolBar != null) {
oDataToolBar.setNodeSelected(selected);
}
if (oTagsToolBar != null) {
oTagsToolBar.setNodeSelected(selected);
}
}
/**
* Set the enabled status of cut cop and delete.
* @param selected, true to enable, false to disable.
*/
public void setNodeOrLinkSelected(boolean selected) {
if (oMainToolBar != null) {
oMainToolBar.setNodeOrLinkSelected(selected);
}
if (oFormatToolBar != null) {
oFormatToolBar.setNodeOrLinkSelected(selected);
}
if (oNodeFormatToolBar != null) {
oNodeFormatToolBar.setNodeOrLinkSelected(selected);
}
if (oLinkFormatToolBar != null) {
oLinkFormatToolBar.setNodeOrLinkSelected(selected);
}
if (oNodeToolBar != null) {
oNodeToolBar.setNodeOrLinkSelected(selected);
}
if (oZoomToolBar != null) {
oZoomToolBar.setNodeOrLinkSelected(selected);
}
if (oScribbleToolBar != null) {
oScribbleToolBar.setNodeOrLinkSelected(selected);
}
if (oDataToolBar != null) {
oDataToolBar.setNodeOrLinkSelected(selected);
}
if (oTagsToolBar != null) {
oTagsToolBar.setNodeOrLinkSelected(selected);
}
}
////Formatting Toolbar redirects
/**
* Update the node label font style on the currently selected nodes by
* adding / removing the given style depending on existing style.
*/
public void addFontStyle(int nStyle) {
if (oFormatToolBar != null) {
oFormatToolBar.addFontStyle(nStyle);
}
}
//// Tags toolbar redirect
/**
* Update the current tags list when a change occurs.
*/
public void updateCodeChoiceBoxData() {
if (oTagsToolBar != null) {
oTagsToolBar.updateCodeChoiceBoxData();
}
}
//// Data toolbar redirects
/**
* Update the data in the profiles choicebox.
*/
public synchronized void updateProfilesChoiceBoxData(int selectedIndex) {
if (oDataToolBar != null) {
oDataToolBar.updateProfilesChoiceBoxData(selectedIndex);
}
}
/**
* Disable the Refresh button
*/
public void disableDataRefresh() {
oDataToolBar.disableRefresh();
}
/**
* Enable the Refresh button
*/
public void enableDataRefresh() {
oDataToolBar.enableRefresh();
}
/**
* Select the indicated database profile.
* An empty string means, select the Derby default option.
*/
public synchronized void selectProfile(String sName) {
if (oDataToolBar != null) {
oDataToolBar.selectProfile(sName);
}
}
//// Node toolbar redirects
/**
* Used to change the Node toolbar icons when a different skin has been chosen.
*/
public void swapToobarSkin() {
if (oNodeToolBar != null) {
oNodeToolBar.swapToobarSkin();
}
}
//// Scribble toolbar redirects
/**
* Is scribble pad on.
* @return boolean, true if on, else false.
*/
public boolean isScribblePadOn() {
if (oScribbleToolBar != null) {
return oScribbleToolBar.isScribblePadOn();
}
return false;
}
/**
* Enable/disable the draw toolbar.
* @param enabled, true to enable, false to disable.
*/
public void setDrawToolBarEnabled(boolean enabled) {
if (oScribbleToolBar != null) {
oScribbleToolBar.setEnabled(enabled);
}
}
/**
* Enable/disable the drawing toolbar items.
* @param enabled, true to enable, false to disable.
*/
public void setDrawToolBarPaintEnabled(boolean enabled) {
if (oScribbleToolBar != null) {
oScribbleToolBar.setDrawToolBarPaintEnabled(enabled);
}
}
/**
* Toggle scribble pad on and off.
*/
public void onToggleScribble() {
if (oScribbleToolBar != null) {
oScribbleToolBar.onToggleScribble();
}
}
/**
* Position scribble pad at the bacl or front of node layer.
*/
public void onPositionScribble() {
if (oScribbleToolBar != null) {
oScribbleToolBar.onPositionScribble();
}
}
//// Zoom toolbar redirects
public int getTextZoom() {
int zoom = 0;
if (oZoomToolBar != null) {
zoom = oZoomToolBar.getTextZoom();
}
return zoom;
}
/**
* Enable/disable the zoom toolbar.
* @param enabled, true to enable, false to disable.
*/
public void setZoomToolBarEnabled(boolean enabled) {
if (oZoomToolBar != null) {
oZoomToolBar.setEnabled(enabled);
}
}
/**
* Zoom the current map to the next level up(75/50/25/full).
*/
public void onZoomOut() {
if (oZoomToolBar != null) {
oZoomToolBar.onZoomOut();
}
}
/**
* Zoom the current map to the next level down(75/50/25/full).
*/
public void onZoomIn() {
if (oZoomToolBar != null) {
oZoomToolBar.onZoomIn();
}
}
/**
* Reset the zoom choicebox to reflect the current views settings.
*/
public void resetZoom() {
if (oZoomToolBar != null) {
oZoomToolBar.resetZoom();
}
}
/**
* Zoom the current map using the given scale.
* @param scale, the scale to zoom to.
*/
public void onZoomTo(double scale) {
if (oZoomToolBar != null) {
oZoomToolBar.onZoomTo(scale);
}
}
/**
* Zoom the current map to fit it all on the visible view.
*/
public void onZoomToFit() {
if (oZoomToolBar != null) {
oZoomToolBar.onZoomToFit();
}
}
/**
* Zoom the current map back to normal and focus on the last selected node.
*/
public boolean onZoomRefocused() {
if (oZoomToolBar != null) {
return oZoomToolBar.onZoomRefocused();
}
return false;
}
//// Main toolbar redirects
/**
* Refreshes the undo/redo icons with the last action performed.
* @param oUndoManager, the manager to use to check for undo/redo possibilities.
*/
public void refreshUndoRedo(UndoManager oUndoManager) {
if (oMainToolBar != null) {
oMainToolBar.refreshUndoRedo(oUndoManager);
}
}
/**
* Enable all the view history related toolbar icons.
*/
public void enableHistoryButtons() {
if (oMainToolBar != null) {
oMainToolBar.enableHistoryButtons();
}
}
/**
* Clear the view history.
*/
public void clearHistory() {
if (oMainToolBar != null) {
oMainToolBar.clearHistory();
}
}
/**
* Try to remove a View object from the history.
* @param view com.compendium.core.datamodel.View, the view to add to the history.
*/
public void removeFromHistory(View view) {
if (oMainToolBar != null) {
oMainToolBar.removeFromHistory(view);
}
}
/**
* Try to add a View object to the history.
* @param view com.compendium.core.datamodel.View, the view to add to the history.
*/
public void addToHistory(View view) {
if (oMainToolBar != null) {
oMainToolBar.addToHistory(view);
}
}
/**
* Enable/disable paste button.
* @param enabled, true to enalbe, false to disable.
*/
public void setPasteEnabled(boolean enabled) {
if (oMainToolBar != null) {
oMainToolBar.setPasteEnabled(enabled);
}
}
/**
* Enable/disable file open button.
* @param enabled, true to enable, false to disable.
*/
public void setFileOpenEnablement(boolean enabled) {
if (oMainToolBar != null) {
oMainToolBar.setFileOpenEnablement(enabled);
}
}
/**
* Reset the image rollover icon as enabled/disabled.
* @param enabled, the status to draw the image rollover icon for.
*/
public void updateImageRollover(boolean enabled) {
if (oMainToolBar != null) {
oMainToolBar.updateImageRollover(enabled);
}
}
//// IUIToolBarManager Methods
/**
* Returns the JFrame in which is to be the parent of the floating toolbars.
*
* @return JFrame which represents the parent of the floating toolbars.
*/
public JFrame getToolBarFloatFrame() {
return oParent;
}
/**
* Returns the toolbar controller for the top edge of the container.
*
* @return com.compendium.ui.toolbars.UIToolBarController object for the top edge of the container.
*/
public UIToolBarController getTopToolBarController() {
return oTopToolBarManager;
}
/**
* Returns the toolbar controller for the bottom edge of the container.
*
* @return com.compendium.ui.toolbars.UIToolBarController object for the bottom edge of the container.
*/
public UIToolBarController getBottomToolBarController() {
return oBottomToolBarManager;
}
/**
* Returns the toolbar controller for the left edge of the container.
*
* @return com.compendium.ui.toolbars.UIToolBarController object for the left hand side of the container.
*/
public UIToolBarController getLeftToolBarController() {
return oLeftToolBarManager;
}
/**
* Returns the toolbar controller for the right edge of the container.
*
* @return com.compendium.ui.toolbars.UIToolBarController object for the right hand side of the container.
*/
public UIToolBarController getRightToolBarController() {
return oRightToolBarManager;
}
private Vector floaters = new Vector(10);
/**
* Tell the manager that a toolbar is now floating by passing the UIToolBarFloater object to it.
* @param floater com.compendium.ui.toolbars.UIToolBarFloater, the floating toolbar to add.
*/
public void addFloatingToolBar(UIToolBarFloater floater) {
floaters.addElement(floater);
}
/**
* Tell the manager that a toolbar is now docked by removing the UIToolBarFloater object from it.
* @param floater com.compendium.ui.toolbars.UIToolBarFloater, the floating toolbar to remove.
*/
public void removeFloatingToolBar(UIToolBarFloater floater) {
floaters.removeElement(floater);
}
/**
* Dispose of all toolbars currently floating.
*/
public void disposeFloatingToolBars() {
int count = floaters.size();
for (int i=0; i< count; i++) {
UIToolBarFloater floater = (UIToolBarFloater)floaters.elementAt(i);
floater.setVisible(false);
floater.dispose();
}
floaters.removeAllElements();
}
/**
* Create instances of UIToolBarFloater, for all toolbars tha should be floating.
*/
public void showFloatingToolBars() {
int count = floaters.size();
for (int i=0; i< count; i++) {
UIToolBarFloater floater = (UIToolBarFloater)floaters.elementAt(i);
floater.setVisible(true);
}
}
/**
* Returns a xml string containing the toolbar data from the toolbar controllers
* The <code>UIToolBarController</code> class has a <code>toXML</code> method that can be used to get this information.
*
* @return a String object containing formatted xml representation of the toolbar data
*/
public String getToolbarXML() {
StringBuffer data = new StringBuffer(600);
data.append("<?xml version=\"1.0\"?>\n");
data.append("<!DOCTYPE toolbarcontrollers [\n");
data.append("<!ELEMENT toolbarcontrollers (#PCDATA | controller | floaters)*>\n");
data.append("<!ELEMENT controller (#PCDATA | toolbars)*>\n");
data.append("<!ATTLIST controller\n");
data.append("position CDATA #REQUIRED\n");
data.append("isClosed CDATA #REQUIRED\n>\n");
data.append("<!ELEMENT toolbars (#PCDATA | toolbar)*>\n");
data.append("<!ELEMENT toolbar (#PCDATA)>\n");
data.append("<!ATTLIST toolbar\n");
data.append("type CDATA #REQUIRED\n");
data.append("name CDATA #REQUIRED\n");
data.append("isVisible CDATA #REQUIRED\n");
data.append("wasVisible CDATA #REQUIRED\n");
data.append("isOn CDATA #REQUIRED\n");
data.append("row CDATA #REQUIRED\n");
data.append(">\n");
data.append("<!ELEMENT floaters (#PCDATA | floater)*>\n");
data.append("<!ELEMENT floater (#PCDATA)>\n");
data.append("<!ATTLIST floater\n");
data.append("name CDATA #REQUIRED\n");
data.append("isVisible CDATA #REQUIRED\n");
data.append("wasVisible CDATA #REQUIRED\n");
data.append("xPos CDATA #REQUIRED\n");
data.append("yPos CDATA #REQUIRED\n");
data.append("row CDATA #REQUIRED\n");
data.append(">\n]>\n\n");
data.append("<toolbarcontrollers>\n");
data.append(getRightToolBarController().toXML());
data.append(getLeftToolBarController().toXML());
data.append(getTopToolBarController().toXML());
data.append(getBottomToolBarController().toXML());
// ADD FLOATERS
data.append("<floaters>");
int count = floaters.size();
if (count > 0)
data.append("\n");
for (int i=0; i< count; i++) {
UIToolBarFloater floater = (UIToolBarFloater)floaters.elementAt(i);
data.append(floater.toXML());
}
data.append("</floaters>\n");
data.append("</toolbarcontrollers>\n");
return data.toString();
}
/**
* Save all the current toolbar setting to an xml file.
*/
public void saveToolBarData() {
String toolbardata = getToolbarXML();
try {
FileWriter fileWriter = new FileWriter("System"+ProjectCompendium.sFS+"resources"+ProjectCompendium.sFS+"toolbars.xml");
fileWriter.write(toolbardata);
fileWriter.close();
}
catch (IOException e) {
oParent.displayError("Exception:" + e.getMessage());
}
}
}