1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
// Copyright (c) 2010 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 CHROME_BROWSER_CHROMEOS_STATUS_NETWORK_MENU_H_
#define CHROME_BROWSER_CHROMEOS_STATUS_NETWORK_MENU_H_
#pragma once
#include <string>
#include <vector>
#include "chrome/browser/chromeos/options/network_config_view.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/base/models/simple_menu_model.h"
#include "ui/gfx/native_widget_types.h"
#include "views/controls/menu/view_menu_delegate.h"
namespace gfx {
class Canvas;
}
namespace views {
class Menu2;
}
namespace chromeos {
// Menu for network menu button in the status area/welcome screen.
// This class will populating the menu with the list of networks.
// It will also handle connecting to another wifi/cellular network.
//
// The network menu looks like this:
//
// <icon> Ethernet
// <icon> Wifi Network A
// <icon> Wifi Network B
// <icon> Wifi Network C
// <icon> Cellular Network A
// <icon> Cellular Network B
// <icon> Cellular Network C
// <icon> Other...
// --------------------------------
// Disable Wifi
// Disable Celluar
// --------------------------------
// <IP Address>
// Network settings...
//
// <icon> will show the strength of the wifi/cellular networks.
// The label will be BOLD if the network is currently connected.
class NetworkMenu : public views::ViewMenuDelegate,
public ui::MenuModel {
public:
struct NetworkInfo {
NetworkInfo() :
need_passphrase(false), remembered(true), auto_connect(true) {}
// "ethernet" | "wifi" | "cellular" | "other".
std::string network_type;
// "connected" | "connecting" | "disconnected" | "error".
std::string status;
// status message or error message, empty if unknown status.
std::string message;
// IP address (if network is active, empty otherwise)
std::string ip_address;
// Remembered passphrase.
std::string passphrase;
// true if the network requires a passphrase.
bool need_passphrase;
// true if the network is currently remembered.
bool remembered;
// true if the network is auto connect (meaningful for Wifi only).
bool auto_connect;
};
NetworkMenu();
virtual ~NetworkMenu();
// Retrieves network info for the DOMUI NetworkMenu (NetworkMenuUI).
// |index| is the index in menu_items_, set when the menu is built.
bool GetNetworkAt(int index, NetworkInfo* info) const;
// Connect or reconnect to the network at |index|.
// If remember >= 0, set the favorite state of the network.
// Returns true if a connect occurred (e.g. menu should be closed).
bool ConnectToNetworkAt(int index,
const std::string& passphrase,
const std::string& ssid,
int remember) const;
// ui::MenuModel implementation.
virtual bool HasIcons() const { return true; }
virtual int GetItemCount() const;
virtual ui::MenuModel::ItemType GetTypeAt(int index) const;
virtual int GetCommandIdAt(int index) const { return index; }
virtual string16 GetLabelAt(int index) const;
virtual bool IsItemDynamicAt(int index) const { return true; }
virtual const gfx::Font* GetLabelFontAt(int index) const;
virtual bool GetAcceleratorAt(int index,
ui::Accelerator* accelerator) const { return false; }
virtual bool IsItemCheckedAt(int index) const;
virtual int GetGroupIdAt(int index) const { return 0; }
virtual bool GetIconAt(int index, SkBitmap* icon) const;
virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt(int index) const {
return NULL;
}
virtual bool IsEnabledAt(int index) const;
virtual ui::MenuModel* GetSubmenuModelAt(int index) const { return NULL; }
virtual void HighlightChangedTo(int index) {}
virtual void ActivatedAt(int index);
virtual void MenuWillShow() {}
void SetFirstLevelMenuWidth(int width);
// Cancels the active menu.
void CancelMenu();
// Returns the Icon for a network strength for a WifiNetwork |wifi|.
// |black| is used to specify whether to return a black icon for display
// on a light background or a white icon for display on a dark background.
static SkBitmap IconForNetworkStrength(const WifiNetwork* wifi, bool black);
// Returns the Icon for a network strength for CellularNetwork |cellular|.
// |black| is used to specify whether to return a black icon for display
// on a light background or a white icon for display on a dark background.
static SkBitmap IconForNetworkStrength(const CellularNetwork* cellular,
bool black);
// Returns the Icon for animating network connecting.
// |animation_value| is the value from Animation.GetCurrentValue()
// |black| is used to specify whether to return a black icon for display
// on a light background or a white icon for display on a dark background.
static SkBitmap IconForNetworkConnecting(double animation_value, bool black);
// Returns the Badge for a given network technology.
// This returns different colored symbols depending on cellular data left.
static SkBitmap BadgeForNetworkTechnology(const CellularNetwork* cellular);
// This method will convert the |icon| bitmap to the correct size for display.
// If the |badge| icon is not empty, it will draw that on top of the icon.
static SkBitmap IconForDisplay(SkBitmap icon, SkBitmap badge);
protected:
virtual bool IsBrowserMode() const = 0;
virtual gfx::NativeWindow GetNativeWindow() const = 0;
virtual void OpenButtonOptions() = 0;
virtual bool ShouldOpenButtonOptions() const = 0;
// Notify subclasses that connection to |network| was initiated.
virtual void OnConnectNetwork(const Network* network,
SkBitmap selected_icon_) {}
// Update the menu (e.g. when the network list or status has changed).
void UpdateMenu();
private:
enum MenuItemFlags {
FLAG_DISABLED = 1 << 0,
FLAG_TOGGLE_ETHERNET = 1 << 1,
FLAG_TOGGLE_WIFI = 1 << 2,
FLAG_TOGGLE_CELLULAR = 1 << 3,
FLAG_TOGGLE_OFFLINE = 1 << 4,
FLAG_ASSOCIATED = 1 << 5,
FLAG_ETHERNET = 1 << 6,
FLAG_WIFI = 1 << 7,
FLAG_CELLULAR = 1 << 8,
FLAG_OPTIONS = 1 << 9,
FLAG_OTHER_NETWORK = 1 << 10,
};
struct MenuItem {
MenuItem()
: type(ui::MenuModel::TYPE_SEPARATOR),
flags(0) {}
MenuItem(ui::MenuModel::ItemType type, string16 label, SkBitmap icon,
const std::string& wireless_path, int flags)
: type(type),
label(label),
icon(icon),
wireless_path(wireless_path),
flags(flags) {}
ui::MenuModel::ItemType type;
string16 label;
SkBitmap icon;
std::string wireless_path;
int flags;
};
typedef std::vector<MenuItem> MenuItemVector;
// views::ViewMenuDelegate implementation.
virtual void RunMenu(views::View* source, const gfx::Point& pt);
// Called by RunMenu to initialize our list of menu items.
void InitMenuItems();
// Shows network details in Web UI options window.
void ShowTabbedNetworkSettings(const Network* network) const;
// Show a NetworkConfigView modal dialog instance.
// TODO(stevenjb): deprecate this once all of the UI is embedded in the menu.
void ShowNetworkConfigView(NetworkConfigView* view) const;
void ActivateCellular(const CellularNetwork* cellular) const;
void ShowOther() const;
// Set to true if we are currently refreshing the menu.
bool refreshing_menu_;
// The number of bars images for representing network strength.
static const int kNumBarsImages;
// Bars image resources.
static const int kBarsImages[];
static const int kBarsImagesBlack[];
// TODO(chocobo): Add these back when we decide to do colored bars again.
// static const int kBarsImagesLowData[];
// static const int kBarsImagesVLowData[];
// Our menu items.
MenuItemVector menu_items_;
// The network menu.
scoped_ptr<views::Menu2> network_menu_;
// Holds minimum width or -1 if it wasn't set up.
int min_width_;
// If true, call into the settings UI for network configuration dialogs.
bool use_settings_ui_;
DISALLOW_COPY_AND_ASSIGN(NetworkMenu);
};
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_STATUS_NETWORK_MENU_H_
|
