Package org.pentaho.reporting.designer.core.util.dnd

Source Code of org.pentaho.reporting.designer.core.util.dnd.InsertationUtil

/*!
* This program is free software; you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
* Foundation.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
* or from the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* Copyright (c) 2002-2013 Pentaho Corporation..  All rights reserved.
*/

package org.pentaho.reporting.designer.core.util.dnd;

import java.awt.Component;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import javax.swing.FocusManager;

import org.pentaho.reporting.designer.core.ReportDesignerBoot;
import org.pentaho.reporting.designer.core.editor.ReportDocumentContext;
import org.pentaho.reporting.designer.core.editor.report.RootBandRenderComponent;
import org.pentaho.reporting.designer.core.editor.structuretree.ReportFunctionNode;
import org.pentaho.reporting.designer.core.editor.structuretree.ReportParametersNode;
import org.pentaho.reporting.designer.core.editor.structuretree.SubReportParametersNode;
import org.pentaho.reporting.designer.core.model.ModelUtility;
import org.pentaho.reporting.designer.core.model.selection.DocumentContextSelectionModel;
import org.pentaho.reporting.designer.core.util.exceptions.UncaughtExceptionsModel;
import org.pentaho.reporting.designer.core.util.undo.BandedSubreportEditUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.DataSourceEditUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.ElementEditUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.ExpressionRemoveUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.ParameterEditUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.SectionEditUndoEntry;
import org.pentaho.reporting.designer.core.util.undo.UndoEntry;
import org.pentaho.reporting.engine.classic.core.AbstractReportDefinition;
import org.pentaho.reporting.engine.classic.core.AbstractRootLevelBand;
import org.pentaho.reporting.engine.classic.core.Band;
import org.pentaho.reporting.engine.classic.core.CompoundDataFactory;
import org.pentaho.reporting.engine.classic.core.CrosstabCell;
import org.pentaho.reporting.engine.classic.core.CrosstabCellBody;
import org.pentaho.reporting.engine.classic.core.CrosstabGroup;
import org.pentaho.reporting.engine.classic.core.DataFactory;
import org.pentaho.reporting.engine.classic.core.DetailsFooter;
import org.pentaho.reporting.engine.classic.core.DetailsHeader;
import org.pentaho.reporting.engine.classic.core.Element;
import org.pentaho.reporting.engine.classic.core.Group;
import org.pentaho.reporting.engine.classic.core.GroupBody;
import org.pentaho.reporting.engine.classic.core.GroupDataBody;
import org.pentaho.reporting.engine.classic.core.GroupFooter;
import org.pentaho.reporting.engine.classic.core.GroupHeader;
import org.pentaho.reporting.engine.classic.core.ItemBand;
import org.pentaho.reporting.engine.classic.core.MasterReport;
import org.pentaho.reporting.engine.classic.core.NoDataBand;
import org.pentaho.reporting.engine.classic.core.PageFooter;
import org.pentaho.reporting.engine.classic.core.PageHeader;
import org.pentaho.reporting.engine.classic.core.RelationalGroup;
import org.pentaho.reporting.engine.classic.core.ReportElement;
import org.pentaho.reporting.engine.classic.core.ReportFooter;
import org.pentaho.reporting.engine.classic.core.ReportHeader;
import org.pentaho.reporting.engine.classic.core.RootLevelBand;
import org.pentaho.reporting.engine.classic.core.Section;
import org.pentaho.reporting.engine.classic.core.SubGroupBody;
import org.pentaho.reporting.engine.classic.core.SubReport;
import org.pentaho.reporting.engine.classic.core.Watermark;
import org.pentaho.reporting.engine.classic.core.filter.types.bands.BandType;
import org.pentaho.reporting.engine.classic.core.function.Expression;
import org.pentaho.reporting.engine.classic.core.function.ExpressionCollection;
import org.pentaho.reporting.engine.classic.core.parameters.ModifiableReportParameterDefinition;
import org.pentaho.reporting.engine.classic.core.parameters.ParameterDefinitionEntry;
import org.pentaho.reporting.engine.classic.core.parameters.ReportParameterDefinition;

