org.crsh.text.LineRenderer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of crash.shell Show documentation
The Shell module
The newest version!
/*
 * Copyright (C) 2012 eXo Platform SAS.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */

package org.crsh.text;

import java.util.Iterator;

/**
 * A line oriented renderer.
 */
public abstract class LineRenderer {

  public static final LineRenderer NULL = new LineRenderer() {
    @Override
    public int getActualWidth() {
      return 0;
    }
    @Override
    public int getMinWidth() {
      return 0;
    }
    @Override
    public int getMinHeight(int width) {
      return 0;
    }
    @Override
    public int getActualHeight(int width) {
      return 0;
    }
    @Override
    public LineReader reader(int width) {
      return new LineReader() {
        public boolean hasLine() {
          return false;
        }
        public void renderLine(RenderAppendable to) throws IllegalStateException {
          throw new IllegalStateException();
        }
      };
    }
  };

  public static LineRenderer vertical(Iterable renderers) {
    Iterator i = renderers.iterator();
    if (i.hasNext()) {
      LineRenderer renderer = i.next();
      if (i.hasNext()) {
        return new Composite(renderers);
      } else {
        return renderer;
      }
    } else {
      return NULL;
    }
  }

  /**
   * Returns the element actual width.
   *
   * @return the actual width
   */
  public abstract int getActualWidth();

  /**
   * Returns the element minimum width.
   *
   * @return the minimum width
   */
  public abstract int getMinWidth();

  /**
   * Return the minimum height for the specified with.
   *
   * @param width the width
   * @return the actual height
   */
  public abstract int getMinHeight(int width);

  /**
   * Return the actual height for the specified with.
   *
   * @param width the width
   * @return the minimum height
   */
  public abstract int getActualHeight(int width);

  /**
   * Create a renderer for the specified width and height or return null if the element does not provide any output
   * for the specified dimensions. The default implementation delegates to the {@link #reader(int)} method when the
   * height argument is not positive otherwise it returns null. Subclasses should override this method
   * when they want to provide content that can adapts to the specified height.
   *
   * @param width the width
   * @param height the height
   * @return the renderer
   */
  public LineReader reader(int width, int height) {
    if (height > 0) {
      return null;
    } else {
      return reader(width);
    }
  }

  /**
   * Create a renderer for the specified width or return null if the element does not provide any output.
   *
   * @param width the width
   * @return the renderer
   */
  public abstract LineReader reader(int width);

  /**
   * Renders this object to the provided output.
   *
   * @param out the output
   */
  public final void render(RenderAppendable out) {
    LineReader renderer = reader(out.getWidth());
    if (renderer != null) {
      while (renderer.hasLine()) {
        renderer.renderLine(out);
        out.append('\n');
      }
    }
  }

  private static class Composite extends LineRenderer {

    /** . */
    private final Iterable renderers;

    /** . */
    private final int actualWidth;

    /** . */
    private final int minWidth;

    private Composite(Iterable renderers) {

      int actualWidth = 0;
      int minWidth = 0;
      for (LineRenderer renderer : renderers) {
        actualWidth = Math.max(actualWidth, renderer.getActualWidth());
        minWidth = Math.max(minWidth, renderer.getMinWidth());
      }

      this.actualWidth = actualWidth;
      this.minWidth = minWidth;
      this.renderers = renderers;
    }

    @Override
    public int getActualWidth() {
      return actualWidth;
    }

    @Override
    public int getMinWidth() {
      return minWidth;
    }

    @Override
    public int getActualHeight(int width) {
      int actualHeight = 0;
      for (LineRenderer renderer : renderers) {
        actualHeight += renderer.getActualHeight(width);
      }
      return actualHeight;
    }

    @Override
    public int getMinHeight(int width) {
      return 1;
    }

    @Override
    public LineReader reader(final int width, final int height) {

      final Iterator i = renderers.iterator();

      //
      return new LineReader() {

        /** . */
        private LineReader current;

        /** . */
        private int index = 0;

        public boolean hasLine() {
          if (height > 0 && index >= height) {
            return false;
          } else {
            if (current == null || !current.hasLine()) {
              while (i.hasNext()) {
                LineRenderer next = i.next();
                LineReader reader = next.reader(width);
                if (reader != null && reader.hasLine()) {
                  current = reader;
                  return true;
                }
              }
              return false;
            } else {
              return true;
            }
          }
        }

        public void renderLine(RenderAppendable to) throws IllegalStateException {
          if (hasLine()) {
            current.renderLine(to);
            index++;
          } else {
            throw new IllegalStateException();
          }
        }
      };
    }

    @Override
    public LineReader reader(final int width) {
      return reader(width, -1);
    }
  }
}