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

chrome/browser/task_manager_win.cc

 // Copyright (c) 2009 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 "chrome/browser/task_manager.h"
 
 #include "base/stats_table.h"
+#include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/accelerator.h"
 #include "views/background.h"
 #include "views/controls/button/native_button.h"
@@ skipping 165 matching lines @@
   virtual void GetSelection(std::vector<int>* selection);
   virtual void GetFocused(std::vector<int>* focused);
   virtual void OpenWindow();
 
   // ButtonListener implementation.
   virtual void ButtonPressed(views::Button* sender);
 
   // views::DialogDelegate
   virtual bool CanResize() const;
   virtual bool CanMaximize() const;
-  virtual bool IsAlwaysOnTop() const;
-  virtual bool HasAlwaysOnTopMenu() const;
+  virtual bool ExecuteWindowsCommand(int command_id);
   virtual std::wstring GetWindowTitle() const;
   virtual std::wstring GetWindowName() const;
   virtual int GetDialogButtons() const;
   virtual void WindowClosing();
   virtual void DeleteDelegate();
   virtual views::View* GetContentsView();
 
   // views::TableViewObserver implementation.
   virtual void OnSelectionChanged();
   virtual void OnDoubleClick();
   virtual void OnKeyDown(unsigned short virtual_keycode);
 
   // views::LinkController implementation.
   virtual void LinkActivated(views::Link* source, int event_flags);
 
   // Called by the column picker to pick up any new stat counters that
   // may have appeared since last time.
   void UpdateStatsCounters();
 
   // Menu::Delegate
   virtual void ShowContextMenu(views::View* source,
                                int x,
                                int y,
                                bool is_mouse_gesture);
   virtual bool IsItemChecked(int id) const;
   virtual void ExecuteCommand(int id);
 
  private:
+  // Initialize the state of the always-on-top setting as the window is shown.

[jcampan, 2009/05/14 21:15:09]

Nit: Initializes

+  void InitAlwaysOnTopState();
+
+  // Adds an always on top item to the window's system menu.
+  void AddAlwaysOnTopSystemMenuItem();
+
+  // Restores saved always on top state from a previous session.
+  bool GetSavedAlwaysOnTopState(bool* always_on_top) const;
+
   scoped_ptr<views::NativeButton> kill_button_;
   scoped_ptr<views::Link> about_memory_link_;
   views::GroupTableView* tab_table_;
 
   TaskManager* task_manager_;
 
   TaskManagerModel* model_;
 
   // all possible columns, not necessarily visible
   std::vector<views::TableColumn> columns_;
 
   scoped_ptr<TaskManagerTableModel> table_model_;
 
+  // True when the Task Manager window should be shown on top of other windows.
+  bool is_always_on_top_;
+
+  // We need to own the text of the menu, the Windows API does not copy it.
+  std::wstring always_on_top_menu_text_;
+
   DISALLOW_COPY_AND_ASSIGN(TaskManagerViewImpl);
 };
 
 TaskManagerViewImpl::TaskManagerViewImpl(TaskManager* task_manager,
                                          TaskManagerModel* model)
     : task_manager_(task_manager),
-      model_(model) {
+      model_(model),
+      is_always_on_top_(false) {
   Init();
 }
 
 TaskManagerViewImpl::~TaskManagerViewImpl() {
 }
 
 void TaskManagerViewImpl::Init() {
   table_model_.reset(new TaskManagerTableModel(model_));
 
   columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN,
@@ skipping 150 matching lines @@
     if (tab_table_->ItemHasTheFocus(i))
       focused->insert(focused->begin(), i);
   }
 }
 
 void TaskManagerViewImpl::OpenWindow() {
   if (window()) {
     window()->Activate();
   } else {
     views::Window::CreateChromeWindow(NULL, gfx::Rect(), this);
+    InitAlwaysOnTopState();
     model_->StartUpdating();
     window()->Show();
   }
 }
 
 // ButtonListener implementation.
 void TaskManagerViewImpl::ButtonPressed(views::Button* sender) {
   if (sender == kill_button_.get())
     task_manager_->KillSelectedProcesses();
 }
 
 // DialogDelegate implementation.
 bool TaskManagerViewImpl::CanResize() const {
   return true;
 }
 
 bool TaskManagerViewImpl::CanMaximize() const {
   return true;
 }
 
-bool TaskManagerViewImpl::IsAlwaysOnTop() const {
-  return true;
+bool TaskManagerViewImpl::ExecuteWindowsCommand(int command_id) {
+  if (command_id == IDC_ALWAYS_ON_TOP) {
+    is_always_on_top_ = !is_always_on_top_;
+
+    // Change the menu check state.
+    HMENU system_menu = GetSystemMenu(GetWindow()->GetNativeWindow(), 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.
+    window()->SetIsAlwaysOnTop(is_always_on_top_);
+
+    // Save the state.
+    if (g_browser_process->local_state()) {
+      DictionaryValue* window_preferences =
+          g_browser_process->local_state()->GetMutableDictionary(
+              GetWindowName().c_str());
+      window_preferences->SetBoolean(L"always_on_top", is_always_on_top_);
+    }
+    return true;
+  }
+  return false;
 }
 
-bool TaskManagerViewImpl::HasAlwaysOnTopMenu() const {
-  return true;
-};
-
 std::wstring TaskManagerViewImpl::GetWindowTitle() const {
   return l10n_util::GetString(IDS_TASK_MANAGER_TITLE);
 }
 
 std::wstring TaskManagerViewImpl::GetWindowName() const {
   return prefs::kTaskManagerWindowPlacement;
 }
 
 int TaskManagerViewImpl::GetDialogButtons() const {
   return MessageBoxFlags::DIALOGBUTTON_NONE;
@@ skipping 56 matching lines @@
 }
 
 bool TaskManagerViewImpl::IsItemChecked(int id) const {
   return tab_table_->IsColumnVisible(id);
 }
 
 void TaskManagerViewImpl::ExecuteCommand(int id) {
   tab_table_->SetColumnVisibility(id, !tab_table_->IsColumnVisible(id));
 }
 
+void TaskManagerViewImpl::InitAlwaysOnTopState() {
+  is_always_on_top_ = false;
+  if (GetSavedAlwaysOnTopState(&is_always_on_top_))
+    window()->SetIsAlwaysOnTop(is_always_on_top_);
+  AddAlwaysOnTopSystemMenuItem();
+}
+
+void TaskManagerViewImpl::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(GetWindow()->GetNativeWindow(), 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);
+}
+
+bool TaskManagerViewImpl::GetSavedAlwaysOnTopState(bool* always_on_top) const {
+  if (!g_browser_process->local_state())
+    return false;
+
+  const DictionaryValue* dictionary =
+      g_browser_process->local_state()->GetDictionary(GetWindowName().c_str());
+  return dictionary && dictionary->GetBoolean(L"always_on_top", always_on_top) &&

[jcampan, 2009/05/14 21:15:09]

Nit: is it more than 80 chars?

+      always_on_top;
+}
+
 }  // namespace
 
 void TaskManager::Init() {
   view_.reset(new TaskManagerViewImpl(this, model_.get()));
 }