content: /*
   * 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.internal.policy;
  
  import android.graphics.Rect;
  
  import static android.view.WindowManager.DOCKED_BOTTOM;
  import static android.view.WindowManager.DOCKED_INVALID;
  import static android.view.WindowManager.DOCKED_LEFT;
  import static android.view.WindowManager.DOCKED_RIGHT;
  import static android.view.WindowManager.DOCKED_TOP;
  
  /**
   * Utility functions for docked stack divider used by both window manager and System UI.
   *
   * @hide
   */
  public class DockedDividerUtils {
  
      public static void calculateBoundsForPosition(int position, int dockSide, Rect outRect,
              int displayWidth, int displayHeight, int dividerSize) {
          outRect.set(0, 0, displayWidth, displayHeight);
          switch (dockSide) {
              case DOCKED_LEFT:
                  outRect.right = position;
                  break;
              case DOCKED_TOP:
                  outRect.bottom = position;
                  break;
              case DOCKED_RIGHT:
                  outRect.left = position + dividerSize;
                  break;
              case DOCKED_BOTTOM:
                  outRect.top = position + dividerSize;
                  break;
          }
          sanitizeStackBounds(outRect, dockSide == DOCKED_LEFT || dockSide == DOCKED_TOP);
      }
  
      /**
       * Makes sure that the bounds are always valid, i. e. they are at least one pixel high and wide.
       *
       * @param bounds The bounds to sanitize.
       * @param topLeft Pass true if the bounds are at the top/left of the screen, false if they are
       *                at the bottom/right. This is used to determine in which direction to extend
       *                the bounds.
       */
      public static void sanitizeStackBounds(Rect bounds, boolean topLeft) {
  
          // If the bounds are either on the top or left of the screen, rather move it further to the
          // left/top to make it more offscreen. If they are on the bottom or right, push them off the
          // screen by moving it even more to the bottom/right.
          if (topLeft) {
              if (bounds.left >= bounds.right) {
                  bounds.left = bounds.right - 1;
              }
              if (bounds.top >= bounds.bottom) {
                  bounds.top = bounds.bottom - 1;
              }
          } else {
              if (bounds.right <= bounds.left) {
                  bounds.right = bounds.left + 1;
              }
              if (bounds.bottom <= bounds.top) {
                  bounds.bottom = bounds.top + 1;
              }
          }
      }
  
      public static int calculatePositionForBounds(Rect bounds, int dockSide, int dividerSize) {
          switch (dockSide) {
              case DOCKED_LEFT:
                  return bounds.right;
              case DOCKED_TOP:
                  return bounds.bottom;
              case DOCKED_RIGHT:
                  return bounds.left - dividerSize;
              case DOCKED_BOTTOM:
                  return bounds.top - dividerSize;
              default:
                  return 0;
          }
      }
  
      public static int calculateMiddlePosition(boolean isHorizontalDivision, Rect insets,
              int displayWidth, int displayHeight, int dividerSize) {
          int start = isHorizontalDivision ? insets.top : insets.left;
          int end = isHorizontalDivision
                  ? displayHeight - insets.bottom
                  : displayWidth - insets.right;
          return start + (end - start) / 2 - dividerSize / 2;
      }
  
      public static int getDockSideFromCreatedMode(boolean dockOnTopOrLeft,
              boolean isHorizontalDivision) {
          if (dockOnTopOrLeft) {
              if (isHorizontalDivision) {
                  return DOCKED_TOP;
              } else {
                  return DOCKED_LEFT;
              }
          } else {
              if (isHorizontalDivision) {
                  return DOCKED_BOTTOM;
              } else {
                  return DOCKED_RIGHT;
              }
          }
      }
  
      public static int invertDockSide(int dockSide) {
          switch (dockSide) {
              case DOCKED_LEFT:
                  return DOCKED_RIGHT;
              case DOCKED_TOP:
                  return DOCKED_BOTTOM;
              case DOCKED_RIGHT:
                  return DOCKED_LEFT;
              case DOCKED_BOTTOM:
                  return DOCKED_TOP;
              default:
                  return DOCKED_INVALID;
          }
      }
  }
  