Lines Matching defs:windows
234 * for multiple windows of the same type and Z-ordering adjustment
238 /** Offset from TYPE_LAYER_MULTIPLIER for moving a group of windows above
322 * Current user when multi-user is enabled. Don't show windows of
327 * Users that are profiles of the current user. These are also allowed to show windows
373 * and now need to have the policy remove their windows.
378 * The input consumer added to the window manager which consumes input events to windows below
413 * list or contain windows that need to be force removed.
427 * Used when rebuilding window list to keep track of windows that have
463 /** Dump of the windows and app tokens at the time of the last ANR. Cleared after
511 // Last systemUiVisibility we dispatched to windows.
556 * orphaned windows references */
790 // tell all the windows that the drag has ended
1024 final WindowList windows = pos.getWindowList();
1025 final int i = windows.indexOf(pos);
1028 + (i+1) + " of " + windows.size() + " (after " + pos + ")");
1029 windows.add(i+1, window);
1034 final WindowList windows = pos.getWindowList();
1035 int i = windows.indexOf(pos);
1038 + i + " of " + windows.size() + " (before " + pos + ")");
1040 Slog.w(TAG, "placeWindowBefore: Unable to find " + pos + " in " + windows);
1043 windows.add(i, window);
1048 //win. used for z ordering the windows in mWindows
1050 WindowList windows = win.getWindowList();
1051 for(int j = windows.size() - 1; j >= 0; j--) {
1052 WindowState wentry = windows.get(j);
1062 * @param token The token with all the windows.
1064 * @return List of windows from token that are on displayContent.
1068 final int count = token.windows.size();
1070 final WindowState win = token.windows.get(i);
1079 * Recursive search through a WindowList and all of its windows' children.
1081 * @param windows The list to search.
1082 * @return The index of win in windows or of the window that is an ancestor of win.
1084 private int indexOfWinInWindowList(WindowState targetWin, WindowList windows) {
1085 for (int i = windows.size() - 1; i >= 0; i--) {
1086 final WindowState w = windows.get(i);
1108 final WindowList windows = win.getWindowList();
1109 final int N = windows.size();
1114 // If this application has existing windows, we
1118 // Base windows go behind everything else.
1121 tokenWindowsPos = indexOfWinInWindowList(lowestWindow, token.windows);
1127 tokenWindowsPos = indexOfWinInWindowList(lastWindow, token.windows);
1133 //windows associated with this token.
1137 windows.add(newIdx + 1, win);
1143 windows.get(newIdx), token.windows) + 1;
1151 // No windows from this token on this display
1177 // is not going to the bottom and has windows on this display, we can
1194 // Move behind any windows attached to this one.
1212 // token that has windows on this display.
1231 // Move in front of any windows attached to this
1235 final int NC = atoken.windows.size();
1237 WindowState top = atoken.windows.get(NC-1);
1251 WindowState w = windows.get(i);
1258 windows.add(i + 1, win);
1264 final WindowList windows = win.getWindowList();
1269 for (i = windows.size() - 1; i >= 0; i--) {
1270 if (windows.get(i).mBaseLayer <= myLayer) {
1276 "Free window: Adding window " + win + " at " + i + " of " + windows.size());
1277 windows.add(i, win);
1306 // For negative sublayers, we go below all windows
1311 token.windows.add(i, win);
1317 // For positive sublayers, we go above all windows
1322 token.windows.add(i, win);
1332 token.windows.add(win);
1358 token.windows.add(tokenWindowsPos, win);
1401 // IME/target. For now only look for input windows on the main screen.
1402 WindowList windows = getDefaultWindowListLocked();
1405 for (i = windows.size() - 1; i >= 0; --i) {
1406 WindowState win = windows.get(i);
1422 WindowState wb = windows.get(i-1);
1448 return windows.indexOf(curTarget) + 1;
1459 // modify the Z order. We need to look at all windows below
1578 WindowList windows = win.getWindowList();
1579 int wpos = windows.indexOf(win);
1583 windows.remove(wpos);
1589 int cpos = windows.indexOf(cw);
1594 windows.remove(cpos);
1603 // This is a hack to get all of the child windows added as well
1604 // at the right position. Child windows should be rare and
1606 WindowList windows = win.getWindowList();
1607 int wpos = windows.indexOf(win);
1610 windows.remove(wpos);
1616 void logWindowList(final WindowList windows, String prefix) {
1617 int N = windows.size();
1620 Slog.v(TAG, prefix + "#" + N + ": " + windows.get(N));
1628 WindowList windows = getDefaultWindowListLocked();
1636 logWindowList(windows, " ");
1641 // Skip windows owned by the input method.
1643 while (pos < windows.size()) {
1644 WindowState wp = windows.get(pos);
1660 logWindowList(windows, " ");
1670 logWindowList(windows, " ");
1683 WindowList windows = getDefaultWindowListLocked();
1687 // In this case, the input method windows are to be placed
1690 // First check to see if the input method windows are already
1692 final int N = windows.size();
1694 ? windows.get(imPos) : null;
1706 // The windows haven't moved... but are they still contiguous?
1710 if (!(windows.get(pos)).mIsImWindow) {
1716 // Now there should be no more input method windows above.
1718 if ((windows.get(pos)).mIsImWindow) {
1736 logWindowList(windows, " ");
1741 logWindowList(windows, " ");
1747 logWindowList(windows, " ");
1755 // In this case, the input method windows go in a fixed layer,
1765 logWindowList(windows, " ");
1775 assignLayersLocked(windows);
1810 for (int j = token.windows.size() - 1; j >= 0; j--) {
1811 final WindowState wallpaper = token.windows.get(j);
1841 final WindowList windows = getDefaultWindowListLocked();
1842 int N = windows.size();
1852 w = windows.get(i);
1929 int oldI = windows.indexOf(oldW);
2005 // need to be sure to also be behind any of its attached windows,
2009 WindowState wb = windows.get(foundI - 1);
2035 foundW = foundI > 0 ? windows.get(foundI - 1) : null;
2055 // Start stepping backwards from here, ensuring that our wallpaper windows
2068 final WindowList tokenWindows = token.windows;
2087 foundW = foundI > 0 ? windows.get(foundI - 1) : null;
2094 int oldIndex = windows.indexOf(wallpaper);
2098 windows.remove(oldIndex);
2113 insertionIndex = windows.indexOf(foundW);
2121 windows.add(insertionIndex, wallpaper);
2138 WindowList windows = mWallpaperTokens.get(curTokenNdx).windows;
2139 for (int wallpaperNdx = windows.size() - 1; wallpaperNdx >= 0; wallpaperNdx--) {
2140 WindowState wallpaper = windows.get(wallpaperNdx);
2285 WindowList windows = mWallpaperTokens.get(curTokenNdx).windows;
2286 for (int wallpaperNdx = windows.size() - 1; wallpaperNdx >= 0; wallpaperNdx--) {
2287 WindowState wallpaper = windows.get(wallpaperNdx);
2291 // No need to lay out the windows - we can just set the wallpaper position
2341 final WindowList windows = token.windows;
2342 for (int wallpaperNdx = windows.size() - 1; wallpaperNdx >= 0; wallpaperNdx--) {
2343 WindowState wallpaper = windows.get(wallpaperNdx);
2651 * Returns whether screen capture is disabled for all windows of a specific user.
2683 // Update secure surface for all windows belonging to this user.
2685 WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
2686 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
2687 final WindowState win = windows.get(winNdx);
2848 token.windows.remove(win);
2854 + token.windows.size());
2855 if (token.windows.size() == 0) {
2889 final WindowList windows = win.getWindowList();
2890 if (windows != null) {
2891 windows.remove(win);
2893 assignLayersLocked(windows);
2914 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
2915 final int numWindows = windows.size();
2917 final WindowState win = windows.get(winNdx);
3038 final WindowList windows = mWallpaperTokens.get(curTokenNdx).windows;
3039 for (int wallpaperNdx = windows.size() - 1; wallpaperNdx >= 0; wallpaperNdx--) {
3040 WindowState wallpaper = windows.get(wallpaperNdx);
3487 // For fullscreen windows use the window frames and insets to set the thumbnail
3488 // clip. For none-fullscreen windows we use the app display region so the clip
3656 final int N = wtoken.windows.size();
3660 WindowState win = wtoken.windows.get(i);
3816 final WindowList windows = getDefaultWindowListLocked();
3817 for (int pos = windows.size() - 1; pos >= 0; --pos) {
3818 WindowState win = windows.get(pos);
3863 // Top system windows are not requesting an orientation. Start searching from apps.
4010 * The orientation is computed from non-application windows first. If none of
4011 * the non-application windows specify orientation, the orientation is computed from
4088 final WindowList windows = mFocusedApp.allAppWindows;
4089 for (int i = windows.size() - 1; i >= 0; --i) {
4090 final WindowState win = windows.get(i);
4318 // letting windows get shown immediately without any more transitions.
4348 ttoken.windows.remove(startingWindow);
4720 // its windows to be ready.
4729 // to tell the client to make its windows visible so
4731 // performing the transition until all windows have
4926 // so any windows associated with it will be removed as
4997 final WindowList windows = displayContent.getWindowList();
4998 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
4999 Slog.v(TAG, " #" + winNdx + ": " + windows.get(winNdx));
5005 final WindowList windows = win.getWindowList();
5006 // Adding child windows relies on mChildWindows being ordered by mSubLayer.
5015 windows.add(index, win);
5022 windows.add(index, cwin);
5029 windows.add(index, win);
5038 final int NW = token.windows.size();
5040 final WindowState win = token.windows.get(i);
5052 final WindowList windows = displayContent.getWindowList();
5053 mTmpWindows.addAll(windows);
5059 final int winSize = windows.size();
5062 // Skip over all exiting windows, they've been moved out of order.
5070 win = windows.get(winNdx++);
5170 final WindowList windows = displayContent.getWindowList();
5171 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
5172 windows.get(winNdx).reportResized();
5258 * Re-sizes the specified stack and its containing windows.
5511 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
5512 final int numWindows = windows.size();
5514 final WindowState w = windows.get(winNdx);
5689 // Hide windows that should not be seen by the new user.
5782 final WindowList windows = getDefaultWindowListLocked();
5783 final int N = windows.size();
5785 WindowState w = windows.get(i);
5841 // Don't enable the screen until all existing windows have been drawn.
6060 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
6061 final int numWindows = windows.size();
6063 final WindowState ws = windows.get(winNdx);
6227 final WindowList windows = displayContent.getWindowList();
6228 for (int i = windows.size() - 1; i >= 0; i--) {
6229 WindowState ws = windows.get(i);
6244 // all windows are moved behind the wallpaper. We don't want to
6374 for (int i = 0; i < windows.size(); i++) {
6375 WindowState win = windows.get(i);
6660 final WindowList windows = displayContent.getWindowList();
6661 for (int i = windows.size() - 1; i >= 0; i--) {
6662 WindowState w = windows.get(i);
6680 // windows in final state. Otherwise, we make this call at the rotation end.
6899 * Lists all availble windows in the system. The listing is written in the
6914 WindowList windows = new WindowList();
6920 windows.addAll(displayContent.getWindowList());
6931 final int count = windows.size();
6933 final WindowState w = windows.get(i);
7150 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
7151 final int numWindows = windows.size();
7153 final WindowState w = windows.get(winNdx);
7787 // the windows before the newly focused one starts firing eventgs.
7985 final WindowList windows = getDefaultWindowListLocked();
7986 int i = windows.size();
7989 WindowState w = windows.get(i);
8323 for (int i=0; i<imFocus.mAppToken.windows.size(); i++) {
8324 WindowState w = imFocus.mAppToken.windows.get(i);
8763 final WindowList windows = displayContent.getWindowList();
8764 int NW = windows.size();
8773 // First remove all existing app windows.
8776 WindowState w = windows.get(i);
8778 WindowState win = windows.remove(i);
8794 // Keep whatever windows were below the app windows still below,
8800 // in the main app list, but still have windows shown. We put them
8834 numRemoved + " windows but added " + i,
8856 private final void assignLayersLocked(WindowList windows) {
8857 int N = windows.size();
8862 if (DEBUG_LAYERS) Slog.v(TAG, "Assigning layers based on windows=" + windows,
8868 final WindowState w = windows.get(i);
8921 && windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
9004 Slog.wtf(TAG, "Unhandled exception while laying out windows", e);
9016 WindowList windows = displayContent.getWindowList();
9027 final int N = windows.size();
9052 // First perform layout of any root windows (not attached
9056 final WindowState win = windows.get(i);
9087 // windows, since that means "perform layout as normal,
9100 // Don't layout windows behind a dream, so that if it
9121 // Now perform layout of attached windows, which usually
9123 // XXX does not deal with windows that are attached to windows
9126 final WindowState win = windows.get(i);
9136 // windows, since that means "perform layout as normal,
9157 // Don't layout windows behind a dream, so that if it
9195 * @param windows List of windows on default display.
9198 public int handleAppTransitionReadyLocked(WindowList windows) {
9226 for (int curWallpaperIndex = token.windows.size() - 1; curWallpaperIndex >= 0;
9228 WindowState wallpaper = token.windows.get(curWallpaperIndex);
9382 // If all closing windows are obscured, then there is
9452 for (int j = 0; j < wtoken.windows.size(); j++) {
9453 WindowState win = wtoken.windows.get(j);
9480 // starting windows removed after the animation is complete
9488 for (int j = 0; j < wtoken.windows.size(); j++) {
9489 WindowState win = wtoken.windows.get(j);
9576 // This has changed the visibility of windows, so perform
9583 if (windows == getDefaultWindowListLocked()
9585 assignLayersLocked(windows);
9634 // have to be recomputed since the actual order of windows
9808 // See if any windows have been drawn, so they (and others
9906 WindowList windows = displayContent.getWindowList();
9935 assignLayersLocked(windows);
9967 for (i = windows.size() - 1; i >= 0; i--) {
9968 WindowState w = windows.get(i);
9986 final int N = windows.size();
9988 WindowState w = windows.get(i);
10193 // was force hiding other windows behind it, but now it
10249 // Destroy the surface of any windows that are no longer visible.
10293 // so any windows associated with it will be removed as
10317 // Finally update all input windows now that the window changes have stabilized.
10435 if (DEBUG_SCREEN_ON) Slog.d(TAG, "All windows drawn!");
10532 WindowList windows = winAnimator.mWin.getWindowList();
10533 for (int i = windows.size() - 1; i >= 0; --i) {
10534 WindowState testWin = windows.get(i);
10560 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
10561 final int numWindows = windows.size();
10563 final WindowState ws = windows.get(winNdx);
10598 final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
10599 final int numWindows = windows.size();
10601 final WindowState ws = windows.get(winNdx);
10659 // TODO(multidisplay): Focused windows on default display only.
10722 final WindowList windows = displayContent.getWindowList();
10723 for (int i = windows.size() - 1; i >= 0; i--) {
10724 final WindowState win = windows.get(i);
10777 if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "findFocusedWindow: No focusable windows.");
10827 final WindowList windows = getDefaultWindowListLocked();
10828 final int N = windows.size();
10830 WindowState ws = windows.get(i);
11025 final WindowList windows = getDefaultWindowListLocked();
11026 final int N = windows.size();
11028 WindowState ws = windows.get(i);
11248 ArrayList<WindowState> windows) {
11249 pw.println("WINDOW MANAGER WINDOWS (dumpsys window windows)");
11250 dumpWindowsNoHeaderLocked(pw, dumpAll, windows);
11254 ArrayList<WindowState> windows) {
11260 if (windows == null || windows.contains(w)) {
11263 w.dump(pw, " ", dumpAll || windows != null);
11272 if (windows == null || windows.contains(w)) {
11282 if (windows == null || windows.contains(w)) {
11314 if (windows == null || windows.contains(w)) {
11331 if (windows == null || windows.contains(w)) {
11348 if (windows == null || windows.contains(w)) {
11362 pw.println(" Clients waiting for these windows to be drawn:");
11432 pw.print(" windows="); pw.print(mWindowsFreezingScreen);
11454 WindowList windows = new WindowList();
11464 windows.add(w);
11486 windows.add(w);
11489 windows.add(w);
11496 if (windows.size() <= 0) {
11501 dumpWindowsLocked(pw, dumpAll, windows);
11583 pw.println(" cmd may also be a NAME to dump windows. NAME may");
11586 pw.println(" \"all\" for all windows, or");
11587 pw.println(" \"visible\" for the visible windows.");
11634 } else if ("windows".equals(cmd) || "w".equals(cmd)) {
11647 pw.println("Bad window command, or no windows match: " + cmd);
11784 * @param display The screen to return windows from.
11793 * @param displayId The screen to return windows from.
11965 final WindowList windows = getDefaultWindowListLocked();
11966 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
11967 final WindowState win = windows.get(winNdx);
11976 // No need to wait for the windows below Keyguard.