Move Always On Top setting out of Window/WindowDelegate and into task manager...

views/window/window_win.cc

 // Copyright (c) 2006-2008 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 "views/window/window_win.h"
 
 #include <shellapi.h>
 
 #include "app/gfx/chrome_canvas.h"
 #include "app/gfx/chrome_font.h"
 #include "app/gfx/icon_util.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/win_util.h"
 #include "base/win_util.h"
-#include "chrome/app/chrome_dll_resource.h"
 #include "grit/generated_resources.h"
 #include "views/widget/root_view.h"
 #include "views/window/client_view.h"
 #include "views/window/custom_frame_view.h"
 #include "views/window/native_frame_view.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window_delegate.h"
 
 namespace {
 
@@ skipping 366 matching lines @@
     if (old_icon)
       DestroyIcon(old_icon);
     old_icon = reinterpret_cast<HICON>(
         SendMessage(GetNativeView(), WM_SETICON, ICON_BIG,
                     reinterpret_cast<LPARAM>(windows_icon)));
     if (old_icon)
       DestroyIcon(old_icon);
   }
 }
 
+void WindowWin::SetIsAlwaysOnTop(bool always_on_top) {
+  ::SetWindowPos(GetNativeView(),
+      always_on_top ? HWND_TOPMOST : HWND_NOTOPMOST,
+      0, 0, 0, 0,
+      SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
+}
+
 NonClientFrameView* WindowWin::CreateFrameViewForWindow() {
   if (non_client_view_->UseNativeFrame())
     return new NativeFrameView(this);
   return new CustomFrameView(this);
 }
 
 void WindowWin::UpdateFrameAfterFrameChange() {
   // We've either gained or lost a custom window region, so reset it now.
   ResetWindowRegion(true);
 }
@@ skipping 19 matching lines @@
 
 WindowWin::WindowWin(WindowDelegate* window_delegate)
     : WidgetWin(),
       focus_on_creation_(true),
       window_delegate_(window_delegate),
       non_client_view_(new NonClientView(this)),
       owning_hwnd_(NULL),
       minimum_size_(100, 100),
       is_modal_(false),
       restored_enabled_(false),
-      is_always_on_top_(false),
       fullscreen_(false),
       window_closed_(false),
       disable_inactive_rendering_(false),
       is_active_(false),
       lock_updates_(false),
       saved_window_style_(0),
       saved_maximized_state_(0),
       ignore_window_pos_changes_(false),
       ignore_pos_changes_factory_(this),
       force_hidden_count_(0),
@@ skipping 10 matching lines @@
 
 void WindowWin::Init(HWND parent, const gfx::Rect& bounds) {
   // We need to save the parent window, since later calls to GetParent() will
   // return NULL.
   owning_hwnd_ = parent;
   // We call this after initializing our members since our implementations of
   // assorted WidgetWin functions may be called during initialization.
   is_modal_ = window_delegate_->IsModal();
   if (is_modal_)
     BecomeModal();
-  is_always_on_top_ = window_delegate_->IsAlwaysOnTop();
 
   if (window_style() == 0)
     set_window_style(CalculateWindowStyle());
   if (window_ex_style() == 0)
     set_window_ex_style(CalculateWindowExStyle());
 
   WidgetWin::Init(parent, bounds, true);
   win_util::SetWindowUserData(GetNativeView(), this);
 
   // Create the ClientView, add it to the NonClientView and add the
   // NonClientView to the RootView. This will cause everything to be parented.
   non_client_view_->set_client_view(window_delegate_->CreateClientView(this));
   WidgetWin::SetContentsView(non_client_view_);
 
   UpdateWindowTitle();
 
   SetInitialBounds(bounds);
-  InitAlwaysOnTopState();
 
   GetMonitorAndRects(bounds.ToRECT(), &last_monitor_, &last_monitor_rect_,
                      &last_work_area_);
   ResetWindowRegion(false);
 }
 
 void WindowWin::SizeWindowToDefault() {
   win_util::CenterAndSizeWindow(owning_window(), GetNativeView(),
                                 non_client_view_->GetPreferredSize().ToSIZE(),
                                 false);
@@ skipping 546 matching lines @@
         // sizing/moving feedback can be continuous.
         UnlockUpdates();
       }
     }
   }
 
   // First see if the delegate can handle it.
   if (window_delegate_->ExecuteWindowsCommand(notification_code))
     return;
 
-  if (notification_code == IDC_ALWAYS_ON_TOP) {
-    is_always_on_top_ = !is_always_on_top_;
-
-    // Change the menu check state.
-    HMENU system_menu = GetSystemMenu(GetNativeView(), FALSE);
-    MENUITEMINFO menu_info;
-    memset(&menu_info, 0, sizeof(MENUITEMINFO));
-    menu_info.cbSize = sizeof(MENUITEMINFO);
-    BOOL r = GetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP,
-                             FALSE, &menu_info);
-    DCHECK(r);
-    menu_info.fMask = MIIM_STATE;
-    if (is_always_on_top_)
-      menu_info.fState = MFS_CHECKED;
-    r = SetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP, FALSE, &menu_info);
-
-    // Now change the actual window's behavior.
-    AlwaysOnTopChanged();
-  } else if ((notification_code == SC_KEYMENU) && (click.x == VK_SPACE)) {
+  if ((notification_code == SC_KEYMENU) && (click.x == VK_SPACE)) {
     // Run the system menu at the NonClientView's desired location.
     RunSystemMenu(non_client_view_->GetSystemMenuPoint());
   } else {
     // Use the default implementation for any other command.
     DefWindowProc(GetNativeView(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(click.y, click.x));
   }
 }
 
 void WindowWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
@@ skipping 134 matching lines @@
       // No initial bounds supplied, so size the window to its content and
       // center over its parent.
       SizeWindowToDefault();
     } else {
       // Use the supplied initial bounds.
       SetBounds(create_bounds);
     }
   }
 }
 
