* 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.

*/

* Base class to handle rendering & dnd events of elements rendered inside sub-reports

*

* @author Thomas Morgner

*/

    implements ReportElementEditorContext, CellEditorListener

  {

    public void run()

    {

      final AbstractElementRenderer elementRenderer = (AbstractElementRenderer) getElementRenderer();

      elementRenderer.fireChangeEvent();

    }

  }

  protected class RequestFocusHandler extends MouseAdapter implements PropertyChangeListener

  {

    /**

     * Invoked when the mouse has been clicked on a component.

     */

    public void mouseClicked(final MouseEvent e)

    {

      requestFocusInWindow();

      setFocused(true);

      SwingUtilities.invokeLater(new AsyncChangeNotifier());

    }

    /**

     * This method gets called when a bound property is changed.

     *

     * @param evt A PropertyChangeEvent object describing the event source and the property that has changed.

     */

    public void propertyChange(final PropertyChangeEvent evt)

    {

      final Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner();

      final boolean oldFocused = isFocused();

      final boolean focused = (owner == AbstractRenderComponent.this);

      if (oldFocused != focused)

      {

        setFocused(focused);

        repaintConditionally();

      }

      SwingUtilities.invokeLater(new AsyncChangeNotifier());

    }

  }

  protected class RootBandChangeHandler implements SettingsListener, ReportModelListener

  {

    protected RootBandChangeHandler()

    {

      updateGridSettings();

    }

    public void nodeChanged(final ReportModelEvent event)

    {

      final Object element = event.getElement();

      if (element instanceof ReportElement == false)

      {

        return;

      }

      final Object parameter = event.getParameter();

      if (parameter instanceof DataFactoryChange ||

          parameter instanceof SubReportParameterChange ||

          parameter instanceof AttributeExpressionChange ||

          parameter instanceof StyleExpressionChange)

      {

        // filter out known change events that cannot alter the layout.

        // this saves us a few CPU cycles here and there

        return;

      }

      getElementRenderer().invalidateLayout();

      revalidate();

      repaintConditionally();

    }

    public void settingsChanged()

    {

      updateGridSettings();

      // this is cheap, just repaint and we will be happy

      repaintConditionally();

    }

  }

  protected class MouseSelectionHandler extends MouseAdapter implements MouseMotionListener

  {

    private Point2D normalizedSelectionRectangleOrigin;

    private Point selectionRectangleOrigin;

    private Point selectionRectangleTarget;

    private boolean clearSelectionOnDrag;

    private HashSet<Element> newlySelectedElements;

    protected MouseSelectionHandler()

    {

      newlySelectedElements = new HashSet<Element>();

    }

    /**

     * Invoked when a mouse button has been released on a component.

     */

    public void mouseReleased(final MouseEvent e)

    {

      getDesignerContext().setSelectionWaiting(false);

      normalizedSelectionRectangleOrigin = null;

      selectionRectangleOrigin = null;

      selectionRectangleTarget = null;

      newlySelectedElements.clear();

      repaintConditionally();

    }

    /**

     * Invoked when a mouse button is pressed on a component and then dragged. <code>MOUSE_DRAGGED</code> events will

     * continue to be delivered to the component where the drag originated until the mouse button is released

     * (regardless of whether the mouse position is within the bounds of the component).

     * <p/>

     * Due to platform-dependent Drag&Drop implementations, <code>MOUSE_DRAGGED</code> events may not be delivered

     * during a native Drag&Drop operation.

     */

    public void mouseDragged(final MouseEvent e)

    {

      if (getDesignerContext().isSelectionWaiting() == false)

      {

        return;

      }

      // Check to see if this mouse handler should handle this mouse event (Mouse Operation Handler vs the Mouse Selection Handler)

      if (isMouseOperationInProgress())

      {

        return;

      }

      if (normalizedSelectionRectangleOrigin == null)

      {

        return;

      }

      final Point2D normalizedSelectionRectangleTarget = normalize(e.getPoint());

      normalizedSelectionRectangleTarget.setLocation(Math.max(0, normalizedSelectionRectangleTarget.getX()), Math.max(0, normalizedSelectionRectangleTarget

          .getY()));

      final ElementRenderer rendererRoot = getElementRenderer();

      final ReportDocumentContext renderContext = getRenderContext();

      if (clearSelectionOnDrag)

      {

        final DocumentContextSelectionModel selectionModel = renderContext.getSelectionModel();

        selectionModel.clearSelection();

        clearSelectionOnDrag = false;

      }

      selectionRectangleTarget = e.getPoint();

      // Calculate the bounding box for the selection

      final double y1 = Math.min(normalizedSelectionRectangleOrigin.getY(), normalizedSelectionRectangleTarget.getY());

      final double x1 = Math.min(normalizedSelectionRectangleOrigin.getX(), normalizedSelectionRectangleTarget.getX());

      final double y2 = Math.max(normalizedSelectionRectangleOrigin.getY(), normalizedSelectionRectangleTarget.getY());

      final double x2 = Math.max(normalizedSelectionRectangleOrigin.getX(), normalizedSelectionRectangleTarget.getX());

      final Element[] allNodes = rendererRoot.getElementsAt(x1, y1, x2 - x1, y2 - y1);

      final DocumentContextSelectionModel selectionModel = renderContext.getSelectionModel();

      // Convert between points to micro-points (1 point X 100K is a micro-point)

      final StrictBounds rect1 = StrictGeomUtility.createBounds(x1, y1, x2 - x1, y2 - y1);

      final StrictBounds rect2 = new StrictBounds();

      for (int i = allNodes.length - 1; i >= 0; i -= 1)

      {

        final Element element = allNodes[i];

        if (element instanceof RootLevelBand)

        {

          continue;

        }

        final CachedLayoutData data = ModelUtility.getCachedLayoutData(element);

        rect2.setRect(data.getX(), data.getY(), data.getWidth(), data.getHeight());

        // Checking if the bounding box intersects an element

        if (StrictBounds.intersects(rect1, rect2))

        {

          if (selectionModel.add(element))

          {

            newlySelectedElements.add(element);

          }

        }

      }

      // second step, check which previously added elements are no longer selected by the rectangle.

      for (Iterator<Element> visualReportElementIterator = newlySelectedElements.iterator(); visualReportElementIterator.hasNext(); )

      {

        final Element element = visualReportElementIterator.next();

        final CachedLayoutData data = ModelUtility.getCachedLayoutData(element);

        rect2.setRect(data.getX(), data.getY(), data.getWidth(), data.getHeight());

        if (StrictBounds.intersects(rect1, rect2) == false)

        {

          selectionModel.remove(element);

          visualReportElementIterator.remove();

        }

      }

      repaintConditionally();

    }

    public Point getSelectionRectangleOrigin()

    {

      return selectionRectangleOrigin;

    }

    public Point getSelectionRectangleTarget()

    {

      return selectionRectangleTarget;

    }

    /**

     * Invoked when the mouse cursor has been moved onto a component but no buttons have been pushed.

     */

    public void mouseMoved(final MouseEvent e)

    {

    }

    /**

     * Invoked when a mouse button has been pressed on a component.

     */

    public void mousePressed(final MouseEvent e)

    {

      if (isMouseOperationPossible())

      {

        return;

      }

      if (getDesignerContext().isSelectionWaiting() == false)

      {

        return;

      }

      newlySelectedElements.clear();

      normalizedSelectionRectangleOrigin = normalize(e.getPoint());

      normalizedSelectionRectangleOrigin.setLocation(Math.max(0,

          normalizedSelectionRectangleOrigin.getX()), Math.max(0, normalizedSelectionRectangleOrigin.getY()));

      selectionRectangleOrigin = e.getPoint();

      if (e.isShiftDown() == false)

      {

        clearSelectionOnDrag = true;

      }

      final ReportDocumentContext renderContext = getRenderContext();

      final ElementRenderer rendererRoot = getElementRenderer();

      final DocumentContextSelectionModel selectionModel = renderContext.getSelectionModel();

      final Element[] allNodes = rendererRoot.getElementsAt

          (normalizedSelectionRectangleOrigin.getX(), normalizedSelectionRectangleOrigin.getY());

      for (int i = allNodes.length - 1; i >= 0; i -= 1)

      {

        final Element element = allNodes[i];

        if (element instanceof RootLevelBand)

        {

          continue;

        }

        if (!e.isShiftDown())

        {

          if (!selectionModel.isSelected(element))

          {

            selectionModel.clearSelection();

            selectionModel.add(element);

            return;

          }

        }

      }

    }

    /**

     * Invoked when the mouse has been clicked on a component.

     */

    public void mouseClicked(final MouseEvent e)

    {

      final Point2D point = normalize(e.getPoint());

      if (point.getX() < 0 || point.getY() < 0)

      {

        return; // we do not handle that one ..

      }

      final DocumentContextSelectionModel selectionModel = getRenderContext().getSelectionModel();

      final ElementRenderer rendererRoot = getElementRenderer();

      // Sorted list of all elements that intersect the point we are seeking

      final Element[] allNodes = rendererRoot.getElementsAt(point.getX(), point.getY());

      for (int i = allNodes.length - 1; i >= 0; i -= 1)

      {

        // Check if element is null due to structural helper node like (SectionRenderBox)

        final Element element = allNodes[i];

        if (element instanceof RootLevelBand)

        {

          continue;

        }

        if (e.isShiftDown())

        {

          toggleSelection(selectionModel, element);

        }

        else

        {

          if (!selectionModel.isSelected(element))

          {

            selectionModel.clearSelection();

            selectionModel.add(element);

          }

        }

        return;

      }

      if (e.isShiftDown() == false)

      {

        selectionModel.clearSelection();

      }

      final Element element = rendererRoot.getElement();

      if (element instanceof RootLevelBand)

      {

        if (e.isShiftDown())

        {

          toggleSelection(selectionModel, element);

        }

        else

        {

          if (!selectionModel.isSelected(element))

          {

            selectionModel.clearSelection();

            selectionModel.add(element);

          }

        }

      }

    }

    private void toggleSelection(final DocumentContextSelectionModel selectionModel, final Element element)

    {

      // toggle selection ..

      if (selectionModel.isSelected(element))

      {

        selectionModel.remove(element);

      }

      else

      {

        selectionModel.add(element);

      }

    }

  }

  protected class SelectionModelListener implements ReportSelectionListener

  {

    protected SelectionModelListener()

    {

    }

    public void selectionAdded(final ReportSelectionEvent event)

    {

      final Object element = event.getElement();

      if (element instanceof Element == false)

      {

        return;

      }

      final Element velement = (Element) element;

      ReportElement parentSearch = velement;

      final Section rootBand = getElementRenderer().getElement();

      final ZoomModel zoomModel = getRenderContext().getZoomModel();

      while (parentSearch != null)

      {

        if (parentSearch == rootBand)

        {

          final SelectionOverlayInformation renderer = new SelectionOverlayInformation(velement);

          renderer.validate(zoomModel.getZoomAsPercentage());

          velement.setAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, ReportDesignerBoot.SELECTION_OVERLAY_INFORMATION, renderer, false);

          repaintConditionally();

          return;

        }

        parentSearch = parentSearch.getParentSection();

      }

    }

    public void selectionRemoved(final ReportSelectionEvent event)

    {

      final Object element = event.getElement();

      if (element instanceof Element)

      {

        final Element e = (Element) element;

        e.setAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, ReportDesignerBoot.SELECTION_OVERLAY_INFORMATION, null, false);

      }

      repaintConditionally();

    }

    public void leadSelectionChanged(final ReportSelectionEvent event)

    {

      if (event.getModel().getSelectionCount() != 1)

      {

        return;

      }

      final Object raw = event.getElement();

      if (raw instanceof Element == false)

      {

        return;

      }

      Element e = (Element) raw;

      while (e != null && e instanceof RootLevelBand == false)

      {

        e = e.getParent();

      }

      if (e == getRootBand())

      {

        setFocused(true);

        repaintConditionally();

        SwingUtilities.invokeLater(new AsyncChangeNotifier());

      }

      else

      {

        setFocused(false);

        repaintConditionally();

        SwingUtilities.invokeLater(new AsyncChangeNotifier());

      }

    }

  }

  protected static final class RepaintHandler implements LinealModelListener, ZoomModelListener, ChangeListener

  {

    private AbstractRenderComponent component;

    private RepaintHandler(final AbstractRenderComponent component)

    {

      this.component = component;

    }

    public void stateChanged(final ChangeEvent e)

    {

      // this is cheap, just repaint and we will be happy

      component.revalidate();

      component.repaintConditionally();

    }

    public void modelChanged(final LinealModelEvent event)

    {

      component.revalidate();

      component.repaintConditionally();

    }

    public void zoomFactorChanged()

    {

      component.revalidate();

      component.repaintConditionally();

      component.stopCellEditing();

    }

  }

  protected class SettingsUpdateHandler implements SettingsListener

  {

    protected SettingsUpdateHandler()

    {

    }

    public void settingsChanged()

    {

      updateGridSettings();

      revalidate();

      repaintConditionally();

    }

  }

  protected class KeyboardElementMoveHandler extends KeyAdapter

  {

    public KeyboardElementMoveHandler()

    {

    }

    public void keyReleased(final KeyEvent e)

    {

      if (e.isShiftDown() == false && getDesignerContext().isSelectionWaiting())

      {

        if (currentIndicator == SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE)

        {

          setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));

        }

        else if (currentIndicator == SelectionOverlayInformation.InRangeIndicator.MOVE)

        {

          setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));

        }

        getDesignerContext().setSelectionWaiting(false);

      }

    }

    public void keyPressed(final KeyEvent keyEvent)

    {

      // move all selected components 1px

      List<Element> selectedElements = getRenderContext().getSelectionModel().getSelectedElementsOfType(Element.class);

      if (selectedElements.isEmpty())

      {

        return;

      }

      // if any element's X or Y is == 0, then do not move anything

      // PRD-1442

      final int keyCode = keyEvent.getKeyCode();

      if (keyCode != KeyEvent.VK_UP && keyCode != KeyEvent.VK_DOWN &&

          keyCode != KeyEvent.VK_LEFT && keyCode != KeyEvent.VK_RIGHT)

      {

        return;

      }

      if (keyEvent.isShiftDown() || keyEvent.isAltDown() || keyEvent.isControlDown())

      {

        return;

      }

      keyEvent.consume();

      for (final Element element: selectedElements)

      {

        if (element instanceof RootLevelBand)

        {

          continue;

        }

        final double elementX = element.getStyle().getDoubleStyleProperty(ElementStyleKeys.POS_X, 0);

        final double elementY = element.getStyle().getDoubleStyleProperty(ElementStyleKeys.POS_Y, 0);

        // check if we can't move, one of the elements in the group is already at the minimum position

        if (keyCode == KeyEvent.VK_UP && elementY == 0)

        {

          return;

        }

        else if (keyCode == KeyEvent.VK_LEFT && elementX == 0)

        {

          return;

        }

      }

      final MassElementStyleUndoEntryBuilder builder = new MassElementStyleUndoEntryBuilder(selectedElements);

      final MoveDragOperation mop = new MoveDragOperation(selectedElements, new Point(), EmptySnapModel.INSTANCE, EmptySnapModel.INSTANCE);

      if (keyCode == KeyEvent.VK_UP)

      {

        mop.update(new Point(0, -1), 1);

      }

      else if (keyCode == KeyEvent.VK_DOWN)

      {

        mop.update(new Point(0, 1), 1);

      }

      else if (keyCode == KeyEvent.VK_LEFT)

      {

        mop.update(new Point(-1, 0), 1);

      }

      else

      {

        mop.update(new Point(1, 0), 1);

      }

      final MassElementStyleUndoEntry massElementStyleUndoEntry = builder.finish();

      getRenderContext().getUndo().addChange(Messages.getString("AbstractRenderComponent.MoveUndoName"), massElementStyleUndoEntry);

      mop.finish();

    }

  }

  /**

   * When you double-click on an element, you can edit it inside

   * the canvas editor area.

   */

  protected class MouseEditorActionHandler extends MouseAdapter

  {

    private MouseEditorActionHandler()

    {

    }

    /**

     * Invoked when the mouse has been clicked on a component.

     */

    public void mouseClicked(final MouseEvent e)

    {

      if (stopCellEditing() == false)

      {

        return;

      }

      if (e.isPopupTrigger())

      {

        final Point2D point = normalize(e.getPoint());

        if (point.getX() < 0 || point.getY() < 0)

        {

          return; // we do not handle that one ..

        }

        showElementPopup(e, point);

        return;

      }

      // ReportElementInlineEditor ...

      if (e.getClickCount() >= 2 && (e.getButton() == MouseEvent.BUTTON1))

      {

        final Point2D point = normalize(e.getPoint());

        if (point.getX() < 0 || point.getY() < 0)

        {

          return; // we do not handle that one ..

        }

        final Element element = getElementForLocation(point, true);

        if (element == null)

        {

          return;

        }

        final String typeName = element.getElementTypeName();

        ReportElementEditor elementEditor = ReportElementEditorRegistry.getInstance().getPlugin(typeName);

        if (elementEditor == null)

        {

          elementEditor = ReportElementEditorRegistry.getInstance().getPlugin(null);

          if (elementEditor == null)

          {

            return;

          }

        }

        final ReportElementInlineEditor inlineEditor = elementEditor.createInlineEditor();

        if (inlineEditor == null)

        {

          return;

        }

        installEditor(inlineEditor, element);

      }

    }

    /**

     * Invoked when a mouse button has been released on a component.

     */

    public void mouseReleased(final MouseEvent e)

    {

      if (stopCellEditing() == false)

      {

        return;

      }

      if (e.isPopupTrigger())

      {

        final Point2D point = normalize(e.getPoint());

        if (point.getX() < 0 || point.getY() < 0)

        {

          return; // we do not handle that one ..

        }

        showElementPopup(e, point);

      }

    }

    /**

     * Invoked when a mouse button has been pressed on a component.

     */

    public void mousePressed(final MouseEvent e)

    {

      if (stopCellEditing() == false)

      {

        return;

      }

      if (e.isPopupTrigger())

      {

        final Point2D point = normalize(e.getPoint());

        if (point.getX() < 0 || point.getY() < 0)

        {

          return; // we do not handle that one ..

        }

        showElementPopup(e, point);

      }

    }

    protected void showElementPopup(final MouseEvent e, final Point2D normalizedPoint)

    {

      Element element = getElementForLocation(normalizedPoint, true);

      if (element == null)

      {

        element = (Element) findRootBandForPosition(normalizedPoint);

      }

      if (element == null)

      {

        return;

      }

      final JPopupMenu pop = ContextMenuUtility.getMenu(getDesignerContext(), element);

      if (pop == null)

      {

        return;

      }

      pop.show(AbstractRenderComponent.this, e.getX(), e.getY());

    }

  }

  private class MouseOperationHandler extends MouseAdapter implements MouseMotionListener

  {

    private SelectionOverlayInformation currentRenderer;

    private Point2D lastPoint;

    private MouseOperationHandler()

    {

    }

    /**

     * Invoked when a mouse button is pressed on a component and then dragged. <code>MOUSE_DRAGGED</code> events will continue to be delivered to the component

     * where the drag originated until the mouse button is released (regardless of whether the mouse position is within the bounds of the component).

     * <p/>

     * Due to platform-dependent Drag&Drop implementations, <code>MOUSE_DRAGGED</code> events may not be delivered during a native Drag&Drop operation.

     */

    public void mouseDragged(final MouseEvent e)

    {

      if (lastPoint == null)

      {

        return;

      }

      final Point2D normalizedPoint = normalize(e.getPoint());

      updateElements(normalizedPoint, e.isAltDown(), e.isControlDown());

    }

    /**

     * Invoked when the mouse cursor has been moved onto a component but no buttons have been pushed.

     */

    public void mouseMoved(final MouseEvent e)

    {

      final Point point1 = e.getPoint();

      updateCursor(point1);

    }

    private void updateCursor(final Point rawPoint)

    {

      final boolean selectionMode = getDesignerContext().isSelectionWaiting();

      if (selectionMode)

      {

        setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

        currentIndicator = SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE;

        return;

      }

      currentIndicator = SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE;

      final Point2D normalizedPoint = normalize(rawPoint);

      if (currentRenderer != null)

      {

        currentIndicator = currentRenderer.getMouseInRangeIndicator(normalizedPoint);

        if (currentIndicator == SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE)

        {

          currentRenderer = null;

          currentIndicator = SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE;

        }

        if (currentIndicator == SelectionOverlayInformation.InRangeIndicator.MOVE)

        {

          currentRenderer = null;

          currentIndicator = SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE;

        }

      }

      for (final Element e : getRenderContext().getSelectionModel().getSelectedElementsOfType(Element.class))

      {

        final Object o = e.getAttribute(ReportDesignerBoot.DESIGNER_NAMESPACE, "selection-overlay-information"); // NON-NLS

        if (o instanceof SelectionOverlayInformation == false)

        {

          continue;

        }

        if (isLocalElement(e) == false)

        {

          continue;

        }

        final SelectionOverlayInformation renderer = (SelectionOverlayInformation) o;

        final SelectionOverlayInformation.InRangeIndicator indicator = renderer.getMouseInRangeIndicator(normalizedPoint);

        if (indicator == SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE)

        {

          continue;

        }

        // a resize-handle wins over a ordinary move selection

        if (currentIndicator == SelectionOverlayInformation.InRangeIndicator.MOVE

            || currentIndicator == SelectionOverlayInformation.InRangeIndicator.NOT_IN_RANGE)

        {

          currentIndicator = indicator;

          currentRenderer = renderer;

        }

        else

        {

          break;

        }

      }

      updateCursorForIndicator();

    }

    /**

     * Invoked when a mouse button has been pressed on a component.

     */

    public void mousePressed(final MouseEvent e)

    {

      lastPoint = normalize(e.getPoint());

      updateCursor(e.getPoint());

      initializeDragOperation(lastPoint, currentIndicator);

    }

    /**

     * Invoked when a mouse button has been released on a component.

     */

    public void mouseReleased(final MouseEvent e)

    {

      if (lastPoint == null)

      {

        return;

      }

      if (lastPoint.equals(normalize(e.getPoint())) == false)

      {

        // only fire a drag operation if we moved the mouse

        finishDragOperation();

      }

    }

    /**

     * Invoked when the mouse enters a component.

     */

    public void mouseEntered(final MouseEvent e)

    {

      updateCursor(e.getPoint());

    }

    /**

     * Invoked when the mouse has been clicked on a component.

     */

    public void mouseClicked(final MouseEvent e)

    {

      updateCursor(e.getPoint());

    }

  }

  protected class CellEditorRemover implements PropertyChangeListener

  {

    private KeyboardFocusManager focusManager;

    public CellEditorRemover(final KeyboardFocusManager fm)

    {

      this.focusManager = fm;

    }

    public void propertyChange(final PropertyChangeEvent ev)

    {

      if (!isEditing() || isTerminateEditOnFocusLost() == false)

      {

        return;

      }

      Component c = focusManager.getPermanentFocusOwner();

      while (c != null)

      {

        if (c == AbstractRenderComponent.this)

        {

          // focus remains inside the table

          return;

        }

        else if ((c instanceof Window) || (c instanceof Applet && c.getParent() == null))

        {

          if (c == SwingUtilities.getRoot(AbstractRenderComponent.this))

          {

            if (!getCellEditor().stopCellEditing())

            {

              getCellEditor().cancelCellEditing();

            }

          }

          break;

        }

        c = c.getParent();

      }

    }

  }

  private class DragAbortReportModelListener implements ReportModelListener

  {

    private DragAbortReportModelListener()

    {

    }

    public void nodeChanged(final ReportModelEvent event)

    {

      if (event.isNodeAddedEvent() || event.isNodeDeleteEvent())

      {

        finishDragOperation();

      }

    }

  }

  private class SelectionStateHandler implements PropertyChangeListener

  {

    /**

     * This method gets called when a bound property is changed.

     *

     * @param evt A PropertyChangeEvent object describing the event source

     *            and the property that has changed.

     */

    public void propertyChange(final PropertyChangeEvent evt)

    {

      if (getDesignerContext().isSelectionWaiting())

      {

        setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

      }

      else

      {

        updateCursorForIndicator();

      }

    }

  }

  protected class SelectionRectangleOverlayRenderer implements OverlayRenderer

  {

    public SelectionRectangleOverlayRenderer()

    {

    }

    public void validate(final ReportDocumentContext context, final double zoomFactor, final Point2D sectionOffset)

    {

    }

    public void draw(final Graphics2D graphics, final Rectangle2D bounds, final ImageObserver obs)

    {

      paintSelectionRectangle(graphics);

    }

  }

  // 50 fps max

  private static final long REPAINT_INTERVAL = 1000 / 50;

  private static final Log logger = LogFactory.getLog(AbstractRenderComponent.class);

  private static final BasicStroke SELECTION_STROKE = new BasicStroke(0.5f);

  private CellEditorRemover editorRemover;

  private RepaintHandler repaintHandler;

  private SettingsUpdateHandler settingsUpdateHandler;

  private ReportDesignerContext designerContext;

  private ReportDocumentContext renderContext;

  private boolean showLeftBorder;

  private boolean showTopBorder;

  private double gridSize;

  private int gridDivisions;

  private boolean terminateEditOnFocusLost;

  private Component editorComponent;

  private ReportElementInlineEditor inlineEditor;

  private MouseDragOperation operation;

  private MassElementStyleUndoEntryBuilder undoEntryBuilder;

  private FullSnapModel horizontalSnapModel;

  private FullSnapModel verticalSnapModel;

  private LinealModel verticalLinealModel;

  private LinealModel horizontalLinealModel;

  private HorizontalPositionsModel horizontalPositionsModel;

  private boolean focused;

  private SelectionOverlayInformation.InRangeIndicator currentIndicator;

  private SelectionStateHandler selectionStateHandler;

  private ArrayList<Object> oldValues = new ArrayList<Object>();

  private MouseSelectionHandler selectionHandler;

  private RequestFocusHandler focusHandler;

  private SelectionModelListener selectionModelListener;

  private RootBandChangeHandler changeHandler;

  private SimpleStyleResolver styleResolver;

  private ResolverStyleSheet resolvedStyle;

  private FpsCalculator fpsCalculator;

  private boolean paintingImmediately = false;

  protected AbstractRenderComponent(final ReportDesignerContext designerContext,

                                    final ReportDocumentContext renderContext)

  {

    if (renderContext == null)

    {

      throw new NullPointerException();

    }

    if (designerContext == null)

    {

      throw new NullPointerException();

    }

    setDoubleBuffered(true);

    setOpaque(false);

    setFocusable(true);

    setFocusCycleRoot(true);

    setFocusTraversalKeysEnabled(false);

    setLayout(null);

    this.fpsCalculator = new FpsCalculator();