235 lines
8.8 KiB
Java
235 lines
8.8 KiB
Java
/*
|
|
* Copyright (C) 2013 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.server.wm;
|
|
|
|
import android.graphics.Rect;
|
|
|
|
import java.io.PrintWriter;
|
|
import java.util.ArrayList;
|
|
|
|
public class StackBox {
|
|
/** For use with {@link WindowManagerService#createStack} */
|
|
public static final int TASK_STACK_GOES_BEFORE = 0;
|
|
public static final int TASK_STACK_GOES_AFTER = 1;
|
|
public static final int TASK_STACK_GOES_ABOVE = 2;
|
|
public static final int TASK_STACK_GOES_BELOW = 3;
|
|
public static final int TASK_STACK_GOES_OVER = 4;
|
|
public static final int TASK_STACK_GOES_UNDER = 5;
|
|
|
|
/** The display this box sits in. */
|
|
final DisplayContent mDisplayContent;
|
|
|
|
/** Non-null indicates this is mFirst or mSecond of a parent StackBox. Null indicates this
|
|
* is this entire size of mDisplayContent. */
|
|
StackBox mParent;
|
|
|
|
/** First child, this is null exactly when mStack is non-null. */
|
|
StackBox mFirst;
|
|
|
|
/** Second child, this is null exactly when mStack is non-null. */
|
|
StackBox mSecond;
|
|
|
|
/** Stack of Tasks, this is null exactly when mFirst and mSecond are non-null. */
|
|
TaskStack mStack;
|
|
|
|
/** Content limits relative to the DisplayContent this sits in. */
|
|
Rect mBounds;
|
|
|
|
/** Relative orientation of mFirst and mSecond. */
|
|
boolean mVertical;
|
|
|
|
/** Dirty flag. Something inside this or some descendant of this has changed. */
|
|
boolean layoutNeeded;
|
|
|
|
/** Used to keep from reallocating a temporary array to hold the list of Tasks below */
|
|
ArrayList<Task> mTmpTasks = new ArrayList<Task>();
|
|
|
|
StackBox(DisplayContent displayContent, Rect bounds) {
|
|
mDisplayContent = displayContent;
|
|
mBounds = bounds;
|
|
}
|
|
|
|
/** Propagate #layoutNeeded bottom up. */
|
|
void makeDirty() {
|
|
layoutNeeded = true;
|
|
if (mParent != null) {
|
|
mParent.makeDirty();
|
|
}
|
|
}
|
|
|
|
/** Propagate #layoutNeeded top down. */
|
|
void makeClean() {
|
|
layoutNeeded = false;
|
|
if (mFirst != null) {
|
|
mFirst.makeClean();
|
|
mSecond.makeClean();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detremine if a particular TaskStack is in this StackBox or any of its descendants.
|
|
* @param stackId The TaskStack being considered.
|
|
* @return true if the specified TaskStack is in this box or its descendants. False otherwise.
|
|
*/
|
|
boolean contains(int stackId) {
|
|
if (mStack != null) {
|
|
return mStack.mStackId == stackId;
|
|
}
|
|
return mFirst.contains(stackId) || mSecond.contains(stackId);
|
|
}
|
|
|
|
/**
|
|
* Create a new TaskStack relative to a specified one by splitting the StackBox containing
|
|
* the specified TaskStack into two children. The size and position each of the new StackBoxes
|
|
* is determined by the passed parameters.
|
|
* @param stackId The id of the new TaskStack to create.
|
|
* @param relativeStackId The id of the TaskStack to place the new one next to.
|
|
* @param position One of the static TASK_STACK_GOES_xxx positions defined in this class.
|
|
* @param weight The percentage size of the parent StackBox to devote to the new TaskStack.
|
|
* @return The new TaskStack.
|
|
*/
|
|
TaskStack split(int stackId, int relativeStackId, int position, float weight) {
|
|
if (mStack != null) {
|
|
if (mStack.mStackId == relativeStackId) {
|
|
// Found it!
|
|
TaskStack stack = new TaskStack(stackId, this);
|
|
TaskStack firstStack;
|
|
TaskStack secondStack;
|
|
int width, height, split;
|
|
switch (position) {
|
|
default:
|
|
case TASK_STACK_GOES_BEFORE:
|
|
case TASK_STACK_GOES_AFTER:
|
|
mVertical = false;
|
|
width = (int)(weight * mBounds.width());
|
|
height = mBounds.height();
|
|
if (position == TASK_STACK_GOES_BEFORE) {
|
|
firstStack = stack;
|
|
secondStack = mStack;
|
|
split = mBounds.left + width;
|
|
} else {
|
|
firstStack = mStack;
|
|
secondStack = stack;
|
|
split = mBounds.right - width;
|
|
}
|
|
break;
|
|
case TASK_STACK_GOES_ABOVE:
|
|
case TASK_STACK_GOES_BELOW:
|
|
mVertical = true;
|
|
width = mBounds.width();
|
|
height = (int)(weight * mBounds.height());
|
|
if (position == TASK_STACK_GOES_ABOVE) {
|
|
firstStack = stack;
|
|
secondStack = mStack;
|
|
split = mBounds.top + height;
|
|
} else {
|
|
firstStack = mStack;
|
|
secondStack = stack;
|
|
split = mBounds.bottom - height;
|
|
}
|
|
break;
|
|
}
|
|
mFirst = new StackBox(mDisplayContent, new Rect(mBounds.left, mBounds.top,
|
|
mVertical ? mBounds.right : split, mVertical ? split : mBounds.bottom));
|
|
mFirst.mStack = firstStack;
|
|
mSecond = new StackBox(mDisplayContent, new Rect(mVertical ? mBounds.left : split,
|
|
mVertical ? split : mBounds.top, mBounds.right, mBounds.bottom));
|
|
mSecond.mStack = secondStack;
|
|
mStack = null;
|
|
return stack;
|
|
}
|
|
// Not the intended TaskStack.
|
|
return null;
|
|
}
|
|
|
|
// Propagate the split to see if the target task stack is in either sub box.
|
|
TaskStack stack = mFirst.split(stackId, relativeStackId, position, weight);
|
|
if (stack != null) {
|
|
return stack;
|
|
}
|
|
return mSecond.split(stackId, relativeStackId, position, weight);
|
|
}
|
|
|
|
/**
|
|
* @return List of all Tasks underneath this StackBox. The order is currently mFirst followed
|
|
* by mSecond putting mSecond Tasks more recent than mFirst Tasks.
|
|
* TODO: Change to MRU ordering.
|
|
*/
|
|
ArrayList<Task> getTasks() {
|
|
mTmpTasks.clear();
|
|
if (mStack != null) {
|
|
mTmpTasks.addAll(mStack.getTasks());
|
|
} else {
|
|
mTmpTasks.addAll(mFirst.getTasks());
|
|
mTmpTasks.addAll(mSecond.getTasks());
|
|
}
|
|
return mTmpTasks;
|
|
}
|
|
|
|
/** Combine a child StackBox into its parent.
|
|
* @param child The surviving child to be merge up into this StackBox. */
|
|
void absorb(StackBox child) {
|
|
mFirst = child.mFirst;
|
|
mSecond = child.mSecond;
|
|
mStack = child.mStack;
|
|
layoutNeeded = true;
|
|
}
|
|
|
|
/** Return the stackId of the first mFirst StackBox with a non-null mStack */
|
|
int getStackId() {
|
|
if (mStack != null) {
|
|
return mStack.mStackId;
|
|
}
|
|
return mFirst.getStackId();
|
|
}
|
|
|
|
/** Remove this box and propagate its sibling's content up to their parent.
|
|
* @return The first stackId of the resulting StackBox. */
|
|
int removeStack() {
|
|
if (mParent.mFirst == this) {
|
|
mParent.absorb(mParent.mSecond);
|
|
} else {
|
|
mParent.absorb(mParent.mFirst);
|
|
}
|
|
mParent.makeDirty();
|
|
return getStackId();
|
|
}
|
|
|
|
/** TODO: */
|
|
boolean resize(int stackId, float weight) {
|
|
return false;
|
|
}
|
|
|
|
public void dump(String prefix, PrintWriter pw) {
|
|
pw.print(prefix); pw.print("mParent="); pw.println(mParent);
|
|
pw.print(prefix); pw.print("mFirst="); pw.println(mFirst);
|
|
pw.print(prefix); pw.print("mSecond="); pw.println(mSecond);
|
|
pw.print(prefix); pw.print("mBounds="); pw.print(mBounds.toShortString());
|
|
pw.print("mVertical="); pw.print(mVertical);
|
|
pw.print("layoutNeeded="); pw.println(layoutNeeded);
|
|
if (mStack != null) {
|
|
pw.print(prefix); pw.print("mStack="); pw.println(mStack);
|
|
mStack.dump(prefix + " ", pw);
|
|
} else {
|
|
pw.print(prefix); pw.print("mFirst="); pw.println(mStack);
|
|
mFirst.dump(prefix + " ", pw);
|
|
pw.print(prefix); pw.print("mSecond="); pw.println(mStack);
|
|
mSecond.dump(prefix + " ", pw);
|
|
}
|
|
}
|
|
}
|