Created min size for print preview dialog and modified to allow the

ui/wm/core/window_modality_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/wm/core/window_modality_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/core/window_util.h"
 
 namespace wm {
 
+const char kAllowTransientParentEventsKey[] = "__ALLOW_PARENT_EVENTS__";
+
 // Transient child's modal parent.
 extern const aura::WindowProperty<aura::Window*>* const kModalParentKey;
 DEFINE_WINDOW_PROPERTY_KEY(aura::Window*, kModalParentKey, NULL);
 
 namespace {
 
 bool HasAncestor(aura::Window* window, aura::Window* ancestor) {
   if (!window)
     return false;
   if (window == ancestor)
@@ skipping 18 matching lines @@
 }
 
 bool IsModalTransientChild(aura::Window* transient, aura::Window* original) {
   return transient->IsVisible() &&
       (TransientChildIsWindowModal(transient) ||
        TransientChildIsSystemModal(transient) ||
        (TransientChildIsChildModal(transient) &&
         (HasAncestor(original, GetModalParent(transient)))));
 }
 
+aura::Window* GetNonModalTransientChild(
+    aura::Window* activatable,
+    aura::Window* original) {
+  for (aura::Window::Windows::const_iterator it =
+           GetTransientChildren(activatable).begin();
+       it != GetTransientChildren(activatable).end();
+       ++it) {
+    aura::Window* transient = *it;
+    if (IsModalTransientChild(transient, original) ||
+        transient->GetNativeWindowProperty(
+            wm::kAllowTransientParentEventsKey)) {
+      if (GetTransientChildren(transient).empty())
+        return transient;
+
+      aura::Window* modal_child = GetNonModalTransientChild(transient,
+                                                            original);
+      return modal_child ? modal_child : transient;
+    }
+  }
+  return NULL;
+}
+
 aura::Window* GetModalTransientChild(
     aura::Window* activatable,
     aura::Window* original) {
   for (aura::Window::Windows::const_iterator it =
            GetTransientChildren(activatable).begin();
        it != GetTransientChildren(activatable).end();
        ++it) {
     aura::Window* transient = *it;
     if (IsModalTransientChild(transient, original)) {
       if (GetTransientChildren(transient).empty())
         return transient;
 
       aura::Window* modal_child = GetModalTransientChild(transient, original);
       return modal_child ? modal_child : transient;
     }
   }
   return NULL;
 }
 
 }  // namespace
 
 void SetModalParent(aura::Window* child, aura::Window* parent) {
   child->SetProperty(kModalParentKey, parent);
 }
 
+aura::Window* GetNonModalTransient(aura::Window* window) {
+  if (!window)
+    return NULL;
+
+  // We always want to check the for the transient child of the toplevel window.
+  aura::Window* toplevel = GetToplevelWindow(window);
+  if (!toplevel)
+    return NULL;
+
+  return GetNonModalTransientChild(toplevel, window);
+}
+
 aura::Window* GetModalTransient(aura::Window* window) {
   if (!window)
     return NULL;
 
   // We always want to check the for the transient child of the toplevel window.
   aura::Window* toplevel = GetToplevelWindow(window);
   if (!toplevel)
     return NULL;
 
   return GetModalTransientChild(toplevel, window);
@@ skipping 22 matching lines @@
 
 void WindowModalityController::OnKeyEvent(ui::KeyEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (GetModalTransient(target))
     event->SetHandled();
 }
 
 void WindowModalityController::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (ProcessLocatedEvent(target, event))
-   event->SetHandled();
+    event->SetHandled();
 }
 
 void WindowModalityController::OnTouchEvent(ui::TouchEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (ProcessLocatedEvent(target, event))
     event->SetHandled();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowModalityController, aura::EnvObserver implementation:
@@ skipping 25 matching lines @@
   if (visible &&
       window->GetProperty(aura::client::kModalKey) != ui::MODAL_TYPE_NONE) {
     ui::GestureRecognizer::Get()->CancelActiveTouchesExcept(nullptr);
     // Make sure no other window has capture, otherwise |window| won't get mouse
     // events.
     aura::Window* capture_window = aura::client::GetCaptureWindow(window);
     if (capture_window) {
       bool should_release_capture = true;
       if (window->GetProperty(aura::client::kModalKey) ==
               ui::MODAL_TYPE_CHILD &&
-          !HasAncestor(capture_window, GetModalParent(window))) {
+         !HasAncestor(capture_window, GetModalParent(window))) {
         // For child modal windows we only need ensure capture is not on a
         // descendant of the modal parent. This way we block events to the
         // parents subtree appropriately.
         should_release_capture = false;
       }
 
       if (should_release_capture)
         capture_window->ReleaseCapture();
     }
   }
@@ skipping 13 matching lines @@
                                 event->type() == ui::ET_TOUCH_PRESSED)) {
     // Activate top window if transient child window is window modal.
     if (TransientChildIsWindowModal(modal_transient_child)) {
       aura::Window* toplevel = GetToplevelWindow(target);
       DCHECK(toplevel);
       ActivateWindow(toplevel);
     }
 
     AnimateWindow(modal_transient_child, WINDOW_ANIMATION_TYPE_BOUNCE);
   }
+  if (!modal_transient_child) {
+    aura::Window* transient = GetNonModalTransient(target);
+    if (transient &&
+        transient->GetNativeWindowProperty(kAllowTransientParentEventsKey) &&
+        (event->type() == ui::ET_MOUSE_PRESSED ||
+         event->type() == ui::ET_TOUCH_PRESSED) &&
+        transient->IsVisible()) {
+      bool is_child = false;
+      for (aura::Window::Windows::const_iterator it =
+           GetTransientChildren(target).begin();
+           it != GetTransientChildren(target).end();
+           ++it) {
+        if (*it == transient)
+          is_child = true;
+      }
+      if (!is_child) {
+        aura::Window* toplevel = GetToplevelWindow(target);
+        DCHECK(toplevel);
+        ActivateWindow(toplevel);
+        return true;
+      }
+    }
+  }
   if (event->type() == ui::ET_TOUCH_CANCELLED)
     return false;
   return !!modal_transient_child;
 }
 
 }  // namespace wm