/**
* Todo: Document Me
*
* @author Thomas Morgner
*/
public class InsertationUtil
{
  public static final String SUBREPORT_BANDED_HINT = "subreport-banded-hint";

  private InsertationUtil()
  {
  }

  private static final Object[] EMPTY_ARRAY = new Object[0];

  public static Object[] getFromClipboard()
  {
    try
    {
      final Object[] data = ClipboardManager.getManager().getContents();
      if (data == null)
      {
        return EMPTY_ARRAY;
      }
      return data;
    }
    catch (final UnsupportedFlavorException e1)
    {
      UncaughtExceptionsModel.getInstance().addException(e1);
      return EMPTY_ARRAY;
    }
    catch (final IOException e1)
    {
      UncaughtExceptionsModel.getInstance().addException(e1);
      return EMPTY_ARRAY;
    }
  }

  public static boolean isInsertAllowed(final Object target, final Object data)
  {
    if (target instanceof SubReport ||
        target instanceof MasterReport)
    {
      return (data instanceof Group ||
          data instanceof ReportHeader ||
          data instanceof ReportFooter ||
          data instanceof PageHeader ||
          data instanceof PageFooter);
    }
    if (target instanceof Group)
    {
      return (data instanceof Group ||
          data instanceof GroupBody ||
          data instanceof GroupHeader ||
          data instanceof GroupFooter);
    }
    if (target instanceof SubGroupBody)
    {
      return (data instanceof Group);
    }
    if (target instanceof GroupDataBody)
    {
      return (data instanceof DetailsHeader ||
          data instanceof DetailsFooter ||
          data instanceof NoDataBand ||
          data instanceof ItemBand);
    }
    if (target instanceof Band)
    {
      if (data instanceof AbstractReportDefinition)
      {
        Band b = (Band) target;
        while (b != null)
        {
          if (b instanceof PageHeader || b instanceof PageFooter ||
              b instanceof DetailsHeader || b instanceof DetailsFooter ||
              b instanceof Watermark)
          {
            return false;
          }
          b = b.getParent();
        }
      }
      else if (data instanceof Group || data instanceof GroupBody)
      {
        // exclude groups and group-body, they cannot be a child of bands.
        return false;
      }
      return (data instanceof Element);
    }

    return (data instanceof Expression ||
        data instanceof ParameterDefinitionEntry ||
        data instanceof DataFactory);
  }

  public static Object getInsertationPoint(final ReportDocumentContext renderContext)
  {
    final Component owner = FocusManager.getCurrentManager().getPermanentFocusOwner();
    if (owner instanceof RootBandRenderComponent == false)
    {
      final Object o = renderContext.getSelectionModel().getLeadSelection();
      if (o == null)
      {
        return null;
      }
      if (o instanceof Band)
      {
        return o;
      }
      if (o instanceof ReportElement)
      {
        final ReportElement element = (ReportElement) o;
        final Section parentSection = element.getParentSection();
        if (parentSection instanceof Band)
        {
          return parentSection;
        }
      }
      if (o instanceof CompoundDataFactory)
      {
        return o;
      }
      if (o instanceof ReportFunctionNode)
      {
        return o;
      }
      if (o instanceof ReportParametersNode)
      {
        return o;
      }
      if (o instanceof SubReportParametersNode)
      {
        return o;
      }

      return null;
    }

    final RootBandRenderComponent rootBandRenderComponent = (RootBandRenderComponent) owner;
    final Band rootBand = rootBandRenderComponent.getRootBand();

    final DocumentContextSelectionModel selectionModel = renderContext.getSelectionModel();
    for (final Element element : selectionModel.getSelectedElementsOfType(Element.class))
    {
      if (element instanceof Band && ModelUtility.isDescendant(rootBand, element))
      {
        return element;
      }
    }
    return rootBand;
  }

