/* $Id: PrivateHandler.java 17832 2010-01-12 19:02:29Z linus $
*****************************************************************************
* Copyright (c) 2009 Contributors - see below
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* tfmorris
*****************************************************************************
*
* Some portions of this file was previously release using the BSD License:
*/
// Copyright (c) 1996-2009 The Regents of the University of California. All
// Rights Reserved. Permission to use, copy, modify, and distribute this
// software and its documentation without fee, and without a written
// agreement is hereby granted, provided that the above copyright notice
// and this paragraph appear in all copies. This software program and
// documentation are copyrighted by The Regents of the University of
// California. The software program and documentation are supplied "AS
// IS", without any accompanying services from The Regents. The Regents
// does not warrant that the operation of the program will be
// uninterrupted or error-free. The end-user understands that the program
// was developed for research purposes and is advised not to rely
// exclusively on the program for any reason. IN NO EVENT SHALL THE
// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
package org.argouml.persistence;
import java.util.StringTokenizer;
import org.apache.log4j.Logger;
import org.argouml.uml.diagram.ui.PathItemPlacement;
import org.argouml.util.IItemUID;
import org.argouml.util.ItemUID;
import org.tigris.gef.base.PathItemPlacementStrategy;
import org.tigris.gef.persistence.pgml.Container;
import org.tigris.gef.persistence.pgml.FigEdgeHandler;
import org.tigris.gef.persistence.pgml.FigGroupHandler;
import org.tigris.gef.persistence.pgml.PGMLHandler;
import org.tigris.gef.presentation.Fig;
import org.tigris.gef.presentation.FigEdge;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
/**
* Will set the ItemUID for objects represented by
* PGML elements that contain private elements that have
* ItemUID assignments in them.<p>
*
* Currently, there are three possibilities: ArgoDiagram,
* FigNode, FigEdge
*/
class PrivateHandler
extends org.tigris.gef.persistence.pgml.PrivateHandler {
private Container container;
/**
* Logger.
*/
private static final Logger LOG = Logger.getLogger(PrivateHandler.class);
/**
* The constructor.
*
* @param parser
* @param cont
*/
public PrivateHandler(PGMLStackParser parser, Container cont) {
super(parser, cont);
container = cont;
}
/**
* If the containing object is a type for which the private element
* might contain an ItemUID, extract the ItemUID if it exists and assign it
* to the object.
*
* @param contents
* @exception SAXException
*/
public void gotElement(String contents)
throws SAXException {
if (container instanceof PGMLHandler) {
Object o = getPGMLStackParser().getDiagram();
if (o instanceof IItemUID) {
ItemUID uid = getItemUID(contents);
if (uid != null) {
((IItemUID) o).setItemUID(uid);
}
}
// No other uses of string in PGMLHandler
return;
}
if (container instanceof FigGroupHandler) {
Object o = ((FigGroupHandler) container).getFigGroup();
if (o instanceof IItemUID) {
ItemUID uid = getItemUID(contents);
if (uid != null) {
((IItemUID) o).setItemUID(uid);
}
}
}
if (container instanceof FigEdgeHandler) {
Object o = ((FigEdgeHandler) container).getFigEdge();
if (o instanceof IItemUID) {
ItemUID uid = getItemUID(contents);
if (uid != null) {
((IItemUID) o).setItemUID(uid);
}
}
}
// Handle other uses of <private> contents
super.gotElement(contents);
}
/**
* Process starting elements within the private tag.
* This method handles all attributes within tags within private methods.
* The only specific tags we handle here at the moment are pathitems.
*
* The strategy for handling pathitems is as follows:
* <ul>
* <li>Data is saved for each path item using one <argouml:pathitem ... />
* tag per path item.
* <li>The code that defines what is stored is in
* org.argouml.persistence.PGML.tee
* <li>Each <argouml:pathitem> tag stores
* <ul>
* <li>The class name of the PathItemPlacementStrategy
* <li>The class name of the fig which it places.
* <li>The href of the model element which owns the fig being placed.
* <li>The angle of the placement vector (PathItemPlacement.angle)
* <li>The distance along the displacement vector to place the fig
* (PathItemPlacement.vectorOffset).
* </ul>
* </li>
* <li>No specific data is stored to match pathitem tags to the
* diagram figs which they control.
* <li>The matching during file load depends entirely on
* there being a unique figclassname and ownerhref combination
* for each pathitem on the diagram. For example, For a
* FigAssociation, the main label is a FigTextGroup, and it's
* owner is assigned to the Association. This combination is
* unique, and is used to match the parsed pathitem data back
* to the instantiated PathItemPlacement.
* Another example is the source multiplicity, which is a
* FigMultiplicity, and it's owner is assigned to the
* source model element.
* In each case, the combination is unique, so there is only
* one pathitem that matches when rebuilding the diagram.
* </ul>
*
* @param uri
* @param localname
* @param qname
* @param attributes
* @throws SAXException
* @see org.tigris.gef.persistence.pgml.BaseHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
*/
public void startElement(String uri, String localname, String qname,
Attributes attributes) throws SAXException {
if ("argouml:pathitem".equals(qname)
&& container instanceof FigEdgeHandler) {
String classname = attributes.getValue("classname");
String figclassname =
attributes.getValue("figclassname");
String ownerhref = attributes.getValue("ownerhref");
String angle = attributes.getValue("angle");
String offset = attributes.getValue("offset");
if ( classname != null
&& figclassname != null
&& ownerhref != null
&& angle != null
&& offset != null ) {
// Method 2: (assign data immediately, see end of file).
// TODO: if we ever want to extend PathItemPlacement,
// we should modify this, so that we also recognise any
// subclass of PathItemPlacement.
// Is the class name a PathItemPlacment?
// TODO: Use class reference to make this dependency obvious
if ("org.argouml.uml.diagram.ui.PathItemPlacement".equals(
classname)) {
PathItemPlacementStrategy pips
= getPips(figclassname, ownerhref);
// Sanity check - the returned path item placement
// strategy should match the one in the UML.
// If it doesn't, it could be that the UML was
// created with an older argo version, and the new
// argo version use a different placement strategy.
// If they don't match, just use the default.
if (pips != null
&& classname.equals(pips.getClass().getName())) {
// Now we're into processing each specific path
// item strategy.
// At the moment, we only know PathItemPlacement
if (pips instanceof PathItemPlacement) {
PathItemPlacement pip =
(PathItemPlacement) pips;
pip.setDisplacementVector(
Double.parseDouble(angle),
Integer.parseInt(offset));
}
// Continue (future PathItemPlacementStrategy impl)
//else if (...) {
//}
}
// If the PathItemPlacement was unknown, leave the
// diagram with the default settings.
else {
LOG.warn("PGML stored pathitem class name does "
+ "not match the class name on the "
+ "diagram. Label position will revert "
+ "to defaults.");
}
}
}
// If any of the values are null, ignore the element.
else {
LOG.warn("Could not find all attributes for <"
+ qname + "> tag, ignoring.");
//System.out.println("Error - one of these is null:"
// + "classname=" + classname
// + " figclassname=" + figclassname
// + " ownerhref=" + ownerhref
// + " angle=" + angle
// + " offset=" + offset);
}
}
super.startElement(uri, localname, qname, attributes);
}
/**
* Finds the path item placement strategy for a sub Fig, by its class name,
* and it's owner href.
* @param figclassname The class name of the fig being placed.
* @param ownerhref The href of the owner of the fig being placed.
* @return The path item placement strategy.
*/
private PathItemPlacementStrategy getPips(String figclassname,
String ownerhref) {
if (container instanceof FigEdgeHandler) {
FigEdge fe = ((FigEdgeHandler) container).getFigEdge();
Object owner = getPGMLStackParser().findOwner(ownerhref);
for (Object o : fe.getPathItemFigs()) {
Fig f = (Fig) o;
// For a match to be found, it has to have the same
// owner, and the same long class name.
if (owner.equals(f.getOwner())
&& figclassname.equals(f.getClass().getName())) {
//System.out.println("MATCHED! " + figclassname);
return fe.getPathItemPlacementStrategy(f);
}
}
}
LOG.warn("Could not load path item for fig '" + figclassname
+ "', using default placement.");
return null;
}
/**
* Determine if the string contains an ItemUID.
*
* @return a newly created ItemUID (or <code>null</code>).
*/
private ItemUID getItemUID(String privateContents) {
StringTokenizer st = new StringTokenizer(privateContents, "\n");
while (st.hasMoreElements()) {
String str = st.nextToken();
NameVal nval = splitNameVal(str);
if (nval != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Private Element: \"" + nval.getName()
+ "\" \"" + nval.getValue() + "\"");
}
if ("ItemUID".equals(nval.getName())
&& nval.getValue().length() > 0) {
return new ItemUID(nval.getValue());
}
}
}
return null;
}
/**
* Utility class to pair a name and a value String together.
*/
static class NameVal {
private String name;
private String value;
/**
* The constructor.
*
* @param n the name
* @param v the value
*/
NameVal(String n, String v) {
name = n.trim();
value = v.trim();
}
/**
* @return returns the name
*/
String getName() {
return name;
}
/**
* @return returns the value
*/
String getValue() {
return value;
}
}
/**
* Splits a name value pair into a NameVal instance. A name value pair is
* a String on the form < name = ["] value ["] >.
*
* @param str A String with a name value pair.
* @return A NameVal, or null if they could not be split.
*/
protected NameVal splitNameVal(String str) {
NameVal rv = null;
int lqpos, rqpos;
int eqpos = str.indexOf('=');
if (eqpos < 0) {
return null;
}
lqpos = str.indexOf('"', eqpos);
rqpos = str.lastIndexOf('"');
if (lqpos < 0 || rqpos <= lqpos) {
return null;
}
rv =
new NameVal(str.substring(0, eqpos),
str.substring(lqpos + 1, rqpos));
return rv;
}
}
// An alternative implementation of the parsing of pathitems is to collect
// everything at the start, then iterate through it all at the end.
// The code below does this - it works, but it is currently not used,
// since it is a unnecessarily complicated.
// There are probably better ways to implement this than using an
// ArrayList of Hashtables.
// see option 1 in
// http://argouml.tigris.org/issues/show_bug.cgi?id=1048#desc66
//
///**
// * A list of the path item attributes for this container.
// * The list is populated during parsing, them processed at endElement()
// */
//private List<Hashtable<String, String>> pathItemAttrs =
// new ArrayList<Hashtable<String, String>>();
// This code has to go within the startElement block after the strings
// have been matched.
//// Method 1:
//// (collect data and assign later in endElement() method).
//Hashtable<String, String> ht =
// new Hashtable<String, String>();
//ht.put("classname", classname);
//ht.put("figclassname", figclassname);
//ht.put("ownerhref", ownerhref);
//ht.put("angle", angle);
//ht.put("offset", offset);
//pathItemAttrs.add(ht);
//public void endElement(String uri, String localname, String qname)
//throws SAXException {
////System.out.print("Got endElement: "
//// + "uri='" + uri + "'\n"
//// + "localname='" + localname + "'\n"
//// + "qname='" + qname + "'\n"
////);
//// If we collected any path items for a FigEdgeModelElement,
//// process them now, and assign their values to real Figs on the diag.
//if (!(pathItemAttrs.isEmpty())) {
// for (Hashtable<String, String> attrs : pathItemAttrs) {
// // Is the class name a PathItemPlacment?
// // TODO: if we ever want to extend PathItemPlacement,
// // we should modify this, so that we also recognise any
// // subclass of PathItemPlacement.
// if ("org.argouml.uml.diagram.ui.PathItemPlacement".
// equals(attrs.get("classname"))) {
// //System.out.println("figclassname=" + attrs.get("figclassname"));
//
// PathItemPlacementStrategy pips
// = getPips(attrs.get("figclassname"),
// attrs.get("ownerhref"));
// // Sanity check - the returned path item placement straty
// // should match the one in the uml.
// if (pips.getClass().getName().equals(attrs.get("classname"))) {
// // Now we're into processing each specific path item
// // strategy.
// // At the moment, we only know about PathItemPlacement
// if (pips instanceof PathItemPlacement) {
// PathItemPlacement pip = (PathItemPlacement) pips;
// pip.setDisplacementVector(
// Double.parseDouble(attrs.get("angle")),
// Integer.parseInt(attrs.get("offset")));
// }
// // Continue (future PathItemPlacementStrategy impl)
// //else if (...) {
// //
// //}
//
// }
// else {
// LOG.warn("PGML stored pathitem class name does not "
// + "match the class name on the diagram."
// + "Label position will revert to defaults.");
// }
// }
// }
//}
//
//super.endElement(uri, localname, qname);
//}