refactor: rename the atom directory to shell
This commit is contained in:
Samuel Attard
Samuel Attard
parent
4575a4aae3
commit
d7f07e8a80
631 changed files with 0 additions and 0 deletions
115
shell/browser/ui/views/atom_views_delegate.cc
Normal file
115
shell/browser/ui/views/atom_views_delegate.cc
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
// Copyright (c) 2014 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-CHROMIUM file.
|
||||
|
||||
#include "atom/browser/ui/views/atom_views_delegate.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
|
||||
#include "ui/views/widget/native_widget_aura.h"
|
||||
|
||||
#if defined(OS_LINUX)
|
||||
#include "base/environment.h"
|
||||
#include "base/nix/xdg_util.h"
|
||||
#include "ui/views/linux_ui/linux_ui.h"
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
#if defined(OS_LINUX)
|
||||
bool IsDesktopEnvironmentUnity() {
|
||||
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
||||
base::nix::DesktopEnvironment desktop_env =
|
||||
base::nix::GetDesktopEnvironment(env.get());
|
||||
return desktop_env == base::nix::DESKTOP_ENVIRONMENT_UNITY;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace atom {
|
||||
|
||||
ViewsDelegate::ViewsDelegate() {}
|
||||
|
||||
ViewsDelegate::~ViewsDelegate() {}
|
||||
|
||||
void ViewsDelegate::SaveWindowPlacement(const views::Widget* window,
|
||||
const std::string& window_name,
|
||||
const gfx::Rect& bounds,
|
||||
ui::WindowShowState show_state) {}
|
||||
|
||||
bool ViewsDelegate::GetSavedWindowPlacement(
|
||||
const views::Widget* widget,
|
||||
const std::string& window_name,
|
||||
gfx::Rect* bounds,
|
||||
ui::WindowShowState* show_state) const {
|
||||
return false;
|
||||
}
|
||||
|
||||
void ViewsDelegate::NotifyMenuItemFocused(const base::string16& menu_name,
|
||||
const base::string16& menu_item_name,
|
||||
int item_index,
|
||||
int item_count,
|
||||
bool has_submenu) {}
|
||||
|
||||
#if defined(OS_WIN)
|
||||
HICON ViewsDelegate::GetDefaultWindowIcon() const {
|
||||
// Use current exe's icon as default window icon.
|
||||
return LoadIcon(GetModuleHandle(NULL),
|
||||
MAKEINTRESOURCE(1 /* IDR_MAINFRAME */));
|
||||
}
|
||||
|
||||
HICON ViewsDelegate::GetSmallWindowIcon() const {
|
||||
return GetDefaultWindowIcon();
|
||||
}
|
||||
|
||||
bool ViewsDelegate::IsWindowInMetro(gfx::NativeWindow window) const {
|
||||
return false;
|
||||
}
|
||||
|
||||
#elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
|
||||
gfx::ImageSkia* ViewsDelegate::GetDefaultWindowIcon() const {
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
views::NonClientFrameView* ViewsDelegate::CreateDefaultNonClientFrameView(
|
||||
views::Widget* widget) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ViewsDelegate::AddRef() {}
|
||||
|
||||
void ViewsDelegate::ReleaseRef() {}
|
||||
|
||||
void ViewsDelegate::OnBeforeWidgetInit(
|
||||
views::Widget::InitParams* params,
|
||||
views::internal::NativeWidgetDelegate* delegate) {
|
||||
// If we already have a native_widget, we don't have to try to come
|
||||
// up with one.
|
||||
if (params->native_widget)
|
||||
return;
|
||||
|
||||
if (params->parent && params->type != views::Widget::InitParams::TYPE_MENU &&
|
||||
params->type != views::Widget::InitParams::TYPE_TOOLTIP) {
|
||||
params->native_widget = new views::NativeWidgetAura(delegate);
|
||||
} else {
|
||||
params->native_widget = new views::DesktopNativeWidgetAura(delegate);
|
||||
}
|
||||
}
|
||||
|
||||
bool ViewsDelegate::WindowManagerProvidesTitleBar(bool maximized) {
|
||||
#if defined(OS_LINUX)
|
||||
// On Ubuntu Unity, the system always provides a title bar for maximized
|
||||
// windows.
|
||||
if (!maximized)
|
||||
return false;
|
||||
static bool is_desktop_environment_unity = IsDesktopEnvironmentUnity();
|
||||
return is_desktop_environment_unity;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
58
shell/browser/ui/views/atom_views_delegate.h
Normal file
58
shell/browser/ui/views/atom_views_delegate.h
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
// Copyright (c) 2014 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-CHROMIUM file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_ATOM_VIEWS_DELEGATE_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_ATOM_VIEWS_DELEGATE_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "base/compiler_specific.h"
|
||||
#include "ui/views/views_delegate.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class ViewsDelegate : public views::ViewsDelegate {
|
||||
public:
|
||||
ViewsDelegate();
|
||||
~ViewsDelegate() override;
|
||||
|
||||
protected:
|
||||
// views::ViewsDelegate:
|
||||
void SaveWindowPlacement(const views::Widget* window,
|
||||
const std::string& window_name,
|
||||
const gfx::Rect& bounds,
|
||||
ui::WindowShowState show_state) override;
|
||||
bool GetSavedWindowPlacement(const views::Widget* widget,
|
||||
const std::string& window_name,
|
||||
gfx::Rect* bounds,
|
||||
ui::WindowShowState* show_state) const override;
|
||||
void NotifyMenuItemFocused(const base::string16& menu_name,
|
||||
const base::string16& menu_item_name,
|
||||
int item_index,
|
||||
int item_count,
|
||||
bool has_submenu) override;
|
||||
|
||||
#if defined(OS_WIN)
|
||||
HICON GetDefaultWindowIcon() const override;
|
||||
HICON GetSmallWindowIcon() const override;
|
||||
bool IsWindowInMetro(gfx::NativeWindow window) const override;
|
||||
#elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
|
||||
gfx::ImageSkia* GetDefaultWindowIcon() const override;
|
||||
#endif
|
||||
views::NonClientFrameView* CreateDefaultNonClientFrameView(
|
||||
views::Widget* widget) override;
|
||||
void AddRef() override;
|
||||
void ReleaseRef() override;
|
||||
void OnBeforeWidgetInit(
|
||||
views::Widget::InitParams* params,
|
||||
views::internal::NativeWidgetDelegate* delegate) override;
|
||||
bool WindowManagerProvidesTitleBar(bool maximized) override;
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(ViewsDelegate);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_ATOM_VIEWS_DELEGATE_H_
|
||||
492
shell/browser/ui/views/autofill_popup_view.cc
Normal file
492
shell/browser/ui/views/autofill_popup_view.cc
Normal file
|
|
@ -0,0 +1,492 @@
|
|||
// 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 "atom/browser/ui/views/autofill_popup_view.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "base/bind.h"
|
||||
#include "base/i18n/rtl.h"
|
||||
#include "cc/paint/skia_paint_canvas.h"
|
||||
#include "content/public/browser/render_view_host.h"
|
||||
#include "ui/events/keycodes/keyboard_codes.h"
|
||||
#include "ui/gfx/canvas.h"
|
||||
#include "ui/gfx/geometry/point.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/text_utils.h"
|
||||
#include "ui/views/border.h"
|
||||
#include "ui/views/focus/focus_manager.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
void AutofillPopupChildView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
|
||||
node_data->role = ax::mojom::Role::kMenuItem;
|
||||
node_data->SetName(suggestion_);
|
||||
}
|
||||
|
||||
AutofillPopupView::AutofillPopupView(AutofillPopup* popup,
|
||||
views::Widget* parent_widget)
|
||||
: popup_(popup), parent_widget_(parent_widget), weak_ptr_factory_(this) {
|
||||
CreateChildViews();
|
||||
SetFocusBehavior(FocusBehavior::ALWAYS);
|
||||
set_drag_controller(this);
|
||||
}
|
||||
|
||||
AutofillPopupView::~AutofillPopupView() {
|
||||
if (popup_) {
|
||||
auto* host = popup_->frame_host_->GetRenderViewHost()->GetWidget();
|
||||
host->RemoveKeyPressEventCallback(keypress_callback_);
|
||||
popup_->view_ = nullptr;
|
||||
popup_ = nullptr;
|
||||
}
|
||||
|
||||
RemoveObserver();
|
||||
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
if (view_proxy_.get()) {
|
||||
view_proxy_->ResetView();
|
||||
}
|
||||
#endif
|
||||
|
||||
if (GetWidget()) {
|
||||
GetWidget()->Close();
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::Show() {
|
||||
bool visible = parent_widget_->IsVisible();
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
visible = visible || view_proxy_;
|
||||
#endif
|
||||
if (!popup_ || !visible || parent_widget_->IsClosed())
|
||||
return;
|
||||
|
||||
const bool initialize_widget = !GetWidget();
|
||||
if (initialize_widget) {
|
||||
parent_widget_->AddObserver(this);
|
||||
|
||||
// The widget is destroyed by the corresponding NativeWidget, so we use
|
||||
// a weak pointer to hold the reference and don't have to worry about
|
||||
// deletion.
|
||||
views::Widget* widget = new views::Widget;
|
||||
views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
|
||||
params.delegate = this;
|
||||
params.parent = parent_widget_->GetNativeView();
|
||||
widget->Init(params);
|
||||
|
||||
// No animation for popup appearance (too distracting).
|
||||
widget->SetVisibilityAnimationTransition(views::Widget::ANIMATE_HIDE);
|
||||
|
||||
show_time_ = base::Time::Now();
|
||||
}
|
||||
|
||||
SetBorder(views::CreateSolidBorder(
|
||||
kPopupBorderThickness,
|
||||
GetNativeTheme()->GetSystemColor(
|
||||
ui::NativeTheme::kColorId_UnfocusedBorderColor)));
|
||||
|
||||
DoUpdateBoundsAndRedrawPopup();
|
||||
GetWidget()->Show();
|
||||
|
||||
if (initialize_widget)
|
||||
views::WidgetFocusManager::GetInstance()->AddFocusChangeListener(this);
|
||||
|
||||
keypress_callback_ = base::BindRepeating(
|
||||
&AutofillPopupView::HandleKeyPressEvent, base::Unretained(this));
|
||||
auto* host = popup_->frame_host_->GetRenderViewHost()->GetWidget();
|
||||
host->AddKeyPressEventCallback(keypress_callback_);
|
||||
|
||||
NotifyAccessibilityEvent(ax::mojom::Event::kMenuStart, true);
|
||||
}
|
||||
|
||||
void AutofillPopupView::Hide() {
|
||||
if (popup_) {
|
||||
auto* host = popup_->frame_host_->GetRenderViewHost()->GetWidget();
|
||||
host->RemoveKeyPressEventCallback(keypress_callback_);
|
||||
popup_ = nullptr;
|
||||
}
|
||||
|
||||
RemoveObserver();
|
||||
NotifyAccessibilityEvent(ax::mojom::Event::kMenuEnd, true);
|
||||
|
||||
if (GetWidget()) {
|
||||
GetWidget()->Close();
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnSuggestionsChanged() {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
CreateChildViews();
|
||||
if (popup_->GetLineCount() == 0) {
|
||||
popup_->Hide();
|
||||
return;
|
||||
}
|
||||
DoUpdateBoundsAndRedrawPopup();
|
||||
}
|
||||
|
||||
void AutofillPopupView::WriteDragDataForView(views::View*,
|
||||
const gfx::Point&,
|
||||
ui::OSExchangeData*) {}
|
||||
|
||||
int AutofillPopupView::GetDragOperationsForView(views::View*,
|
||||
const gfx::Point&) {
|
||||
return ui::DragDropTypes::DRAG_NONE;
|
||||
}
|
||||
|
||||
bool AutofillPopupView::CanStartDragForView(views::View*,
|
||||
const gfx::Point&,
|
||||
const gfx::Point&) {
|
||||
return false;
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnSelectedRowChanged(
|
||||
base::Optional<int> previous_row_selection,
|
||||
base::Optional<int> current_row_selection) {
|
||||
SchedulePaint();
|
||||
|
||||
if (current_row_selection) {
|
||||
int selected = current_row_selection.value_or(-1);
|
||||
if (selected == -1 || static_cast<size_t>(selected) >= children().size())
|
||||
return;
|
||||
children().at(selected)->NotifyAccessibilityEvent(
|
||||
ax::mojom::Event::kSelection, true);
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::DrawAutofillEntry(gfx::Canvas* canvas,
|
||||
int index,
|
||||
const gfx::Rect& entry_rect) {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
canvas->FillRect(entry_rect, GetNativeTheme()->GetSystemColor(
|
||||
popup_->GetBackgroundColorIDForRow(index)));
|
||||
|
||||
const bool is_rtl = base::i18n::IsRTL();
|
||||
const int text_align =
|
||||
is_rtl ? gfx::Canvas::TEXT_ALIGN_RIGHT : gfx::Canvas::TEXT_ALIGN_LEFT;
|
||||
gfx::Rect value_rect = entry_rect;
|
||||
value_rect.Inset(kEndPadding, 0);
|
||||
|
||||
int x_align_left = value_rect.x();
|
||||
const int value_width = gfx::GetStringWidth(
|
||||
popup_->GetValueAt(index), popup_->GetValueFontListForRow(index));
|
||||
int value_x_align_left = x_align_left;
|
||||
value_x_align_left =
|
||||
is_rtl ? value_rect.right() - value_width : value_rect.x();
|
||||
|
||||
canvas->DrawStringRectWithFlags(
|
||||
popup_->GetValueAt(index), popup_->GetValueFontListForRow(index),
|
||||
GetNativeTheme()->GetSystemColor(
|
||||
ui::NativeTheme::kColorId_ResultsTableNormalText),
|
||||
gfx::Rect(value_x_align_left, value_rect.y(), value_width,
|
||||
value_rect.height()),
|
||||
text_align);
|
||||
|
||||
// Draw the label text, if one exists.
|
||||
if (!popup_->GetLabelAt(index).empty()) {
|
||||
const int label_width = gfx::GetStringWidth(
|
||||
popup_->GetLabelAt(index), popup_->GetLabelFontListForRow(index));
|
||||
int label_x_align_left = x_align_left;
|
||||
label_x_align_left =
|
||||
is_rtl ? value_rect.x() : value_rect.right() - label_width;
|
||||
|
||||
canvas->DrawStringRectWithFlags(
|
||||
popup_->GetLabelAt(index), popup_->GetLabelFontListForRow(index),
|
||||
GetNativeTheme()->GetSystemColor(
|
||||
ui::NativeTheme::kColorId_ResultsTableDimmedText),
|
||||
gfx::Rect(label_x_align_left, entry_rect.y(), label_width,
|
||||
entry_rect.height()),
|
||||
text_align);
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::CreateChildViews() {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
RemoveAllChildViews(true);
|
||||
|
||||
for (int i = 0; i < popup_->GetLineCount(); ++i) {
|
||||
auto* child_view = new AutofillPopupChildView(popup_->GetValueAt(i));
|
||||
child_view->set_drag_controller(this);
|
||||
AddChildView(child_view);
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::DoUpdateBoundsAndRedrawPopup() {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
GetWidget()->SetBounds(popup_->popup_bounds_);
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
if (view_proxy_.get()) {
|
||||
view_proxy_->SetBounds(popup_->popup_bounds_in_view());
|
||||
}
|
||||
#endif
|
||||
SchedulePaint();
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnPaint(gfx::Canvas* canvas) {
|
||||
if (!popup_ ||
|
||||
static_cast<size_t>(popup_->GetLineCount()) != children().size())
|
||||
return;
|
||||
gfx::Canvas* draw_canvas = canvas;
|
||||
SkBitmap bitmap;
|
||||
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
std::unique_ptr<cc::SkiaPaintCanvas> paint_canvas;
|
||||
if (view_proxy_.get()) {
|
||||
bitmap.allocN32Pixels(popup_->popup_bounds_in_view().width(),
|
||||
popup_->popup_bounds_in_view().height(), true);
|
||||
paint_canvas.reset(new cc::SkiaPaintCanvas(bitmap));
|
||||
draw_canvas = new gfx::Canvas(paint_canvas.get(), 1.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
draw_canvas->DrawColor(GetNativeTheme()->GetSystemColor(
|
||||
ui::NativeTheme::kColorId_ResultsTableNormalBackground));
|
||||
OnPaintBorder(draw_canvas);
|
||||
|
||||
for (int i = 0; i < popup_->GetLineCount(); ++i) {
|
||||
gfx::Rect line_rect = popup_->GetRowBounds(i);
|
||||
|
||||
DrawAutofillEntry(draw_canvas, i, line_rect);
|
||||
}
|
||||
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
if (view_proxy_.get()) {
|
||||
view_proxy_->SetBounds(popup_->popup_bounds_in_view());
|
||||
view_proxy_->SetBitmap(bitmap);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void AutofillPopupView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
|
||||
node_data->role = ax::mojom::Role::kMenu;
|
||||
node_data->SetName("Autofill Menu");
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnMouseCaptureLost() {
|
||||
ClearSelection();
|
||||
}
|
||||
|
||||
bool AutofillPopupView::OnMouseDragged(const ui::MouseEvent& event) {
|
||||
if (HitTestPoint(event.location())) {
|
||||
SetSelection(event.location());
|
||||
|
||||
// We must return true in order to get future OnMouseDragged and
|
||||
// OnMouseReleased events.
|
||||
return true;
|
||||
}
|
||||
|
||||
// If we move off of the popup, we lose the selection.
|
||||
ClearSelection();
|
||||
return false;
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnMouseExited(const ui::MouseEvent& event) {
|
||||
// Pressing return causes the cursor to hide, which will generate an
|
||||
// OnMouseExited event. Pressing return should activate the current selection
|
||||
// via AcceleratorPressed, so we need to let that run first.
|
||||
base::ThreadTaskRunnerHandle::Get()->PostTask(
|
||||
FROM_HERE, base::BindOnce(&AutofillPopupView::ClearSelection,
|
||||
weak_ptr_factory_.GetWeakPtr()));
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnMouseMoved(const ui::MouseEvent& event) {
|
||||
// A synthesized mouse move will be sent when the popup is first shown.
|
||||
// Don't preview a suggestion if the mouse happens to be hovering there.
|
||||
#if defined(OS_WIN)
|
||||
if (base::Time::Now() - show_time_ <= base::TimeDelta::FromMilliseconds(50))
|
||||
return;
|
||||
#else
|
||||
if (event.flags() & ui::EF_IS_SYNTHESIZED)
|
||||
return;
|
||||
#endif
|
||||
|
||||
if (HitTestPoint(event.location()))
|
||||
SetSelection(event.location());
|
||||
else
|
||||
ClearSelection();
|
||||
}
|
||||
|
||||
bool AutofillPopupView::OnMousePressed(const ui::MouseEvent& event) {
|
||||
return event.GetClickCount() == 1;
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnMouseReleased(const ui::MouseEvent& event) {
|
||||
// We only care about the left click.
|
||||
if (event.IsOnlyLeftMouseButton() && HitTestPoint(event.location()))
|
||||
AcceptSelection(event.location());
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnGestureEvent(ui::GestureEvent* event) {
|
||||
switch (event->type()) {
|
||||
case ui::ET_GESTURE_TAP_DOWN:
|
||||
case ui::ET_GESTURE_SCROLL_BEGIN:
|
||||
case ui::ET_GESTURE_SCROLL_UPDATE:
|
||||
if (HitTestPoint(event->location()))
|
||||
SetSelection(event->location());
|
||||
else
|
||||
ClearSelection();
|
||||
break;
|
||||
case ui::ET_GESTURE_TAP:
|
||||
case ui::ET_GESTURE_SCROLL_END:
|
||||
if (HitTestPoint(event->location()))
|
||||
AcceptSelection(event->location());
|
||||
else
|
||||
ClearSelection();
|
||||
break;
|
||||
case ui::ET_GESTURE_TAP_CANCEL:
|
||||
case ui::ET_SCROLL_FLING_START:
|
||||
ClearSelection();
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
event->SetHandled();
|
||||
}
|
||||
|
||||
bool AutofillPopupView::AcceleratorPressed(const ui::Accelerator& accelerator) {
|
||||
if (accelerator.modifiers() != ui::EF_NONE)
|
||||
return false;
|
||||
|
||||
if (accelerator.key_code() == ui::VKEY_ESCAPE) {
|
||||
if (popup_)
|
||||
popup_->Hide();
|
||||
return true;
|
||||
}
|
||||
|
||||
if (accelerator.key_code() == ui::VKEY_RETURN)
|
||||
return AcceptSelectedLine();
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool AutofillPopupView::HandleKeyPressEvent(
|
||||
const content::NativeWebKeyboardEvent& event) {
|
||||
if (!popup_)
|
||||
return false;
|
||||
switch (event.windows_key_code) {
|
||||
case ui::VKEY_UP:
|
||||
SelectPreviousLine();
|
||||
return true;
|
||||
case ui::VKEY_DOWN:
|
||||
SelectNextLine();
|
||||
return true;
|
||||
case ui::VKEY_PRIOR: // Page up.
|
||||
SetSelectedLine(0);
|
||||
return true;
|
||||
case ui::VKEY_NEXT: // Page down.
|
||||
SetSelectedLine(popup_->GetLineCount() - 1);
|
||||
return true;
|
||||
case ui::VKEY_ESCAPE:
|
||||
popup_->Hide();
|
||||
return true;
|
||||
case ui::VKEY_TAB:
|
||||
// A tab press should cause the selected line to be accepted, but still
|
||||
// return false so the tab key press propagates and changes the cursor
|
||||
// location.
|
||||
AcceptSelectedLine();
|
||||
return false;
|
||||
case ui::VKEY_RETURN:
|
||||
return AcceptSelectedLine();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnNativeFocusChanged(gfx::NativeView focused_now) {
|
||||
if (GetWidget() && GetWidget()->GetNativeView() != focused_now && popup_)
|
||||
popup_->Hide();
|
||||
}
|
||||
|
||||
void AutofillPopupView::OnWidgetBoundsChanged(views::Widget* widget,
|
||||
const gfx::Rect& new_bounds) {
|
||||
if (widget != parent_widget_)
|
||||
return;
|
||||
if (popup_)
|
||||
popup_->Hide();
|
||||
}
|
||||
|
||||
void AutofillPopupView::AcceptSuggestion(int index) {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
popup_->AcceptSuggestion(index);
|
||||
popup_->Hide();
|
||||
}
|
||||
|
||||
bool AutofillPopupView::AcceptSelectedLine() {
|
||||
if (!selected_line_ || selected_line_.value() >= popup_->GetLineCount())
|
||||
return false;
|
||||
|
||||
AcceptSuggestion(selected_line_.value());
|
||||
return true;
|
||||
}
|
||||
|
||||
void AutofillPopupView::AcceptSelection(const gfx::Point& point) {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
SetSelectedLine(popup_->LineFromY(point.y()));
|
||||
AcceptSelectedLine();
|
||||
}
|
||||
|
||||
void AutofillPopupView::SetSelectedLine(base::Optional<int> selected_line) {
|
||||
if (!popup_)
|
||||
return;
|
||||
if (selected_line_ == selected_line)
|
||||
return;
|
||||
if (selected_line && selected_line.value() >= popup_->GetLineCount())
|
||||
return;
|
||||
|
||||
auto previous_selected_line(selected_line_);
|
||||
selected_line_ = selected_line;
|
||||
OnSelectedRowChanged(previous_selected_line, selected_line_);
|
||||
}
|
||||
|
||||
void AutofillPopupView::SetSelection(const gfx::Point& point) {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
SetSelectedLine(popup_->LineFromY(point.y()));
|
||||
}
|
||||
|
||||
void AutofillPopupView::SelectNextLine() {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
int new_selected_line = selected_line_ ? *selected_line_ + 1 : 0;
|
||||
if (new_selected_line >= popup_->GetLineCount())
|
||||
new_selected_line = 0;
|
||||
|
||||
SetSelectedLine(new_selected_line);
|
||||
}
|
||||
|
||||
void AutofillPopupView::SelectPreviousLine() {
|
||||
if (!popup_)
|
||||
return;
|
||||
|
||||
int new_selected_line = selected_line_.value_or(0) - 1;
|
||||
if (new_selected_line < 0)
|
||||
new_selected_line = popup_->GetLineCount() - 1;
|
||||
|
||||
SetSelectedLine(new_selected_line);
|
||||
}
|
||||
|
||||
void AutofillPopupView::ClearSelection() {
|
||||
SetSelectedLine(base::nullopt);
|
||||
}
|
||||
|
||||
void AutofillPopupView::RemoveObserver() {
|
||||
parent_widget_->RemoveObserver(this);
|
||||
views::WidgetFocusManager::GetInstance()->RemoveFocusChangeListener(this);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
155
shell/browser/ui/views/autofill_popup_view.h
Normal file
155
shell/browser/ui/views/autofill_popup_view.h
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
// 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.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_AUTOFILL_POPUP_VIEW_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_AUTOFILL_POPUP_VIEW_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "atom/browser/ui/autofill_popup.h"
|
||||
|
||||
#include "base/optional.h"
|
||||
#include "content/public/browser/native_web_keyboard_event.h"
|
||||
#include "content/public/browser/render_widget_host.h"
|
||||
#include "electron/buildflags/buildflags.h"
|
||||
#include "ui/accessibility/ax_node_data.h"
|
||||
#include "ui/views/drag_controller.h"
|
||||
#include "ui/views/focus/widget_focus_manager.h"
|
||||
#include "ui/views/widget/widget_delegate.h"
|
||||
#include "ui/views/widget/widget_observer.h"
|
||||
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
#include "atom/browser/osr/osr_view_proxy.h"
|
||||
#endif
|
||||
|
||||
namespace atom {
|
||||
|
||||
const int kPopupBorderThickness = 1;
|
||||
const int kSmallerFontSizeDelta = -1;
|
||||
const int kEndPadding = 8;
|
||||
const int kNamePadding = 15;
|
||||
const int kRowHeight = 24;
|
||||
|
||||
class AutofillPopup;
|
||||
|
||||
// Child view only for triggering accessibility events. Rendering is handled
|
||||
// by |AutofillPopupViewViews|.
|
||||
class AutofillPopupChildView : public views::View {
|
||||
public:
|
||||
explicit AutofillPopupChildView(const base::string16& suggestion)
|
||||
: suggestion_(suggestion) {
|
||||
SetFocusBehavior(FocusBehavior::ALWAYS);
|
||||
}
|
||||
|
||||
private:
|
||||
~AutofillPopupChildView() override {}
|
||||
|
||||
// views::Views implementation
|
||||
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
|
||||
|
||||
base::string16 suggestion_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(AutofillPopupChildView);
|
||||
};
|
||||
|
||||
class AutofillPopupView : public views::WidgetDelegateView,
|
||||
public views::WidgetFocusChangeListener,
|
||||
public views::WidgetObserver,
|
||||
public views::DragController {
|
||||
public:
|
||||
explicit AutofillPopupView(AutofillPopup* popup,
|
||||
views::Widget* parent_widget);
|
||||
~AutofillPopupView() override;
|
||||
|
||||
void Show();
|
||||
void Hide();
|
||||
|
||||
void OnSuggestionsChanged();
|
||||
|
||||
int GetSelectedLine() { return selected_line_.value_or(-1); }
|
||||
|
||||
void WriteDragDataForView(views::View*,
|
||||
const gfx::Point&,
|
||||
ui::OSExchangeData*) override;
|
||||
int GetDragOperationsForView(views::View*, const gfx::Point&) override;
|
||||
bool CanStartDragForView(views::View*,
|
||||
const gfx::Point&,
|
||||
const gfx::Point&) override;
|
||||
|
||||
private:
|
||||
friend class AutofillPopup;
|
||||
|
||||
void OnSelectedRowChanged(base::Optional<int> previous_row_selection,
|
||||
base::Optional<int> current_row_selection);
|
||||
|
||||
// Draw the given autofill entry in |entry_rect|.
|
||||
void DrawAutofillEntry(gfx::Canvas* canvas,
|
||||
int index,
|
||||
const gfx::Rect& entry_rect);
|
||||
|
||||
// Creates child views based on the suggestions given by |controller_|. These
|
||||
// child views are used for accessibility events only. We need child views to
|
||||
// populate the correct |AXNodeData| when user selects a suggestion.
|
||||
void CreateChildViews();
|
||||
|
||||
void DoUpdateBoundsAndRedrawPopup();
|
||||
|
||||
// views::Views implementation.
|
||||
void OnPaint(gfx::Canvas* canvas) override;
|
||||
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
|
||||
void OnMouseCaptureLost() override;
|
||||
bool OnMouseDragged(const ui::MouseEvent& event) override;
|
||||
void OnMouseExited(const ui::MouseEvent& event) override;
|
||||
void OnMouseMoved(const ui::MouseEvent& event) override;
|
||||
bool OnMousePressed(const ui::MouseEvent& event) override;
|
||||
void OnMouseReleased(const ui::MouseEvent& event) override;
|
||||
void OnGestureEvent(ui::GestureEvent* event) override;
|
||||
bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
|
||||
bool HandleKeyPressEvent(const content::NativeWebKeyboardEvent& event);
|
||||
|
||||
// views::WidgetFocusChangeListener implementation.
|
||||
void OnNativeFocusChanged(gfx::NativeView focused_now) override;
|
||||
|
||||
// views::WidgetObserver implementation.
|
||||
void OnWidgetBoundsChanged(views::Widget* widget,
|
||||
const gfx::Rect& new_bounds) override;
|
||||
|
||||
void AcceptSuggestion(int index);
|
||||
bool AcceptSelectedLine();
|
||||
void AcceptSelection(const gfx::Point& point);
|
||||
void SetSelectedLine(base::Optional<int> selected_line);
|
||||
void SetSelection(const gfx::Point& point);
|
||||
void SelectNextLine();
|
||||
void SelectPreviousLine();
|
||||
void ClearSelection();
|
||||
|
||||
// Stop observing the widget.
|
||||
void RemoveObserver();
|
||||
|
||||
// Controller for this popup. Weak reference.
|
||||
AutofillPopup* popup_;
|
||||
|
||||
// The widget of the window that triggered this popup. Weak reference.
|
||||
views::Widget* parent_widget_;
|
||||
|
||||
// The time when the popup was shown.
|
||||
base::Time show_time_;
|
||||
|
||||
// The index of the currently selected line
|
||||
base::Optional<int> selected_line_;
|
||||
|
||||
#if BUILDFLAG(ENABLE_OSR)
|
||||
std::unique_ptr<OffscreenViewProxy> view_proxy_;
|
||||
#endif
|
||||
|
||||
// The registered keypress callback, responsible for switching lines on
|
||||
// key presses
|
||||
content::RenderWidgetHost::KeyPressEventCallback keypress_callback_;
|
||||
|
||||
base::WeakPtrFactory<AutofillPopupView> weak_ptr_factory_;
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_AUTOFILL_POPUP_VIEW_H_
|
||||
114
shell/browser/ui/views/frameless_view.cc
Normal file
114
shell/browser/ui/views/frameless_view.cc
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/frameless_view.h"
|
||||
|
||||
#include "atom/browser/native_window_views.h"
|
||||
#include "ui/aura/window.h"
|
||||
#include "ui/base/hit_test.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
#include "ui/views/widget/widget_delegate.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
const int kResizeInsideBoundsSize = 5;
|
||||
const int kResizeAreaCornerSize = 16;
|
||||
|
||||
} // namespace
|
||||
|
||||
// static
|
||||
const char FramelessView::kViewClassName[] = "FramelessView";
|
||||
|
||||
FramelessView::FramelessView() {}
|
||||
|
||||
FramelessView::~FramelessView() {}
|
||||
|
||||
void FramelessView::Init(NativeWindowViews* window, views::Widget* frame) {
|
||||
window_ = window;
|
||||
frame_ = frame;
|
||||
}
|
||||
|
||||
int FramelessView::ResizingBorderHitTest(const gfx::Point& point) {
|
||||
// Check the frame first, as we allow a small area overlapping the contents
|
||||
// to be used for resize handles.
|
||||
bool can_ever_resize = frame_->widget_delegate()
|
||||
? frame_->widget_delegate()->CanResize()
|
||||
: false;
|
||||
// Don't allow overlapping resize handles when the window is maximized or
|
||||
// fullscreen, as it can't be resized in those states.
|
||||
int resize_border = frame_->IsMaximized() || frame_->IsFullscreen()
|
||||
? 0
|
||||
: kResizeInsideBoundsSize;
|
||||
return GetHTComponentForFrame(point, resize_border, resize_border,
|
||||
kResizeAreaCornerSize, kResizeAreaCornerSize,
|
||||
can_ever_resize);
|
||||
}
|
||||
|
||||
gfx::Rect FramelessView::GetBoundsForClientView() const {
|
||||
return bounds();
|
||||
}
|
||||
|
||||
gfx::Rect FramelessView::GetWindowBoundsForClientBounds(
|
||||
const gfx::Rect& client_bounds) const {
|
||||
gfx::Rect window_bounds = client_bounds;
|
||||
// Enforce minimum size (1, 1) in case that client_bounds is passed with
|
||||
// empty size. This could occur when the frameless window is being
|
||||
// initialized.
|
||||
if (window_bounds.IsEmpty()) {
|
||||
window_bounds.set_width(1);
|
||||
window_bounds.set_height(1);
|
||||
}
|
||||
return window_bounds;
|
||||
}
|
||||
|
||||
int FramelessView::NonClientHitTest(const gfx::Point& cursor) {
|
||||
if (frame_->IsFullscreen())
|
||||
return HTCLIENT;
|
||||
|
||||
// Check for possible draggable region in the client area for the frameless
|
||||
// window.
|
||||
SkRegion* draggable_region = window_->draggable_region();
|
||||
if (draggable_region && draggable_region->contains(cursor.x(), cursor.y()))
|
||||
return HTCAPTION;
|
||||
|
||||
// Support resizing frameless window by dragging the border.
|
||||
int frame_component = ResizingBorderHitTest(cursor);
|
||||
if (frame_component != HTNOWHERE)
|
||||
return frame_component;
|
||||
|
||||
return HTCLIENT;
|
||||
}
|
||||
|
||||
void FramelessView::GetWindowMask(const gfx::Size& size, SkPath* window_mask) {}
|
||||
|
||||
void FramelessView::ResetWindowControls() {}
|
||||
|
||||
void FramelessView::UpdateWindowIcon() {}
|
||||
|
||||
void FramelessView::UpdateWindowTitle() {}
|
||||
|
||||
void FramelessView::SizeConstraintsChanged() {}
|
||||
|
||||
gfx::Size FramelessView::CalculatePreferredSize() const {
|
||||
return frame_->non_client_view()
|
||||
->GetWindowBoundsForClientBounds(
|
||||
gfx::Rect(frame_->client_view()->GetPreferredSize()))
|
||||
.size();
|
||||
}
|
||||
|
||||
gfx::Size FramelessView::GetMinimumSize() const {
|
||||
return window_->GetContentMinimumSize();
|
||||
}
|
||||
|
||||
gfx::Size FramelessView::GetMaximumSize() const {
|
||||
return window_->GetContentMaximumSize();
|
||||
}
|
||||
|
||||
const char* FramelessView::GetClassName() const {
|
||||
return kViewClassName;
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
57
shell/browser/ui/views/frameless_view.h
Normal file
57
shell/browser/ui/views/frameless_view.h
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_FRAMELESS_VIEW_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_FRAMELESS_VIEW_H_
|
||||
|
||||
#include "ui/views/window/non_client_view.h"
|
||||
|
||||
namespace views {
|
||||
class Widget;
|
||||
}
|
||||
|
||||
namespace atom {
|
||||
|
||||
class NativeWindowViews;
|
||||
|
||||
class FramelessView : public views::NonClientFrameView {
|
||||
public:
|
||||
static const char kViewClassName[];
|
||||
FramelessView();
|
||||
~FramelessView() override;
|
||||
|
||||
virtual void Init(NativeWindowViews* window, views::Widget* frame);
|
||||
|
||||
// Returns whether the |point| is on frameless window's resizing border.
|
||||
int ResizingBorderHitTest(const gfx::Point& point);
|
||||
|
||||
protected:
|
||||
// views::NonClientFrameView:
|
||||
gfx::Rect GetBoundsForClientView() const override;
|
||||
gfx::Rect GetWindowBoundsForClientBounds(
|
||||
const gfx::Rect& client_bounds) const override;
|
||||
int NonClientHitTest(const gfx::Point& point) override;
|
||||
void GetWindowMask(const gfx::Size& size, SkPath* window_mask) override;
|
||||
void ResetWindowControls() override;
|
||||
void UpdateWindowIcon() override;
|
||||
void UpdateWindowTitle() override;
|
||||
void SizeConstraintsChanged() override;
|
||||
|
||||
// Overridden from View:
|
||||
gfx::Size CalculatePreferredSize() const override;
|
||||
gfx::Size GetMinimumSize() const override;
|
||||
gfx::Size GetMaximumSize() const override;
|
||||
const char* GetClassName() const override;
|
||||
|
||||
// Not owned.
|
||||
NativeWindowViews* window_ = nullptr;
|
||||
views::Widget* frame_ = nullptr;
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(FramelessView);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_FRAMELESS_VIEW_H_
|
||||
336
shell/browser/ui/views/global_menu_bar_x11.cc
Normal file
336
shell/browser/ui/views/global_menu_bar_x11.cc
Normal file
|
|
@ -0,0 +1,336 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/global_menu_bar_x11.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <glib-object.h>
|
||||
|
||||
#include "atom/browser/native_window_views.h"
|
||||
#include "atom/browser/ui/atom_menu_model.h"
|
||||
#include "base/logging.h"
|
||||
#include "base/strings/stringprintf.h"
|
||||
#include "base/strings/utf_string_conversions.h"
|
||||
#include "chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.h"
|
||||
#include "ui/aura/window.h"
|
||||
#include "ui/aura/window_tree_host.h"
|
||||
#include "ui/base/accelerators/menu_label_accelerator_util_linux.h"
|
||||
#include "ui/events/keycodes/keyboard_code_conversion_x.h"
|
||||
#include "ui/gfx/x/x11.h"
|
||||
|
||||
// libdbusmenu-glib types
|
||||
typedef struct _DbusmenuMenuitem DbusmenuMenuitem;
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_new_func)();
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_new_with_id_func)(int id);
|
||||
|
||||
typedef int (*dbusmenu_menuitem_get_id_func)(DbusmenuMenuitem* item);
|
||||
typedef GList* (*dbusmenu_menuitem_get_children_func)(DbusmenuMenuitem* item);
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_child_append_func)(
|
||||
DbusmenuMenuitem* parent,
|
||||
DbusmenuMenuitem* child);
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_func)(
|
||||
DbusmenuMenuitem* item,
|
||||
const char* property,
|
||||
const char* value);
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_variant_func)(
|
||||
DbusmenuMenuitem* item,
|
||||
const char* property,
|
||||
GVariant* value);
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_bool_func)(
|
||||
DbusmenuMenuitem* item,
|
||||
const char* property,
|
||||
bool value);
|
||||
typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_int_func)(
|
||||
DbusmenuMenuitem* item,
|
||||
const char* property,
|
||||
int value);
|
||||
|
||||
typedef struct _DbusmenuServer DbusmenuServer;
|
||||
typedef DbusmenuServer* (*dbusmenu_server_new_func)(const char* object);
|
||||
typedef void (*dbusmenu_server_set_root_func)(DbusmenuServer* self,
|
||||
DbusmenuMenuitem* root);
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
// Retrieved functions from libdbusmenu-glib.
|
||||
|
||||
// DbusmenuMenuItem methods:
|
||||
dbusmenu_menuitem_new_func menuitem_new = NULL;
|
||||
dbusmenu_menuitem_new_with_id_func menuitem_new_with_id = NULL;
|
||||
dbusmenu_menuitem_get_id_func menuitem_get_id = NULL;
|
||||
dbusmenu_menuitem_get_children_func menuitem_get_children = NULL;
|
||||
dbusmenu_menuitem_get_children_func menuitem_take_children = NULL;
|
||||
dbusmenu_menuitem_child_append_func menuitem_child_append = NULL;
|
||||
dbusmenu_menuitem_property_set_func menuitem_property_set = NULL;
|
||||
dbusmenu_menuitem_property_set_variant_func menuitem_property_set_variant =
|
||||
NULL;
|
||||
dbusmenu_menuitem_property_set_bool_func menuitem_property_set_bool = NULL;
|
||||
dbusmenu_menuitem_property_set_int_func menuitem_property_set_int = NULL;
|
||||
|
||||
// DbusmenuServer methods:
|
||||
dbusmenu_server_new_func server_new = NULL;
|
||||
dbusmenu_server_set_root_func server_set_root = NULL;
|
||||
|
||||
// Properties that we set on menu items:
|
||||
const char kPropertyEnabled[] = "enabled";
|
||||
const char kPropertyLabel[] = "label";
|
||||
const char kPropertyShortcut[] = "shortcut";
|
||||
const char kPropertyType[] = "type";
|
||||
const char kPropertyToggleType[] = "toggle-type";
|
||||
const char kPropertyToggleState[] = "toggle-state";
|
||||
const char kPropertyVisible[] = "visible";
|
||||
const char kPropertyChildrenDisplay[] = "children-display";
|
||||
|
||||
const char kToggleCheck[] = "checkmark";
|
||||
const char kToggleRadio[] = "radio";
|
||||
const char kTypeSeparator[] = "separator";
|
||||
const char kDisplaySubmenu[] = "submenu";
|
||||
|
||||
void EnsureMethodsLoaded() {
|
||||
static bool attempted_load = false;
|
||||
if (attempted_load)
|
||||
return;
|
||||
attempted_load = true;
|
||||
|
||||
void* dbusmenu_lib = dlopen("libdbusmenu-glib.so", RTLD_LAZY);
|
||||
if (!dbusmenu_lib)
|
||||
dbusmenu_lib = dlopen("libdbusmenu-glib.so.4", RTLD_LAZY);
|
||||
if (!dbusmenu_lib)
|
||||
return;
|
||||
|
||||
// DbusmenuMenuItem methods.
|
||||
menuitem_new = reinterpret_cast<dbusmenu_menuitem_new_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_new"));
|
||||
menuitem_new_with_id = reinterpret_cast<dbusmenu_menuitem_new_with_id_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_new_with_id"));
|
||||
menuitem_get_id = reinterpret_cast<dbusmenu_menuitem_get_id_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_id"));
|
||||
menuitem_get_children = reinterpret_cast<dbusmenu_menuitem_get_children_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_children"));
|
||||
menuitem_take_children =
|
||||
reinterpret_cast<dbusmenu_menuitem_get_children_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_take_children"));
|
||||
menuitem_child_append = reinterpret_cast<dbusmenu_menuitem_child_append_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_child_append"));
|
||||
menuitem_property_set = reinterpret_cast<dbusmenu_menuitem_property_set_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set"));
|
||||
menuitem_property_set_variant =
|
||||
reinterpret_cast<dbusmenu_menuitem_property_set_variant_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_variant"));
|
||||
menuitem_property_set_bool =
|
||||
reinterpret_cast<dbusmenu_menuitem_property_set_bool_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_bool"));
|
||||
menuitem_property_set_int =
|
||||
reinterpret_cast<dbusmenu_menuitem_property_set_int_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_int"));
|
||||
|
||||
// DbusmenuServer methods.
|
||||
server_new = reinterpret_cast<dbusmenu_server_new_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_server_new"));
|
||||
server_set_root = reinterpret_cast<dbusmenu_server_set_root_func>(
|
||||
dlsym(dbusmenu_lib, "dbusmenu_server_set_root"));
|
||||
}
|
||||
|
||||
AtomMenuModel* ModelForMenuItem(DbusmenuMenuitem* item) {
|
||||
return reinterpret_cast<AtomMenuModel*>(
|
||||
g_object_get_data(G_OBJECT(item), "model"));
|
||||
}
|
||||
|
||||
bool GetMenuItemID(DbusmenuMenuitem* item, int* id) {
|
||||
gpointer id_ptr = g_object_get_data(G_OBJECT(item), "menu-id");
|
||||
if (id_ptr != NULL) {
|
||||
*id = GPOINTER_TO_INT(id_ptr) - 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void SetMenuItemID(DbusmenuMenuitem* item, int id) {
|
||||
DCHECK_GE(id, 0);
|
||||
|
||||
// Add 1 to the menu_id to avoid setting zero (null) to "menu-id".
|
||||
g_object_set_data(G_OBJECT(item), "menu-id", GINT_TO_POINTER(id + 1));
|
||||
}
|
||||
|
||||
std::string GetMenuModelStatus(AtomMenuModel* model) {
|
||||
std::string ret;
|
||||
for (int i = 0; i < model->GetItemCount(); ++i) {
|
||||
int status = model->GetTypeAt(i) | (model->IsVisibleAt(i) << 3) |
|
||||
(model->IsEnabledAt(i) << 4) |
|
||||
(model->IsItemCheckedAt(i) << 5);
|
||||
ret += base::StringPrintf(
|
||||
"%s-%X\n", base::UTF16ToUTF8(model->GetLabelAt(i)).c_str(), status);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
GlobalMenuBarX11::GlobalMenuBarX11(NativeWindowViews* window)
|
||||
: window_(window),
|
||||
xid_(window_->GetNativeWindow()->GetHost()->GetAcceleratedWidget()) {
|
||||
EnsureMethodsLoaded();
|
||||
if (server_new)
|
||||
InitServer(xid_);
|
||||
|
||||
GlobalMenuBarRegistrarX11::GetInstance()->OnWindowMapped(xid_);
|
||||
}
|
||||
|
||||
GlobalMenuBarX11::~GlobalMenuBarX11() {
|
||||
if (IsServerStarted())
|
||||
g_object_unref(server_);
|
||||
|
||||
GlobalMenuBarRegistrarX11::GetInstance()->OnWindowUnmapped(xid_);
|
||||
}
|
||||
|
||||
// static
|
||||
std::string GlobalMenuBarX11::GetPathForWindow(gfx::AcceleratedWidget xid) {
|
||||
return base::StringPrintf("/com/canonical/menu/%lX", xid);
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::SetMenu(AtomMenuModel* menu_model) {
|
||||
if (!IsServerStarted())
|
||||
return;
|
||||
|
||||
DbusmenuMenuitem* root_item = menuitem_new();
|
||||
menuitem_property_set(root_item, kPropertyLabel, "Root");
|
||||
menuitem_property_set_bool(root_item, kPropertyVisible, true);
|
||||
if (menu_model != nullptr) {
|
||||
BuildMenuFromModel(menu_model, root_item);
|
||||
}
|
||||
|
||||
server_set_root(server_, root_item);
|
||||
g_object_unref(root_item);
|
||||
}
|
||||
|
||||
bool GlobalMenuBarX11::IsServerStarted() const {
|
||||
return server_;
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::InitServer(gfx::AcceleratedWidget xid) {
|
||||
std::string path = GetPathForWindow(xid);
|
||||
server_ = server_new(path.c_str());
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::OnWindowMapped() {
|
||||
GlobalMenuBarRegistrarX11::GetInstance()->OnWindowMapped(xid_);
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::OnWindowUnmapped() {
|
||||
GlobalMenuBarRegistrarX11::GetInstance()->OnWindowUnmapped(xid_);
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::BuildMenuFromModel(AtomMenuModel* model,
|
||||
DbusmenuMenuitem* parent) {
|
||||
for (int i = 0; i < model->GetItemCount(); ++i) {
|
||||
DbusmenuMenuitem* item = menuitem_new();
|
||||
menuitem_property_set_bool(item, kPropertyVisible, model->IsVisibleAt(i));
|
||||
|
||||
AtomMenuModel::ItemType type = model->GetTypeAt(i);
|
||||
if (type == AtomMenuModel::TYPE_SEPARATOR) {
|
||||
menuitem_property_set(item, kPropertyType, kTypeSeparator);
|
||||
} else {
|
||||
std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
|
||||
base::UTF16ToUTF8(model->GetLabelAt(i)));
|
||||
menuitem_property_set(item, kPropertyLabel, label.c_str());
|
||||
menuitem_property_set_bool(item, kPropertyEnabled, model->IsEnabledAt(i));
|
||||
|
||||
g_object_set_data(G_OBJECT(item), "model", model);
|
||||
SetMenuItemID(item, i);
|
||||
|
||||
if (type == AtomMenuModel::TYPE_SUBMENU) {
|
||||
menuitem_property_set(item, kPropertyChildrenDisplay, kDisplaySubmenu);
|
||||
g_signal_connect(item, "about-to-show", G_CALLBACK(OnSubMenuShowThunk),
|
||||
this);
|
||||
} else {
|
||||
ui::Accelerator accelerator;
|
||||
if (model->GetAcceleratorAtWithParams(i, true, &accelerator))
|
||||
RegisterAccelerator(item, accelerator);
|
||||
|
||||
g_signal_connect(item, "item-activated",
|
||||
G_CALLBACK(OnItemActivatedThunk), this);
|
||||
|
||||
if (type == AtomMenuModel::TYPE_CHECK ||
|
||||
type == AtomMenuModel::TYPE_RADIO) {
|
||||
menuitem_property_set(
|
||||
item, kPropertyToggleType,
|
||||
type == AtomMenuModel::TYPE_CHECK ? kToggleCheck : kToggleRadio);
|
||||
menuitem_property_set_int(item, kPropertyToggleState,
|
||||
model->IsItemCheckedAt(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
menuitem_child_append(parent, item);
|
||||
g_object_unref(item);
|
||||
}
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::RegisterAccelerator(DbusmenuMenuitem* item,
|
||||
const ui::Accelerator& accelerator) {
|
||||
// A translation of libdbusmenu-gtk's menuitem_property_set_shortcut()
|
||||
// translated from GDK types to ui::Accelerator types.
|
||||
GVariantBuilder builder;
|
||||
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
|
||||
|
||||
if (accelerator.IsCtrlDown())
|
||||
g_variant_builder_add(&builder, "s", "Control");
|
||||
if (accelerator.IsAltDown())
|
||||
g_variant_builder_add(&builder, "s", "Alt");
|
||||
if (accelerator.IsShiftDown())
|
||||
g_variant_builder_add(&builder, "s", "Shift");
|
||||
|
||||
char* name =
|
||||
XKeysymToString(XKeysymForWindowsKeyCode(accelerator.key_code(), false));
|
||||
if (!name) {
|
||||
NOTIMPLEMENTED();
|
||||
return;
|
||||
}
|
||||
g_variant_builder_add(&builder, "s", name);
|
||||
|
||||
GVariant* inside_array = g_variant_builder_end(&builder);
|
||||
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
|
||||
g_variant_builder_add_value(&builder, inside_array);
|
||||
GVariant* outside_array = g_variant_builder_end(&builder);
|
||||
|
||||
menuitem_property_set_variant(item, kPropertyShortcut, outside_array);
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::OnItemActivated(DbusmenuMenuitem* item,
|
||||
unsigned int timestamp) {
|
||||
int id;
|
||||
AtomMenuModel* model = ModelForMenuItem(item);
|
||||
if (model && GetMenuItemID(item, &id))
|
||||
model->ActivatedAt(id, 0);
|
||||
}
|
||||
|
||||
void GlobalMenuBarX11::OnSubMenuShow(DbusmenuMenuitem* item) {
|
||||
int id;
|
||||
AtomMenuModel* model = ModelForMenuItem(item);
|
||||
if (!model || !GetMenuItemID(item, &id))
|
||||
return;
|
||||
|
||||
// Do not update menu if the submenu has not been changed.
|
||||
std::string status = GetMenuModelStatus(model);
|
||||
char* old = static_cast<char*>(g_object_get_data(G_OBJECT(item), "status"));
|
||||
if (old && status == old)
|
||||
return;
|
||||
|
||||
// Save the new status.
|
||||
g_object_set_data_full(G_OBJECT(item), "status", g_strdup(status.c_str()),
|
||||
g_free);
|
||||
|
||||
// Clear children.
|
||||
GList* children = menuitem_take_children(item);
|
||||
g_list_foreach(children, reinterpret_cast<GFunc>(g_object_unref), NULL);
|
||||
g_list_free(children);
|
||||
|
||||
// Build children.
|
||||
BuildMenuFromModel(model->GetSubmenuModelAt(id), item);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
81
shell/browser/ui/views/global_menu_bar_x11.h
Normal file
81
shell/browser/ui/views/global_menu_bar_x11.h
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_GLOBAL_MENU_BAR_X11_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_GLOBAL_MENU_BAR_X11_H_
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "atom/browser/ui/atom_menu_model.h"
|
||||
#include "base/compiler_specific.h"
|
||||
#include "base/macros.h"
|
||||
#include "ui/base/glib/glib_signal.h"
|
||||
#include "ui/gfx/native_widget_types.h"
|
||||
|
||||
typedef struct _DbusmenuMenuitem DbusmenuMenuitem;
|
||||
typedef struct _DbusmenuServer DbusmenuServer;
|
||||
|
||||
namespace ui {
|
||||
class Accelerator;
|
||||
}
|
||||
|
||||
namespace atom {
|
||||
|
||||
class NativeWindowViews;
|
||||
|
||||
// Controls the Mac style menu bar on Unity.
|
||||
//
|
||||
// Unity has an Apple-like menu bar at the top of the screen that changes
|
||||
// depending on the active window. In the GTK port, we had a hidden GtkMenuBar
|
||||
// object in each GtkWindow which existed only to be scrapped by the
|
||||
// libdbusmenu-gtk code. Since we don't have GtkWindows anymore, we need to
|
||||
// interface directly with the lower level libdbusmenu-glib, which we
|
||||
// opportunistically dlopen() since not everyone is running Ubuntu.
|
||||
//
|
||||
// This class is like the chrome's corresponding one, but it generates the menu
|
||||
// from menu models instead, and it is also per-window specific.
|
||||
class GlobalMenuBarX11 {
|
||||
public:
|
||||
explicit GlobalMenuBarX11(NativeWindowViews* window);
|
||||
virtual ~GlobalMenuBarX11();
|
||||
|
||||
// Creates the object path for DbusmenuServer which is attached to |xid|.
|
||||
static std::string GetPathForWindow(gfx::AcceleratedWidget xid);
|
||||
|
||||
void SetMenu(AtomMenuModel* menu_model);
|
||||
bool IsServerStarted() const;
|
||||
|
||||
// Called by NativeWindow when it show/hides.
|
||||
void OnWindowMapped();
|
||||
void OnWindowUnmapped();
|
||||
|
||||
private:
|
||||
// Creates a DbusmenuServer.
|
||||
void InitServer(gfx::AcceleratedWidget xid);
|
||||
|
||||
// Create a menu from menu model.
|
||||
void BuildMenuFromModel(AtomMenuModel* model, DbusmenuMenuitem* parent);
|
||||
|
||||
// Sets the accelerator for |item|.
|
||||
void RegisterAccelerator(DbusmenuMenuitem* item,
|
||||
const ui::Accelerator& accelerator);
|
||||
|
||||
CHROMEG_CALLBACK_1(GlobalMenuBarX11,
|
||||
void,
|
||||
OnItemActivated,
|
||||
DbusmenuMenuitem*,
|
||||
unsigned int);
|
||||
CHROMEG_CALLBACK_0(GlobalMenuBarX11, void, OnSubMenuShow, DbusmenuMenuitem*);
|
||||
|
||||
NativeWindowViews* window_;
|
||||
gfx::AcceleratedWidget xid_;
|
||||
|
||||
DbusmenuServer* server_ = nullptr;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(GlobalMenuBarX11);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_GLOBAL_MENU_BAR_X11_H_
|
||||
235
shell/browser/ui/views/inspectable_web_contents_view_views.cc
Normal file
235
shell/browser/ui/views/inspectable_web_contents_view_views.cc
Normal file
|
|
@ -0,0 +1,235 @@
|
|||
// Copyright (c) 2014 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-CHROMIUM file.
|
||||
|
||||
#include "atom/browser/ui/views/inspectable_web_contents_view_views.h"
|
||||
|
||||
#include "atom/browser/ui/inspectable_web_contents_delegate.h"
|
||||
#include "atom/browser/ui/inspectable_web_contents_impl.h"
|
||||
#include "atom/browser/ui/inspectable_web_contents_view_delegate.h"
|
||||
#include "base/strings/utf_string_conversions.h"
|
||||
#include "ui/views/controls/label.h"
|
||||
#include "ui/views/controls/webview/webview.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
#include "ui/views/widget/widget_delegate.h"
|
||||
#include "ui/views/window/client_view.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
class DevToolsWindowDelegate : public views::ClientView,
|
||||
public views::WidgetDelegate {
|
||||
public:
|
||||
DevToolsWindowDelegate(InspectableWebContentsViewViews* shell,
|
||||
views::View* view,
|
||||
views::Widget* widget)
|
||||
: views::ClientView(widget, view),
|
||||
shell_(shell),
|
||||
view_(view),
|
||||
widget_(widget) {
|
||||
// A WidgetDelegate should be deleted on DeleteDelegate.
|
||||
set_owned_by_client();
|
||||
|
||||
if (shell->GetDelegate())
|
||||
icon_ = shell->GetDelegate()->GetDevToolsWindowIcon();
|
||||
}
|
||||
~DevToolsWindowDelegate() override {}
|
||||
|
||||
// views::WidgetDelegate:
|
||||
void DeleteDelegate() override { delete this; }
|
||||
views::View* GetInitiallyFocusedView() override { return view_; }
|
||||
bool CanResize() const override { return true; }
|
||||
bool CanMaximize() const override { return true; }
|
||||
bool CanMinimize() const override { return true; }
|
||||
base::string16 GetWindowTitle() const override { return shell_->GetTitle(); }
|
||||
gfx::ImageSkia GetWindowAppIcon() override { return GetWindowIcon(); }
|
||||
gfx::ImageSkia GetWindowIcon() override { return icon_; }
|
||||
views::Widget* GetWidget() override { return widget_; }
|
||||
const views::Widget* GetWidget() const override { return widget_; }
|
||||
views::View* GetContentsView() override { return view_; }
|
||||
views::ClientView* CreateClientView(views::Widget* widget) override {
|
||||
return this;
|
||||
}
|
||||
|
||||
// views::ClientView:
|
||||
bool CanClose() override {
|
||||
shell_->inspectable_web_contents()->CloseDevTools();
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
InspectableWebContentsViewViews* shell_;
|
||||
views::View* view_;
|
||||
views::Widget* widget_;
|
||||
gfx::ImageSkia icon_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(DevToolsWindowDelegate);
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
InspectableWebContentsView* CreateInspectableContentsView(
|
||||
InspectableWebContentsImpl* inspectable_web_contents) {
|
||||
return new InspectableWebContentsViewViews(inspectable_web_contents);
|
||||
}
|
||||
|
||||
InspectableWebContentsViewViews::InspectableWebContentsViewViews(
|
||||
InspectableWebContentsImpl* inspectable_web_contents)
|
||||
: inspectable_web_contents_(inspectable_web_contents),
|
||||
devtools_window_web_view_(nullptr),
|
||||
contents_web_view_(nullptr),
|
||||
devtools_web_view_(new views::WebView(nullptr)),
|
||||
devtools_visible_(false),
|
||||
devtools_window_delegate_(nullptr),
|
||||
title_(base::ASCIIToUTF16("Developer Tools")) {
|
||||
set_owned_by_client();
|
||||
|
||||
if (!inspectable_web_contents_->IsGuest() &&
|
||||
inspectable_web_contents_->GetWebContents()->GetNativeView()) {
|
||||
views::WebView* contents_web_view = new views::WebView(nullptr);
|
||||
contents_web_view->SetWebContents(
|
||||
inspectable_web_contents_->GetWebContents());
|
||||
contents_web_view_ = contents_web_view;
|
||||
} else {
|
||||
contents_web_view_ =
|
||||
new views::Label(base::ASCIIToUTF16("No content under offscreen mode"));
|
||||
}
|
||||
|
||||
devtools_web_view_->SetVisible(false);
|
||||
AddChildView(devtools_web_view_);
|
||||
AddChildView(contents_web_view_);
|
||||
}
|
||||
|
||||
InspectableWebContentsViewViews::~InspectableWebContentsViewViews() {
|
||||
if (devtools_window_)
|
||||
inspectable_web_contents()->SaveDevToolsBounds(
|
||||
devtools_window_->GetWindowBoundsInScreen());
|
||||
}
|
||||
|
||||
views::View* InspectableWebContentsViewViews::GetView() {
|
||||
return this;
|
||||
}
|
||||
|
||||
views::View* InspectableWebContentsViewViews::GetWebView() {
|
||||
return contents_web_view_;
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::ShowDevTools(bool activate) {
|
||||
if (devtools_visible_)
|
||||
return;
|
||||
|
||||
devtools_visible_ = true;
|
||||
if (devtools_window_) {
|
||||
devtools_window_web_view_->SetWebContents(
|
||||
inspectable_web_contents_->GetDevToolsWebContents());
|
||||
devtools_window_->SetBounds(
|
||||
inspectable_web_contents()->GetDevToolsBounds());
|
||||
if (activate) {
|
||||
devtools_window_->Show();
|
||||
} else {
|
||||
devtools_window_->ShowInactive();
|
||||
}
|
||||
} else {
|
||||
devtools_web_view_->SetVisible(true);
|
||||
devtools_web_view_->SetWebContents(
|
||||
inspectable_web_contents_->GetDevToolsWebContents());
|
||||
devtools_web_view_->RequestFocus();
|
||||
Layout();
|
||||
}
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::CloseDevTools() {
|
||||
if (!devtools_visible_)
|
||||
return;
|
||||
|
||||
devtools_visible_ = false;
|
||||
if (devtools_window_) {
|
||||
inspectable_web_contents()->SaveDevToolsBounds(
|
||||
devtools_window_->GetWindowBoundsInScreen());
|
||||
devtools_window_.reset();
|
||||
devtools_window_web_view_ = nullptr;
|
||||
devtools_window_delegate_ = nullptr;
|
||||
} else {
|
||||
devtools_web_view_->SetVisible(false);
|
||||
devtools_web_view_->SetWebContents(NULL);
|
||||
Layout();
|
||||
}
|
||||
}
|
||||
|
||||
bool InspectableWebContentsViewViews::IsDevToolsViewShowing() {
|
||||
return devtools_visible_;
|
||||
}
|
||||
|
||||
bool InspectableWebContentsViewViews::IsDevToolsViewFocused() {
|
||||
if (devtools_window_web_view_)
|
||||
return devtools_window_web_view_->HasFocus();
|
||||
else if (devtools_web_view_)
|
||||
return devtools_web_view_->HasFocus();
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::SetIsDocked(bool docked, bool activate) {
|
||||
CloseDevTools();
|
||||
|
||||
if (!docked) {
|
||||
devtools_window_.reset(new views::Widget);
|
||||
devtools_window_web_view_ = new views::WebView(NULL);
|
||||
devtools_window_delegate_ = new DevToolsWindowDelegate(
|
||||
this, devtools_window_web_view_, devtools_window_.get());
|
||||
|
||||
views::Widget::InitParams params;
|
||||
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
|
||||
params.delegate = devtools_window_delegate_;
|
||||
params.bounds = inspectable_web_contents()->GetDevToolsBounds();
|
||||
|
||||
#if defined(USE_X11)
|
||||
params.wm_role_name = "devtools";
|
||||
if (GetDelegate())
|
||||
GetDelegate()->GetDevToolsWindowWMClass(¶ms.wm_class_name,
|
||||
¶ms.wm_class_class);
|
||||
#endif
|
||||
|
||||
devtools_window_->Init(params);
|
||||
devtools_window_->UpdateWindowIcon();
|
||||
}
|
||||
|
||||
ShowDevTools(activate);
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::SetContentsResizingStrategy(
|
||||
const DevToolsContentsResizingStrategy& strategy) {
|
||||
strategy_.CopyFrom(strategy);
|
||||
Layout();
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::SetTitle(const base::string16& title) {
|
||||
if (devtools_window_) {
|
||||
title_ = title;
|
||||
devtools_window_->UpdateWindowTitle();
|
||||
}
|
||||
}
|
||||
|
||||
void InspectableWebContentsViewViews::Layout() {
|
||||
if (!devtools_web_view_->GetVisible()) {
|
||||
contents_web_view_->SetBoundsRect(GetContentsBounds());
|
||||
return;
|
||||
}
|
||||
|
||||
gfx::Size container_size(width(), height());
|
||||
gfx::Rect new_devtools_bounds;
|
||||
gfx::Rect new_contents_bounds;
|
||||
ApplyDevToolsContentsResizingStrategy(
|
||||
strategy_, container_size, &new_devtools_bounds, &new_contents_bounds);
|
||||
|
||||
// DevTools cares about the specific position, so we have to compensate RTL
|
||||
// layout here.
|
||||
new_devtools_bounds.set_x(GetMirroredXForRect(new_devtools_bounds));
|
||||
new_contents_bounds.set_x(GetMirroredXForRect(new_contents_bounds));
|
||||
|
||||
devtools_web_view_->SetBoundsRect(new_devtools_bounds);
|
||||
contents_web_view_->SetBoundsRect(new_contents_bounds);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
72
shell/browser/ui/views/inspectable_web_contents_view_views.h
Normal file
72
shell/browser/ui/views/inspectable_web_contents_view_views.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
// Copyright (c) 2014 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-CHROMIUM file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_INSPECTABLE_WEB_CONTENTS_VIEW_VIEWS_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_INSPECTABLE_WEB_CONTENTS_VIEW_VIEWS_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "atom/browser/ui/inspectable_web_contents_view.h"
|
||||
#include "base/compiler_specific.h"
|
||||
#include "chrome/browser/devtools/devtools_contents_resizing_strategy.h"
|
||||
#include "ui/views/view.h"
|
||||
|
||||
namespace views {
|
||||
class WebView;
|
||||
class Widget;
|
||||
class WidgetDelegate;
|
||||
} // namespace views
|
||||
|
||||
namespace atom {
|
||||
|
||||
class InspectableWebContentsImpl;
|
||||
|
||||
class InspectableWebContentsViewViews : public InspectableWebContentsView,
|
||||
public views::View {
|
||||
public:
|
||||
explicit InspectableWebContentsViewViews(
|
||||
InspectableWebContentsImpl* inspectable_web_contents_impl);
|
||||
~InspectableWebContentsViewViews() override;
|
||||
|
||||
// InspectableWebContentsView:
|
||||
views::View* GetView() override;
|
||||
views::View* GetWebView() override;
|
||||
void ShowDevTools(bool activate) override;
|
||||
void CloseDevTools() override;
|
||||
bool IsDevToolsViewShowing() override;
|
||||
bool IsDevToolsViewFocused() override;
|
||||
void SetIsDocked(bool docked, bool activate) override;
|
||||
void SetContentsResizingStrategy(
|
||||
const DevToolsContentsResizingStrategy& strategy) override;
|
||||
void SetTitle(const base::string16& title) override;
|
||||
|
||||
InspectableWebContentsImpl* inspectable_web_contents() {
|
||||
return inspectable_web_contents_;
|
||||
}
|
||||
|
||||
const base::string16& GetTitle() const { return title_; }
|
||||
|
||||
private:
|
||||
// views::View:
|
||||
void Layout() override;
|
||||
|
||||
// Owns us.
|
||||
InspectableWebContentsImpl* inspectable_web_contents_;
|
||||
|
||||
std::unique_ptr<views::Widget> devtools_window_;
|
||||
views::WebView* devtools_window_web_view_;
|
||||
views::View* contents_web_view_;
|
||||
views::WebView* devtools_web_view_;
|
||||
|
||||
DevToolsContentsResizingStrategy strategy_;
|
||||
bool devtools_visible_;
|
||||
views::WidgetDelegate* devtools_window_delegate_;
|
||||
base::string16 title_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(InspectableWebContentsViewViews);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_INSPECTABLE_WEB_CONTENTS_VIEW_VIEWS_H_
|
||||
349
shell/browser/ui/views/menu_bar.cc
Normal file
349
shell/browser/ui/views/menu_bar.cc
Normal file
|
|
@ -0,0 +1,349 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/menu_bar.h"
|
||||
|
||||
#include <memory>
|
||||
#include <set>
|
||||
#include <sstream>
|
||||
|
||||
#include "atom/browser/ui/views/submenu_button.h"
|
||||
#include "atom/common/keyboard_util.h"
|
||||
#include "ui/aura/window.h"
|
||||
#include "ui/base/models/menu_model.h"
|
||||
#include "ui/views/background.h"
|
||||
#include "ui/views/layout/box_layout.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
|
||||
#if defined(USE_X11)
|
||||
#include "chrome/browser/ui/libgtkui/gtk_util.h"
|
||||
#endif
|
||||
|
||||
#if defined(OS_WIN)
|
||||
#include "ui/gfx/color_utils.h"
|
||||
#endif
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
// Default color of the menu bar.
|
||||
const SkColor kDefaultColor = SkColorSetARGB(255, 233, 233, 233);
|
||||
|
||||
} // namespace
|
||||
|
||||
const char MenuBar::kViewClassName[] = "ElectronMenuBar";
|
||||
|
||||
MenuBarColorUpdater::MenuBarColorUpdater(MenuBar* menu_bar)
|
||||
: menu_bar_(menu_bar) {}
|
||||
|
||||
MenuBarColorUpdater::~MenuBarColorUpdater() {}
|
||||
|
||||
void MenuBarColorUpdater::OnDidChangeFocus(views::View* focused_before,
|
||||
views::View* focused_now) {
|
||||
if (menu_bar_) {
|
||||
// if we've changed window focus, update menu bar colors
|
||||
const auto had_focus = menu_bar_->has_focus_;
|
||||
menu_bar_->has_focus_ = focused_now != nullptr;
|
||||
if (menu_bar_->has_focus_ != had_focus)
|
||||
menu_bar_->UpdateViewColors();
|
||||
}
|
||||
}
|
||||
|
||||
MenuBar::MenuBar(RootView* window)
|
||||
: background_color_(kDefaultColor),
|
||||
window_(window),
|
||||
color_updater_(new MenuBarColorUpdater(this)) {
|
||||
RefreshColorCache();
|
||||
UpdateViewColors();
|
||||
SetFocusBehavior(FocusBehavior::ALWAYS);
|
||||
SetLayoutManager(
|
||||
std::make_unique<views::BoxLayout>(views::BoxLayout::kHorizontal));
|
||||
window_->GetFocusManager()->AddFocusChangeListener(color_updater_.get());
|
||||
}
|
||||
|
||||
MenuBar::~MenuBar() {
|
||||
window_->GetFocusManager()->RemoveFocusChangeListener(color_updater_.get());
|
||||
}
|
||||
|
||||
void MenuBar::SetMenu(AtomMenuModel* model) {
|
||||
menu_model_ = model;
|
||||
RebuildChildren();
|
||||
}
|
||||
|
||||
void MenuBar::SetAcceleratorVisibility(bool visible) {
|
||||
for (auto* child : GetChildrenInZOrder())
|
||||
static_cast<SubmenuButton*>(child)->SetAcceleratorVisibility(visible);
|
||||
}
|
||||
|
||||
MenuBar::View* MenuBar::FindAccelChild(base::char16 key) {
|
||||
for (auto* child : GetChildrenInZOrder()) {
|
||||
if (static_cast<SubmenuButton*>(child)->accelerator() == key)
|
||||
return child;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool MenuBar::HasAccelerator(base::char16 key) {
|
||||
return FindAccelChild(key) != nullptr;
|
||||
}
|
||||
|
||||
void MenuBar::ActivateAccelerator(base::char16 key) {
|
||||
auto* child = FindAccelChild(key);
|
||||
if (child)
|
||||
static_cast<SubmenuButton*>(child)->Activate(nullptr);
|
||||
}
|
||||
|
||||
int MenuBar::GetItemCount() const {
|
||||
return menu_model_ ? menu_model_->GetItemCount() : 0;
|
||||
}
|
||||
|
||||
bool MenuBar::GetMenuButtonFromScreenPoint(const gfx::Point& screenPoint,
|
||||
AtomMenuModel** menu_model,
|
||||
views::MenuButton** button) {
|
||||
if (!GetBoundsInScreen().Contains(screenPoint))
|
||||
return false;
|
||||
|
||||
auto children = GetChildrenInZOrder();
|
||||
for (int i = 0, n = children.size(); i < n; ++i) {
|
||||
if (children[i]->GetBoundsInScreen().Contains(screenPoint) &&
|
||||
(menu_model_->GetTypeAt(i) == AtomMenuModel::TYPE_SUBMENU)) {
|
||||
*menu_model = menu_model_->GetSubmenuModelAt(i);
|
||||
*button = static_cast<views::MenuButton*>(children[i]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void MenuBar::OnBeforeExecuteCommand() {
|
||||
if (GetPaneFocusTraversable() != nullptr) {
|
||||
RemovePaneFocus();
|
||||
}
|
||||
window_->RestoreFocus();
|
||||
}
|
||||
|
||||
void MenuBar::OnMenuClosed() {
|
||||
SetAcceleratorVisibility(true);
|
||||
}
|
||||
|
||||
bool MenuBar::AcceleratorPressed(const ui::Accelerator& accelerator) {
|
||||
views::View* focused_view = GetFocusManager()->GetFocusedView();
|
||||
if (!ContainsForFocusSearch(this, focused_view))
|
||||
return false;
|
||||
|
||||
switch (accelerator.key_code()) {
|
||||
case ui::VKEY_MENU:
|
||||
case ui::VKEY_ESCAPE: {
|
||||
RemovePaneFocus();
|
||||
window_->RestoreFocus();
|
||||
return true;
|
||||
}
|
||||
case ui::VKEY_LEFT:
|
||||
GetFocusManager()->AdvanceFocus(true);
|
||||
return true;
|
||||
case ui::VKEY_RIGHT:
|
||||
GetFocusManager()->AdvanceFocus(false);
|
||||
return true;
|
||||
case ui::VKEY_HOME:
|
||||
GetFocusManager()->SetFocusedViewWithReason(
|
||||
GetFirstFocusableChild(), views::FocusManager::kReasonFocusTraversal);
|
||||
return true;
|
||||
case ui::VKEY_END:
|
||||
GetFocusManager()->SetFocusedViewWithReason(
|
||||
GetLastFocusableChild(), views::FocusManager::kReasonFocusTraversal);
|
||||
return true;
|
||||
default: {
|
||||
auto children = GetChildrenInZOrder();
|
||||
for (int i = 0, n = children.size(); i < n; ++i) {
|
||||
auto* button = static_cast<SubmenuButton*>(children[i]);
|
||||
bool shifted = false;
|
||||
auto keycode =
|
||||
atom::KeyboardCodeFromCharCode(button->accelerator(), &shifted);
|
||||
|
||||
if (keycode == accelerator.key_code()) {
|
||||
const gfx::Point p(0, 0);
|
||||
auto event = accelerator.ToKeyEvent();
|
||||
OnMenuButtonClicked(button, p, &event);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool MenuBar::SetPaneFocus(views::View* initial_focus) {
|
||||
// TODO(zcbenz): Submit patch to upstream Chromium to fix the crash.
|
||||
//
|
||||
// Without this check, Electron would crash when running tests.
|
||||
//
|
||||
// Check failed: rules_->CanFocusWindow(window, nullptr).
|
||||
// logging::LogMessage::~LogMessage
|
||||
// wm::FocusController::SetFocusedWindow
|
||||
// wm::FocusController::ResetFocusWithinActiveWindow
|
||||
// views::View::OnFocus
|
||||
// views::Button::OnFocus
|
||||
// views::LabelButton::OnFocus
|
||||
// views::View::Focus
|
||||
// views::FocusManager::SetFocusedViewWithReason
|
||||
// views::AccessiblePaneView::SetPaneFocus
|
||||
// atom::MenuBar::SetPaneFocus
|
||||
if (initial_focus && initial_focus->GetWidget()) {
|
||||
aura::Window* window = initial_focus->GetWidget()->GetNativeWindow();
|
||||
if (!window || !window->GetRootWindow())
|
||||
return false;
|
||||
}
|
||||
|
||||
bool result = views::AccessiblePaneView::SetPaneFocus(initial_focus);
|
||||
|
||||
if (result) {
|
||||
auto children = GetChildrenInZOrder();
|
||||
std::set<ui::KeyboardCode> reg;
|
||||
for (int i = 0, n = children.size(); i < n; ++i) {
|
||||
auto* button = static_cast<SubmenuButton*>(children[i]);
|
||||
bool shifted = false;
|
||||
auto keycode =
|
||||
atom::KeyboardCodeFromCharCode(button->accelerator(), &shifted);
|
||||
|
||||
// We want the menu items to activate if the user presses the accelerator
|
||||
// key, even without alt, since we are now focused on the menu bar
|
||||
if (keycode != ui::VKEY_UNKNOWN && reg.find(keycode) != reg.end()) {
|
||||
reg.insert(keycode);
|
||||
focus_manager()->RegisterAccelerator(
|
||||
ui::Accelerator(keycode, ui::EF_NONE),
|
||||
ui::AcceleratorManager::kNormalPriority, this);
|
||||
}
|
||||
}
|
||||
|
||||
// We want to remove focus / hide menu bar when alt is pressed again
|
||||
focus_manager()->RegisterAccelerator(
|
||||
ui::Accelerator(ui::VKEY_MENU, ui::EF_ALT_DOWN),
|
||||
ui::AcceleratorManager::kNormalPriority, this);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void MenuBar::RemovePaneFocus() {
|
||||
views::AccessiblePaneView::RemovePaneFocus();
|
||||
SetAcceleratorVisibility(false);
|
||||
|
||||
auto children = GetChildrenInZOrder();
|
||||
std::set<ui::KeyboardCode> unreg;
|
||||
for (int i = 0, n = children.size(); i < n; ++i) {
|
||||
auto* button = static_cast<SubmenuButton*>(children[i]);
|
||||
bool shifted = false;
|
||||
auto keycode =
|
||||
atom::KeyboardCodeFromCharCode(button->accelerator(), &shifted);
|
||||
|
||||
if (keycode != ui::VKEY_UNKNOWN && unreg.find(keycode) != unreg.end()) {
|
||||
unreg.insert(keycode);
|
||||
focus_manager()->UnregisterAccelerator(
|
||||
ui::Accelerator(keycode, ui::EF_NONE), this);
|
||||
}
|
||||
}
|
||||
|
||||
focus_manager()->UnregisterAccelerator(
|
||||
ui::Accelerator(ui::VKEY_MENU, ui::EF_ALT_DOWN), this);
|
||||
}
|
||||
|
||||
const char* MenuBar::GetClassName() const {
|
||||
return kViewClassName;
|
||||
}
|
||||
|
||||
void MenuBar::OnMenuButtonClicked(views::Button* source,
|
||||
const gfx::Point& point,
|
||||
const ui::Event* event) {
|
||||
// Hide the accelerator when a submenu is activated.
|
||||
SetAcceleratorVisibility(false);
|
||||
|
||||
if (!menu_model_)
|
||||
return;
|
||||
|
||||
if (!window_->HasFocus())
|
||||
window_->RequestFocus();
|
||||
|
||||
int id = source->tag();
|
||||
AtomMenuModel::ItemType type = menu_model_->GetTypeAt(id);
|
||||
if (type != AtomMenuModel::TYPE_SUBMENU) {
|
||||
menu_model_->ActivatedAt(id, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
GetFocusManager()->SetFocusedViewWithReason(
|
||||
source, views::FocusManager::kReasonFocusTraversal);
|
||||
|
||||
// Deleted in MenuDelegate::OnMenuClosed
|
||||
MenuDelegate* menu_delegate = new MenuDelegate(this);
|
||||
menu_delegate->RunMenu(menu_model_->GetSubmenuModelAt(id), source,
|
||||
event != nullptr && event->IsKeyEvent()
|
||||
? ui::MENU_SOURCE_KEYBOARD
|
||||
: ui::MENU_SOURCE_MOUSE);
|
||||
menu_delegate->AddObserver(this);
|
||||
}
|
||||
|
||||
void MenuBar::RefreshColorCache() {
|
||||
const ui::NativeTheme* theme = GetNativeTheme();
|
||||
if (theme) {
|
||||
#if defined(USE_X11)
|
||||
background_color_ = libgtkui::GetBgColor("GtkMenuBar#menubar");
|
||||
enabled_color_ = libgtkui::GetFgColor(
|
||||
"GtkMenuBar#menubar GtkMenuItem#menuitem GtkLabel");
|
||||
disabled_color_ = libgtkui::GetFgColor(
|
||||
"GtkMenuBar#menubar GtkMenuItem#menuitem:disabled GtkLabel");
|
||||
#else
|
||||
background_color_ =
|
||||
theme->GetSystemColor(ui::NativeTheme::kColorId_MenuBackgroundColor);
|
||||
#endif
|
||||
}
|
||||
#if defined(OS_WIN)
|
||||
background_color_ = color_utils::GetSysSkColor(COLOR_MENUBAR);
|
||||
#endif
|
||||
}
|
||||
|
||||
void MenuBar::OnThemeChanged() {
|
||||
RefreshColorCache();
|
||||
UpdateViewColors();
|
||||
}
|
||||
|
||||
void MenuBar::RebuildChildren() {
|
||||
RemoveAllChildViews(true);
|
||||
for (int i = 0, n = GetItemCount(); i < n; ++i) {
|
||||
auto* button =
|
||||
new SubmenuButton(menu_model_->GetLabelAt(i), this, background_color_);
|
||||
button->set_tag(i);
|
||||
AddChildView(button);
|
||||
}
|
||||
UpdateViewColors();
|
||||
}
|
||||
|
||||
void MenuBar::UpdateViewColors() {
|
||||
// set menubar background color
|
||||
SetBackground(views::CreateSolidBackground(background_color_));
|
||||
|
||||
// set child colors
|
||||
if (menu_model_ == nullptr)
|
||||
return;
|
||||
#if defined(USE_X11)
|
||||
const auto& textColor = has_focus_ ? enabled_color_ : disabled_color_;
|
||||
for (auto* child : GetChildrenInZOrder()) {
|
||||
auto* button = static_cast<SubmenuButton*>(child);
|
||||
button->SetTextColor(views::Button::STATE_NORMAL, textColor);
|
||||
button->SetTextColor(views::Button::STATE_DISABLED, disabled_color_);
|
||||
button->SetTextColor(views::Button::STATE_PRESSED, enabled_color_);
|
||||
button->SetTextColor(views::Button::STATE_HOVERED, textColor);
|
||||
button->SetUnderlineColor(textColor);
|
||||
}
|
||||
#elif defined(OS_WIN)
|
||||
for (auto* child : GetChildrenInZOrder()) {
|
||||
auto* button = static_cast<SubmenuButton*>(child);
|
||||
button->SetUnderlineColor(color_utils::GetSysSkColor(COLOR_MENUTEXT));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
114
shell/browser/ui/views/menu_bar.h
Normal file
114
shell/browser/ui/views/menu_bar.h
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_MENU_BAR_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_MENU_BAR_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "atom/browser/ui/atom_menu_model.h"
|
||||
#include "atom/browser/ui/views/menu_delegate.h"
|
||||
#include "atom/browser/ui/views/root_view.h"
|
||||
#include "ui/views/accessible_pane_view.h"
|
||||
#include "ui/views/controls/button/menu_button_listener.h"
|
||||
#include "ui/views/focus/focus_manager.h"
|
||||
#include "ui/views/view.h"
|
||||
|
||||
namespace views {
|
||||
class Button;
|
||||
class MenuButton;
|
||||
} // namespace views
|
||||
|
||||
namespace atom {
|
||||
|
||||
class MenuBarColorUpdater : public views::FocusChangeListener {
|
||||
public:
|
||||
explicit MenuBarColorUpdater(MenuBar* menu_bar);
|
||||
~MenuBarColorUpdater() override;
|
||||
|
||||
void OnDidChangeFocus(views::View* focused_before,
|
||||
views::View* focused_now) override;
|
||||
void OnWillChangeFocus(views::View* focused_before,
|
||||
views::View* focused_now) override {}
|
||||
|
||||
private:
|
||||
MenuBar* menu_bar_;
|
||||
};
|
||||
|
||||
class MenuBar : public views::AccessiblePaneView,
|
||||
public views::MenuButtonListener,
|
||||
public atom::MenuDelegate::Observer {
|
||||
public:
|
||||
static const char kViewClassName[];
|
||||
|
||||
explicit MenuBar(RootView* window);
|
||||
~MenuBar() override;
|
||||
|
||||
// Replaces current menu with a new one.
|
||||
void SetMenu(AtomMenuModel* menu_model);
|
||||
|
||||
// Shows underline under accelerators.
|
||||
void SetAcceleratorVisibility(bool visible);
|
||||
|
||||
// Returns true if the submenu has accelerator |key|
|
||||
bool HasAccelerator(base::char16 key);
|
||||
|
||||
// Shows the submenu whose accelerator is |key|.
|
||||
void ActivateAccelerator(base::char16 key);
|
||||
|
||||
// Returns there are how many items in the root menu.
|
||||
int GetItemCount() const;
|
||||
|
||||
// Get the menu under specified screen point.
|
||||
bool GetMenuButtonFromScreenPoint(const gfx::Point& point,
|
||||
AtomMenuModel** menu_model,
|
||||
views::MenuButton** button);
|
||||
|
||||
// atom::MenuDelegate::Observer:
|
||||
void OnBeforeExecuteCommand() override;
|
||||
void OnMenuClosed() override;
|
||||
|
||||
// views::AccessiblePaneView:
|
||||
bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
|
||||
bool SetPaneFocus(views::View* initial_focus) override;
|
||||
void RemovePaneFocus() override;
|
||||
|
||||
protected:
|
||||
// views::View:
|
||||
const char* GetClassName() const override;
|
||||
|
||||
// views::MenuButtonListener:
|
||||
void OnMenuButtonClicked(views::Button* source,
|
||||
const gfx::Point& point,
|
||||
const ui::Event* event) override;
|
||||
void OnThemeChanged() override;
|
||||
|
||||
private:
|
||||
friend class MenuBarColorUpdater;
|
||||
|
||||
void RebuildChildren();
|
||||
void UpdateViewColors();
|
||||
|
||||
void RefreshColorCache();
|
||||
SkColor background_color_;
|
||||
#if defined(USE_X11)
|
||||
SkColor enabled_color_;
|
||||
SkColor disabled_color_;
|
||||
#endif
|
||||
|
||||
RootView* window_ = nullptr;
|
||||
AtomMenuModel* menu_model_ = nullptr;
|
||||
|
||||
View* FindAccelChild(base::char16 key);
|
||||
|
||||
bool has_focus_ = true;
|
||||
|
||||
std::unique_ptr<MenuBarColorUpdater> color_updater_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(MenuBar);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_MENU_BAR_H_
|
||||
143
shell/browser/ui/views/menu_delegate.cc
Normal file
143
shell/browser/ui/views/menu_delegate.cc
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/menu_delegate.h"
|
||||
|
||||
#include "atom/browser/ui/views/menu_bar.h"
|
||||
#include "atom/browser/ui/views/menu_model_adapter.h"
|
||||
#include "base/task/post_task.h"
|
||||
#include "content/public/browser/browser_task_traits.h"
|
||||
#include "content/public/browser/browser_thread.h"
|
||||
#include "ui/views/controls/button/menu_button.h"
|
||||
#include "ui/views/controls/menu/menu_item_view.h"
|
||||
#include "ui/views/controls/menu/menu_runner.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
MenuDelegate::MenuDelegate(MenuBar* menu_bar)
|
||||
: menu_bar_(menu_bar), id_(-1), hold_first_switch_(false) {}
|
||||
|
||||
MenuDelegate::~MenuDelegate() {}
|
||||
|
||||
void MenuDelegate::RunMenu(AtomMenuModel* model,
|
||||
views::Button* button,
|
||||
ui::MenuSourceType source_type) {
|
||||
gfx::Point screen_loc;
|
||||
views::View::ConvertPointToScreen(button, &screen_loc);
|
||||
// Subtract 1 from the height to make the popup flush with the button border.
|
||||
gfx::Rect bounds(screen_loc.x(), screen_loc.y(), button->width(),
|
||||
button->height() - 1);
|
||||
|
||||
if (source_type == ui::MENU_SOURCE_KEYBOARD) {
|
||||
hold_first_switch_ = true;
|
||||
}
|
||||
|
||||
id_ = button->tag();
|
||||
adapter_.reset(new MenuModelAdapter(model));
|
||||
|
||||
views::MenuItemView* item = new views::MenuItemView(this);
|
||||
static_cast<MenuModelAdapter*>(adapter_.get())->BuildMenu(item);
|
||||
|
||||
menu_runner_.reset(new views::MenuRunner(
|
||||
item,
|
||||
views::MenuRunner::CONTEXT_MENU | views::MenuRunner::HAS_MNEMONICS));
|
||||
menu_runner_->RunMenuAt(
|
||||
button->GetWidget()->GetTopLevelWidget(),
|
||||
static_cast<views::MenuButton*>(button)->button_controller(), bounds,
|
||||
views::MenuAnchorPosition::kTopRight, source_type);
|
||||
}
|
||||
|
||||
void MenuDelegate::ExecuteCommand(int id) {
|
||||
for (Observer& obs : observers_)
|
||||
obs.OnBeforeExecuteCommand();
|
||||
adapter_->ExecuteCommand(id);
|
||||
}
|
||||
|
||||
void MenuDelegate::ExecuteCommand(int id, int mouse_event_flags) {
|
||||
for (Observer& obs : observers_)
|
||||
obs.OnBeforeExecuteCommand();
|
||||
adapter_->ExecuteCommand(id, mouse_event_flags);
|
||||
}
|
||||
|
||||
bool MenuDelegate::IsTriggerableEvent(views::MenuItemView* source,
|
||||
const ui::Event& e) {
|
||||
return adapter_->IsTriggerableEvent(source, e);
|
||||
}
|
||||
|
||||
bool MenuDelegate::GetAccelerator(int id, ui::Accelerator* accelerator) const {
|
||||
return adapter_->GetAccelerator(id, accelerator);
|
||||
}
|
||||
|
||||
base::string16 MenuDelegate::GetLabel(int id) const {
|
||||
return adapter_->GetLabel(id);
|
||||
}
|
||||
|
||||
void MenuDelegate::GetLabelStyle(int id, LabelStyle* style) const {
|
||||
return adapter_->GetLabelStyle(id, style);
|
||||
}
|
||||
|
||||
bool MenuDelegate::IsCommandEnabled(int id) const {
|
||||
return adapter_->IsCommandEnabled(id);
|
||||
}
|
||||
|
||||
bool MenuDelegate::IsCommandVisible(int id) const {
|
||||
return adapter_->IsCommandVisible(id);
|
||||
}
|
||||
|
||||
bool MenuDelegate::IsItemChecked(int id) const {
|
||||
return adapter_->IsItemChecked(id);
|
||||
}
|
||||
|
||||
void MenuDelegate::WillShowMenu(views::MenuItemView* menu) {
|
||||
adapter_->WillShowMenu(menu);
|
||||
}
|
||||
|
||||
void MenuDelegate::WillHideMenu(views::MenuItemView* menu) {
|
||||
adapter_->WillHideMenu(menu);
|
||||
}
|
||||
|
||||
void MenuDelegate::OnMenuClosed(views::MenuItemView* menu) {
|
||||
for (Observer& obs : observers_)
|
||||
obs.OnMenuClosed();
|
||||
|
||||
// Only switch to new menu when current menu is closed.
|
||||
if (button_to_open_)
|
||||
button_to_open_->Activate(nullptr);
|
||||
delete this;
|
||||
}
|
||||
|
||||
views::MenuItemView* MenuDelegate::GetSiblingMenu(
|
||||
views::MenuItemView* menu,
|
||||
const gfx::Point& screen_point,
|
||||
views::MenuAnchorPosition* anchor,
|
||||
bool* has_mnemonics,
|
||||
views::MenuButton**) {
|
||||
if (hold_first_switch_) {
|
||||
hold_first_switch_ = false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// TODO(zcbenz): We should follow Chromium's logics on implementing the
|
||||
// sibling menu switches, this code is almost a hack.
|
||||
views::MenuButton* button;
|
||||
AtomMenuModel* model;
|
||||
if (menu_bar_->GetMenuButtonFromScreenPoint(screen_point, &model, &button) &&
|
||||
button->tag() != id_) {
|
||||
bool switch_in_progress = !!button_to_open_;
|
||||
// Always update target to open.
|
||||
button_to_open_ = button;
|
||||
// Switching menu asyncnously to avoid crash.
|
||||
if (!switch_in_progress) {
|
||||
base::PostTaskWithTraits(
|
||||
FROM_HERE, {content::BrowserThread::UI},
|
||||
base::BindOnce(&views::MenuRunner::Cancel,
|
||||
base::Unretained(menu_runner_.get())));
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
80
shell/browser/ui/views/menu_delegate.h
Normal file
80
shell/browser/ui/views/menu_delegate.h
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_MENU_DELEGATE_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_MENU_DELEGATE_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "atom/browser/ui/atom_menu_model.h"
|
||||
#include "base/observer_list.h"
|
||||
#include "ui/views/controls/menu/menu_delegate.h"
|
||||
|
||||
namespace views {
|
||||
class MenuRunner;
|
||||
class Button;
|
||||
} // namespace views
|
||||
|
||||
namespace atom {
|
||||
|
||||
class MenuBar;
|
||||
|
||||
class MenuDelegate : public views::MenuDelegate {
|
||||
public:
|
||||
explicit MenuDelegate(MenuBar* menu_bar);
|
||||
~MenuDelegate() override;
|
||||
|
||||
void RunMenu(AtomMenuModel* model,
|
||||
views::Button* button,
|
||||
ui::MenuSourceType source_type);
|
||||
|
||||
class Observer {
|
||||
public:
|
||||
virtual void OnBeforeExecuteCommand() = 0;
|
||||
virtual void OnMenuClosed() = 0;
|
||||
};
|
||||
|
||||
void AddObserver(Observer* obs) { observers_.AddObserver(obs); }
|
||||
|
||||
void RemoveObserver(const Observer* obs) { observers_.RemoveObserver(obs); }
|
||||
|
||||
protected:
|
||||
// views::MenuDelegate:
|
||||
void ExecuteCommand(int id) override;
|
||||
void ExecuteCommand(int id, int mouse_event_flags) override;
|
||||
bool IsTriggerableEvent(views::MenuItemView* source,
|
||||
const ui::Event& e) override;
|
||||
bool GetAccelerator(int id, ui::Accelerator* accelerator) const override;
|
||||
base::string16 GetLabel(int id) const override;
|
||||
void GetLabelStyle(int id, LabelStyle* style) const override;
|
||||
bool IsCommandEnabled(int id) const override;
|
||||
bool IsCommandVisible(int id) const override;
|
||||
bool IsItemChecked(int id) const override;
|
||||
void WillShowMenu(views::MenuItemView* menu) override;
|
||||
void WillHideMenu(views::MenuItemView* menu) override;
|
||||
void OnMenuClosed(views::MenuItemView* menu) override;
|
||||
views::MenuItemView* GetSiblingMenu(views::MenuItemView* menu,
|
||||
const gfx::Point& screen_point,
|
||||
views::MenuAnchorPosition* anchor,
|
||||
bool* has_mnemonics,
|
||||
views::MenuButton** button) override;
|
||||
|
||||
private:
|
||||
MenuBar* menu_bar_;
|
||||
int id_;
|
||||
std::unique_ptr<views::MenuDelegate> adapter_;
|
||||
std::unique_ptr<views::MenuRunner> menu_runner_;
|
||||
|
||||
// The menu button to switch to.
|
||||
views::MenuButton* button_to_open_ = nullptr;
|
||||
bool hold_first_switch_;
|
||||
|
||||
base::ObserverList<Observer>::Unchecked observers_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(MenuDelegate);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_MENU_DELEGATE_H_
|
||||
25
shell/browser/ui/views/menu_model_adapter.cc
Normal file
25
shell/browser/ui/views/menu_model_adapter.cc
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright (c) 2016 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/menu_model_adapter.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
MenuModelAdapter::MenuModelAdapter(AtomMenuModel* menu_model)
|
||||
: views::MenuModelAdapter(menu_model), menu_model_(menu_model) {}
|
||||
|
||||
MenuModelAdapter::~MenuModelAdapter() {}
|
||||
|
||||
bool MenuModelAdapter::GetAccelerator(int id,
|
||||
ui::Accelerator* accelerator) const {
|
||||
ui::MenuModel* model = menu_model_;
|
||||
int index = 0;
|
||||
if (ui::MenuModel::GetModelAndIndexForCommandId(id, &model, &index)) {
|
||||
return static_cast<AtomMenuModel*>(model)->GetAcceleratorAtWithParams(
|
||||
index, true, accelerator);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
29
shell/browser/ui/views/menu_model_adapter.h
Normal file
29
shell/browser/ui/views/menu_model_adapter.h
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
// Copyright (c) 2016 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_MENU_MODEL_ADAPTER_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_MENU_MODEL_ADAPTER_H_
|
||||
|
||||
#include "atom/browser/ui/atom_menu_model.h"
|
||||
#include "ui/views/controls/menu/menu_model_adapter.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class MenuModelAdapter : public views::MenuModelAdapter {
|
||||
public:
|
||||
explicit MenuModelAdapter(AtomMenuModel* menu_model);
|
||||
~MenuModelAdapter() override;
|
||||
|
||||
protected:
|
||||
bool GetAccelerator(int id, ui::Accelerator* accelerator) const override;
|
||||
|
||||
private:
|
||||
AtomMenuModel* menu_model_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(MenuModelAdapter);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_MENU_MODEL_ADAPTER_H_
|
||||
28
shell/browser/ui/views/native_frame_view.cc
Normal file
28
shell/browser/ui/views/native_frame_view.cc
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
// Copyright (c) 2015 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/native_frame_view.h"
|
||||
|
||||
#include "atom/browser/native_window.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
const char NativeFrameView::kViewClassName[] = "AtomNativeFrameView";
|
||||
|
||||
NativeFrameView::NativeFrameView(NativeWindow* window, views::Widget* widget)
|
||||
: views::NativeFrameView(widget), window_(window) {}
|
||||
|
||||
gfx::Size NativeFrameView::GetMinimumSize() const {
|
||||
return window_->GetMinimumSize();
|
||||
}
|
||||
|
||||
gfx::Size NativeFrameView::GetMaximumSize() const {
|
||||
return window_->GetMaximumSize();
|
||||
}
|
||||
|
||||
const char* NativeFrameView::GetClassName() const {
|
||||
return kViewClassName;
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
35
shell/browser/ui/views/native_frame_view.h
Normal file
35
shell/browser/ui/views/native_frame_view.h
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
// Copyright (c) 2015 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_NATIVE_FRAME_VIEW_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_NATIVE_FRAME_VIEW_H_
|
||||
|
||||
#include "ui/views/window/native_frame_view.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class NativeWindow;
|
||||
|
||||
// Like the views::NativeFrameView, but returns the min/max size from the
|
||||
// NativeWindowViews.
|
||||
class NativeFrameView : public views::NativeFrameView {
|
||||
public:
|
||||
static const char kViewClassName[];
|
||||
NativeFrameView(NativeWindow* window, views::Widget* widget);
|
||||
|
||||
protected:
|
||||
// views::View:
|
||||
gfx::Size GetMinimumSize() const override;
|
||||
gfx::Size GetMaximumSize() const override;
|
||||
const char* GetClassName() const override;
|
||||
|
||||
private:
|
||||
NativeWindow* window_; // weak ref.
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(NativeFrameView);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_NATIVE_FRAME_VIEW_H_
|
||||
233
shell/browser/ui/views/root_view.cc
Normal file
233
shell/browser/ui/views/root_view.cc
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
// Copyright (c) 2018 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/root_view.h"
|
||||
|
||||
#include "atom/browser/native_window.h"
|
||||
#include "atom/browser/ui/views/menu_bar.h"
|
||||
#include "content/public/browser/native_web_keyboard_event.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
namespace {
|
||||
|
||||
// The menu bar height in pixels.
|
||||
#if defined(OS_WIN)
|
||||
const int kMenuBarHeight = 20;
|
||||
#else
|
||||
const int kMenuBarHeight = 25;
|
||||
#endif
|
||||
|
||||
bool IsAltKey(const content::NativeWebKeyboardEvent& event) {
|
||||
return event.windows_key_code == ui::VKEY_MENU;
|
||||
}
|
||||
|
||||
bool IsAltModifier(const content::NativeWebKeyboardEvent& event) {
|
||||
typedef content::NativeWebKeyboardEvent::Modifiers Modifiers;
|
||||
int modifiers = event.GetModifiers();
|
||||
modifiers &= ~Modifiers::kNumLockOn;
|
||||
modifiers &= ~Modifiers::kCapsLockOn;
|
||||
return (modifiers == Modifiers::kAltKey) ||
|
||||
(modifiers == (Modifiers::kAltKey | Modifiers::kIsLeft)) ||
|
||||
(modifiers == (Modifiers::kAltKey | Modifiers::kIsRight));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
RootView::RootView(NativeWindow* window)
|
||||
: window_(window),
|
||||
last_focused_view_tracker_(std::make_unique<views::ViewTracker>()) {
|
||||
set_owned_by_client();
|
||||
}
|
||||
|
||||
RootView::~RootView() {}
|
||||
|
||||
void RootView::SetMenu(AtomMenuModel* menu_model) {
|
||||
if (menu_model == nullptr) {
|
||||
// Remove accelerators
|
||||
UnregisterAcceleratorsWithFocusManager();
|
||||
// and menu bar.
|
||||
SetMenuBarVisibility(false);
|
||||
menu_bar_.reset();
|
||||
return;
|
||||
}
|
||||
|
||||
RegisterAcceleratorsWithFocusManager(menu_model);
|
||||
|
||||
// Do not show menu bar in frameless window.
|
||||
if (!window_->has_frame())
|
||||
return;
|
||||
|
||||
if (!menu_bar_) {
|
||||
menu_bar_.reset(new MenuBar(this));
|
||||
menu_bar_->set_owned_by_client();
|
||||
if (!menu_bar_autohide_)
|
||||
SetMenuBarVisibility(true);
|
||||
}
|
||||
|
||||
menu_bar_->SetMenu(menu_model);
|
||||
Layout();
|
||||
}
|
||||
|
||||
bool RootView::HasMenu() const {
|
||||
return !!menu_bar_;
|
||||
}
|
||||
|
||||
int RootView::GetMenuBarHeight() const {
|
||||
return kMenuBarHeight;
|
||||
}
|
||||
|
||||
void RootView::SetAutoHideMenuBar(bool auto_hide) {
|
||||
menu_bar_autohide_ = auto_hide;
|
||||
}
|
||||
|
||||
bool RootView::IsMenuBarAutoHide() const {
|
||||
return menu_bar_autohide_;
|
||||
}
|
||||
|
||||
void RootView::SetMenuBarVisibility(bool visible) {
|
||||
if (!window_->content_view() || !menu_bar_ || menu_bar_visible_ == visible)
|
||||
return;
|
||||
|
||||
menu_bar_visible_ = visible;
|
||||
if (visible) {
|
||||
DCHECK_EQ(children().size(), 1ul);
|
||||
AddChildView(menu_bar_.get());
|
||||
} else {
|
||||
DCHECK_EQ(children().size(), 2ul);
|
||||
RemoveChildView(menu_bar_.get());
|
||||
}
|
||||
|
||||
Layout();
|
||||
}
|
||||
|
||||
bool RootView::IsMenuBarVisible() const {
|
||||
return menu_bar_visible_;
|
||||
}
|
||||
|
||||
void RootView::HandleKeyEvent(const content::NativeWebKeyboardEvent& event) {
|
||||
if (!menu_bar_)
|
||||
return;
|
||||
|
||||
// Show accelerator when "Alt" is pressed.
|
||||
if (menu_bar_visible_ && IsAltKey(event))
|
||||
menu_bar_->SetAcceleratorVisibility(event.GetType() ==
|
||||
blink::WebInputEvent::kRawKeyDown);
|
||||
|
||||
// Show the submenu when "Alt+Key" is pressed.
|
||||
if (event.GetType() == blink::WebInputEvent::kRawKeyDown &&
|
||||
!IsAltKey(event) && IsAltModifier(event)) {
|
||||
if (menu_bar_->HasAccelerator(event.windows_key_code)) {
|
||||
if (!menu_bar_visible_) {
|
||||
SetMenuBarVisibility(true);
|
||||
|
||||
View* focused_view = GetFocusManager()->GetFocusedView();
|
||||
last_focused_view_tracker_->SetView(focused_view);
|
||||
menu_bar_->RequestFocus();
|
||||
}
|
||||
|
||||
menu_bar_->ActivateAccelerator(event.windows_key_code);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Toggle the menu bar only when a single Alt is released.
|
||||
if (event.GetType() == blink::WebInputEvent::kRawKeyDown && IsAltKey(event)) {
|
||||
// When a single Alt is pressed:
|
||||
menu_bar_alt_pressed_ = true;
|
||||
} else if (event.GetType() == blink::WebInputEvent::kKeyUp &&
|
||||
IsAltKey(event) && menu_bar_alt_pressed_) {
|
||||
// When a single Alt is released right after a Alt is pressed:
|
||||
menu_bar_alt_pressed_ = false;
|
||||
if (menu_bar_autohide_)
|
||||
SetMenuBarVisibility(!menu_bar_visible_);
|
||||
|
||||
View* focused_view = GetFocusManager()->GetFocusedView();
|
||||
last_focused_view_tracker_->SetView(focused_view);
|
||||
if (menu_bar_visible_) {
|
||||
menu_bar_->RequestFocus();
|
||||
// Show accelerators when menu bar is focused
|
||||
menu_bar_->SetAcceleratorVisibility(true);
|
||||
}
|
||||
} else {
|
||||
// When any other keys except single Alt have been pressed/released:
|
||||
menu_bar_alt_pressed_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
void RootView::RestoreFocus() {
|
||||
View* last_focused_view = last_focused_view_tracker_->view();
|
||||
if (last_focused_view) {
|
||||
GetFocusManager()->SetFocusedViewWithReason(
|
||||
last_focused_view, views::FocusManager::kReasonFocusRestore);
|
||||
}
|
||||
if (menu_bar_autohide_)
|
||||
SetMenuBarVisibility(false);
|
||||
}
|
||||
|
||||
void RootView::ResetAltState() {
|
||||
menu_bar_alt_pressed_ = false;
|
||||
}
|
||||
|
||||
void RootView::Layout() {
|
||||
if (!window_->content_view()) // Not ready yet.
|
||||
return;
|
||||
|
||||
const auto menu_bar_bounds =
|
||||
menu_bar_visible_
|
||||
? gfx::Rect(insets_.left(), insets_.top(),
|
||||
size().width() - insets_.width(), kMenuBarHeight)
|
||||
: gfx::Rect();
|
||||
if (menu_bar_)
|
||||
menu_bar_->SetBoundsRect(menu_bar_bounds);
|
||||
|
||||
window_->content_view()->SetBoundsRect(
|
||||
gfx::Rect(insets_.left(),
|
||||
menu_bar_visible_ ? menu_bar_bounds.bottom() : insets_.top(),
|
||||
size().width() - insets_.width(),
|
||||
size().height() - menu_bar_bounds.height() - insets_.height()));
|
||||
}
|
||||
|
||||
gfx::Size RootView::GetMinimumSize() const {
|
||||
return window_->GetMinimumSize();
|
||||
}
|
||||
|
||||
gfx::Size RootView::GetMaximumSize() const {
|
||||
return window_->GetMaximumSize();
|
||||
}
|
||||
|
||||
bool RootView::AcceleratorPressed(const ui::Accelerator& accelerator) {
|
||||
return accelerator_util::TriggerAcceleratorTableCommand(&accelerator_table_,
|
||||
accelerator);
|
||||
}
|
||||
|
||||
void RootView::RegisterAcceleratorsWithFocusManager(AtomMenuModel* menu_model) {
|
||||
if (!menu_model)
|
||||
return;
|
||||
// Clear previous accelerators.
|
||||
UnregisterAcceleratorsWithFocusManager();
|
||||
|
||||
views::FocusManager* focus_manager = GetFocusManager();
|
||||
// Register accelerators with focus manager.
|
||||
accelerator_util::GenerateAcceleratorTable(&accelerator_table_, menu_model);
|
||||
for (const auto& iter : accelerator_table_) {
|
||||
focus_manager->RegisterAccelerator(
|
||||
iter.first, ui::AcceleratorManager::kNormalPriority, this);
|
||||
}
|
||||
}
|
||||
|
||||
void RootView::UnregisterAcceleratorsWithFocusManager() {
|
||||
views::FocusManager* focus_manager = GetFocusManager();
|
||||
accelerator_table_.clear();
|
||||
focus_manager->UnregisterAccelerators(this);
|
||||
}
|
||||
|
||||
void RootView::SetInsets(const gfx::Insets& insets) {
|
||||
if (insets != insets_) {
|
||||
insets_ = insets;
|
||||
Layout();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
74
shell/browser/ui/views/root_view.h
Normal file
74
shell/browser/ui/views/root_view.h
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
// Copyright (c) 2018 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "atom/browser/ui/accelerator_util.h"
|
||||
#include "ui/gfx/geometry/insets.h"
|
||||
#include "ui/views/view.h"
|
||||
#include "ui/views/view_tracker.h"
|
||||
|
||||
namespace content {
|
||||
struct NativeWebKeyboardEvent;
|
||||
}
|
||||
|
||||
namespace atom {
|
||||
|
||||
class AtomMenuModel;
|
||||
class MenuBar;
|
||||
class NativeWindow;
|
||||
|
||||
class RootView : public views::View {
|
||||
public:
|
||||
explicit RootView(NativeWindow* window);
|
||||
~RootView() override;
|
||||
|
||||
void SetMenu(AtomMenuModel* menu_model);
|
||||
bool HasMenu() const;
|
||||
int GetMenuBarHeight() const;
|
||||
void SetAutoHideMenuBar(bool auto_hide);
|
||||
bool IsMenuBarAutoHide() const;
|
||||
void SetMenuBarVisibility(bool visible);
|
||||
bool IsMenuBarVisible() const;
|
||||
void HandleKeyEvent(const content::NativeWebKeyboardEvent& event);
|
||||
void ResetAltState();
|
||||
void RestoreFocus();
|
||||
// Register/Unregister accelerators supported by the menu model.
|
||||
void RegisterAcceleratorsWithFocusManager(AtomMenuModel* menu_model);
|
||||
void UnregisterAcceleratorsWithFocusManager();
|
||||
void SetInsets(const gfx::Insets& insets);
|
||||
gfx::Insets insets() const { return insets_; }
|
||||
|
||||
// views::View:
|
||||
void Layout() override;
|
||||
gfx::Size GetMinimumSize() const override;
|
||||
gfx::Size GetMaximumSize() const override;
|
||||
bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
|
||||
|
||||
private:
|
||||
// Parent window, weak ref.
|
||||
NativeWindow* window_;
|
||||
|
||||
// Menu bar.
|
||||
std::unique_ptr<MenuBar> menu_bar_;
|
||||
bool menu_bar_autohide_ = false;
|
||||
bool menu_bar_visible_ = false;
|
||||
bool menu_bar_alt_pressed_ = false;
|
||||
|
||||
gfx::Insets insets_;
|
||||
|
||||
// Map from accelerator to menu item's command id.
|
||||
accelerator_util::AcceleratorTable accelerator_table_;
|
||||
|
||||
std::unique_ptr<views::ViewTracker> last_focused_view_tracker_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(RootView);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_ROOT_VIEW_H_
|
||||
116
shell/browser/ui/views/submenu_button.cc
Normal file
116
shell/browser/ui/views/submenu_button.cc
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/submenu_button.h"
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
|
||||
#include "base/strings/string_util.h"
|
||||
#include "base/strings/utf_string_conversions.h"
|
||||
#include "ui/gfx/canvas.h"
|
||||
#include "ui/gfx/color_utils.h"
|
||||
#include "ui/gfx/text_utils.h"
|
||||
#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
|
||||
#include "ui/views/animation/ink_drop_host_view.h"
|
||||
#include "ui/views/animation/ink_drop_impl.h"
|
||||
#include "ui/views/controls/button/label_button_border.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
SubmenuButton::SubmenuButton(const base::string16& title,
|
||||
views::MenuButtonListener* menu_button_listener,
|
||||
const SkColor& background_color)
|
||||
: views::MenuButton(gfx::RemoveAcceleratorChar(title, '&', NULL, NULL),
|
||||
menu_button_listener),
|
||||
background_color_(background_color) {
|
||||
#if defined(OS_LINUX)
|
||||
// Dont' use native style border.
|
||||
SetBorder(CreateDefaultBorder());
|
||||
#endif
|
||||
|
||||
if (GetUnderlinePosition(title, &accelerator_, &underline_start_,
|
||||
&underline_end_))
|
||||
gfx::Canvas::SizeStringInt(GetText(), gfx::FontList(), &text_width_,
|
||||
&text_height_, 0, 0);
|
||||
|
||||
SetInkDropMode(InkDropMode::ON);
|
||||
set_ink_drop_base_color(
|
||||
color_utils::BlendTowardMaxContrast(background_color_, 0x81));
|
||||
}
|
||||
|
||||
SubmenuButton::~SubmenuButton() {}
|
||||
|
||||
std::unique_ptr<views::InkDropRipple> SubmenuButton::CreateInkDropRipple()
|
||||
const {
|
||||
std::unique_ptr<views::InkDropRipple> ripple(
|
||||
new views::FloodFillInkDropRipple(
|
||||
size(), GetInkDropCenterBasedOnLastEvent(), GetInkDropBaseColor(),
|
||||
ink_drop_visible_opacity()));
|
||||
return ripple;
|
||||
}
|
||||
|
||||
std::unique_ptr<views::InkDrop> SubmenuButton::CreateInkDrop() {
|
||||
std::unique_ptr<views::InkDropImpl> ink_drop =
|
||||
views::Button::CreateDefaultInkDropImpl();
|
||||
ink_drop->SetShowHighlightOnHover(false);
|
||||
ink_drop->SetShowHighlightOnFocus(true);
|
||||
return std::move(ink_drop);
|
||||
}
|
||||
|
||||
void SubmenuButton::SetAcceleratorVisibility(bool visible) {
|
||||
if (visible == show_underline_)
|
||||
return;
|
||||
|
||||
show_underline_ = visible;
|
||||
SchedulePaint();
|
||||
}
|
||||
|
||||
void SubmenuButton::SetUnderlineColor(SkColor color) {
|
||||
underline_color_ = color;
|
||||
}
|
||||
|
||||
void SubmenuButton::GetAccessibleNodeData(ui::AXNodeData* node_data) {
|
||||
node_data->SetName(GetAccessibleName());
|
||||
node_data->role = ax::mojom::Role::kPopUpButton;
|
||||
}
|
||||
|
||||
void SubmenuButton::PaintButtonContents(gfx::Canvas* canvas) {
|
||||
views::MenuButton::PaintButtonContents(canvas);
|
||||
|
||||
if (show_underline_ && (underline_start_ != underline_end_)) {
|
||||
float padding = (width() - text_width_) / 2;
|
||||
float underline_height = (height() + text_height_) / 2 - 2;
|
||||
canvas->DrawSharpLine(
|
||||
gfx::PointF(underline_start_ + padding, underline_height),
|
||||
gfx::PointF(underline_end_ + padding, underline_height),
|
||||
underline_color_);
|
||||
}
|
||||
}
|
||||
|
||||
bool SubmenuButton::GetUnderlinePosition(const base::string16& text,
|
||||
base::char16* accelerator,
|
||||
int* start,
|
||||
int* end) const {
|
||||
int pos, span;
|
||||
base::string16 trimmed = gfx::RemoveAcceleratorChar(text, '&', &pos, &span);
|
||||
if (pos > -1 && span != 0) {
|
||||
*accelerator = base::ToUpperASCII(trimmed[pos]);
|
||||
GetCharacterPosition(trimmed, pos, start);
|
||||
GetCharacterPosition(trimmed, pos + span, end);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void SubmenuButton::GetCharacterPosition(const base::string16& text,
|
||||
int index,
|
||||
int* pos) const {
|
||||
int height = 0;
|
||||
gfx::Canvas::SizeStringInt(text.substr(0, index), gfx::FontList(), pos,
|
||||
&height, 0, 0);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
63
shell/browser/ui/views/submenu_button.h
Normal file
63
shell/browser/ui/views/submenu_button.h
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_SUBMENU_BUTTON_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_SUBMENU_BUTTON_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "ui/accessibility/ax_node_data.h"
|
||||
#include "ui/views/animation/ink_drop_highlight.h"
|
||||
#include "ui/views/controls/button/menu_button.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
// Special button that used by menu bar to show submenus.
|
||||
class SubmenuButton : public views::MenuButton {
|
||||
public:
|
||||
SubmenuButton(const base::string16& title,
|
||||
views::MenuButtonListener* menu_button_listener,
|
||||
const SkColor& background_color);
|
||||
~SubmenuButton() override;
|
||||
|
||||
void SetAcceleratorVisibility(bool visible);
|
||||
void SetUnderlineColor(SkColor color);
|
||||
|
||||
base::char16 accelerator() const { return accelerator_; }
|
||||
|
||||
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
|
||||
|
||||
// views::MenuButton:
|
||||
void PaintButtonContents(gfx::Canvas* canvas) override;
|
||||
|
||||
// views::InkDropHostView:
|
||||
std::unique_ptr<views::InkDropRipple> CreateInkDropRipple() const override;
|
||||
std::unique_ptr<views::InkDrop> CreateInkDrop() override;
|
||||
|
||||
private:
|
||||
bool GetUnderlinePosition(const base::string16& text,
|
||||
base::char16* accelerator,
|
||||
int* start,
|
||||
int* end) const;
|
||||
void GetCharacterPosition(const base::string16& text,
|
||||
int index,
|
||||
int* pos) const;
|
||||
|
||||
base::char16 accelerator_ = 0;
|
||||
|
||||
bool show_underline_ = false;
|
||||
|
||||
int underline_start_ = 0;
|
||||
int underline_end_ = 0;
|
||||
int text_width_ = 0;
|
||||
int text_height_ = 0;
|
||||
SkColor underline_color_ = SK_ColorBLACK;
|
||||
SkColor background_color_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(SubmenuButton);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_SUBMENU_BUTTON_H_
|
||||
37
shell/browser/ui/views/win_frame_view.cc
Normal file
37
shell/browser/ui/views/win_frame_view.cc
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "atom/browser/ui/views/win_frame_view.h"
|
||||
|
||||
#include "atom/browser/native_window_views.h"
|
||||
#include "ui/views/widget/widget.h"
|
||||
#include "ui/views/win/hwnd_util.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
const char WinFrameView::kViewClassName[] = "WinFrameView";
|
||||
|
||||
WinFrameView::WinFrameView() {}
|
||||
|
||||
WinFrameView::~WinFrameView() {}
|
||||
|
||||
gfx::Rect WinFrameView::GetWindowBoundsForClientBounds(
|
||||
const gfx::Rect& client_bounds) const {
|
||||
return views::GetWindowBoundsForClientBounds(
|
||||
static_cast<views::View*>(const_cast<WinFrameView*>(this)),
|
||||
client_bounds);
|
||||
}
|
||||
|
||||
int WinFrameView::NonClientHitTest(const gfx::Point& point) {
|
||||
if (window_->has_frame())
|
||||
return frame_->client_view()->NonClientHitTest(point);
|
||||
else
|
||||
return FramelessView::NonClientHitTest(point);
|
||||
}
|
||||
|
||||
const char* WinFrameView::GetClassName() const {
|
||||
return kViewClassName;
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
32
shell/browser/ui/views/win_frame_view.h
Normal file
32
shell/browser/ui/views/win_frame_view.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
// Copyright (c) 2014 GitHub, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#ifndef ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
|
||||
#define ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
|
||||
|
||||
#include "atom/browser/ui/views/frameless_view.h"
|
||||
|
||||
namespace atom {
|
||||
|
||||
class WinFrameView : public FramelessView {
|
||||
public:
|
||||
static const char kViewClassName[];
|
||||
WinFrameView();
|
||||
~WinFrameView() override;
|
||||
|
||||
// views::NonClientFrameView:
|
||||
gfx::Rect GetWindowBoundsForClientBounds(
|
||||
const gfx::Rect& client_bounds) const override;
|
||||
int NonClientHitTest(const gfx::Point& point) override;
|
||||
|
||||
// views::View:
|
||||
const char* GetClassName() const override;
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(WinFrameView);
|
||||
};
|
||||
|
||||
} // namespace atom
|
||||
|
||||
#endif // ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
|
||||
Loading…
Add table
Add a link
Reference in a new issue