  public static Object insert(final Object rawLeadSelection,
                              final AbstractReportDefinition report,
                              final Object fromClipboard)
  {
    if (fromClipboard instanceof Expression)
    {
      return insertExpression(report, (Expression) fromClipboard);
    }

    if (fromClipboard instanceof ParameterDefinitionEntry)
    {
      return insertParameter(report, (ParameterDefinitionEntry) fromClipboard);
    }

    if (fromClipboard instanceof DataFactory)
    {
      return insertDataFactory(report, (DataFactory) fromClipboard);
    }

    if (fromClipboard instanceof Element == false)
    {
      return false;
    }

    final Element insert = (Element) fromClipboard;

    if (rawLeadSelection instanceof Element == false)
    {
      return false;
    }

    if (rawLeadSelection instanceof Band)
    {
      final Band target = (Band) rawLeadSelection;
      if (target == insert)
      {
        return false;
      }
      if (ModelUtility.isDescendant(target, insert))
      {
        return false;
      }
      if (insert.getParent() != null)
      {
        // this should not happen. We should only see clones here ..
        throw new IllegalStateException();
      }

      try
      {
        final Element element = normalizeForInsert(insert);
        if (element == null)
        {
          return false;
        }

        if (element instanceof SubReport)
        {
          final Object subreportHint = insert.getAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, SUBREPORT_BANDED_HINT);
          if (Boolean.TRUE.equals(subreportHint))
          {
            if (target instanceof AbstractRootLevelBand)
            {
              final AbstractRootLevelBand rlb = (AbstractRootLevelBand) target;
              rlb.addSubReport((SubReport) element);
              return element;
            }
            else
            {
              return false;
            }
          }
        }

        target.addElement(element);
        return element;
      }
      catch (CloneNotSupportedException e1)
      {
        UncaughtExceptionsModel.getInstance().addException(e1);
        return false;
      }
    }

    if (rawLeadSelection instanceof AbstractReportDefinition)
    {
      final AbstractReportDefinition g = (AbstractReportDefinition) rawLeadSelection;
      if (insert instanceof PageHeader)
      {
        final PageHeader header = (PageHeader) insert.derive();
        g.setPageHeader(header);
        return header;
      }

      if (insert instanceof PageFooter)
      {
        final PageFooter footer = (PageFooter) insert.derive();
        g.setPageFooter(footer);
        return footer;
      }

      if (insert instanceof ReportHeader)
      {
        final ReportHeader header = (ReportHeader) insert.derive();
        g.setReportHeader(header);
        return header;
      }

      if (insert instanceof ReportFooter)
      {
        final ReportFooter footer = (ReportFooter) insert.derive();
        g.setReportFooter(footer);
        return footer;
      }
      if (insert instanceof Group)
      {
        final Group group = (Group) insert.derive();
        g.setRootGroup(group);
        return group;
      }
      return null;
    }

    if (rawLeadSelection instanceof RelationalGroup)
    {
      final RelationalGroup g = (RelationalGroup) rawLeadSelection;
      if (insert instanceof GroupHeader)
      {
        final GroupHeader header = (GroupHeader) insert.derive();
        g.setHeader(header);
        return header;
      }

      if (insert instanceof GroupFooter)
      {
        final GroupFooter footer = (GroupFooter) insert.derive();
        g.setFooter(footer);
        return footer;
      }

      if (insert instanceof GroupBody)
      {
        final GroupBody body = (GroupBody) insert.derive();
        try
        {
          g.setBody(body);
          return body;
        }
        catch (final Exception e)
        {
          return null;
        }
      }
      return null;
    }

    if (rawLeadSelection instanceof SubGroupBody)
    {
      final SubGroupBody body = (SubGroupBody) rawLeadSelection;
      if (insert instanceof RelationalGroup || insert instanceof CrosstabGroup)
      {
        try
        {
          final Group group = (Group) insert.derive();
          body.setGroup(group);
          return group;
        }
        catch (Exception cne)
        {
          UncaughtExceptionsModel.getInstance().addException(cne);
          return null;
        }
      }
      return null;
    }

