gryf/wicd
1
0
Fork 0
mirror of https://github.com/gryf/wicd.git synced 2025-12-19 20:38:00 +01:00
Code Issues Projects Releases Wiki Activity
Files
2db3b3e60dc8a2a403160d8e08556041a9b36f92
wicd/curses/prefs_curses.py
Andrew Psaltis 2db3b3e60d Checkpoint in getting the Preferences dialog functional. There's still some tweaking left to do. 
curses/curses_misc.py: Changed the internal layout of the widgets to allow me to stick buttons on the bottom.
curses/prefs_curses.py: Added rudimentary Dbus support to the dialog.
Started getting the config settings to save to wicd.
Added buttons (which don't do anything yet).
The PrefOverlay has been renamed to PrefsDialog.  The PrefsDialog widget is wrapped around a TabColumns widget.
Added a main entry point into the file to allow for somewhat easier testing.  It can now be called indepentently of wicd-curses, if needed.
curses/wicd-curses.py: Undid a change that caused the ESC key to disconnect from the current network, in addition to its current function.
2008-12-29 22:04:40 -05:00

351 lines
14 KiB
Python
Raw Blame History

#!/usr/bin/env python
# Copyright (C) 2008 Andrew Psaltis
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
import urwid
import urwid.curses_display
from wicd import misc
from wicd import dbusmanager
from curses_misc import SelText,ToggleEdit,ComboText,TabColumns
daemon = None
wireless = None
wired = None
# Will work for now, I guess.
language = misc.get_language_list_gui()
class PrefsDialog(urwid.WidgetWrap):
def __init__(self,body,pos,ui,dbus=None):
global daemon, wireless, wired
self.ui = ui
daemon = dbus['daemon']
wireless = dbus['wireless']
wired = dbus['wired']
width,height = ui.get_cols_rows()
height -= 3
#width = 80
#height = 20
# Stuff that goes at the top
header0_t = language["gen_settings"]
header1_t = language["ext_programs"]
header2_t = language["advanced_settings"]
self.header0 = urwid.AttrWrap(SelText(header0_t),'tab active','focus')
self.header1 = urwid.AttrWrap(SelText(header1_t),'body','focus')
self.header2 = urwid.AttrWrap(SelText(header2_t),'body','focus')
title = language['preferences']
# Blank line
self._blank = urwid.Text('')
####
#### Text in the widgets
####
# General Settings
net_cat_t = ('header','Network Interfaces')
wired_t = ('editcp',language['wired_interface']+': ')
wless_t = ('editcp',language['wireless_interface']+':')
always_show_wired_t = 'Always show wired interface'
global_dns_cat_t = ('header','Global DNS Servers')
global_dns_t = ('editcp',language['use_global_dns'])
search_dom_t = ('editcp',' Search domain:')
dns1_t = ('editcp',' DNS server 1: ')
dns2_t = ('editcp',' DNS server 2: ')
dns3_t = ('editcp',' DNS server 3: ')
wired_auto_cat_t= ('header','Wired Autoconnect Settings')
wired_auto_1_t = language['use_default_profile']
wired_auto_2_t = language['show_wired_list']
wired_auto_3_t = language['use_last_used_profile']
#### External Programs
automatic_t = language['wicd_auto_config']
dhcp_header_t = ('header',language["dhcp_client"])
# Automatic
dhcp1_t = 'dhclient'
dhcp2_t = 'dhcpcd'
dhcp3_t = 'pump'
wired_detect_header_t = ('header',language["wired_detect"])
wired1_t = 'ethtool'
wired2_t = 'mii-tool'
route_table_header_t = ('header',language["route_flush"])
route1_t = 'ip'
route2_t = 'route'
#### Advanced Settings
#wpa_t=('editcp',language['wpa_supplicant_driver']+':')
wpa_cat_t=('header','WPA_Supplicant')
wpa_t=('editcp','Driver:')
wpa_list = ['spam','double spam','triple spam','quadruple spam']
wpa_warn_t = ('important','You should almost always use wext as the WPA Supplicant Driver')
backend_cat_t = ('header',language['backend'])
backend_t = language['backend']+':'
backend_list = ['spam','double spam','triple spam','quadruple spam']
debug_cat_t = ('header','Debugging')
debug_mode_t = language['use_debug_mode']
wless_cat_t = ('header','Wireless Interface')
use_dbm_t = language['display_type_dialog']
auto_reconn_cat_t = ('header','Automatic Reconnect')
auto_reconn_t = 'Automatically reconnect on connection loss'
####
#### UI Widgets
####
# General Settings
self.net_cat = urwid.Text(net_cat_t)
self.wired_iface = urwid.AttrWrap(urwid.Edit(wired_t),'editbx','editfc')
self.wless_iface = urwid.AttrWrap(urwid.Edit(wless_t),'editbx','editfc')
self.global_dns_cat = urwid.Text(global_dns_cat_t)
global_dns_state = False
self.global_dns_checkb = urwid.CheckBox(global_dns_t,global_dns_state,
on_state_change=self.global_dns_trigger)
self.search_dom = ToggleEdit(search_dom_t,global_dns_state)
self.dns1 = ToggleEdit(dns1_t,global_dns_state)
self.dns2 = ToggleEdit(dns2_t,global_dns_state)
self.dns3 = ToggleEdit(dns3_t,global_dns_state)
self.always_show_wired_checkb = urwid.CheckBox(always_show_wired_t)
wired_auto_l = []
self.wired_auto_cat = urwid.Text(wired_auto_cat_t)
self.wired_auto_1 = urwid.RadioButton(wired_auto_l,wired_auto_1_t)
self.wired_auto_2 = urwid.RadioButton(wired_auto_l,wired_auto_2_t)
self.wired_auto_3 = urwid.RadioButton(wired_auto_l,wired_auto_3_t)
generalLB = urwid.ListBox([self.net_cat,
self.wless_iface,#self._blank,
self.wired_iface,
self.always_show_wired_checkb,self._blank,
self.global_dns_cat,
self.global_dns_checkb,#self._blank,
self.search_dom,
self.dns1,self.dns2,self.dns3,self._blank,
self.wired_auto_cat,
self.wired_auto_1,
self.wired_auto_2,
self.wired_auto_3
])
#### External Programs tab
automatic_t = language['wicd_auto_config']
self.dhcp_header = urwid.Text(dhcp_header_t)
dhcp_l = []
# Automatic
self.dhcp0 = urwid.RadioButton(dhcp_l,automatic_t)
self.dhcp1 = urwid.RadioButton(dhcp_l,dhcp1_t)
self.dhcp2 = urwid.RadioButton(dhcp_l,dhcp2_t)
self.dhcp3 = urwid.RadioButton(dhcp_l,dhcp3_t)
wired_l = []
self.wired_detect_header = urwid.Text(wired_detect_header_t)
self.wired0 = urwid.RadioButton(wired_l,automatic_t)
self.wired1 = urwid.RadioButton(wired_l,wired1_t)
self.wired2 = urwid.RadioButton(wired_l,wired2_t)
route_l = []
self.route_table_header = urwid.Text(route_table_header_t)
self.route0 = urwid.RadioButton(route_l,automatic_t)
self.route1 = urwid.RadioButton(route_l,route1_t)
self.route2 = urwid.RadioButton(route_l,route2_t)
externalLB = urwid.ListBox([self.dhcp_header,
self.dhcp0,self.dhcp1,self.dhcp2,self.dhcp3,
self._blank,
self.wired_detect_header,
self.wired0,self.wired1,self.wired2,
self._blank,
self.route_table_header,
self.route0,self.route1,self.route2
])
#### Advanced settings
self.wpa_cat = urwid.Text(wpa_cat_t)
self.wpa_cbox = ComboText(wpa_t,wpa_list,self,ui,4)
self.wpa_warn = urwid.Text(wpa_warn_t)
self.backend_cat = urwid.Text(backend_cat_t)
self.backend_cbox = ComboText(backend_t,backend_list,self,ui,8)
self.debug_cat = urwid.Text(debug_cat_t)
self.debug_mode_checkb = urwid.CheckBox(debug_mode_t)
self.wless_cat = urwid.Text(wless_cat_t)
self.use_dbm_checkb = urwid.CheckBox(use_dbm_t)
self.auto_reconn_cat = urwid.Text(auto_reconn_cat_t)
self.auto_reconn_checkb = urwid.CheckBox(auto_reconn_t)
advancedLB = urwid.ListBox([self.wpa_cat,
self.wpa_cbox,self.wpa_warn,self._blank,
self.backend_cat,
self.backend_cbox,self._blank,
self.debug_cat,
self.debug_mode_checkb, self._blank,
self.wless_cat,
self.use_dbm_checkb, self._blank,
self.auto_reconn_cat,
self.auto_reconn_checkb])
headerList = [self.header0,self.header1,self.header2]
lbList = [generalLB,externalLB,advancedLB]
self.tab_map = {self.header0 : generalLB,
self.header1 : externalLB,
self.header2 : advancedLB}
self.load_settings()
# Now for the buttons:
ok_t = 'OK'
cancel_t = 'Cancel'
ok_button = urwid.AttrWrap(urwid.Button('OK'),'body','focus')
cancel_button = urwid.AttrWrap(urwid.Button('Cancel'),'body','focus')
self.button_cols = urwid.Columns([ok_button,cancel_button])
#self.active_tab = self.header0
#self.columns = urwid.Columns([('fixed',len(header0_t),self.header0),
# ('fixed',len(header1_t),self.header1),
# ('fixed',len(header2_t),self.header2),
# urwid.Text(('header',title),align='right')],
# dividechars=1)
#content = [self.columns,generalPile]
#self._label = urwid.AttrWrap(SelText(titles),attr[0],attr[1])
#self.walker = urwid.SimpleListWalker(content)
#self.listbox = urwid.ListBox(self.walker)
#self._linebox = urwid.LineBox(self._listbox)
self.tabs = TabColumns(headerList,lbList,'Preferences',self.button_cols)
#overlay = urwid.Overlay(self.tabs, body, ('fixed left', pos[0]),
# width, ('fixed top', pos[1]), height)
self.__super.__init__(self.tabs)
def load_settings(self):
self.always_show_wired_checkb.set_state(
daemon.GetAlwaysShowWiredInterface())
self.auto_reconn_checkb.set_state(daemon.GetAutoReconnect())
self.debug_mode_checkb.set_state(daemon.GetDebugMode())
self.use_dbm_checkb.set_state(daemon.GetSignalDisplayType())
def store_results(self):
daemon.SetAlwaysShowWiredInterface(self.always_show_wired_checkb.get_state())
def global_dns_trigger(self,check_box,new_state,user_data=None):
for w in self.search_dom,self.dns1,self.dns2,self.dns3:
w.set_sensitive(new_state)
# Normal keypress, but if we are at the top, then be "tabbish" instead
#def keypress(self,size,ui):
# self._w.keypress(size,ui)
# (wid,pos) = self._listbox.get_focus()
# if wid is self.columns:
# lw = self.listbox.body
# lw.pop(1)
# self.active_tab.set_attr('body')
# self.columns.get_focus().set_attr('tab active')
# self.active_tab = self.columns.get_focus()
# lw.append(self.tab_map[self.columns.get_focus()])
# self.listbox.body = lw
#@wrap_exceptions()
# Put the widget into an overlay, and run!
def run(self,ui, dim, display):
width,height = ui.get_cols_rows()
# If we are small, "tabbify" the interface
# Else, pile it together
overlay = urwid.Overlay(self.tabs, display, ('fixed left', 0),width
, ('fixed top',1), height-3)
#dialog = TabbedOverlay(["Foo", "Bar", "Quit"],
# ('body', 'focus'), (1, 1), display)
#dialog = PrefOverlay(display,(0,1))
keys = True
while True:
if keys:
ui.draw_screen(dim, overlay.render(dim, True))
keys = ui.get_input()
if "window resize" in keys:
dim = ui.get_cols_rows()
if "esc" in keys or 'Q' in keys:
return
for k in keys:
#Send key to underlying widget:
overlay.keypress(dim, k)
def run():
dialog = PrefsDialog(None,(0,0),ui,dbusmanager.get_dbus_ifaces())
keys = True
dim = ui.get_cols_rows()
while True:
if keys:
ui.draw_screen(dim, dialog.render(dim, True))
keys = ui.get_input()
if "window resize" in keys:
dim = ui.get_cols_rows()
if "esc" in keys or 'Q' in keys:
return
for k in keys:
#Send key to underlying widget:
dialog.keypress(dim, k)
if __name__=='__main__':
try:
dbusmanager.connect_to_dbus()
except DBusException:
# I may need to be a little more verbose here.
# Suggestions as to what should go here
print "Can't connect to the daemon. Are you sure it is running?"
print "Please check the wicd log for error messages."
raise
ui = urwid.curses_display.Screen()
ui.register_palette([
('body','light gray','default'),
('focus','dark magenta','light gray'),
('header','light blue','default'),
('important','light red','default'),
('connected','dark green','default'),
('connected focus','default','dark green'),
('editcp', 'default', 'default', 'standout'),
('editbx', 'light gray', 'dark blue'),
('editfc', 'white','dark blue', 'bold'),
('tab active','dark green','light gray')])
ui.run_wrapper(run)
Reference in New Issue View Git Blame Copy Permalink