688 lines
21 KiB
Lua
688 lines
21 KiB
Lua
------------------------------------
|
|
-- This is the network controller --
|
|
------------------------------------
|
|
|
|
-- Awesome Libs
|
|
local awful = require("awful")
|
|
local dbus_proxy = require("dbus_proxy")
|
|
local dpi = require("beautiful").xresources.apply_dpi
|
|
local gtable = require("gears").table
|
|
local gtimer = require("gears").timer
|
|
local gshape = require("gears").shape
|
|
local gobject = require("gears").object
|
|
local gcolor = require("gears").color
|
|
local gears = require("gears")
|
|
local lgi = require("lgi")
|
|
local wibox = require("wibox")
|
|
|
|
local NM = require("lgi").NM
|
|
|
|
local rubato = require("src.lib.rubato")
|
|
|
|
local access_point = require("src.modules.network_controller.access_point")
|
|
|
|
local icondir = gears.filesystem.get_configuration_dir() .. "src/assets/icons/network/"
|
|
|
|
local capi = {
|
|
awesome = awesome,
|
|
}
|
|
|
|
local network = { mt = {} }
|
|
|
|
network.access_points = { layout = wibox.layout.fixed.vertical }
|
|
|
|
network.NMState = {
|
|
UNKNOWN = 0,
|
|
ASLEEP = 10,
|
|
DISCONNECTED = 20,
|
|
DISCONNECTING = 30,
|
|
CONNECTING = 40,
|
|
CONNECTED_LOCAL = 50,
|
|
CONNECTED_SITE = 60,
|
|
CONNECTED_GLOBAL = 70,
|
|
}
|
|
|
|
network.DeviceType = {
|
|
ETHERNET = 1,
|
|
WIFI = 2
|
|
}
|
|
|
|
network.DeviceState = {
|
|
UNKNOWN = 0,
|
|
UNMANAGED = 10,
|
|
UNAVAILABLE = 20,
|
|
DISCONNECTED = 30,
|
|
PREPARE = 40,
|
|
CONFIG = 50,
|
|
NEED_AUTH = 60,
|
|
IP_CONFIG = 70,
|
|
IP_CHECK = 80,
|
|
SECONDARIES = 90,
|
|
ACTIVATED = 100,
|
|
DEACTIVATING = 110,
|
|
FAILED = 120
|
|
}
|
|
|
|
local function flags_to_security(flags, wpa_flags, rsn_flags)
|
|
local str = ""
|
|
if flags == 1 and wpa_flags == 0 and rsn_flags == 0 then
|
|
str = str .. " WEP"
|
|
end
|
|
if wpa_flags ~= 0 then
|
|
str = str .. " WPA1"
|
|
end
|
|
if not rsn_flags ~= 0 then
|
|
str = str .. " WPA2"
|
|
end
|
|
if wpa_flags == 512 or rsn_flags == 512 then
|
|
str = str .. " 802.1X"
|
|
end
|
|
|
|
return (str:gsub("^%s", ""))
|
|
end
|
|
|
|
local function get_wifi_proxy(self)
|
|
local devices = self._private.client_proxy:GetDevices()
|
|
for _, device in ipairs(devices) do
|
|
local device_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.Device",
|
|
path = device
|
|
}
|
|
|
|
if device_proxy.DeviceType == network.DeviceType.WIFI then
|
|
self._private.device_proxy = device_proxy
|
|
self._private.wifi_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.Device.Wireless",
|
|
path = device
|
|
}
|
|
|
|
self._private.device_proxy:connect_signal(function(proxy, new_state, old_state, reason)
|
|
local active_access_point_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.AccessPoint",
|
|
path = self._private.wifi_proxy.ActiveAccessPoint
|
|
}
|
|
|
|
self:emit_signal(tostring(active_access_point_proxy.HwAddress) .. "::state", new_state, old_state)
|
|
if new_state == network.DeviceState.ACTIVATED then
|
|
local ssid = NM.utils_ssid_to_utf8(active_access_point_proxy.Ssid)
|
|
self:emit_signal("NM::AccessPointConnected", ssid, active_access_point_proxy.Strength)
|
|
end
|
|
end, "StateChanged")
|
|
end
|
|
end
|
|
end
|
|
|
|
function network.device_state_to_string(state)
|
|
local device_state_to_string =
|
|
{
|
|
[0] = "Unknown",
|
|
[10] = "Unmanaged",
|
|
[20] = "Unavailable",
|
|
[30] = "Disconnected",
|
|
[40] = "Prepare",
|
|
[50] = "Config",
|
|
[60] = "Need Auth",
|
|
[70] = "IP Config",
|
|
[80] = "IP Check",
|
|
[90] = "Secondaries",
|
|
[100] = "Activated",
|
|
[110] = "Deactivated",
|
|
[120] = "Failed"
|
|
}
|
|
|
|
return device_state_to_string[state]
|
|
end
|
|
|
|
local function get_access_point_connections(self, ssid)
|
|
local connection_proxies = {}
|
|
|
|
local connections = self._private.settings_proxy:ListConnections()
|
|
for _, connection_path in ipairs(connections) do
|
|
local connection_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.Settings.Connection",
|
|
path = connection_path
|
|
}
|
|
|
|
if connection_proxy.Filename:find(ssid) then
|
|
table.insert(connection_proxies, connection_proxy)
|
|
end
|
|
end
|
|
|
|
return connection_proxies
|
|
end
|
|
|
|
local function generate_uuid()
|
|
local template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
|
|
local uuid = string.gsub(template, '[xy]', function(c)
|
|
local v = (c == 'x') and math.random(0, 0xf) or math.random(8, 0xb)
|
|
return string.format('%x', v)
|
|
end)
|
|
return uuid
|
|
end
|
|
|
|
local function create_profile(ap, password, auto_connect)
|
|
local s_con =
|
|
{
|
|
-- ["interface-name"] = lgi.GLib.Variant("s", ap.device_interface),
|
|
["uuid"] = lgi.GLib.Variant("s", generate_uuid()),
|
|
["id"] = lgi.GLib.Variant("s", ap.ssid),
|
|
["type"] = lgi.GLib.Variant("s", "802-11-wireless"),
|
|
["autoconnect"] = lgi.GLib.Variant("b", auto_connect),
|
|
}
|
|
|
|
local s_ip4 =
|
|
{
|
|
["method"] = lgi.GLib.Variant("s", "auto")
|
|
}
|
|
|
|
local s_ip6 =
|
|
{
|
|
["method"] = lgi.GLib.Variant("s", "auto"),
|
|
}
|
|
|
|
local s_wifi =
|
|
{
|
|
["mode"] = lgi.GLib.Variant("s", "infrastructure"),
|
|
}
|
|
|
|
local s_wsec = {}
|
|
if ap.security ~= "" then
|
|
if ap.security:match("WPA") ~= nil then
|
|
s_wsec["key-mgmt"] = lgi.GLib.Variant("s", "wpa-psk")
|
|
s_wsec["auth-alg"] = lgi.GLib.Variant("s", "open")
|
|
--s_wsec["psk"] = lgi.GLib.Variant("s", helpers.string.trim(password))
|
|
else
|
|
s_wsec["key-mgmt"] = lgi.GLib.Variant("s", "None")
|
|
s_wsec["wep-key-type"] = lgi.GLib.Variant("s", NM.WepKeyType.PASSPHRASE)
|
|
--s_wsec["wep-key0"] = lgi.GLib.Variant("s", helpers.string.trim(password))
|
|
end
|
|
end
|
|
|
|
return {
|
|
["connection"] = s_con,
|
|
["ipv4"] = s_ip4,
|
|
["ipv6"] = s_ip6,
|
|
["802-11-wireless"] = s_wifi,
|
|
["802-11-wireless-security"] = s_wsec
|
|
}
|
|
end
|
|
|
|
function network:scan_access_points()
|
|
self._private.access_points = {}
|
|
|
|
self._private.wifi_proxy:RequestScanAsync(function(proxy, context, success, failure)
|
|
if failure ~= nil then
|
|
self.access_points = { layout = wibox.layout.fixed.vertical }
|
|
self:emit_signal("NM::AccessPointsFound", self.access_points[1].ssid)
|
|
self:emit_signal("NM::ScanFailed", tostring(failure))
|
|
return
|
|
end
|
|
|
|
local access_points = self._private.wifi_proxy:GetAllAccessPoints()
|
|
|
|
self._private.access_points = {}
|
|
if (not access_point) or (#access_points == 0) then
|
|
self.access_points = { layout = wibox.layout.fixed.vertical }
|
|
self:emit_signal("NM::AccessPointsFound", self.access_points[1].ssid)
|
|
end
|
|
|
|
for _, ap in ipairs(access_points) do
|
|
local access_point_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.AccessPoint",
|
|
path = ap
|
|
}
|
|
|
|
if access_point_proxy.Ssid then
|
|
local appSsid = access_point_proxy.Ssid or ""
|
|
local ssid = NM.utils_ssid_to_utf8(appSsid) or ""
|
|
local security = flags_to_security(access_point_proxy.Flags, access_point_proxy.WpaFlags)
|
|
local password = ""
|
|
local connections = get_access_point_connections(self, ssid)
|
|
|
|
for _, connection in ipairs(connections) do
|
|
if connection.Filename:find(ssid) then
|
|
local secrets = connection:GetSecrets("802-11-wireless-security")
|
|
if secrets then
|
|
password = secrets["802-11-wireless-security"].psk
|
|
end
|
|
end
|
|
end
|
|
|
|
table.insert(self._private.access_points, {
|
|
ssid = ssid,
|
|
security = security,
|
|
password = password,
|
|
strength = access_point_proxy.Strength,
|
|
hw_address = access_point_proxy.HwAddress,
|
|
device_interface = self._private.device_proxy.Interface,
|
|
device_path = self._private.device_proxy.object_path,
|
|
access_point_path = ap
|
|
})
|
|
end
|
|
end
|
|
|
|
self.access_points = { layout = wibox.layout.fixed.vertical }
|
|
|
|
local seen = {}
|
|
for _, ap2 in ipairs(self._private.access_points) do
|
|
if not seen[ap2.ssid] then
|
|
seen[ap2.ssid] = true
|
|
table.insert(self.access_points,
|
|
access_point.new { access_point = ap2, active = self._private.wifi_proxy.ActiveAccessPoint }.widget)
|
|
end
|
|
end
|
|
|
|
table.sort(self._private.access_points, function(a, b)
|
|
return a.strength > b.strength
|
|
end)
|
|
|
|
self:emit_signal("NM::AccessPointsFound", self.access_points[1].ssid)
|
|
end, { call_id = "my-id" }, {})
|
|
end
|
|
|
|
function network:toggle()
|
|
self.container.visible = not self.container.visible
|
|
end
|
|
|
|
function network:is_ap_active(ap)
|
|
print(self._private.wifi_proxy.ActiveAccessPoint)
|
|
return ap.path == self._private.wifi_proxy.ActiveAccessPoint
|
|
end
|
|
|
|
function network:disconnect_ap()
|
|
self._private.client_proxy:DeactivateConnection(self._private.device_proxy.ActiveConnection)
|
|
end
|
|
|
|
function network:connect_ap(ap, pw, auto_connect)
|
|
local connections = get_access_point_connections(self, ap.ssid)
|
|
local profile = create_profile(ap, pw, auto_connect)
|
|
|
|
if #connections == 0 then
|
|
self._private.client_proxy:AddAndActivateConnectionAsync(function(proxy, context, success, failure)
|
|
if failure then
|
|
self:emit_signal("NM::AccessPointFailed", tostring(failure))
|
|
return
|
|
end
|
|
|
|
self:emit_signal("NM::AccessPointConnected", ap.ssid)
|
|
end, { call_id = "my-id", profile, ap.device_proxy_path, ap.path })
|
|
else
|
|
connections[1]:Update(profile)
|
|
self._private.client_proxy:ActivateConnectionAsync(function(proxy, context, success, failure)
|
|
if failure then
|
|
self:emit_signal("NM::AccessPointFailed", tostring(failure))
|
|
return
|
|
end
|
|
|
|
self:emit_signal("NM::AccessPointConnected", ap.ssid)
|
|
end, { call_id = "my-id", connections[1].object_path, ap.device_proxy_path, ap.path })
|
|
end
|
|
end
|
|
|
|
function network:toggle_access_point(ap, password, auto_connect)
|
|
if self:is_ap_active(ap) then
|
|
self:disconnect_ap()
|
|
else
|
|
self:connect_ap(ap, password, auto_connect)
|
|
end
|
|
end
|
|
|
|
function network:toggle_wireless()
|
|
local enable = not self._private.client_proxy.WirelessEnabled
|
|
if enable then
|
|
self._private.client_proxy:Enable(true)
|
|
end
|
|
|
|
self._private.client_proxy:Set("org.freedesktop.NetworkManager", "WirelessEnabled", lgi.GLib.Variant("b", enable))
|
|
|
|
return enable
|
|
end
|
|
|
|
function network.new(args)
|
|
args = args or {}
|
|
|
|
local ret = gobject {}
|
|
|
|
gtable.crush(ret, network, true)
|
|
|
|
ret._private = {}
|
|
|
|
ret._private.client_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager",
|
|
path = "/org/freedesktop/NetworkManager",
|
|
}
|
|
|
|
ret._private.settings_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.Settings",
|
|
path = "/org/freedesktop/NetworkManager/Settings",
|
|
}
|
|
|
|
local property_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.DBus.Properties",
|
|
path = "/org/freedesktop/NetworkManager",
|
|
}
|
|
|
|
-- dbus proxy signals are in reversed order (function, signal)
|
|
property_proxy:connect_signal(function(_, properties, data)
|
|
if data.WirelessEnables ~= nil and ret._private.WirelessEnabled ~= data.WirelessEnabled then
|
|
ret._private.WirelessEnabled = data.WirelessEnabled
|
|
ret:emit_signal("NM::WirelessStateChanged", ret._private.WirelessEnabled)
|
|
|
|
if data.WirelessEnabled then
|
|
gtimer {
|
|
timeout = 5,
|
|
autostart = true,
|
|
call_now = false,
|
|
single_shot = true,
|
|
callback = function()
|
|
ret:get_access_points()
|
|
end
|
|
}
|
|
end
|
|
end
|
|
end, "PropertiesChanged")
|
|
|
|
get_wifi_proxy(ret)
|
|
|
|
ret:scan_access_points()
|
|
|
|
gtimer.delayed_call(function()
|
|
ret:emit_signal("NM::WirelessStateChanged", ret._private.client_proxy.WirelessEnabled)
|
|
|
|
local active_access_point = ret._private.wifi_proxy.ActiveAccessPoint
|
|
if ret._private.device_proxy.State == network.DeviceState.ACTIVATED and active_access_point ~= "/" then
|
|
local active_access_point_proxy = dbus_proxy.Proxy:new {
|
|
bus = dbus_proxy.Bus.SYSTEM,
|
|
name = "org.freedesktop.NetworkManager",
|
|
interface = "org.freedesktop.NetworkManager.AccessPoint",
|
|
path = active_access_point,
|
|
}
|
|
|
|
local ssid = NM.utils_ssid_to_utf8(active_access_point_proxy.Ssid)
|
|
ret:emit_signal("NM:AccessPointConnected", ssid, active_access_point_proxy.Strength)
|
|
end
|
|
end)
|
|
|
|
local network_widget = wibox.widget {
|
|
{
|
|
{
|
|
{
|
|
{
|
|
{
|
|
{
|
|
{
|
|
{
|
|
resize = false,
|
|
image = gcolor.recolor_image(icondir .. "menu-down.svg",
|
|
Theme_config.network_manager.wifi_icon_color),
|
|
widget = wibox.widget.imagebox,
|
|
valign = "center",
|
|
halign = "center",
|
|
id = "icon"
|
|
},
|
|
id = "center",
|
|
halign = "center",
|
|
valign = "center",
|
|
widget = wibox.container.place,
|
|
},
|
|
{
|
|
{
|
|
text = "Wifi Networks",
|
|
widget = wibox.widget.textbox,
|
|
id = "ap_name"
|
|
},
|
|
margins = dpi(5),
|
|
widget = wibox.container.margin
|
|
},
|
|
id = "wifi",
|
|
layout = wibox.layout.fixed.horizontal
|
|
},
|
|
id = "wifi_bg",
|
|
bg = Theme_config.network_manager.wifi_bg,
|
|
fg = Theme_config.network_manager.wifi_fg,
|
|
shape = function(cr, width, height)
|
|
gshape.rounded_rect(cr, width, height, dpi(4))
|
|
end,
|
|
widget = wibox.container.background
|
|
},
|
|
id = "wifi_margin",
|
|
widget = wibox.container.margin
|
|
},
|
|
{
|
|
id = "wifi_list",
|
|
{
|
|
{
|
|
step = dpi(50),
|
|
spacing = dpi(10),
|
|
layout = require("src.lib.overflow_widget.overflow").vertical,
|
|
scrollbar_width = 0,
|
|
id = "wifi_ap_list"
|
|
},
|
|
id = "margin",
|
|
margins = dpi(10),
|
|
widget = wibox.container.margin
|
|
},
|
|
border_color = Theme_config.network_manager.ap_border_color,
|
|
border_width = Theme_config.network_manager.ap_border_width,
|
|
shape = function(cr, width, height)
|
|
gshape.partially_rounded_rect(cr, width, height, false, false, true, true, dpi(4))
|
|
end,
|
|
widget = wibox.container.background,
|
|
forced_height = 0
|
|
},
|
|
{
|
|
{ -- action buttons
|
|
{ -- refresh
|
|
{
|
|
{
|
|
image = gcolor.recolor_image(icondir .. "refresh.svg",
|
|
Theme_config.network_manager.refresh_icon_color),
|
|
resize = false,
|
|
valign = "center",
|
|
halign = "center",
|
|
widget = wibox.widget.imagebox,
|
|
id = "icon"
|
|
},
|
|
widget = wibox.container.margin,
|
|
margins = dpi(5),
|
|
id = "center",
|
|
},
|
|
border_width = dpi(2),
|
|
border_color = Theme_config.network_manager.border_color,
|
|
shape = function(cr, width, height)
|
|
gshape.rounded_rect(cr, width, height, dpi(4))
|
|
end,
|
|
bg = Theme_config.network_manager.refresh_bg,
|
|
widget = wibox.container.background,
|
|
id = "refresh"
|
|
},
|
|
nil,
|
|
{ -- airplane mode
|
|
{
|
|
{
|
|
image = gcolor.recolor_image(icondir .. "airplane-off.svg",
|
|
Theme_config.network_manager.airplane_icon_color),
|
|
resize = false,
|
|
valign = "center",
|
|
halign = "center",
|
|
widget = wibox.widget.imagebox,
|
|
id = "icon"
|
|
},
|
|
widget = wibox.container.margin,
|
|
margins = dpi(5),
|
|
id = "center",
|
|
},
|
|
border_width = dpi(2),
|
|
border_color = Theme_config.network_manager.border_color,
|
|
shape = function(cr, width, height)
|
|
gshape.rounded_rect(cr, width, height, dpi(4))
|
|
end,
|
|
bg = Theme_config.network_manager.refresh_bg,
|
|
widget = wibox.container.background,
|
|
id = "airplane"
|
|
},
|
|
layout = wibox.layout.align.horizontal
|
|
},
|
|
widget = wibox.container.margin,
|
|
top = dpi(10),
|
|
id = "action_buttons"
|
|
},
|
|
id = "layout1",
|
|
layout = wibox.layout.fixed.vertical
|
|
},
|
|
id = "margin",
|
|
margins = dpi(15),
|
|
widget = wibox.container.margin
|
|
},
|
|
shape = function(cr, width, height)
|
|
gshape.rounded_rect(cr, width, height, dpi(8))
|
|
end,
|
|
border_color = Theme_config.network_manager.border_color,
|
|
border_width = Theme_config.network_manager.border_width,
|
|
bg = Theme_config.network_manager.bg,
|
|
id = "background",
|
|
widget = wibox.container.background
|
|
},
|
|
width = dpi(400),
|
|
strategy = "exact",
|
|
widget = wibox.container.constraint
|
|
}
|
|
|
|
local refresh_button = network_widget:get_children_by_id("refresh")[1]
|
|
|
|
refresh_button:buttons(
|
|
gtable.join(
|
|
awful.button(
|
|
{},
|
|
1,
|
|
nil,
|
|
function()
|
|
ret:scan_access_points()
|
|
end
|
|
)
|
|
)
|
|
)
|
|
|
|
Hover_signal(refresh_button)
|
|
|
|
local airplane_button = network_widget:get_children_by_id("airplane")[1]
|
|
|
|
airplane_button:buttons(
|
|
gtable.join(
|
|
awful.button(
|
|
{},
|
|
1,
|
|
nil,
|
|
function()
|
|
if ret:toggle_wireless() then
|
|
airplane_button.center.icon.image = gcolor.recolor_image(icondir
|
|
.. "airplane-off.svg",
|
|
Theme_config.network_manager.airplane_icon_color)
|
|
else
|
|
airplane_button.center.icon.image = gcolor.recolor_image(icondir
|
|
.. "airplane-on.svg",
|
|
Theme_config.network_manager.airplane_icon_color)
|
|
end
|
|
ret:scan_access_points()
|
|
end
|
|
)
|
|
)
|
|
)
|
|
|
|
Hover_signal(airplane_button)
|
|
|
|
local wifi_margin = network_widget:get_children_by_id("wifi_margin")[1]
|
|
local wifi_list = network_widget:get_children_by_id("wifi_list")[1]
|
|
local wifi = network_widget:get_children_by_id("wifi")[1].center
|
|
|
|
local rubato_timer = rubato.timed {
|
|
duration = 0.2,
|
|
pos = wifi_list.forced_height,
|
|
easing = rubato.linear,
|
|
subscribed = function(v)
|
|
wifi_list.forced_height = v
|
|
end
|
|
}
|
|
|
|
wifi_margin:buttons(
|
|
gtable.join(
|
|
awful.button(
|
|
{},
|
|
1,
|
|
nil,
|
|
function()
|
|
if wifi_list.forced_height == 0 then
|
|
local size = (#ret.access_points * 49) + 1
|
|
|
|
size = size > 210 and 210 or size
|
|
|
|
rubato_timer.target = dpi(size)
|
|
wifi_margin.wifi_bg.shape = function(cr, width, height)
|
|
gshape.partially_rounded_rect(cr, width, height, true, true, false, false, dpi(4))
|
|
end
|
|
wifi.icon:set_image(gcolor.recolor_image(icondir .. "menu-up.svg",
|
|
Theme_config.network_manager.wifi_icon_color))
|
|
else
|
|
rubato_timer.target = 0
|
|
wifi_margin.wifi_bg.shape = function(cr, width, height)
|
|
gshape.partially_rounded_rect(cr, width, height, true, true, true, true, dpi(4))
|
|
end
|
|
wifi.icon:set_image(gcolor.recolor_image(icondir .. "menu-down.svg",
|
|
Theme_config.network_manager.wifi_icon_color))
|
|
end
|
|
end
|
|
)
|
|
)
|
|
)
|
|
|
|
ret.widget = awful.popup {
|
|
widget = network_widget,
|
|
bg = Theme_config.network_manager.bg,
|
|
screen = args.screen,
|
|
stretch = false,
|
|
visible = false,
|
|
ontop = true,
|
|
placement = function(c) awful.placement.align(c,
|
|
{ position = "top_right", margins = { right = dpi(350), top = dpi(60) } })
|
|
end,
|
|
shape = function(cr, width, height)
|
|
gears.shape.rounded_rect(cr, width, height, dpi(12))
|
|
end
|
|
}
|
|
|
|
capi.awesome.connect_signal("NM::toggle_container", function()
|
|
ret.widget.visible = not ret.widget.visible
|
|
ret:scan_access_points()
|
|
end)
|
|
|
|
capi.awesome.connect_signal("NM::toggle_wifi", function()
|
|
ret:toggle_wireless()
|
|
end)
|
|
|
|
ret:connect_signal("NM::AccessPointsFound", function(tab)
|
|
network_widget:get_children_by_id("wifi_ap_list")[1].children = ret.access_points
|
|
end)
|
|
end
|
|
|
|
function network.mt:__call(...)
|
|
return network.new(...)
|
|
end
|
|
|
|
return setmetatable(network, network.mt)
|