| /** |
| * Copyright (c) 2011 Forschungszentrum Juelich GmbH |
| * 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: |
| * Carsten Karbach, Claudia Knobloch, FZ Juelich |
| */ |
| |
| package org.eclipse.ptp.rm.lml.internal.core.model; |
| |
| import java.io.OutputStream; |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import javax.xml.bind.JAXBContext; |
| import javax.xml.bind.JAXBElement; |
| import javax.xml.bind.JAXBException; |
| import javax.xml.bind.Marshaller; |
| import javax.xml.namespace.QName; |
| |
| import org.eclipse.ptp.rm.lml.core.events.ILguiUpdatedEvent; |
| import org.eclipse.ptp.rm.lml.core.listeners.ILguiListener; |
| import org.eclipse.ptp.rm.lml.core.model.ILguiItem; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.AbslayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ChartType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ChartgroupType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ChartlayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ColumnlayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ComponentType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ComponentlayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.DataType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.GobjectType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.InfoboxType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.InfoboxlayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.LayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.LguiType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.Nodedisplay; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.NodedisplaylayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.ObjectFactory; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.PaneType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.SchemeType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.SplitlayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.TableType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.TablelayoutType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.TextboxType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.UsagebarType; |
| import org.eclipse.ptp.rm.lml.internal.core.elements.UsagebarlayoutType; |
| |
| /** |
| * This class provides access to component-layout-definitions. |
| * Returns layout-objects for standard-lml-objects |
| * |
| * Moreover with this class one is able to manipulate layout definitions |
| * LML-Models can be transformed into layout-only definitions |
| * There are functions, which allow to merge layouts to one lml-model |
| * |
| * |
| * @author karbach |
| * |
| */ |
| public class LayoutAccess extends LguiHandler{ |
| //DefaultLayouts |
| private UsagebarlayoutType defaultUsagebar; |
| private ChartlayoutType defaultChart; |
| private TablelayoutType defaultTable; |
| private InfoboxlayoutType defaultInfobox; |
| |
| private static ObjectFactory objectFactory = new ObjectFactory();//create a objectfactory for all functions in this class |
| |
| /** |
| * @param lguiItem LML-data-handler, which groups this handler and others to a set |
| * of LMLHandler. This instance is needed to notify all LMLHandler, if any data of |
| * the LguiType-instance was changed. |
| */ |
| public LayoutAccess(ILguiItem lguiItem, LguiType lgui){ |
| super(lguiItem, lgui); |
| defaultUsagebar = objectFactory.createUsagebarlayoutType(); |
| defaultChart = objectFactory.createChartlayoutType(); |
| defaultTable = objectFactory.createTablelayoutType(); |
| defaultInfobox = objectFactory.createInfoboxlayoutType(); |
| |
| this.lguiItem.addListener(new ILguiListener() { |
| public void handleEvent(ILguiUpdatedEvent e) { |
| update(e.getLguiItem().getLguiType()); |
| } |
| }); |
| } |
| |
| /** |
| * Replace all componentlayouts for a graphical object with given gid through newlayout.getGid() |
| * with newlayout |
| * @param newLayout new layout, which is placed into the positions of old layouts |
| */ |
| public void replaceComponentLayout(ComponentlayoutType newlayout){ |
| if(newlayout==null) return; |
| String gid=newlayout.getGid(); |
| |
| List<JAXBElement<?>> allobjects=lgui.getObjectsAndRelationsAndInformation(); |
| |
| boolean replaced=false; |
| |
| //Over all objects in lml-file |
| for(JAXBElement<?> aobj: allobjects){ |
| //Over all Componentlayouts |
| if(aobj.getValue() instanceof ComponentlayoutType){ |
| |
| ComponentlayoutType alayout=(ComponentlayoutType)aobj.getValue(); |
| |
| if( alayout.getGid()!=null && alayout.getGid().equals(gid) ){ |
| ((JAXBElement<ComponentlayoutType>)aobj).setValue(newlayout); |
| replaced=true; |
| } |
| |
| } |
| } |
| |
| if(!replaced){//Insert new layout, if there was nothing to replace |
| //Takes any componentlayout |
| JAXBElement<?> newel=null; |
| |
| //Differ between several layouts, create different JAXBElements |
| if(newlayout instanceof TablelayoutType){ |
| newel=new JAXBElement<TablelayoutType>( new QName("tablelayout"), |
| TablelayoutType.class, (TablelayoutType)newlayout ); |
| } |
| else if(newlayout instanceof NodedisplaylayoutType){ |
| newel=new JAXBElement<NodedisplaylayoutType>( new QName("nodedisplaylayout"), |
| NodedisplaylayoutType.class, (NodedisplaylayoutType)newlayout ); |
| } |
| |
| if(newel!=null) |
| lgui.getObjectsAndRelationsAndInformation().add(newel); |
| } |
| |
| } |
| |
| /** |
| * Simply returns the first layout found for a usagebar with the given id |
| * or a default-layout |
| * @param usagebarID |
| * @return defaultlayout for a usagebar or first layout for usagebar with id usagebarid given by lml-file |
| */ |
| public UsagebarlayoutType getUsagebarLayout(String usagebarID) { |
| List<UsagebarlayoutType> usagebarLayouts = getUsagebarLayouts(); |
| //Over all objects in lml-file |
| for (UsagebarlayoutType usagebarLayout : usagebarLayouts) { |
| if (usagebarLayout.getGid().equals(usagebarID)) |
| return usagebarLayout; |
| } |
| return defaultUsagebar; |
| } |
| |
| |
| /** |
| * Simply returns the first layout found for a chart with the given id |
| * or a default-layout |
| * @param chartID |
| * @return defaultlayout for a chart or first layout for chart with id chartid given by lml-file |
| */ |
| public ChartlayoutType getChartLayout(String chartID) { |
| List<ChartlayoutType> chartLayouts = getChartLayouts(); |
| for (ChartlayoutType chartLayout : chartLayouts){ |
| if (chartLayout.getGid().equals(chartID)) |
| return chartLayout; |
| } |
| return defaultChart; |
| } |
| |
| |
| /** |
| * Simply returns the first layout found for a infobox with the given id |
| * or a default-layout |
| * @param infoID |
| * @return defaultlayout for a table or first layout for table with id tableid given by lml-file |
| */ |
| public InfoboxlayoutType getInfoboxLayout(String infoID){ |
| List<InfoboxlayoutType> infoboxLayouts = getInfoboxLayout(); |
| for (InfoboxlayoutType infoboxLayout : infoboxLayouts) { |
| if (infoboxLayout.getGid().equals(infoID) ) |
| return infoboxLayout; |
| } |
| return defaultInfobox; |
| } |
| |
| private List<InfoboxlayoutType> getInfoboxLayout() { |
| List<InfoboxlayoutType> infoboxLayouts = new LinkedList<InfoboxlayoutType>(); |
| for (ComponentlayoutType tag : getComponentLayouts()) { |
| if (tag instanceof InfoboxlayoutType) { |
| infoboxLayouts.add((InfoboxlayoutType) tag); |
| } |
| } |
| return infoboxLayouts; |
| } |
| |
| /** |
| * This function is only for easier understanding this class |
| * Textboxlayouts are identical to infoboxlayouts, so you could |
| * call getInfoboxLayout(textid) and would get the same result. |
| * |
| * @param textID id of a textbox |
| * @return layout for a textbox with an info-tag in it |
| */ |
| public InfoboxlayoutType getTextboxLayout(String textID){ |
| return getInfoboxLayout(textID); |
| } |
| |
| /** |
| * @param data model of lml-data, contingently with layout-information, this object will be modified and returned |
| * @param layout more important layout-data, overwrite componentlayouts of data-model, but add additional abs/-splitlayouts |
| * @return merged lml-model |
| */ |
| public static LguiType mergeLayouts(LguiType data, LguiType layout){ |
| |
| if(data==null || layout==null) return data; |
| LguiItem lgui = new LguiItem(data); |
| LayoutAccess la=new LayoutAccess(lgui, lgui.getLguiType()); |
| //Replace component-layouts |
| for(JAXBElement<?> el:layout.getObjectsAndRelationsAndInformation()){ |
| if(el.getValue() instanceof ComponentlayoutType){ |
| la.replaceComponentLayout((ComponentlayoutType)el.getValue()); |
| } |
| } |
| |
| /** really merge layouts, do not overwrite |
| //Collect existing layout-ids |
| HashSet<String> layoutids=new HashSet<String>(); |
| |
| for(JAXBElement<?> el:data.getObjectsAndRelationsAndInformation()){ |
| if(el.getValue() instanceof LayoutType){ |
| LayoutType lay=(LayoutType) el.getValue(); |
| layoutids.add(lay.getId()); |
| } |
| } |
| |
| //Generate new ids if layout-ids already exist in data, then add new layout to data |
| for(JAXBElement<?> el:layout.getObjectsAndRelationsAndInformation()){ |
| if(el.getValue() instanceof LayoutType){ |
| LayoutType lay=(LayoutType) el.getValue(); |
| |
| String newid=lay.getId(); |
| while(layoutids.contains( newid )){ |
| newid=newid+"'"; |
| } |
| |
| lay.setId(newid); |
| layoutids.add(newid); |
| //Add this layout with new id to data-instance |
| data.getObjectsAndRelationsAndInformation().add(el); |
| } |
| } |
| **/ |
| |
| //Overwrite layouts with the same name |
| for(JAXBElement<?> el:layout.getObjectsAndRelationsAndInformation()){ |
| if(el.getValue() instanceof LayoutType){ |
| if( ! replaceGlobalLayout( (LayoutType)el.getValue(), data) ){//If not replaced, insert it |
| data.getObjectsAndRelationsAndInformation().add(el); |
| } |
| } |
| } |
| |
| return data; |
| } |
| |
| /** |
| * Replace a global layout within the lml-model by a new one |
| * @param newlayout new layout, which replaces the old in model with the same id |
| * @param model lgui-instance, which is changed |
| */ |
| public static boolean replaceGlobalLayout(LayoutType newlayout, LguiType model){ |
| |
| List<JAXBElement<?>> all=model.getObjectsAndRelationsAndInformation(); |
| |
| //Go through all objects, search for layouttypes with newlayout.getId as id and replace them with this layout |
| for(int i=0; i<all.size(); i++){ |
| JAXBElement<?> aobj=all.get(i); |
| if(aobj.getValue() instanceof LayoutType){ |
| LayoutType old=(LayoutType) aobj.getValue(); |
| if(old.getId().equals(newlayout.getId())){ |
| ( (JAXBElement<LayoutType>)aobj).setValue( newlayout ); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| |
| /** |
| * Search for gid-attributes of a pane and put it into neededComponents |
| * Recursively search all graphical objects referenced by this pane |
| * |
| * @param p part of SplitLayout, which is scanned for gid-attributes |
| * @param neededComponents resulting Hashset |
| */ |
| private static void collectComponents(PaneType p, HashSet<String> neededComponents){ |
| |
| if(p.getGid()!=null) |
| neededComponents.add(p.getGid()); |
| else{ |
| //top and bottom components? |
| if(p.getBottom()!=null){ |
| collectComponents(p.getBottom(), neededComponents); |
| collectComponents(p.getTop(), neededComponents); |
| } |
| else{//Left and right |
| collectComponents(p.getLeft(), neededComponents); |
| collectComponents(p.getRight(), neededComponents); |
| } |
| } |
| |
| } |
| |
| /** |
| * @param gobj |
| * @return a copy of gobj with minimal size, only attributes in GobjectType are copied |
| * and lower special elements which are needed to make lml-model valid |
| */ |
| private static JAXBElement<GobjectType> minimizeGobjectType(GobjectType gobj){ |
| |
| String qname="table"; |
| Class<GobjectType> c=(Class<GobjectType>)gobj.getClass(); |
| |
| GobjectType value=objectFactory.createGobjectType(); |
| |
| if( gobj instanceof TableType ){ |
| TableType tt=objectFactory.createTableType(); |
| |
| value=tt; |
| |
| qname="table"; |
| } |
| else if(gobj instanceof UsagebarType){ |
| UsagebarType ut=objectFactory.createUsagebarType(); |
| |
| value=ut; |
| |
| qname="usagebar"; |
| } |
| else if(gobj instanceof TextboxType){ |
| TextboxType ut=objectFactory.createTextboxType(); |
| |
| value=ut; |
| |
| qname="text"; |
| } |
| else if(gobj instanceof InfoboxType){ |
| InfoboxType ut=objectFactory.createInfoboxType(); |
| |
| value=ut; |
| |
| qname="infobox"; |
| } |
| else if(gobj instanceof Nodedisplay){//Create minimal nodedisplay |
| Nodedisplay ut=objectFactory.createNodedisplay(); |
| |
| value=ut; |
| SchemeType scheme=objectFactory.createSchemeType(); |
| scheme.getEl1().add(objectFactory.createSchemeElement1()); |
| ut.setScheme(scheme); |
| |
| DataType dat=objectFactory.createDataType(); |
| dat.getEl1().add(objectFactory.createDataElement1()); |
| ut.setData(dat); |
| |
| qname="nodedisplay"; |
| } |
| else if(gobj instanceof ChartType){ |
| ChartType ut=objectFactory.createChartType(); |
| |
| value=ut; |
| |
| qname="chart"; |
| } |
| else if(gobj instanceof ChartgroupType){ |
| ChartgroupType ut=objectFactory.createChartgroupType(); |
| |
| value=ut; |
| |
| qname="chartgroup"; |
| } |
| |
| value.setDescription(gobj.getDescription()); |
| value.setId(gobj.getId()); |
| value.setTitle(gobj.getTitle()); |
| |
| |
| JAXBElement<GobjectType> res=new JAXBElement<GobjectType>(new QName(qname), c, value ); |
| |
| return res; |
| } |
| |
| |
| /** |
| * Remove all important data from modell |
| * return only layout-information and data, which is needed to make |
| * lml-model valid |
| * @param modell lml-modell with data and layout-information |
| * @return |
| */ |
| public static LguiType getLayoutFromModell(LguiType modell){ |
| |
| LguiType res=objectFactory.createLguiType(); |
| |
| HashSet<String> neededComponents=new HashSet<String>(); |
| |
| for(JAXBElement<?> tag: modell.getObjectsAndRelationsAndInformation()){ |
| |
| Object value=tag.getValue(); |
| |
| //add normal global layouts |
| if(value instanceof LayoutType){ |
| res.getObjectsAndRelationsAndInformation().add(tag); |
| |
| if(value instanceof SplitlayoutType){ |
| SplitlayoutType splitlayout=(SplitlayoutType)value; |
| //Collect needed components from layout recursively |
| if(splitlayout.getLeft()!=null){ |
| collectComponents(splitlayout.getLeft(), neededComponents); |
| collectComponents(splitlayout.getRight(), neededComponents); |
| } |
| } |
| else if(value instanceof AbslayoutType){ |
| |
| AbslayoutType abslayout=(AbslayoutType)value; |
| //Just traverse comp-list for gid-attributes |
| for(ComponentType comp: abslayout.getComp()){ |
| neededComponents.add(comp.getGid()); |
| } |
| |
| } |
| |
| } |
| else if(value instanceof ComponentlayoutType){ |
| res.getObjectsAndRelationsAndInformation().add(tag); |
| |
| ComponentlayoutType complayout=(ComponentlayoutType)value; |
| neededComponents.add(complayout.getGid()); |
| } |
| |
| } |
| |
| HashMap<String, GobjectType> idtoGobject=new HashMap<String, GobjectType>(); |
| //Search needed components in data-tag to discover, which type the needed components have |
| for(JAXBElement<?> tag: modell.getObjectsAndRelationsAndInformation()){ |
| |
| Object value=tag.getValue(); |
| //is it a graphical object? |
| if(value instanceof GobjectType){ |
| GobjectType gobj=(GobjectType)value; |
| if(neededComponents.contains(gobj.getId())){ |
| idtoGobject.put(gobj.getId(), gobj); |
| } |
| } |
| } |
| |
| //Add all gobjects in idtoGobject to the result, so that lml-modell is valid |
| for(GobjectType gobj: idtoGobject.values()){ |
| JAXBElement<GobjectType> min=minimizeGobjectType(gobj); |
| res.getObjectsAndRelationsAndInformation().add(min); |
| } |
| |
| //Set layout-attribute |
| res.setLayout(true); |
| |
| return res; |
| } |
| |
| /** |
| * @param obj LguiType-instance |
| * @param output OutputStream to save xml-representation of obj in |
| * @throws JAXBException |
| */ |
| public static void objToLML(LguiType obj, OutputStream output) throws JAXBException { |
| |
| JAXBContext jc = JAXBContext.newInstance("lml"); |
| |
| Marshaller mar=jc.createMarshaller(); |
| |
| mar.setProperty("jaxb.schemaLocation", "http://www.llview.de lgui.xsd"); |
| |
| QName tagname=new QName("http://www.llview.de", "lgui", "lml"); |
| |
| JAXBElement<LguiType> rootel=new JAXBElement<LguiType>(tagname, LguiType.class, obj); |
| |
| mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); |
| |
| mar.marshal(rootel, output); |
| } |
| |
| /** |
| * Search in component-layouts for layout for the graphical object with id gid. |
| * @param gid id of corresponding graphical object, for which layouts are searched |
| * @return list of componentlayouts corresponding to the graphical object id gid |
| */ |
| public List<ComponentlayoutType> getComponentLayoutByGID(String gid){ |
| |
| List<ComponentlayoutType> complayouts= getComponentLayouts(); |
| |
| ArrayList<ComponentlayoutType> res=new ArrayList<ComponentlayoutType>(); |
| |
| for(ComponentlayoutType alayout: complayouts){ |
| |
| if( alayout.getGid()!=null && alayout.getGid().equals(gid) ){ |
| |
| res.add(alayout); |
| } |
| } |
| |
| return res; |
| } |
| |
| /** |
| * Add a new created layout to the model |
| * @param layout absolute or splitlayout |
| */ |
| public void addLayoutTag(LayoutType layout){ |
| |
| if(layout.getId()==null){ |
| layout.setId(""); |
| } |
| |
| JAXBElement<? extends LayoutType> jaxbel=null; |
| //Create jaxbelement corresponding to the class-type |
| if(layout instanceof AbslayoutType){ |
| |
| AbslayoutType abslayout=(AbslayoutType)layout; |
| |
| jaxbel=new JAXBElement<AbslayoutType>(new QName("abslayout"), AbslayoutType.class, abslayout); |
| |
| } |
| else |
| if(layout instanceof SplitlayoutType){ |
| |
| SplitlayoutType splitlayout=(SplitlayoutType)layout; |
| |
| jaxbel=new JAXBElement<SplitlayoutType>(new QName("splitlayout"), SplitlayoutType.class, splitlayout); |
| |
| } |
| else |
| return; |
| |
| this.lgui.getObjectsAndRelationsAndInformation().add( jaxbel ); |
| |
| if( lguiItem instanceof LguiItem){ |
| LguiItem internal=(LguiItem) lguiItem; |
| |
| internal.updateData(lgui); |
| } |
| |
| } |
| |
| /** |
| * Generates an absolute layout without needing a layout tag. Active components |
| * are placed in a grid on the screen. Use this function, if no layout was specified |
| * by the lml-file. |
| * @param width width in pixels of the area, on which this layout is shown |
| * @param height height in pixels of the area, on which this layout is shown |
| * @return default absolute layout with all active components in it |
| */ |
| public AbslayoutType generateDefaultAbsoluteLayout(int width, int height){ |
| |
| //Collect active components |
| List<GobjectType> gobjects=lguiItem.getOverviewAccess().getGraphicalObjects(); |
| |
| ArrayList<GobjectType> activeobjects=new ArrayList<GobjectType>(); |
| //Go through all graphical objects |
| for(GobjectType gobj: gobjects){ |
| //Get layouts for this object, normally there is only one |
| List<ComponentlayoutType> layouts=getComponentLayoutByGID(gobj.getId()); |
| |
| if(layouts.size()==0){//assume gobj to be active if there is no componentlayout |
| activeobjects.add(gobj); |
| } |
| |
| //Search for a componentlayout which declares gobj to be active |
| for(ComponentlayoutType complayout: layouts){ |
| if( complayout.isActive() ){ |
| activeobjects.add(gobj); |
| } |
| } |
| } |
| |
| //Now activeobjects contains all active graphical objects, which have to be arranged on the screen |
| |
| AbslayoutType res=objectFactory.createAbslayoutType(); |
| |
| res.setId("abs_default"); |
| |
| //Try to create as many columns as rows |
| int columns=(int)Math.round( Math.sqrt( activeobjects.size() ) ); |
| |
| if(columns==0) |
| columns=1; |
| |
| int rows=(int)Math.ceil( (double)activeobjects.size()/columns ); |
| |
| if(rows==0) |
| rows=1; |
| //Calculate width and height of graphical objects |
| int index=0; |
| int rectwidth=width/columns; |
| int rectheight=height/rows; |
| |
| for(GobjectType gobj:activeobjects){ |
| |
| ComponentType pos=objectFactory.createComponentType(); |
| pos.setGid(gobj.getId()); |
| //Positioning the component |
| pos.setW(BigInteger.valueOf(rectwidth)); |
| pos.setH(BigInteger.valueOf(rectheight)); |
| |
| pos.setX( BigInteger.valueOf( (index%columns)*rectwidth )) ; |
| pos.setY( BigInteger.valueOf( (index/columns)*rectheight )) ; |
| |
| //Add this component position to the layout |
| res.getComp().add(pos); |
| |
| index++; |
| } |
| |
| return res; |
| } |
| |
| public TablelayoutType getDefaultTableLayout(TableType table) { |
| String id = table.getId(); |
| if (getTableLayout(id) == null || getTableLayout(id).getColumn().size() <= 0) { |
| getTableLayout(id).setId(table.getId()+"_layout"); |
| getTableLayout(id).setGid(table.getId()); |
| for (int i = 0; i < table.getColumn().size(); i++) { |
| ColumnlayoutType column = new ColumnlayoutType(); |
| column.setCid(BigInteger.valueOf(i + 1)); |
| column.setPos(BigInteger.valueOf(i)); |
| column.setWidth(Double.valueOf(1)); |
| column.setActive(true); |
| column.setKey(table.getColumn().get(i).getName()); |
| getTableLayout(id).getColumn().add(column); |
| } |
| } |
| return getTableLayout(id); |
| } |
| |
| /** |
| * Getting a list of all elements of type ComponentlayoutType from LguiType. |
| * @return list of elements(ComponentlayoutType) |
| */ |
| List<ComponentlayoutType> getComponentLayouts() { |
| List<ComponentlayoutType> layouts = new LinkedList<ComponentlayoutType>(); |
| for (JAXBElement<?> tag : lgui.getObjectsAndRelationsAndInformation()) { |
| if (tag.getValue() instanceof ComponentlayoutType) { |
| layouts.add((ComponentlayoutType) tag.getValue()); |
| } |
| } |
| return layouts; |
| } |
| |
| /** |
| * Getting a list of elements of type NodedisplaylayoutType. |
| * @return list of elements(NodedisplaylayoutType) |
| */ |
| List<NodedisplaylayoutType> getNodedisplayLayouts() { |
| List<NodedisplaylayoutType> nodedisplayLayouts = new LinkedList<NodedisplaylayoutType>(); |
| for (ComponentlayoutType tag : getComponentLayouts()) { |
| if (tag instanceof NodedisplaylayoutType) { |
| nodedisplayLayouts.add((NodedisplaylayoutType) tag); |
| } |
| } |
| return nodedisplayLayouts; |
| } |
| |
| |
| /** |
| * Getting a list of all elements of type TablelayoutType. |
| * @return list of elements(TablelayoutType) |
| */ |
| List<TablelayoutType> getTableLayouts() { |
| List<TablelayoutType> tableLayouts = new LinkedList<TablelayoutType>(); |
| for (ComponentlayoutType tag : getComponentLayouts()) { |
| if (tag instanceof TablelayoutType) { |
| tableLayouts.add((TablelayoutType) tag); |
| } |
| } |
| return tableLayouts; |
| } |
| |
| /** |
| * Getting the layout of a given table, the identifier of the layout is the shared ID of table and layout. |
| * @param tablelayoutID ID of the desired tablelayout |
| * @return Corresponding layout of a table |
| */ |
| public TablelayoutType getTableLayout(String tablelayoutID) { |
| for (TablelayoutType tag : getTableLayouts()) { |
| if (tag.getGid().equals(tablelayoutID)) { |
| return tag; |
| } |
| } |
| return defaultTable; |
| } |
| |
| |
| List<UsagebarlayoutType> getUsagebarLayouts() { |
| List<UsagebarlayoutType> usagebarLayouts = new LinkedList<UsagebarlayoutType>(); |
| for (ComponentlayoutType tag : getComponentLayouts()) { |
| if (tag instanceof UsagebarlayoutType) { |
| usagebarLayouts.add((UsagebarlayoutType) tag); |
| } |
| } |
| return usagebarLayouts; |
| } |
| |
| |
| List<ChartlayoutType> getChartLayouts() { |
| List<ChartlayoutType> chartLayouts = new LinkedList<ChartlayoutType>(); |
| for (ComponentlayoutType tag : chartLayouts) { |
| if (tag instanceof ChartlayoutType) { |
| chartLayouts.add((ChartlayoutType) tag); |
| } |
| } |
| return chartLayouts; |
| } |
| |
| } |