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
232
|
// 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 "app/menus/menu_model.h"
#include "chrome/browser/chromeos/options/network_config_view.h"
#include "gfx/native_widget_types.h"
#include "views/controls/menu/view_menu_delegate.h"
#include "third_party/skia/include/core/SkBitmap.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 menus::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;
// menus::MenuModel implementation.
virtual bool HasIcons() const { return true; }
virtual int GetItemCount() const;
virtual menus::MenuModel::ItemType GetTypeAt(int index) const;
virtual int GetCommandIdAt(int index) const { return index; }
virtual string16 GetLabelAt(int index) const;
virtual bool IsLabelDynamicAt(int index) const { return true; }
virtual const gfx::Font* GetLabelFontAt(int index) const;
virtual bool GetAcceleratorAt(int index,
menus::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 menus::ButtonMenuItemModel* GetButtonMenuItemAt(int index) const {
return NULL;
}
virtual bool IsEnabledAt(int index) const;
virtual menus::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 between 0 and 100.
// |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(int strength, bool black);
// Returns the Icon for a network strength for CellularNetwork |cellular|.
// This returns different colored bars depending on cellular data left.
static SkBitmap IconForNetworkStrength(const CellularNetwork* cellular);
// 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(menus::MenuModel::TYPE_SEPARATOR),
flags(0) {}
MenuItem(menus::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) {}
menus::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 DOM 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, bool focus_login) const;
// Wrappers for the ShowNetworkConfigView / ShowTabbedNetworkSettings.
void ShowWifi(const WifiNetwork* wifi, bool focus_login) const;
void ShowCellular(const CellularNetwork* cellular, bool focus_login) const;
void ActivateCellular(const CellularNetwork* cellular) const;
void ShowEthernet(const EthernetNetwork* ethernet) const;
void ShowOther() const;
// Set to true if we are currently refreshing the menu.
bool refreshing_menu_;
// The number of wifi strength images.
static const int kNumWifiImages;
// Bars image resources.
static const int kBarsImages[];
static const int kBarsImagesBlack[];
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_
|
