designer/src/com/android/tools/idea/uibuilder/model/ResizePolicy.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tools.idea.uibuilder.model;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;

/**
 * A {@link ResizePolicy} records state for whether a widget is resizable, and if so, in
 * which directions
 * <p/>
 * <b>NOTE: This is not a public or final API; if you rely on this be prepared
 * to adjust your code for the next tools release.</b>
 */
public class ResizePolicy {
  private static final int NONE = 0;
  private static final int LEFT_EDGE = 1;
  private static final int RIGHT_EDGE = 2;
  private static final int TOP_EDGE = 4;
  private static final int BOTTOM_EDGE = 8;
  private static final int PRESERVE_RATIO = 16;

  // Aliases
  private static final int HORIZONTAL = LEFT_EDGE | RIGHT_EDGE;
  private static final int VERTICAL = TOP_EDGE | BOTTOM_EDGE;
  private static final int ANY = HORIZONTAL | VERTICAL;

  // Shared objects for common policies

  private static final ResizePolicy ourAny = new ResizePolicy(ANY);
  private static final ResizePolicy ourNone = new ResizePolicy(NONE);
  private static final ResizePolicy ourHorizontal = new ResizePolicy(HORIZONTAL);
  private static final ResizePolicy ourVertical = new ResizePolicy(VERTICAL);
  private static final ResizePolicy ourScaled = new ResizePolicy(ANY | PRESERVE_RATIO);

  private final int myFlags;


  // Use factory methods to construct
  private ResizePolicy(int flags) {
    myFlags = flags;
  }

  /**
   * Returns true if this policy allows resizing in at least one direction
   *
   * @return true if this policy allows resizing in at least one direction
   */
  public boolean isResizable() {
    return (myFlags & ANY) != 0;
  }

  /**
   * Returns true if this policy allows resizing the top edge
   *
   * @return true if this policy allows resizing the top edge
   */
  public boolean topAllowed() {
    return (myFlags & TOP_EDGE) != 0;
  }

  /**
   * Returns true if this policy allows resizing the right edge
   *
   * @return true if this policy allows resizing the right edge
   */
  public boolean rightAllowed() {
    return (myFlags & RIGHT_EDGE) != 0;
  }

  /**
   * Returns true if this policy allows resizing the bottom edge
   *
   * @return true if this policy allows resizing the bottom edge
   */
  public boolean bottomAllowed() {
    return (myFlags & BOTTOM_EDGE) != 0;
  }

  /**
   * Returns true if this policy allows resizing the left edge
   *
   * @return true if this policy allows resizing the left edge
   */
  public boolean leftAllowed() {
    return (myFlags & LEFT_EDGE) != 0;
  }

  /**
   * Returns true if this policy requires resizing in an aspect-ratio preserving manner
   *
   * @return true if this policy requires resizing in an aspect-ratio preserving manner
   */
  public boolean isAspectPreserving() {
    return (myFlags & PRESERVE_RATIO) != 0;
  }

  /**
   * Returns a resize policy allowing resizing in any direction
   *
   * @return a resize policy allowing resizing in any direction
   */
  @NonNull
  public static ResizePolicy full() {
    return ourAny;
  }

  /**
   * Returns a resize policy not allowing any resizing
   *
   * @return a policy which does not allow any resizing
   */
  @NonNull
  public static ResizePolicy none() {
    return ourNone;
  }

  /**
   * Returns a resize policy allowing horizontal resizing only
   *
   * @return a policy which allows horizontal resizing only
   */
  @NonNull
  public static ResizePolicy horizontal() {
    return ourHorizontal;
  }

  /**
   * Returns a resize policy allowing vertical resizing only
   *
   * @return a policy which allows vertical resizing only
   */
  @NonNull
  public static ResizePolicy vertical() {
    return ourVertical;
  }

  /**
   * Returns a resize policy allowing scaled / aspect-ratio preserving resizing only
   *
   * @return a resize policy allowing scaled / aspect-ratio preserving resizing only
   */
  @NonNull
  public static ResizePolicy scaled() {
    return ourScaled;
  }

  /**
   * Returns a resize policy with the specified resizability along the edges and the
   * given aspect ratio behavior
   *
   * @param top      whether the top edge is resizable
   * @param right    whether the right edge is resizable
   * @param bottom   whether the bottom edge is resizable
   * @param left     whether the left edge is resizable
   * @param preserve whether the policy requires the aspect ratio to be preserved
   * @return a resize policy recording the constraints required by the parameters
   */
  @NonNull
  public static ResizePolicy create(boolean top, boolean right, boolean bottom, boolean left, boolean preserve) {
    int mask = NONE;
    if (top) mask |= TOP_EDGE;
    if (right) mask |= RIGHT_EDGE;
    if (bottom) mask |= BOTTOM_EDGE;
    if (left) mask |= LEFT_EDGE;
    if (preserve) mask |= PRESERVE_RATIO;

    return new ResizePolicy(mask);
  }

  /**
   * Returns the {@link ResizePolicy} for the given policy description.
   *
   * @param resize the string describing the resize policy; one of "full", "none",
   *               "horizontal", "vertical", or "scaled"
   * @return the {@link ResizePolicy} for the widget, which will never be null (but may
   *         be the default of {@link ResizePolicy#full()} if no metadata is found for
   *         the given widget)
   */
  @Nullable
  public static ResizePolicy get(@Nullable String resize) {
    if (resize != null && resize.length() > 0) {
      if ("full".equals(resize)) {
        return full();
      } else if ("none".equals(resize)) {
        return none();
      } else if ("horizontal".equals(resize)) {
        return horizontal();
      } else if ("vertical".equals(resize)) {
        return vertical();
      } else if ("scaled".equals(resize)) {
        return scaled();
      } else {
        assert false : resize;
      }
    }

    return null;
  }

  /**
   * Returns the {@link ResizePolicy} for the given component
   *
   * @param component the component to look up a resize policy for
   * @return a suitable {@linkplain ResizePolicy}
   */
  @NonNull
  public static ResizePolicy getResizePolicy(@NonNull NlComponent component) {
    // TODO: Look up from metadata
    return ourAny;
  }
}