diff options
| author | initial.commit <initial.commit@0039d316-1c4b-4281-b951-d872f2087c98> | 2008-07-26 23:55:29 +0000 |
|---|---|---|
| committer | initial.commit <initial.commit@0039d316-1c4b-4281-b951-d872f2087c98> | 2008-07-26 23:55:29 +0000 |
| commit | 09911bf300f1a419907a9412154760efd0b7abc3 (patch) | |
| tree | f131325fb4e2ad12c6d3504ab75b16dd92facfed /chrome/browser/views/toolbar_view.cc | |
| parent | 586acc5fe142f498261f52c66862fa417c3d52d2 (diff) | |
| download | chromium_src-09911bf300f1a419907a9412154760efd0b7abc3.zip chromium_src-09911bf300f1a419907a9412154760efd0b7abc3.tar.gz chromium_src-09911bf300f1a419907a9412154760efd0b7abc3.tar.bz2 | |
Add chrome to the repository.
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'chrome/browser/views/toolbar_view.cc')
| -rw-r--r-- | chrome/browser/views/toolbar_view.cc | 675 |
1 files changed, 675 insertions, 0 deletions
diff --git a/chrome/browser/views/toolbar_view.cc b/chrome/browser/views/toolbar_view.cc new file mode 100644 index 0000000..7b673a3 --- /dev/null +++ b/chrome/browser/views/toolbar_view.cc @@ -0,0 +1,675 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "chrome/browser/views/toolbar_view.h" + +#include <string> + +#include "base/logging.h" +#include "base/path_service.h" +#include "chrome/app/chrome_dll_resource.h" +#include "chrome/app/theme/theme_resources.h" +#include "chrome/browser/browser.h" +#include "chrome/browser/browser_process.h" +#include "chrome/browser/character_encoding.h" +#include "chrome/browser/chrome_frame.h" +#include "chrome/browser/drag_utils.h" +#include "chrome/browser/navigation_controller.h" +#include "chrome/browser/navigation_entry.h" +#include "chrome/browser/profile.h" +#include "chrome/browser/user_metrics.h" +#include "chrome/browser/views/dom_view.h" +#include "chrome/browser/views/go_button.h" +#include "chrome/browser/views/location_bar_view.h" +#include "chrome/browser/views/theme_helpers.h" +#include "chrome/browser/views/toolbar_star_toggle.h" +#include "chrome/browser/view_ids.h" +#include "chrome/common/chrome_constants.h" +#include "chrome/common/l10n_util.h" +#include "chrome/common/notification_service.h" +#include "chrome/common/os_exchange_data.h" +#include "chrome/common/pref_names.h" +#include "chrome/common/resource_bundle.h" +#include "chrome/views/button_dropdown.h" +#include "chrome/views/hwnd_view.h" +#include "chrome/views/view_container.h" +#include "chrome/views/background.h" +#include "chrome/views/label.h" +#include "net/base/net_util.h" + +#include "generated_resources.h" + +static const int kControlHorizOffset = 4; +static const int kControlVertOffset = 6; +static const int kControlIndent = 3; +static const int kStatusBubbleWidth = 480; + +// Separation between the location bar and the menus. +static const int kMenuButtonOffset = 3; + +// Padding to the right of the location bar +static const int kPaddingRight = 2; + +BrowserToolbarView::BrowserToolbarView(CommandController* controller, + Browser* browser) + : EncodingMenuControllerDelegate(browser, controller), + controller_(controller), + model_(browser->toolbar_model()), + back_(NULL), + forward_(NULL), + reload_(NULL), + home_(NULL), + star_(NULL), + location_bar_(NULL), + go_(NULL), + profile_(NULL), + acc_focused_view_(NULL), + browser_(browser), + tab_(NULL) { + back_menu_model_.reset(new BackForwardMenuModel( + browser, BackForwardMenuModel::BACKWARD_MENU_DELEGATE)); + forward_menu_model_.reset(new BackForwardMenuModel( + browser, BackForwardMenuModel::FORWARD_MENU_DELEGATE)); +} + +BrowserToolbarView::~BrowserToolbarView() { +} + +void BrowserToolbarView::Init(Profile* profile) { + // Create all the individual Views in the Toolbar. + CreateLeftSideControls(); + CreateCenterStack(profile); + CreateRightSideControls(profile); + + show_home_button_.Init(prefs::kShowHomeButton, profile->GetPrefs(), this); + + SetProfile(profile); +} + +void BrowserToolbarView::SetProfile(Profile* profile) { + if (profile == profile_) + return; + + profile_ = profile; + location_bar_->SetProfile(profile); +} + +void BrowserToolbarView::CreateLeftSideControls() { + ResourceBundle &rb = ResourceBundle::GetSharedInstance(); + + back_ = new ChromeViews::ButtonDropDown(back_menu_model_.get()); + back_->SetImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_BACK)); + back_->SetImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_BACK_H)); + back_->SetImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_BACK_P)); + back_->SetImage(ChromeViews::Button::BS_DISABLED, + rb.GetBitmapNamed(IDR_BACK_D)); + back_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_BACK)); + back_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_BACK)); + back_->SetID(VIEW_ID_BACK_BUTTON); + AddChildView(back_); + controller_->AddManagedButton(back_, IDC_BACK); + + forward_ = new ChromeViews::ButtonDropDown(forward_menu_model_.get()); + forward_->SetImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_FORWARD)); + forward_->SetImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_FORWARD_H)); + forward_->SetImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_FORWARD_P)); + forward_->SetImage(ChromeViews::Button::BS_DISABLED, + rb.GetBitmapNamed(IDR_FORWARD_D)); + forward_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_FORWARD)); + forward_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_FORWARD)); + forward_->SetID(VIEW_ID_FORWARD_BUTTON); + AddChildView(forward_); + controller_->AddManagedButton(forward_, IDC_FORWARD); + + reload_ = new ChromeViews::Button(); + reload_->SetImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_RELOAD)); + reload_->SetImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_RELOAD_H)); + reload_->SetImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_RELOAD_P)); + reload_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_RELOAD)); + reload_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_RELOAD)); + reload_->SetID(VIEW_ID_RELOAD_BUTTON); + AddChildView(reload_); + controller_->AddManagedButton(reload_, IDC_RELOAD); + + home_ = new ChromeViews::Button(); + home_->SetImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_HOME)); + home_->SetImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_HOME_H)); + home_->SetImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_HOME_P)); + home_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_HOME)); + home_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_HOME)); + AddChildView(home_); + controller_->AddManagedButton(home_, IDC_HOME); +} + +void BrowserToolbarView::CreateCenterStack(Profile *profile) { + ResourceBundle &rb = ResourceBundle::GetSharedInstance(); + + star_ = new ToolbarStarToggle(this); + star_->SetImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_STAR)); + star_->SetImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_STAR_H)); + star_->SetImage(ChromeViews::Button::BS_PUSHED, + rb .GetBitmapNamed(IDR_STAR_P)); + star_->SetImage(ChromeViews::Button::BS_DISABLED, + rb .GetBitmapNamed(IDR_STAR_D)); + star_->SetToggledImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_STARRED)); + star_->SetToggledImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_STARRED_H)); + star_->SetToggledImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_STARRED_P)); + star_->SetDragController(this); + star_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_STAR)); + star_->SetToggledTooltipText(l10n_util::GetString(IDS_TOOLTIP_STARRED)); + star_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_STAR)); + star_->SetID(VIEW_ID_STAR_BUTTON); + AddChildView(star_); + controller_->AddManagedButton(star_, IDC_STAR); + + location_bar_ = new LocationBarView(profile, controller_, model_, + this, false); + AddChildView(location_bar_); + location_bar_->Init(); + + // The Go button. + go_ = new GoButton(location_bar_, controller_); + go_->SetImage(ChromeViews::Button::BS_NORMAL, rb.GetBitmapNamed(IDR_GO)); + go_->SetImage(ChromeViews::Button::BS_HOT, rb.GetBitmapNamed(IDR_GO_H)); + go_->SetImage(ChromeViews::Button::BS_PUSHED, rb.GetBitmapNamed(IDR_GO_P)); + go_->SetToggledImage(ChromeViews::Button::BS_NORMAL, + rb.GetBitmapNamed(IDR_STOP)); + go_->SetToggledImage(ChromeViews::Button::BS_HOT, + rb.GetBitmapNamed(IDR_STOP_H)); + go_->SetToggledImage(ChromeViews::Button::BS_PUSHED, + rb.GetBitmapNamed(IDR_STOP_P)); + go_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_GO)); + go_->SetID(VIEW_ID_GO_BUTTON); + AddChildView(go_); +} + +void BrowserToolbarView::Update(TabContents* tab, bool should_restore_state) { + tab_ = tab; + + if (!location_bar_) + return; + + location_bar_->Update(should_restore_state ? tab : NULL); +} + +void BrowserToolbarView::OnInputInProgress(bool in_progress) { + // The edit should make sure we're only notified when something changes. + DCHECK(model_->input_in_progress() != in_progress); + + model_->set_input_in_progress(in_progress); + location_bar_->Update(NULL); +} + +void BrowserToolbarView::CreateRightSideControls(Profile* profile) { + ResourceBundle &rb = ResourceBundle::GetSharedInstance(); + + page_menu_ = + new ChromeViews::MenuButton(std::wstring(), this, false); + + // We use different menu button images if the locale is right-to-left. + if (UILayoutIsRightToLeft()) + page_menu_->SetIcon(*rb.GetBitmapNamed(IDR_MENU_PAGE_RTL)); + else + page_menu_->SetIcon(*rb.GetBitmapNamed(IDR_MENU_PAGE)); + + page_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_PAGE)); + page_menu_->SetTooltipText(l10n_util::GetString(IDS_PAGEMENU_TOOLTIP)); + page_menu_->SetID(VIEW_ID_PAGE_MENU); + AddChildView(page_menu_); + + app_menu_ = new ChromeViews::MenuButton(std::wstring(), this, false); + if (UILayoutIsRightToLeft()) + app_menu_->SetIcon(*rb.GetBitmapNamed(IDR_MENU_CHROME_RTL)); + else + app_menu_->SetIcon(*rb.GetBitmapNamed(IDR_MENU_CHROME)); + + app_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_APP)); + app_menu_->SetTooltipText(l10n_util::GetStringF(IDS_APPMENU_TOOLTIP, + l10n_util::GetString(IDS_PRODUCT_NAME))); + app_menu_->SetID(VIEW_ID_APP_MENU); + AddChildView(app_menu_); +} + +void BrowserToolbarView::Layout() { + CSize sz; + + // If we have not been initialized yet just do nothing. + if (back_ == NULL) + return; + + back_->GetPreferredSize(&sz); + back_->SetBounds(kControlIndent, + kControlVertOffset, + sz.cx, + sz.cy); + + forward_->GetPreferredSize(&sz); + forward_->SetBounds(back_->GetX() + back_->GetWidth(), + kControlVertOffset, + sz.cx, + sz.cy); + + reload_->GetPreferredSize(&sz); + reload_->SetBounds(forward_->GetX() + forward_->GetWidth() + + kControlHorizOffset, + kControlVertOffset, + sz.cx, + sz.cy); + + int offset = 0; + if (show_home_button_.GetValue()) { + home_->GetPreferredSize(&sz); + offset = kControlHorizOffset; + } else { + sz = CSize(0, 0); + } + home_->SetBounds(reload_->GetX() + reload_->GetWidth() + offset, + kControlVertOffset, sz.cx, sz.cy); + + star_->GetPreferredSize(&sz); + star_->SetBounds(home_->GetX() + home_->GetWidth() + kControlHorizOffset, + kControlVertOffset, sz.cx, sz.cy); + + page_menu_->GetPreferredSize(&sz); + int right_side_width = sz.cx + kMenuButtonOffset; + + app_menu_->GetPreferredSize(&sz); + right_side_width += sz.cx + kPaddingRight; + + go_->GetPreferredSize(&sz); + int go_button_height = sz.cy; + + location_bar_->SetBounds(star_->GetX() + star_->GetWidth(), + kControlVertOffset, + GetWidth() - right_side_width - + (star_->GetX() + star_->GetWidth() + + sz.cx), // go preferred width + sz.cy); + + go_->SetBounds(location_bar_->GetX() + location_bar_->GetWidth(), + kControlVertOffset, + sz.cx, + sz.cy); + + // Make sure the Page menu never overlaps the location bar. + int page_x = go_->GetX() + go_->GetWidth() + kMenuButtonOffset; + page_menu_->GetPreferredSize(&sz); + page_menu_->SetBounds(page_x, kControlVertOffset, sz.cx, go_->GetHeight()); + app_menu_->GetPreferredSize(&sz); + app_menu_->SetBounds(page_menu_->GetX() + page_menu_->GetWidth(), + page_menu_->GetY(), sz.cx, go_->GetHeight()); +} + +void BrowserToolbarView::DidGainFocus() { + // Find first accessible child (-1 for start search at parent). + int first_acc_child = GetNextAccessibleViewIndex(-1, false); + + // No buttons enabled or visible. + if (first_acc_child == -1) + return; + + acc_focused_view_ = GetChildViewAt(first_acc_child); + + // Default focus is on the toolbar. + int view_index = VIEW_ID_TOOLBAR; + + // Set hot-tracking for child, and update focused_view for MSAA focus event. + if (acc_focused_view_) { + acc_focused_view_->SetHotTracked(true); + // Update focused_view with MSAA-adjusted child id. + view_index = acc_focused_view_->GetID(); + } + + HWND hwnd = GetViewContainer()->GetHWND(); + + // Notify Access Technology that there was a change in keyboard focus. + ::NotifyWinEvent(EVENT_OBJECT_FOCUS, hwnd, OBJID_CLIENT, + static_cast<LONG>(view_index)); +} + +void BrowserToolbarView::WillLoseFocus() { + // Resetting focus state. + acc_focused_view_->SetHotTracked(false); + acc_focused_view_ = NULL; +} + +bool BrowserToolbarView::OnKeyPressed(const ChromeViews::KeyEvent& e) { + // Paranoia check, button should be initialized upon toolbar gaining focus. + if (!acc_focused_view_) + return false; + + int focused_view = GetChildIndex(acc_focused_view_); + int next_view = focused_view; + + switch (e.GetCharacter()) { + case VK_LEFT: + next_view = GetNextAccessibleViewIndex(focused_view, true); + break; + case VK_RIGHT: + next_view = GetNextAccessibleViewIndex(focused_view, false); + break; + case VK_DOWN: + case VK_RETURN: + // VK_SPACE is already handled by the default case. + if (acc_focused_view_->GetID() == VIEW_ID_PAGE_MENU || + acc_focused_view_->GetID() == VIEW_ID_APP_MENU) { + // Safe to cast, given to above check. + static_cast<ChromeViews::MenuButton*>(acc_focused_view_)->Activate(); + // Re-enable hot-tracking, as Activate() will disable it. + acc_focused_view_->SetHotTracked(true); + break; + } + default: + // If key is not handled explicitly, pass it on to view. + return acc_focused_view_->OnKeyPressed(e); + } + + // No buttons enabled or visible. + if (next_view == -1) + return false; + + // Only send an event if focus moved. + if (next_view != focused_view) { + // Remove hot-tracking from old focused button. + acc_focused_view_->SetHotTracked(false); + + // All is well, update the focused child member variable. + acc_focused_view_ = GetChildViewAt(next_view); + + // Hot-track new focused button. + acc_focused_view_->SetHotTracked(true); + + // Retrieve information to generate an MSAA focus event. + int view_id = acc_focused_view_->GetID(); + HWND hwnd = GetViewContainer()->GetHWND(); + + // Notify Access Technology that there was a change in keyboard focus. + ::NotifyWinEvent(EVENT_OBJECT_FOCUS, hwnd, OBJID_CLIENT, + static_cast<LONG>(view_id)); + return true; + } + return false; +} + +bool BrowserToolbarView::OnKeyReleased(const ChromeViews::KeyEvent& e) { + // Paranoia check, button should be initialized upon toolbar gaining focus. + if (!acc_focused_view_) + return false; + + // Have keys be handled by the views themselves. + return acc_focused_view_->OnKeyReleased(e); +} + + +void BrowserToolbarView::RunPageMenu(const CPoint& pt, HWND hwnd) { + Menu::AnchorPoint anchor = Menu::TOPRIGHT; + if (UILayoutIsRightToLeft()) + anchor = Menu::TOPLEFT; + + Menu menu(this, anchor, hwnd); + menu.AppendMenuItemWithLabel(IDC_NEWTAB, l10n_util::GetString(IDS_NEWTAB)); + menu.AppendMenuItemWithLabel(IDC_NEWWINDOW, + l10n_util::GetString(IDS_NEWWINDOW)); + menu.AppendMenuItemWithLabel(IDC_GOOFFTHERECORD, + l10n_util::GetString(IDS_GOOFFTHERECORD)); + menu.AppendSeparator(); + // The install menu may be dynamically generated with a contextual label. + // See browser_commands.cc. + menu.AppendMenuItemWithLabel(IDC_CREATE_SHORTCUT, + l10n_util::GetString(IDS_DEFAULT_INSTALL_SITE_LABEL)); + menu.AppendSeparator(); + menu.AppendMenuItemWithLabel(IDC_CUT, l10n_util::GetString(IDS_CUT)); + menu.AppendMenuItemWithLabel(IDC_COPY, l10n_util::GetString(IDS_COPY)); + menu.AppendMenuItemWithLabel(IDC_PASTE, l10n_util::GetString(IDS_PASTE)); + menu.AppendSeparator(); + + menu.AppendMenuItemWithLabel(IDC_FIND, + l10n_util::GetString(IDS_FIND_IN_PAGE)); + menu.AppendMenuItemWithLabel(IDC_SAVEPAGE, + l10n_util::GetString(IDS_SAVEPAGEAS)); + menu.AppendMenuItemWithLabel(IDC_PRINT, l10n_util::GetString(IDS_PRINT)); + menu.AppendSeparator(); + + Menu* zoom_menu = menu.AppendSubMenu(IDC_ZOOM, + l10n_util::GetString(IDS_ZOOM)); + zoom_menu->AppendMenuItemWithLabel(IDC_ZOOM_PLUS, + l10n_util::GetString(IDS_ZOOM_PLUS)); + zoom_menu->AppendMenuItemWithLabel(IDC_ZOOM_NORMAL, + l10n_util::GetString(IDS_ZOOM_NORMAL)); + zoom_menu->AppendMenuItemWithLabel(IDC_ZOOM_MINUS, + l10n_util::GetString(IDS_ZOOM_MINUS)); + + // Create encoding menu. + Menu* encoding_menu = menu.AppendSubMenu(IDC_ENCODING, + l10n_util::GetString(IDS_ENCODING)); + + EncodingMenuControllerDelegate::BuildEncodingMenu(profile_, encoding_menu); + + struct MenuCreateMaterial { + unsigned int menu_id; + unsigned int menu_label_id; + }; + struct MenuCreateMaterial developer_menu_materials[] = { + { IDC_VIEWSOURCE, IDS_VIEWPAGESOURCE }, + { IDC_DEBUGGER, IDS_DEBUGGER }, + { IDC_SHOW_JS_CONSOLE, IDS_VIEWJSCONSOLE }, + { IDC_TASKMANAGER, IDS_TASKMANAGER } + }; + // Append developer menu. + menu.AppendSeparator(); + Menu* developer_menu = + menu.AppendSubMenu(IDC_DEVELOPER, l10n_util::GetString(IDS_DEVELOPER)); + for (int i = 0; i < arraysize(developer_menu_materials); ++i) { + if (developer_menu_materials[i].menu_id) { + developer_menu->AppendMenuItemWithLabel( + developer_menu_materials[i].menu_id, + l10n_util::GetString(developer_menu_materials[i].menu_label_id)); + } else { + developer_menu->AppendSeparator(); + } + } + + menu.AppendSeparator(); + + menu.AppendMenuItemWithLabel(IDS_COMMANDS_REPORTBUG, + l10n_util::GetString(IDS_COMMANDS_REPORTBUG)); + menu.RunMenuAt(pt.x, pt.y); +} + +void BrowserToolbarView::RunAppMenu(const CPoint& pt, HWND hwnd) { + Menu::AnchorPoint anchor = Menu::TOPRIGHT; + if (UILayoutIsRightToLeft()) + anchor = Menu::TOPLEFT; + + Menu menu(this, anchor, hwnd); + menu.AppendMenuItemWithLabel(IDC_SHOW_BOOKMARKS_BAR, + l10n_util::GetString(IDS_SHOW_BOOKMARK_BAR)); + menu.AppendSeparator(); + menu.AppendMenuItemWithLabel(IDC_SHOW_HISTORY, + l10n_util::GetString(IDS_SHOW_HISTORY)); + menu.AppendMenuItemWithLabel(IDC_SHOW_DOWNLOADS, + l10n_util::GetString(IDS_SHOW_DOWNLOADS)); + menu.AppendSeparator(); + menu.AppendMenuItemWithLabel(IDC_CLEAR_BROWSING_DATA, + l10n_util::GetString(IDS_CLEAR_BROWSING_DATA)); + menu.AppendMenuItemWithLabel(IDC_IMPORT_SETTINGS, + l10n_util::GetString(IDS_IMPORT_SETTINGS)); + menu.AppendSeparator(); + menu.AppendMenuItemWithLabel(IDC_OPTIONS, + l10n_util::GetStringF(IDS_OPTIONS, + l10n_util::GetString(IDS_PRODUCT_NAME))); + menu.AppendMenuItemWithLabel(IDC_ABOUT, + l10n_util::GetStringF(IDS_ABOUT, + l10n_util::GetString(IDS_PRODUCT_NAME))); + menu.AppendMenuItemWithLabel(IDC_HELPMENU, l10n_util::GetString(IDS_HELP)); + menu.AppendSeparator(); + menu.AppendMenuItemWithLabel(IDC_EXIT, l10n_util::GetString(IDS_EXIT)); + + menu.RunMenuAt(pt.x, pt.y); +} + +bool BrowserToolbarView::IsItemChecked(int id) const { + if (!profile_) + return false; + if (id == IDC_SHOW_BOOKMARKS_BAR) + return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar); + else + return EncodingMenuControllerDelegate::IsItemChecked(id); +} + +void BrowserToolbarView::RunMenu(ChromeViews::View* source, + const CPoint& pt, + HWND hwnd) { + switch (source->GetID()) { + case VIEW_ID_PAGE_MENU: + RunPageMenu(pt, hwnd); + break; + case VIEW_ID_APP_MENU: + RunAppMenu(pt, hwnd); + break; + default: + NOTREACHED() << "Invalid source menu."; + } +} + +bool BrowserToolbarView::GetAccessibleRole(VARIANT* role) { + DCHECK(role); + + role->vt = VT_I4; + role->lVal = ROLE_SYSTEM_TOOLBAR; + return true; +} + +bool BrowserToolbarView::GetAccessibleName(std::wstring* name) { + if (!accessible_name_.empty()) { + (*name).assign(accessible_name_); + return true; + } + return false; +} + +void BrowserToolbarView::SetAccessibleName(const std::wstring& name) { + accessible_name_.assign(name); +} + +int BrowserToolbarView::GetNextAccessibleViewIndex(int view_index, + bool nav_left) { + int modifier = 1; + + if (nav_left) + modifier = -1; + + int current_view_index = view_index + modifier; + + if ((current_view_index >= 0) && (current_view_index < GetChildViewCount())) { + // Skip the location bar, as it has its own keyboard navigation. + if (current_view_index == GetChildIndex(location_bar_)) + current_view_index += modifier; + + view_index = current_view_index; + } + return view_index; +} + +int BrowserToolbarView::GetDragOperations(ChromeViews::View* sender, + int x, + int y) { + DCHECK(sender == star_); + if (model_->input_in_progress() || !tab_ || !tab_->ShouldDisplayURL() || + !tab_->GetURL().is_valid()) { + return DragDropTypes::DRAG_NONE; + } + return DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_LINK; +} + +void BrowserToolbarView::WriteDragData(ChromeViews::View* sender, + int press_x, + int press_y, + OSExchangeData* data) { + DCHECK( + GetDragOperations(sender, press_x, press_y) != DragDropTypes::DRAG_NONE); + + UserMetrics::RecordAction(L"Toolbar_DragStar", profile_); + + drag_utils::SetURLAndDragImage(tab_->GetURL(), tab_->GetTitle(), + tab_->GetFavIcon(), data); +} + +TabContents* BrowserToolbarView::GetTabContents() { + return tab_; +} + +void BrowserToolbarView::Observe(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details) { + if (type == NOTIFY_PREF_CHANGED) { + std::wstring* pref_name = Details<std::wstring>(details).ptr(); + if (*pref_name == prefs::kShowHomeButton) { + Layout(); + SchedulePaint(); + } + } +} + +bool BrowserToolbarView::GetAcceleratorInfo(int id, + ChromeViews::Accelerator* accel) { + // The standard Ctrl-X, Ctrl-V and Ctrl-C are not defined as accelerators + // anywhere so we need to check for them explicitly here. + // TODO(cpu) Bug 1109102. Query WebKit land for the actual bindings. + switch (id) { + case IDC_CUT: + *accel = ChromeViews::Accelerator(L'X', false, true, false); + return true; + case IDC_COPY: + *accel = ChromeViews::Accelerator(L'C', false, true, false); + return true; + case IDC_PASTE: + *accel = ChromeViews::Accelerator(L'V', false, true, false); + return true; + } + // Else, we retrieve the accelerator information from the frame. + return GetViewContainer()->GetAccelerator(id, accel); +} |