ResizePolicy.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
 *
 * 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.ide.common.api;

import com.android.annotations.NonNull;
import com.google.common.annotations.Beta;

/**
 * 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>
 */
@Beta
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 sAny = new ResizePolicy(ANY);
    private static final ResizePolicy sNone = new ResizePolicy(NONE);
    private static final ResizePolicy sHorizontal = new ResizePolicy(HORIZONTAL);
    private static final ResizePolicy sVertical = new ResizePolicy(VERTICAL);
    private static final ResizePolicy sScaled = new ResizePolicy(ANY | PRESERVE_RATIO);

    private final int mFlags;


    // Use factory methods to construct
    private ResizePolicy(int flags) {
        mFlags = 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 (mFlags & 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 (mFlags & 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 (mFlags & 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 (mFlags & 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 (mFlags & 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 (mFlags & 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 sAny;
    }

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

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

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

    /**
     * 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 sScaled;
    }

    /**
     * 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);
    }
}