    if (rawLeadSelection instanceof GroupDataBody)
    {
      final GroupDataBody body = (GroupDataBody) rawLeadSelection;
      if (insert instanceof DetailsHeader)
      {
        final DetailsHeader detailsHeader = (DetailsHeader) insert.derive();
        body.setDetailsHeader(detailsHeader);
        return detailsHeader;
      }
      if (insert instanceof DetailsFooter)
      {
        final DetailsFooter footer = (DetailsFooter) insert.derive();
        body.setDetailsFooter(footer);
        return footer;
      }
      if (insert instanceof ItemBand)
      {
        final ItemBand itemBand = (ItemBand) insert.derive();
        body.setItemBand(itemBand);
        return itemBand;
      }
      if (insert instanceof NoDataBand)
      {
        final NoDataBand noDataBand = (NoDataBand) insert.derive();
        body.setNoDataBand(noDataBand);
        return noDataBand;
      }
      return null;
    }

    if (rawLeadSelection instanceof CrosstabCellBody)
    {
      final CrosstabCellBody body = (CrosstabCellBody) rawLeadSelection;
      if (insert instanceof CrosstabCell)
      {
        final CrosstabCell crosstabCell = (CrosstabCell) insert.derive();
        body.addElement(crosstabCell);
        return crosstabCell;
      }
    }