-void WindowWin::InitAlwaysOnTopState() {
-  is_always_on_top_ = false;
-  if (window_delegate_->GetSavedAlwaysOnTopState(&is_always_on_top_) &&
-      is_always_on_top_ != window_delegate_->IsAlwaysOnTop()) {
-    AlwaysOnTopChanged();
-  }
-
-  if (window_delegate_->HasAlwaysOnTopMenu())
-    AddAlwaysOnTopSystemMenuItem();
-}
-
-void WindowWin::AddAlwaysOnTopSystemMenuItem() {
-  // The Win32 API requires that we own the text.
-  always_on_top_menu_text_ = l10n_util::GetString(IDS_ALWAYS_ON_TOP);
-
-  // Let's insert a menu to the window.
-  HMENU system_menu = ::GetSystemMenu(GetNativeView(), FALSE);
-  int index = ::GetMenuItemCount(system_menu) - 1;
-  if (index < 0) {
-    // Paranoia check.
-    NOTREACHED();
-    index = 0;
-  }
-  // First we add the separator.
-  MENUITEMINFO menu_info;
-  memset(&menu_info, 0, sizeof(MENUITEMINFO));
-  menu_info.cbSize = sizeof(MENUITEMINFO);
-  menu_info.fMask = MIIM_FTYPE;
-  menu_info.fType = MFT_SEPARATOR;
-  ::InsertMenuItem(system_menu, index, TRUE, &menu_info);
-
-  // Then the actual menu.
-  menu_info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_STATE;
-  menu_info.fType = MFT_STRING;
-  menu_info.fState = MFS_ENABLED;
-  if (is_always_on_top_)
-    menu_info.fState |= MFS_CHECKED;
-  menu_info.wID = IDC_ALWAYS_ON_TOP;
-  menu_info.dwTypeData = const_cast<wchar_t*>(always_on_top_menu_text_.c_str());
-  ::InsertMenuItem(system_menu, index, TRUE, &menu_info);
-}
-
 void WindowWin::RestoreEnabledIfNecessary() {
   if (is_modal_ && !restored_enabled_) {
     restored_enabled_ = true;
     // If we were run modally, we need to undo the disabled-ness we inflicted on
     // the owner's parent hierarchy.
     HWND start = owning_hwnd_;
     while (start != NULL) {
       ::EnableWindow(start, TRUE);
       start = ::GetParent(start);
     }
   }
 }
 
-void WindowWin::AlwaysOnTopChanged() {
-  ::SetWindowPos(GetNativeView(),
-    is_always_on_top_ ? HWND_TOPMOST : HWND_NOTOPMOST,
-    0, 0, 0, 0,
-    SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
-}
-
 DWORD WindowWin::CalculateWindowStyle() {
   DWORD window_styles =
       WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_SYSMENU | WS_CAPTION;
   bool can_resize = window_delegate_->CanResize();
   bool can_maximize = window_delegate_->CanMaximize();
   if (can_maximize) {
     window_styles |= WS_OVERLAPPEDWINDOW;
   } else if (can_resize) {
     window_styles |= WS_OVERLAPPED | WS_THICKFRAME;
   }
   if (window_delegate_->AsDialogDelegate()) {
     window_styles |= DS_MODALFRAME;
     // NOTE: Turning this off means we lose the close button, which is bad.
     // Turning it on though means the user can maximize or size the window
     // from the system menu, which is worse. We may need to provide our own
     // menu to get the close button to appear properly.
     // window_styles &= ~WS_SYSMENU;
   }
   return window_styles;
 }
 
 DWORD WindowWin::CalculateWindowExStyle() {
   DWORD window_ex_styles = 0;
   if (window_delegate_->AsDialogDelegate())
     window_ex_styles |= WS_EX_DLGMODALFRAME;
-  if (window_delegate_->IsAlwaysOnTop())
-    window_ex_styles |= WS_EX_TOPMOST;
   return window_ex_styles;
 }
 
 void WindowWin::SaveWindowPosition() {
   // The window delegate does the actual saving for us. It seems like (judging
   // by go/crash) that in some circumstances we can end up here after
   // WM_DESTROY, at which point the window delegate is likely gone. So just
   // bail.
   if (!window_delegate_)
     return;
 
   WINDOWPLACEMENT win_placement = { 0 };
   win_placement.length = sizeof(WINDOWPLACEMENT);
 
   BOOL r = GetWindowPlacement(GetNativeView(), &win_placement);
   DCHECK(r);
 
   bool maximized = (win_placement.showCmd == SW_SHOWMAXIMIZED);
   CRect window_bounds(win_placement.rcNormalPosition);
   window_delegate_->SaveWindowPlacement(
-      gfx::Rect(win_placement.rcNormalPosition), maximized, is_always_on_top_);
+      gfx::Rect(win_placement.rcNormalPosition), maximized);
 }
 
 void WindowWin::LockUpdates() {
   lock_updates_ = true;
   saved_window_style_ = GetWindowLong(GWL_STYLE);
   SetWindowLong(GWL_STYLE, saved_window_style_ & ~WS_VISIBLE);
 }
 
 void WindowWin::UnlockUpdates() {
   SetWindowLong(GWL_STYLE, saved_window_style_);
@@ skipping 85 matching lines @@
   }
   return TRUE;
 }
 }  // namespace
 
 void Window::CloseAllSecondaryWindows() {
   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
 }
 
 }  // namespace views