    return null;
  }

  private static Object insertDataFactory(final AbstractReportDefinition report, final DataFactory fromClipboard)
  {
    final CompoundDataFactory element = (CompoundDataFactory) report.getDataFactory();
    final DataFactory df = (DataFactory) fromClipboard;
    final DataFactory dataFactory = df.derive();
    element.add(dataFactory);
    report.notifyNodeChildAdded(dataFactory);
    return dataFactory;
  }

  private static Object insertParameter(final AbstractReportDefinition report,
                                        final ParameterDefinitionEntry fromClipboard)
  {
    if ((report instanceof MasterReport) == false)
    {
      return null;
    }

    final MasterReport masterReportElement = (MasterReport) report;
    final ParameterDefinitionEntry pe = (ParameterDefinitionEntry) fromClipboard;
    try
    {
      final ModifiableReportParameterDefinition definition = (ModifiableReportParameterDefinition) masterReportElement.getParameterDefinition();
      final ParameterDefinitionEntry definitionEntry = (ParameterDefinitionEntry) pe.clone();
      definition.addParameterDefinition(definitionEntry);
      report.notifyNodeChildAdded(definitionEntry);
      return definitionEntry;
    }
    catch (CloneNotSupportedException e1)
    {
      // ignore ..
      UncaughtExceptionsModel.getInstance().addException(e1);
      return null;
    }
  }

  private static Object insertExpression(final AbstractReportDefinition report, final Expression fromClipboard)
  {
    final Expression expression = (Expression) fromClipboard;
    final Expression instance = expression.getInstance();
    report.addExpression(instance);
    report.notifyNodeChildAdded(instance);
    return instance;
  }

  private static Element normalizeForInsert(final Element insert) throws CloneNotSupportedException
  {
    if (insert instanceof Section == false)
    {
      return insert.derive();
    }
    if (insert instanceof SubReport)
    {
      return insert.derive();
    }

    if (insert instanceof Band)
    {
      final Band band = (Band) insert;
      if (insert instanceof RootLevelBand == false)
      {
        return band.derive();
      }
      final Band newBand = new Band();
      band.copyInto(newBand);
      band.setElementType(BandType.INSTANCE);
      return newBand;
    }

    return null;
  }

  public static UndoEntry delete(final ReportDocumentContext context, final Object data)
  {
    if (data == context.getReportDefinition())
    {
      // we never delete the root element.
      return null;
    }

    if (data instanceof ParameterDefinitionEntry)
    {
      return deleteParameter(context, data);
    }

    if (data instanceof Expression)
    {
      return deleteExpression(context, data);
    }

    if (data instanceof DataFactory)
    {
      return deleteDataFactory(context, data);
    }

    if (data instanceof MasterReport)
    {
      // cannot remove the master report. But we can copy it.
      return null;
    }

    if (data instanceof GroupBody)
    {
      return deleteGroupBody((GroupBody) data);
    }

    if (data instanceof Group)
    {
      return deleteGroup((Group) data);

    }

    if (data instanceof Element == false)
    {
      return null;
    }

    final Element veElement = (Element) data;
    final Section parent = veElement.getParentSection();
    if (data instanceof SubReport && parent instanceof AbstractRootLevelBand)
    {
      final AbstractRootLevelBand re = (AbstractRootLevelBand) parent;
      final SubReport report = (SubReport) data;
      final int index = ModelUtility.findSubreportIndexOf(re, report);
      if (index != -1)
      {
        re.removeSubreport(report);
      }
      if (veElement.getParent() == null)
      {
        // remove was a success ...
        return new BandedSubreportEditUndoEntry(re.getObjectID(), index, report, null);
      }
    }

    if (parent instanceof Band)
    {
      final Band band = (Band) parent;
      final int index = ModelUtility.findIndexOf(band, veElement);
      band.removeElement(veElement);
      return new ElementEditUndoEntry(band.getObjectID(), index, veElement, null);
    }

    if (data instanceof GroupHeader)
    {
      final RelationalGroup g = (RelationalGroup) parent;
      final GroupHeader oldHeader = g.getHeader();
      final GroupHeader newHeader = new GroupHeader();
      g.setHeader(newHeader);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newHeader), oldHeader, newHeader);
    }

    if (data instanceof GroupFooter)
    {
      final RelationalGroup g = (RelationalGroup) parent;
      final GroupFooter oldFooter = g.getFooter();
      final GroupFooter newFooter = new GroupFooter();
      g.setFooter(newFooter);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newFooter), oldFooter, newFooter);
    }
    if (data instanceof ReportFooter)
    {
      final AbstractReportDefinition g = (AbstractReportDefinition) parent;
      final ReportFooter oldFooter = g.getReportFooter();
      final ReportFooter newFooter = new ReportFooter();
      g.setReportFooter(newFooter);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newFooter), oldFooter, newFooter);
    }
    if (data instanceof ReportHeader)
    {
      final AbstractReportDefinition g = (AbstractReportDefinition) parent;
      final ReportHeader oldHeader = g.getReportHeader();
      final ReportHeader newHeader = new ReportHeader();
      g.setReportHeader(newHeader);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newHeader), oldHeader, newHeader);
    }
    if (data instanceof PageHeader)
    {
      final AbstractReportDefinition g = (AbstractReportDefinition) parent;
      final PageHeader oldHeader = g.getPageHeader();
      final PageHeader newHeader = new PageHeader();
      g.setPageHeader(newHeader);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newHeader), oldHeader, newHeader);
    }
    if (data instanceof PageFooter)
    {
      final AbstractReportDefinition g = (AbstractReportDefinition) parent;
      final PageFooter oldFooter = g.getPageFooter();
      final PageFooter newFooter = new PageFooter();
      g.setPageFooter(newFooter);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newFooter), oldFooter, newFooter);
    }

    if (data instanceof ItemBand)
    {
      final GroupDataBody g = (GroupDataBody) parent;
      final ItemBand oldBand = g.getItemBand();
      final ItemBand newBand = new ItemBand();
      g.setItemBand(newBand);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newBand), oldBand, newBand);
    }
    if (data instanceof NoDataBand)
    {
      final GroupDataBody g = (GroupDataBody) parent;
      final NoDataBand oldBand = g.getNoDataBand();
      final NoDataBand newBand = new NoDataBand();
      g.setNoDataBand(newBand);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newBand), oldBand, newBand);
    }
    if (data instanceof DetailsHeader)
    {
      final GroupDataBody g = (GroupDataBody) parent;
      final DetailsHeader oldHeader = g.getDetailsHeader();
      final DetailsHeader newHeader = new DetailsHeader();
      g.setDetailsHeader(newHeader);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newHeader), oldHeader, newHeader);
    }
    if (data instanceof DetailsFooter)
    {
      final GroupDataBody g = (GroupDataBody) parent;
      final DetailsFooter oldFooter = g.getDetailsFooter();
      final DetailsFooter newFooter = new DetailsFooter();
      g.setDetailsFooter(newFooter);
      return new SectionEditUndoEntry(g.getObjectID(), ModelUtility.findIndexOf(g, newFooter), oldFooter, newFooter);
    }
    return null;

  }

  private static UndoEntry deleteGroupBody(final GroupBody data)
  {
    final GroupBody subgroup = (GroupBody) data;
    final RelationalGroup parent = (RelationalGroup) subgroup.getParentSection();
    if (parent != null)
    {
      final GroupBody body = parent.getBody();
      final GroupDataBody newBody = new GroupDataBody();
      parent.setBody(newBody);
      return new SectionEditUndoEntry
          (parent.getObjectID(), ModelUtility.findIndexOf(parent, newBody), body, newBody);
    }
    return null;
  }

  private static UndoEntry deleteDataFactory(final ReportDocumentContext context, final Object data)
  {
    final AbstractReportDefinition report = context.getReportDefinition();
    // should be safe. If not, then the report-open functionality is wrong.
    final CompoundDataFactory dataFactory = (CompoundDataFactory) report.getDataFactory();
    final int count = dataFactory.size();
    for (int i = 0; i < count; i++)
    {
      final DataFactory df = dataFactory.getReference(i);
      if (df == data)
      {
        dataFactory.remove(i);
        report.notifyNodeChildRemoved(df);
        return new DataSourceEditUndoEntry(i, df, null);
      }
    }
    return null;
  }

  private static UndoEntry deleteExpression(final ReportDocumentContext context, final Object data)
  {
    final AbstractReportDefinition report = context.getReportDefinition();
    final ExpressionCollection expressionCollection = report.getExpressions();
    final int count = expressionCollection.size();
    for (int i = 0; i < count; i++)
    {
      final Expression definitionEntry = expressionCollection.getExpression(i);
      if (definitionEntry == data)
      {
        expressionCollection.removeExpression(i);
        report.notifyNodeChildRemoved(definitionEntry);
        return new ExpressionRemoveUndoEntry(i, definitionEntry);
      }
    }
    return null;
  }

  private static UndoEntry deleteParameter(final ReportDocumentContext context, final Object data)
  {
    final AbstractReportDefinition report = context.getReportDefinition();
    if (report instanceof MasterReport == false)
    {
      return null;
    }

    final MasterReport mreport = (MasterReport) report;
    final ReportParameterDefinition definition = mreport.getParameterDefinition();
    if (definition instanceof ModifiableReportParameterDefinition == false)
    {
      return null;
    }

    final ModifiableReportParameterDefinition mdef = (ModifiableReportParameterDefinition) definition;
    final int count = mdef.getParameterCount();
    for (int i = 0; i < count; i++)
    {
      final ParameterDefinitionEntry definitionEntry = mdef.getParameterDefinition(i);
      if (definitionEntry == data)
      {
        mdef.removeParameterDefinition(i);
        report.notifyNodeChildRemoved(definitionEntry);
        return new ParameterEditUndoEntry(i, definitionEntry, null);
      }
    }
    return null;
  }

  private static UndoEntry deleteGroup(final Group groupElement)
  {
    // deleting this group means, that the body moves down one level.
    final Section parent = groupElement.getParentSection();
    if (parent instanceof SubGroupBody)
    {
      final SubGroupBody parentBody = (SubGroupBody) groupElement.getParentSection();
      final Group oldGroup = parentBody.getGroup();
      final RelationalGroup newRootGroup = new RelationalGroup();
      parentBody.setGroup(newRootGroup);
      return new SectionEditUndoEntry
          (parentBody.getObjectID(), ModelUtility.findIndexOf(parentBody, newRootGroup), oldGroup, newRootGroup);
    }
    if (parent instanceof AbstractReportDefinition)
    {
      final AbstractReportDefinition report = (AbstractReportDefinition) parent;
      final Group oldGroup = report.getRootGroup();
      final RelationalGroup newRootGroup = new RelationalGroup();
      report.setRootGroup(newRootGroup);
      return new SectionEditUndoEntry
          (report.getObjectID(), ModelUtility.findIndexOf(report, newRootGroup), oldGroup, newRootGroup);
    }
    return null;
  }

  public static Object prepareForCopy(final ReportDocumentContext context, final Object data)
  {
    if (data instanceof ParameterDefinitionEntry)
    {
      final AbstractReportDefinition report = context.getReportDefinition();
      if (report instanceof MasterReport == false)
      {
        return null;
      }

      final MasterReport mreport = (MasterReport) report;
      final ReportParameterDefinition definition = mreport.getParameterDefinition();
      if (definition instanceof ModifiableReportParameterDefinition == false)
      {
        return null;
      }

      final ModifiableReportParameterDefinition mdef = (ModifiableReportParameterDefinition) definition;
      final int count = mdef.getParameterCount();
      for (int i = 0; i < count; i++)
      {
        final ParameterDefinitionEntry definitionEntry = mdef.getParameterDefinition(i);
        if (definitionEntry == data)
        {
          try
          {
            return definitionEntry.clone();
          }
          catch (CloneNotSupportedException e)
          {
            UncaughtExceptionsModel.getInstance().addException(e);
            return null;
          }
        }
      }
      return null;
    }

    if (data instanceof Expression)
    {
      final AbstractReportDefinition report = context.getReportDefinition();
      final ExpressionCollection expressionCollection = report.getExpressions();
      final int count = expressionCollection.size();
      for (int i = 0; i < count; i++)
      {
        final Expression definitionEntry = expressionCollection.getExpression(i);
        if (definitionEntry == data)
        {
          return definitionEntry.getInstance();
        }
      }
      return null;
    }


    if (data instanceof DataFactory)
    {
      final AbstractReportDefinition report = context.getReportDefinition();
      // should be safe. If not, then the report-open functionality is wrong.
      final CompoundDataFactory dataFactory = (CompoundDataFactory) report.getDataFactory();
      final int count = dataFactory.size();
      for (int i = 0; i < count; i++)
      {
        final DataFactory df = dataFactory.getReference(i);
        if (df == data)
        {
          return df.derive();
        }
      }
      return null;
    }

    if (data instanceof Element == false)
    {
      return null;
    }

    final Element e = (Element) data;
    final Element derived = e.derive();
    if (e instanceof SubReport)
    {
      if (isBandedSubreport(e))
      {
        derived.setAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, SUBREPORT_BANDED_HINT, Boolean.TRUE);
      }
      else
      {
        derived.setAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, SUBREPORT_BANDED_HINT, Boolean.FALSE);
      }
    }
    return derived;
  }

  private static boolean isBandedSubreport(final Element r)
  {
    final Band parent = r.getParent();
    if (parent instanceof RootLevelBand == false)
    {
      return false;
    }
    final RootLevelBand rlb = (RootLevelBand) parent;
    final SubReport[] reports = rlb.getSubReports();
    for (int i = 0; i < reports.length; i++)
    {
      final SubReport report = reports[i];
      if (r == report)
      {
        return true;
      }
    }
    return false;
  }
}
TOP

Related Classes of org.pentaho.reporting.designer.core.util.dnd.InsertationUtil

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.