def captureState(self):
"""Determines the state of the items on managed by this plugin"""
#Parent functionality for state capturing
MCCPlugin.clearParentState(self)
#If this is a first run of capturing, we might need to fill
#in our remote_count
self.state = {}
for item in ['lirc', 'mythbuntu-lirc-generator']:
self.state[item] = self.query_installed(item)
#TODO, detect smartphone type somehow.
self.state['type'] = 'native'
if self.state['lirc']:
self.state['type'] = 'lirc'
if self.count["remote"] is 0:
self.lirc = LircHandler()
self.populate_lirc()
#Read in our /etc/lirc/hardware.conf
self.lirc.read_hardware_conf()
def __init__(self):
"""Initializes the Mythbuntu installer extra objects"""
#Configure Parent cclass First so we can override things
ParentInstall.__init__(self)
self.lirc=LircHandler()
self.vnc=VNCHandler()
self.type = self.db.get('mythbuntu/install_type')
#This forces install_langpacks to do Nothing
self.langpacks={}
def populate_lirc(self):
"""Fills the lirc pages with the appropriate data"""
self.remote_count = 0
self.transmitter_count = 0
self.lirc=LircHandler()
for item in self.lirc.get_possible_devices("remote"):
self.remote_list.append_text(item)
self.remote_count = self.remote_count + 1
for item in self.lirc.get_possible_devices("transmitter"):
self.transmitter_list.append_text(item)
self.transmitter_count = self.transmitter_count + 1
self.remote_list.set_active(0)
self.transmitter_list.set_active(0)
def root_scripted_changes(self, reconfigure):
"""System-wide changes that need root access to be applied.
This function is ran by the dbus backend"""
lirc = LircHandler()
found = False
for item in reconfigure:
if item == "remote" or item == "transmitter":
logging.debug("Setting item %s to %s." %
(item, reconfigure[item]))
lirc.set_device({item: reconfigure[item]}, item)
found = True
if found:
logging.debug("Writing out /etc/lirc/hardware.conf")
lirc.write_hardware_conf()
logging.debug("Reconfiguring LIRC package")
lirc.reconfigure_lirc(interactive=False)
return found
class Wizard(ubiquity.frontend.gtk_ui.Wizard):
#Overriden Methods
def __init__(self, distro):
del os.environ['UBIQUITY_MIGRATION_ASSISTANT']
ubiquity.frontend.gtk_ui.Wizard.__init__(self,distro)
self.populate_lirc()
self.populate_video()
self.backup=False
def run(self):
"""run the interface."""
def skip_pages(old_backup,old_name,new_name):
"""Skips a mythbuntu page if we should"""
advanced=self.get_advanced()
#advanced install conditionally skips a few pages
if advanced:
type = self.get_installtype()
if (type == "Master Backend" or type == "Slave Backend") and \
(new_name == 'MythbuntuThemes' or new_name == 'MythbuntuRemote'):
if not old_backup:
self.dbfilter.ok_handler()
else:
self.dbfilter.cancel_handler()
self.backup=True
#standard install should fly right through forward
else:
if new_name == 'MythbuntuInstallType' or \
new_name == 'MythbuntuPlugins' or \
new_name == 'MythbuntuThemes' or \
new_name == 'MythbuntuServices' or \
new_name == 'MythbuntuPasswords':
if not old_backup:
self.dbfilter.ok_handler()
else:
self.dbfilter.cancel_handler()
self.backup=True
if os.getuid() != 0:
title = ('This installer must be run with administrative '
'privileges, and cannot continue without them.')
dialog = gtk.MessageDialog(self.live_installer, gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE,
title)
dialog.run()
sys.exit(1)
self.disable_volume_manager()
# show interface
got_intro = self.show_intro()
self.allow_change_step(True)
# Declare SignalHandler
self.glade.signal_autoconnect(self)
# Some signals need to be connected by hand so that we have the
# handler ids.
self.username_changed_id = self.username.connect(
'changed', self.on_username_changed)
self.hostname_changed_id = self.hostname.connect(
'changed', self.on_hostname_changed)
# Start the interface
if got_intro:
global BREADCRUMB_STEPS, BREADCRUMB_MAX_STEP
for step in BREADCRUMB_STEPS:
BREADCRUMB_STEPS[step] += 1
BREADCRUMB_STEPS["stepWelcome"] = 1
BREADCRUMB_MAX_STEP += 1
ubiquity.frontend.gtk_ui.BREADCRUMB_STEPS = BREADCRUMB_STEPS
ubiquity.frontend.gtk_ui.BREADCRUMB_MAX_STEP = BREADCRUMB_MAX_STEP
first_step = self.stepWelcome
else:
first_step = self.stepLanguage
self.set_current_page(self.steps.page_num(first_step))
if got_intro:
# intro_label was the only focusable widget, but got can-focus
# removed, so we end up with no input focus and thus pressing
# Enter doesn't activate the default widget. Work around this.
self.next.grab_focus()
self.pages = [language.Language, timezone.Timezone,
console_setup.ConsoleSetup, partman.Partman,
usersetup.UserSetup, mythbuntu.MythbuntuAdvancedType,
mythbuntu.MythbuntuInstallType, mythbuntu.MythbuntuPlugins,
mythbuntu.MythbuntuThemes, mythbuntu.MythbuntuServices,
mythbuntu.MythbuntuPasswords, mythbuntu.MythbuntuRemote,
mythbuntu.MythbuntuDrivers, mythbuntu_summary.Summary]
self.pagesindex = 0
pageslen = len(self.pages)
if got_intro:
gtk.main()
while(self.pagesindex < pageslen):
if not self.installing:
# Make sure any started progress bars are stopped.
while self.progress_position.depth() != 0:
self.debconf_progress_stop()
old_backup = self.backup
self.backup = False
old_dbfilter = self.dbfilter
self.dbfilter = self.pages[self.pagesindex](self)
# Non-debconf steps are no longer possible as the interface is now
# driven by whether there is a question to ask.
if self.dbfilter is not None and self.dbfilter != old_dbfilter:
self.allow_change_step(False)
self.dbfilter.start(auto_process=True)
skip_pages(old_backup,old_dbfilter.__class__.__name__,self.dbfilter.__class__.__name__)
gtk.main()
if self.backup or self.dbfilter_handle_status():
if self.installing:
self.progress_loop()
elif self.current_page is not None and not self.backup:
self.process_step()
self.pagesindex = self.pagesindex + 1
if self.backup:
if self.pagesindex > 0:
self.pagesindex = self.pagesindex - 1
self.back.show()
# TODO: Move this to after we're done processing GTK events, or is
# that not worth the CPU time?
if self.current_page == None:
break
while gtk.events_pending():
gtk.main_iteration()
# needed to be here for --automatic as there might not be any
# current page in the event all of the questions have been
# preseeded.
if self.pagesindex == pageslen:
# Ready to install
self.live_installer.hide()
self.current_page = None
self.installing = True
self.progress_loop()
#After (and if) install is done, decide what to do
if self.pagesindex == pageslen:
self.run_success_cmd()
if self.get_installtype() == "Frontend":
if not self.get_reboot_seen():
self.finished_dialog.run()
elif self.get_reboot():
self.reboot()
else:
self.live_installer.show()
self.installing = False
self.steps.next_page()
self.back.hide()
self.cancel.hide()
self.next.set_label("Finish")
gtk.main()
self.live_installer.hide()
self.finished_dialog.run()
return self.returncode
def process_step(self):
"""Process and validate the results of this step."""
# setting actual step
step_num = self.steps.get_current_page()
step = self.step_name(step_num)
#Figure out if this is a mythbuntu specific step
if step == "mythbuntu_stepBackendSetup":
syslog.syslog('Step_before = %s' % step)
self.live_installer.hide()
self.current_page = None
self.finished_dialog.run()
else:
ubiquity.frontend.gtk_ui.Wizard.process_step(self)
def progress_loop(self):
"""prepare, copy and config the system in the core install process."""
syslog.syslog('progress_loop()')
self.current_page = None
self.debconf_progress_start(
0, 100, self.get_string('ubiquity/install/title'))
self.debconf_progress_region(0, 15)
dbfilter = partman_commit.PartmanCommit(self)
if dbfilter.run_command(auto_process=True) != 0:
while self.progress_position.depth() != 0:
self.debconf_progress_stop()
self.debconf_progress_window.hide()
self.return_to_partitioning()
return
# No return to partitioning from now on
self.installing_no_return = True
self.debconf_progress_region(15, 100)
dbfilter = mythbuntu_install.Install(self)
ret = dbfilter.run_command(auto_process=True)
if ret != 0:
self.installing = False
if ret == 3:
# error already handled by Install
sys.exit(ret)
elif (os.WIFSIGNALED(ret) and
os.WTERMSIG(ret) in (signal.SIGINT, signal.SIGKILL,
signal.SIGTERM)):
sys.exit(ret)
elif os.path.exists('/var/lib/ubiquity/install.trace'):
tbfile = open('/var/lib/ubiquity/install.trace')
realtb = tbfile.read()
tbfile.close()
raise RuntimeError, ("Install failed with exit code %s\n%s" %
(ret, realtb))
else:
raise RuntimeError, ("Install failed with exit code %s; see "
"/var/log/syslog" % ret)
while self.progress_position.depth() != 0:
self.debconf_progress_stop()
# just to make sure
self.debconf_progress_window.hide()
self.installing = False
def set_page(self, n):
self.run_automation_error_cmd()
gtk_ui_pages = ['Language', 'ConsoleSetup', 'Timezone', 'Partman', 'UserSetup', 'Summary', 'MigrationAssistant']
found = False
for item in gtk_ui_pages:
if n == item:
found = True
ubiquity.frontend.gtk_ui.Wizard.set_page(self,n)
break
if not found:
self.live_installer.show()
if n == 'MythbuntuAdvancedType':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepInstallType))
elif n == 'MythbuntuRemote':
self.set_current_page(self.steps.page_num(self.tab_remote_control))
elif n == 'MythbuntuDrivers':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepDrivers))
if n == 'MythbuntuInstallType':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepCustomInstallType))
elif n == 'MythbuntuPlugins':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepPlugins))
elif n == 'MythbuntuThemes':
self.set_current_page(self.steps.page_num(self.tab_themes))
elif n == 'MythbuntuPasswords':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepPasswords))
installtype=self.get_installtype()
if installtype != "Master Backend/Frontend" and installtype != "Master Backend":
self.allow_go_forward(False)
elif n == 'MythbuntuServices':
self.set_current_page(self.steps.page_num(self.mythbuntu_stepServices))
#Added Methods
def populate_lirc(self):
"""Fills the lirc pages with the appropriate data"""
self.remote_count = 0
self.transmitter_count = 0
self.lirc=LircHandler()
for item in self.lirc.get_possible_devices("remote"):
self.remote_list.append_text(item)
self.remote_count = self.remote_count + 1
for item in self.lirc.get_possible_devices("transmitter"):
self.transmitter_list.append_text(item)
self.transmitter_count = self.transmitter_count + 1
self.remote_list.set_active(0)
self.transmitter_list.set_active(0)
def populate_video(self):
"""Finds the currently active video driver"""
#disable reading xorg.conf. not really a good idea anymore
#with how empty it is as of Hardy
self.video_driver.append_text("Open Source Driver")
self.video_driver.set_active(5)
self.tvoutstandard.set_active(0)
self.tvouttype.set_active(0)
#vid = open('/etc/X11/xorg.conf')
#start_filter = re.compile("Section \"Device\"")
#driver_filter = re.compile("Driver")
#section=False
#for line in vid:
# if not section and start_filter.search(line):
# section=True
# elif section and driver_filter.search(line):
# list = string.split(line, '"')
# if len(list) > 1:
# self.video_driver.append_text("Open Source Driver: " + list[1])
# self.video_driver.set_active(5)
# self.tvoutstandard.set_active(0)
# self.tvouttype.set_active(0)
# break
# else:
# section = False
#if not section:
# self.video_driver.append_text("Open Source Driver")
# self.video_driver.set_active(5)
# self.tvoutstandard.set_active(0)
# self.tvouttype.set_active(0)
#vid.close()
def allow_go_backward(self, allowed):
self.back.set_sensitive(allowed and self.allowed_change_step)
self.allowed_go_backward = allowed
def mythbuntu_password(self,widget):
"""Checks that certain passwords meet requirements"""
#For the services page, the only password we have is the VNC
if (widget is not None and widget.get_name() == 'vnc_password'):
password= widget.get_text().split(' ')[0]
if len(password) >= 6:
self.allow_go_forward(True)
self.allow_go_backward(True)
self.vnc_error_image.hide()
else:
self.allow_go_forward(False)
self.allow_go_backward(False)
self.vnc_error_image.show()
elif (widget is not None and widget.get_name() == 'mythweb_username'):
username = widget.get_text().split(' ')[0]
if len(username) >= 1:
self.mythweb_user_error_image.hide()
else:
self.mythweb_user_error_image.show()
elif (widget is not None and widget.get_name() == 'mythweb_password'):
password = widget.get_text().split(' ')[0]
if len(password) >= 1:
self.mythweb_pass_error_image.hide()
else:
self.mythweb_pass_error_image.show()
elif (widget is not None and widget.get_name() == 'mysql_root_password'):
password = widget.get_text().split(' ')[0]
if len(password) >= 1:
self.mysql_root_error_image.hide()
else:
self.mysql_root_error_image.show()
#The password check page is much more complex. Pieces have to be
#done in a sequential order
if (self.usemysqlrootpassword.get_active() or self.usemythwebpassword.get_active()):
mysql_root_flag = self.mysql_root_error_image.flags() & gtk.VISIBLE
mythweb_user_flag = self.mythweb_user_error_image.flags() & gtk.VISIBLE
mythweb_pass_flag = self.mythweb_pass_error_image.flags() & gtk.VISIBLE
result = not (mythweb_user_flag | mythweb_pass_flag | mysql_root_flag)
self.allow_go_forward(result)
self.allow_go_backward(result)
def do_mythtv_setup(self,widget):
"""Spawn MythTV-Setup binary."""
os.seteuid(0)
execute("/usr/share/ubiquity/mythbuntu-setup")
drop_privileges()
def do_connection_test(self,widget):
"""Tests to make sure that the backend is accessible"""
host = self.mysql_server.get_text()
database = self.mysql_database.get_text()
user = self.mysql_user.get_text()
password = self.mysql_password.get_text()
try:
db = MySQLdb.connect(host=host, user=user, passwd=password,db=database)
cursor = db.cursor()
cursor.execute("SELECT NULL")
result = cursor.fetchone()
cursor.close()
db.close()
result = "Successful"
self.allow_go_forward(True)
except:
result = "Failure"
self.allow_go_forward(False)
self.connection_results_label.show()
self.connection_results.set_text(result)
def toggle_installtype (self,widget):
"""Called whenever standard or full are toggled"""
if self.standardinstall.get_active() :
#Make sure that we have everything turned on in case they came back to this page
#and changed their mind
#Note: This will recursively handle changing the values on the pages
self.master_be_fe.set_active(True)
self.enablessh.set_active(True)
self.enablevnc.set_active(False)
self.enablenfs.set_active(False)
self.enablesamba.set_active(True)
self.enablemysql.set_active(False)
else:
self.theme_mythbuntu.set_sensitive(False)
self.master_backend_expander.hide()
self.mythweb_expander.show()
self.mysql_server_expander.show()
def toggle_customtype (self,widget):
"""Called whenever a custom type is toggled"""
def set_fe_drivers(self,enable):
"""Toggle Visible Frontend Applicable Drivers"""
if enable:
self.frontend_driver_list.show()
else:
self.frontend_driver_list.hide()
def set_be_drivers(self,enable):
"""Toggles Visible Backend Applicable Drivers"""
if enable:
self.backend_driver_list.show()
self.tuner0.set_active(0)
self.tuner1.set_active(0)
self.tuner2.set_active(0)
self.tuner3.set_active(0)
self.tuner4.set_active(0)
else:
self.backend_driver_list.hide()
def set_all_services(self,enable):
"""Toggles visibility on all possible services"""
if enable:
self.ssh_option_hbox.show()
self.samba_option_hbox.show()
self.nfs_option_hbox.show()
self.mysql_option_hbox.show()
else:
self.ssh_option_hbox.hide()
self.samba_option_hbox.hide()
self.nfs_option_hbox.hide()
self.mysql_option_hbox.hide()
def set_all_passwords(self,enable):
"""Toggles visibility on all password selection boxes"""
if enable:
self.master_backend_expander.show()
self.mythweb_expander.show()
self.mysql_server_expander.show()
else:
self.master_backend_expander.hide()
self.mythweb_expander.hide()
self.mysql_server_expander.hide()
def set_all_themes(self,enable):
"""Enables all themes for defaults"""
self.communitythemes.set_active(enable)
self.officialthemes.set_active(enable)
def set_all_fe_plugins(self,enable):
""" Enables all frontend plugins for defaults"""
self.mytharchive.set_active(enable)
self.mythbrowser.set_active(enable)
self.mythcontrols.set_active(enable)
self.mythflix.set_active(enable)
self.mythgallery.set_active(enable)
self.mythgame.set_active(enable)
self.mythmovies.set_active(enable)
self.mythmusic.set_active(enable)
self.mythnews.set_active(enable)
self.mythphone.set_active(enable)
self.mythstream.set_active(enable)
self.mythvideo.set_active(enable)
self.mythweather.set_active(enable)
def set_all_be_plugins(self,enable):
""" Enables all backend plugins for defaults"""
self.mythweb.set_active(enable)
if self.master_be_fe.get_active():
set_all_themes(self,True)
set_all_fe_plugins(self,True)
set_all_be_plugins(self,True)
set_all_passwords(self,True)
set_all_services(self,True)
self.enablessh.set_active(True)
self.enablesamba.set_active(True)
self.frontend_plugin_list.show()
self.backend_plugin_list.show()
self.febe_heading_label.set_label("Choose Frontend / Backend Plugins")
self.master_backend_expander.hide()
set_fe_drivers(self,True)
set_be_drivers(self,True)
elif self.slave_be_fe.get_active():
set_all_themes(self,True)
set_all_fe_plugins(self,True)
set_all_be_plugins(self,True)
set_all_services(self,True)
set_all_passwords(self,True)
self.enablessh.set_active(True)
self.enablesamba.set_active(True)
self.frontend_plugin_list.show()
self.backend_plugin_list.show()
self.febe_heading_label.set_label("Choose Frontend / Backend Plugins")
self.mysql_server_expander.hide()
self.mysql_option_hbox.hide()
set_fe_drivers(self,True)
set_be_drivers(self,True)
elif self.master_be.get_active():
set_all_themes(self,False)
set_all_fe_plugins(self,False)
set_all_be_plugins(self,True)
set_all_services(self,True)
set_all_passwords(self,True)
self.enablessh.set_active(True)
self.enablesamba.set_active(True)
self.frontend_plugin_list.hide()
self.backend_plugin_list.show()
self.febe_heading_label.set_label("Choose Backend Plugins")
self.master_backend_expander.hide()
set_fe_drivers(self,False)
set_be_drivers(self,True)
elif self.slave_be.get_active():
set_all_themes(self,False)
set_all_fe_plugins(self,False)
set_all_be_plugins(self,True)
set_all_services(self,True)
set_all_passwords(self,True)
self.enablessh.set_active(True)
self.enablesamba.set_active(True)
self.frontend_plugin_list.hide()
self.backend_plugin_list.show()
self.febe_heading_label.set_label("Choose Backend Plugins")
self.mysql_server_expander.hide()
self.mysql_option_hbox.hide()
set_fe_drivers(self,False)
set_be_drivers(self,True)
else:
set_all_themes(self,True)
set_all_fe_plugins(self,True)
set_all_be_plugins(self,False)
set_all_services(self,True)
set_all_passwords(self,True)
self.enablessh.set_active(True)
self.enablesamba.set_active(False)
self.enablenfs.set_active(False)
self.enablemysql.set_active(False)
self.frontend_plugin_list.show()
self.backend_plugin_list.hide()
self.febe_heading_label.set_label("Choose Frontend Plugins")
self.mythweb_expander.hide()
self.mysql_server_expander.hide()
self.mysql_option_hbox.hide()
self.nfs_option_hbox.hide()
self.samba_option_hbox.hide()
set_fe_drivers(self,True)
set_be_drivers(self,False)
def toggle_ir(self,widget):
"""Called whenever a request to enable/disable remote is called"""
if widget is not None:
#turn on/off IR remote
if widget.get_name() == 'remotecontrol':
self.remote_hbox.set_sensitive(widget.get_active())
self.generate_lircrc_checkbox.set_sensitive(widget.get_active())
if widget.get_active() and self.remote_list.get_active() == 0:
self.remote_list.set_active(1)
else:
self.remote_list.set_active(0)
#turn on/off IR transmitter
elif widget.get_name() == "transmittercontrol":
self.transmitter_hbox.set_sensitive(widget.get_active())
if widget.get_active():
if self.transmitter_list.get_active() == 0:
self.transmitter_list.set_active(1)
else:
self.transmitter_list.set_active(0)
#if our selected remote itself changed
elif widget.get_name() == 'remote_list':
self.generate_lircrc_checkbox.set_active(True)
if self.remote_list.get_active() == 0:
custom = False
self.remotecontrol.set_active(False)
self.generate_lircrc_checkbox.set_active(False)
elif self.remote_list.get_active_text() == "Custom":
custom = True
else:
custom = False
self.remote_driver.set_text("")
self.remote_modules.set_text("")
self.remote_device.set_text("")
self.remote_driver_hbox.set_sensitive(custom)
self.remote_modules_hbox.set_sensitive(custom)
self.remote_device_hbox.set_sensitive(custom)
self.remote_configuration_hbox.set_sensitive(custom)
self.browse_remote_lircd_conf.set_filename("/usr/share/lirc/remotes")
#if our selected transmitter itself changed
elif widget.get_name() == 'transmitter_list':
if self.transmitter_list.get_active() == 0:
custom = False
self.transmittercontrol.set_active(False)
elif self.transmitter_list.get_active_text() == "Custom":
custom = True
else:
custom = False
self.transmitter_driver.set_text("")
self.transmitter_modules.set_text("")
self.transmitter_device.set_text("")
self.transmitter_driver_hbox.set_sensitive(custom)
self.transmitter_modules_hbox.set_sensitive(custom)
self.transmitter_device_hbox.set_sensitive(custom)
self.transmitter_configuration_hbox.set_sensitive(custom)
self.browse_transmitter_lircd_conf.set_filename("/usr/share/lirc/transmitters")
def mythweb_toggled(self,widget):
"""Called when the checkbox to install Mythweb is toggled"""
if (self.mythweb.get_active()):
self.mythweb_expander.show()
else:
self.mythweb_expander.hide()
def enablevnc_toggled(self,widget):
"""Called when the checkbox to turn on VNC is toggled"""
if (self.enablevnc.get_active()):
self.vnc_pass_hbox.set_sensitive(True)
self.allow_go_forward(False)
self.allow_go_backward(False)
self.vnc_error_image.show()
else:
self.vnc_pass_hbox.set_sensitive(False)
self.vnc_password.set_text("")
self.allow_go_forward(True)
self.allow_go_backward(True)
self.vnc_error_image.hide()
def uselivemysqlinfo_toggled(self,widget):
"""Called when the checkbox to copy live mysql information is pressed"""
if (self.uselivemysqlinfo.get_active()):
#disable modifying
self.master_backend_table.set_sensitive(False)
#read in mysql.txt to set the new defaults
try:
in_f=open("/etc/mythtv/mysql.txt")
for line in in_f:
if re.compile("^DBHostName").search(line):
text=string.split(string.split(line,"=")[1],'\n')[0]
self.old_mysql_server=self.mysql_server.get_text()
self.mysql_server.set_text(text)
elif re.compile("^DBUserName").search(line):
text=string.split(string.split(line,"=")[1],'\n')[0]
self.old_mysql_user=self.mysql_user.get_text()
self.mysql_user.set_text(text)
elif re.compile("^DBName").search(line):
text=string.split(string.split(line,"=")[1],'\n')[0]
self.old_mysql_database=self.mysql_database.get_text()
self.mysql_database.set_text(text)
elif re.compile("^DBPassword").search(line):
text=string.split(string.split(line,"=")[1],'\n')[0]
self.old_mysql_password=self.mysql_password.get_text()
self.mysql_password.set_text(text)
in_f.close()
except IOError:
#in case for some reason we are missing mysql.txt
self.usemysqlinfo.set_active(False)
else:
self.allow_go_forward(False)
self.connection_results_label.hide()
self.connection_results.set_text("Please Test your connection to proceed")
self.master_backend_table.set_sensitive(True)
self.mysql_server.set_text(self.old_mysql_server)
self.mysql_user.set_text(self.old_mysql_user)
self.mysql_password.set_text(self.old_mysql_password)
self.mysql_database.set_text(self.old_mysql_database)
def usemythwebpassword_toggled(self,widget):
"""Called when the checkbox to set a mythweb password is pressed"""
if (self.usemythwebpassword.get_active()):
self.mythweb_table.show()
self.allow_go_forward(False)
self.allow_go_backward(False)
self.mythweb_user_error_image.show()
self.mythweb_pass_error_image.show()
else:
self.mythweb_table.hide()
self.mythweb_password.set_text("")
self.mythweb_username.set_text("")
self.mythweb_user_error_image.hide()
self.mythweb_pass_error_image.hide()
if (not self.usemysqlrootpassword.get_active() or not self.mysql_root_error_image.flags() & gtk.VISIBLE):
self.allow_go_forward(True)
self.allow_go_backward(True)
def usemysqlrootpassword_toggled(self,widget):
"""Called when the checkbox to set a MySQL root password is pressed"""
if (self.usemysqlrootpassword.get_active()):
self.mysql_server_hbox.show()
self.allow_go_forward(False)
self.allow_go_backward(False)
self.mysql_root_error_image.show()
else:
self.mysql_server_hbox.hide()
self.mysql_root_password.set_text("")
self.mysql_root_error_image.hide()
if (not self.usemythwebpassword.get_active() or ((not self.mythweb_pass_error_image.flags() & gtk.VISIBLE) and (not self.mythweb_user_error_image.flags() & gtk.VISIBLE))):
self.allow_go_forward(True)
self.allow_go_backward(True)
def toggle_number_tuners (self,widget):
"""Called whenever a number of tuners is changed"""
num = self.number_tuners.get_value()
if num > 0:
if num > 1:
if num > 2:
if num > 3:
if num > 4:
self.tuner0.show()
self.tuner1.show()
self.tuner2.show()
self.tuner3.show()
self.tuner4.show()
else:
self.tuner0.show()
self.tuner1.show()
self.tuner2.show()
self.tuner3.show()
self.tuner4.hide()
self.tuner4.set_active(0)
else:
self.tuner0.show()
self.tuner1.show()
self.tuner2.show()
self.tuner3.hide()
self.tuner3.set_active(0)
self.tuner4.hide()
self.tuner4.set_active(0)
else:
self.tuner0.show()
self.tuner1.show()
self.tuner2.hide()
self.tuner2.set_active(0)
self.tuner3.hide()
self.tuner3.set_active(0)
self.tuner4.hide()
self.tuner4.set_active(0)
else:
self.tuner0.show()
self.tuner1.hide()
self.tuner1.set_active(0)
self.tuner2.hide()
self.tuner2.set_active(0)
self.tuner3.hide()
self.tuner3.set_active(0)
self.tuner4.hide()
self.tuner4.set_active(0)
else:
self.tuner0.hide()
self.tuner0.set_active(0)
self.tuner1.hide()
self.tuner1.set_active(0)
self.tuner2.hide()
self.tuner2.set_active(0)
self.tuner3.hide()
self.tuner3.set_active(0)
self.tuner4.hide()
self.tuner4.set_active(0)
def toggle_tuners (self,widget):
"""Checks to make sure no tuner widgets have same value"""
def return_tuner_val(self,num):
if num == 0:
return self.tuner0.get_active()
elif num == 1:
return self.tuner1.get_active()
elif num == 2:
return self.tuner2.get_active()
elif num == 3:
return self.tuner3.get_active()
elif num == 4:
return self.tuner4.get_active()
number_tuners = self.number_tuners.get_value_as_int()
enable_warning=False
for i in range(number_tuners):
#Check for the unknown Analogue or Digital Option
if (return_tuner_val(self,i) == 19 or return_tuner_val(self,i) == 20):
enable_warning=True
if enable_warning == True:
self.tunernotice.show()
else:
self.tunernotice.hide()
def video_changed (self,widget):
"""Called whenever the modify video driver option is toggled or its kids"""
if (widget is not None and widget.get_name() == 'modifyvideodriver'):
if (widget.get_active()):
self.videodrivers_hbox.set_sensitive(True)
else:
self.tvout_vbox.set_sensitive(False)
self.videodrivers_hbox.set_sensitive(False)
self.video_driver.set_active(5)
self.tvoutstandard.set_active(0)
self.tvouttype.set_active(0)
elif (widget is not None and widget.get_name() == 'video_driver'):
type = widget.get_active()
if (type == 0 or type == 1 or type == 2 or type == 3 or type == 4):
self.tvout_vbox.set_sensitive(True)
else:
self.tvout_vbox.set_sensitive(False)
self.tvoutstandard.set_active(0)
self.tvouttype.set_active(0)
def toggle_tv_out (self,widget):
"""Called when the tv-out type is toggled"""
if (self.tvouttype.get_active() == 0):
self.tvoutstandard.set_active(0)
elif ((self.tvouttype.get_active() == 1 or self.tvouttype.get_active() == 2) and (self.tvoutstandard.get_active() == 0 or self.tvoutstandard.get_active() >= 11 )):
self.tvoutstandard.set_active(10)
elif self.tvouttype.get_active() == 3:
self.tvoutstandard.set_active(11)
def toggle_tv_standard(self,widget):
"""Called when the tv standard is toggled"""
if (self.tvoutstandard.get_active() >= 11):
self.tvouttype.set_active(3)
elif (self.tvoutstandard.get_active() < 11 and self.tvoutstandard.get_active() > 0 and self.tvouttype.get_active() == 0):
self.tvouttype.set_active(1)
elif (self.tvoutstandard.get_active() < 11 and self.tvouttype.get_active() ==3):
self.tvouttype.set_active(1)
elif (self.tvoutstandard.get_active() == 0):
self.tvouttype.set_active(0)
def get_advanced(self):
"""Returns if this is an advanced install"""
return self.custominstall.get_active()
def get_installtype(self):
"""Returns the current custom installation type"""
if self.master_be_fe.get_active():
return "Master Backend/Frontend"
elif self.slave_be_fe.get_active():
return "Slave Backend/Frontend"
elif self.master_be.get_active():
return "Master Backend"
elif self.slave_be.get_active():
return "Slave Backend"
elif self.fe.get_active():
return "Frontend"
def get_mytharchive(self):
"""Returns the status of the mytharchive plugin"""
if self.mytharchive.get_active():
return True
else:
return False
def get_mythbrowser(self):
"""Returns the status of the mythbrowser plugin"""
if self.mythbrowser.get_active():
return True
else:
return False
def get_mythcontrols(self):
"""Returns the status of the mythcontrols plugin"""
if self.mythcontrols.get_active():
return True
else:
return False
def get_mythmovies(self):
"""Returns the status of the mythmovies plugin"""
if self.mythmovies.get_active():
return True
else:
return False
def get_mythflix(self):
"""Returns the status of the mythflix plugin"""
if self.mythflix.get_active():
return True
else:
return False
def get_mythgallery(self):
"""Returns the status of the mythgallery plugin"""
if self.mythgallery.get_active():
return True
else:
return False
def get_mythgame(self):
"""Returns the status of the mythgame plugin"""
if self.mythgame.get_active():
return True
else:
return False
def get_mythmusic(self):
"""Returns the status of the mythmusic plugin"""
if self.mythmusic.get_active():
return True
else:
return False
def get_mythnews(self):
"""Returns the status of the mythnews plugin"""
if self.mythnews.get_active():
return True
else:
return False
def get_mythphone(self):
"""Returns the status of the mythphone plugin"""
if self.mythphone.get_active():
return True
else:
return False
def get_mythstream(self):
"""Returns the status of the mythstream plugin"""
if self.mythstream.get_active():
return True
else:
return False
def get_mythvideo(self):
"""Returns the status of the mythvideo plugin"""
if self.mythvideo.get_active():
return True
else:
return False
def get_mythweather(self):
"""Returns the status of the mythweather plugin"""
if self.mythweather.get_active():
return True
else:
return False
def get_mythweb(self):
"""Returns the status of the mythweb plugin"""
if self.mythweb.get_active():
return True
else:
return False
def get_officialthemes(self):
"""Returns the status of the official themes"""
return get_official_theme_dictionary(self)
def get_communitythemes(self):
"""Returns the status of the community themes"""
return get_community_theme_dictionary(self)
def get_video(self):
"""Returns the status of the video graphics drivers"""
if (self.modifyvideodriver.get_active()):
driver = self.video_driver.get_active()
if driver == 0:
return "fglrx"
elif driver == 1:
return "nvidia_legacy"
elif driver == 2:
return "nvidia"
elif driver == 3:
return "nvidia_new"
elif driver == 4:
return "pvr_350"
else:
return "None"
else:
return "None"
def get_tvout(self):
"""Returns the status of the TV Out type"""
if (self.modifyvideodriver.get_active()):
return self.tvouttype.get_active_text()
else:
return "Disable TV-Out"
def get_tvstandard(self):
"""Returns the status of the TV Standard type"""
if (self.modifyvideodriver.get_active()):
return self.tvoutstandard.get_active_text()
else:
return "Disable TV-Out"
def get_uselivemysqlinfo(self):
if (self.uselivemysqlinfo.get_active()):
return True
else:
return False
def get_mysqluser(self):
return self.mysql_user.get_text()
def get_mysqlpass(self):
return self.mysql_password.get_text()
def get_mysqldatabase(self):
return self.mysql_database.get_text()
def get_mysqlserver(self):
return self.mysql_server.get_text()
def get_secure_mysql(self):
if self.usemysqlrootpassword.get_active():
return True
else:
return False
def get_mysql_root_password(self):
return self.mysql_root_password.get_text()
def get_secure_mythweb(self):
if self.usemythwebpassword.get_active():
return True
else:
return False
def get_mythweb_username(self):
return self.mythweb_username.get_text()
def get_mythweb_password(self):
return self.mythweb_password.get_text()
def get_vnc(self):
if self.enablevnc.get_active():
return True
else:
return False
def get_vnc_password(self):
return self.vnc_password.get_text()
def get_ssh(self):
if self.enablessh.get_active():
return True
else:
return False
def get_samba(self):
if self.enablesamba.get_active():
return True
else:
return False
def get_nfs(self):
if self.enablenfs.get_active():
return True
else:
return False
def get_mysql_port(self):
if self.enablemysql.get_active():
return True
else:
return False
def get_lirc(self,type):
item = {"modules":"","device":"","driver":"","lircd_conf":""}
if type == "remote":
item["remote"]=self.remote_list.get_active_text()
if item["remote"] == "Custom":
item["modules"]=self.remote_modules.get_text()
item["device"]=self.remote_device.get_text()
item["driver"]=self.remote_driver.get_text()
item["lircd_conf"]=self.browse_remote_lircd_conf.get_filename()
elif type == "transmitter":
item["transmitter"]=self.transmitter_list.get_active_text()
if item["transmitter"] == "Custom":
item["modules"]=self.transmitter_modules.get_text()
item["device"]=self.transmitter_device.get_text()
item["driver"]=self.transmitter_driver.get_text()
item["lircd_conf"]=self.browse_transmitter_lircd_conf.get_filename()
return item
def get_hdhomerun(self):
return self.hdhomerun.get_active()
def get_xmltv(self):
return self.xmltv.get_active()
def get_dvbutils(self):
return self.dvbutils.get_active()
def toggle_meta(self,widget):
"""Called whenever a request to enable / disable all plugins"""
if widget is not None:
list = []
name = widget.get_name()
if (name == 'officialthemes'):
list = get_official_theme_dictionary(self)
elif (name == 'communitythemes'):
list = get_community_theme_dictionary(self)
toggle = widget.get_active()
for item in list:
if list[item].flags() & gtk.SENSITIVE:
list[item].set_active(toggle)
class Install(ParentInstall):
def __init__(self):
"""Initializes the Mythbuntu installer extra objects"""
#Configure Parent cclass First so we can override things
ParentInstall.__init__(self)
self.lirc=LircHandler()
self.vnc=VNCHandler()
self.type = self.db.get('mythbuntu/install_type')
#This forces install_langpacks to do Nothing
self.langpacks={}
def configure_user(self):
"""Configures by the regular user configuration stuff
followed by mythbuntu specific user addons"""
#Before beginning, set the initial root sql pass to the user pass
self.passwd=self.db.get('passwd/user-password')
self.set_debconf('mythtv/mysql_admin_password',self.passwd)
self.set_debconf('mysql-server/root_password',self.passwd)
self.set_debconf('mysql-server/root_password_again',self.passwd)
#Regular ubuntu user configuration
ParentInstall.configure_user(self)
#We'll be needing the username, uid, gid
self.user = self.db.get('passwd/username')
self.uid = self.gid = ''
try:
self.uid = self.db.get('passwd/user-uid')
except debconf.DebconfError:
pass
try:
self.gid = self.db.get('passwd/user-gid')
except debconf.DebconfError:
pass
if self.uid == '':
self.uid = 1000
else:
self.uid = int(self.uid)
if self.gid == '':
self.gid = 1000
else:
self.gid = int(self.gid)
#Create a .mythtv directory
home_mythtv_dir = self.target + '/home/' + self.user + '/.mythtv'
if not os.path.isdir(home_mythtv_dir):
#in case someone made a symlink or file for the directory
if os.path.islink(home_mythtv_dir) or os.path.exists(home_mythtv_dir):
os.remove(home_mythtv_dir)
os.mkdir(home_mythtv_dir)
os.chown(home_mythtv_dir,self.uid,self.gid)
#Remove mysql.txt from home directory if it's there, then make one
sql_txt= home_mythtv_dir + '/mysql.txt'
if os.path.islink(sql_txt) or os.path.exists(sql_txt):
os.remove(sql_txt)
try:
os.symlink('/etc/mythtv/mysql.txt',sql_txt)
except OSError:
#on a live disk there is a chance this was a broken link
#depending on what the user did in the livefs
pass
#mythtv.desktop autostart
if 'Frontend' in self.type:
config_dir = self.target + '/home/' + self.user + '/.config'
autostart_dir = config_dir + '/autostart'
autostart_link = autostart_dir + '/mythtv.desktop'
if not os.path.isdir(config_dir):
os.makedirs(config_dir)
os.chown(config_dir,self.uid,self.gid)
if not os.path.isdir(autostart_dir):
os.makedirs(autostart_dir)
os.chown(autostart_dir,self.uid,self.gid)
elif os.path.islink(autostart_link) or os.path.exists(autostart_link):
os.remove(autostart_link)
try:
os.symlink('/usr/share/applications/mythtv.desktop',autostart_link)
except OSError:
#on a live disk, this will appear a broken link, but it works
pass
#group membership
self.chrex('adduser', self.user, 'mythtv')
self.chrex('adduser', self.user, 'video')
def configure_ma(self):
"""Overrides module assistant configuration method. Mythbuntu doesn't
use module assistant, but we can instead run MySQL and mythweb config
here"""
self.db.progress('INFO', 'ubiquity/install/mythbuntu')
#Copy a few debconf questions that were answered in the installer
for question in ('mythtv/mysql_mythtv_user','mythtv/mysql_mythtv_password',\
'mythtv/mysql_mythtv_dbname','mythtv/mysql_host'):
answer=self.db.get(question)
self.set_debconf(question,answer)
#Setup mysql.txt nicely
os.remove(self.target + '/etc/mythtv/mysql.txt')
self.reconfigure('mythtv-common')
#only reconfigure database if appropriate
if 'Master' in self.type:
#Prepare
self.chrex('mount', '-t', 'proc', 'proc', '/proc')
#Setup database
self.reconfigure('mysql-server-5.0')
self.reconfigure('mythtv-database')
#Cleanup
self.chrex('invoke-rc.d','mysql','stop')
self.chrex('umount', '/proc')
#Mythweb
self.set_debconf('mythweb/enable', 'true')
self.set_debconf('mythweb/username', self.user)
self.set_debconf('mythweb/password', self.passwd)
self.reconfigure('mythweb')
def install_extras(self):
"""Overrides main install_extras function to add in Mythbuntu
drivers and services, and then call the parent function"""
video_driver = self.db.get('mythbuntu/video_driver')
vnc = self.db.get('mythbuntu/x11vnc')
nfs = self.db.get('mythbuntu/nfs-kernel-server')
to_install = []
to_remove = set()
if video_driver != "Open Source Driver":
to_install.append(video_driver)
if vnc == 'true':
to_install.append('x11vnc')
if nfs == 'true':
to_install.append('nfs-kernel-server')
to_install.append('portmap')
#Remove any conflicts before installing new items
if to_remove != []:
self.do_remove(to_remove)
#Mark new items
self.record_installed(to_install)
#Actually install extras
ParentInstall.install_extras(self)
#Run depmod if we might be using a DKMS enabled driver
if video_driver != "Open Source Driver":
self.chrex('/sbin/depmod','-a')
def configure_hardware(self):
"""Overrides parent function to add in hooks for configuring
drivers and services"""
#Drivers
self.db.progress('INFO', 'ubiquity/install/drivers')
video_driver = self.db.get('mythbuntu/video_driver')
out = self.db.get('mythbuntu/tvout')
standard = self.db.get('mythbuntu/tvstandard')
if 'nvidia' in video_driver:
self.enable_nvidia(out,standard)
elif 'fglrx' in video_driver:
self.enable_amd(out,standard)
#Services
self.db.progress('INFO', 'ubiquity/install/services')
if self.db.get('mythbuntu/samba') == 'true':
shutil.copy('/usr/share/mythbuntu-common/examples/smb.conf.dist',self.target + '/etc/samba/smb.conf')
if self.db.get('mythbuntu/nfs-kernel-server') == 'true':
shutil.copy('/usr/share/mythbuntu-common/examples/exports.dist',self.target + '/etc/exports')
if self.db.get('mythbuntu/openssh-server') == 'true':
for file in ['ssh_host_dsa_key','ssh_host_dsa_key.pub','ssh_host_rsa_key','ssh_host_rsa_key.pub']:
os.remove(self.target + '/etc/ssh/' + file)
self.reconfigure('openssh-server')
if self.db.get('mythbuntu/mysql-server') == 'true':
f=open(self.target + '/etc/mysql/conf.d/mythtv.cnf','w')
print >>f, """\
[mysqld]
bind-address=0.0.0.0"""
f.close()
if self.db.get('mythbuntu/x11vnc') == 'true':
self.vnc.create_password(self.passwd)
directory = self.target + '/home/' + self.user + '/.vnc'
if not os.path.exists(directory):
os.mkdir(directory)
shutil.move('/root/.vnc/passwd', directory + '/passwd')
os.system('chown ' + str(self.uid) + ':' + str(self.gid) + ' -R ' + directory)
#Remotes & Transmitters
self.db.progress('INFO', 'ubiquity/install/ir')
self.configure_ir()
#Regular parent hardware configure f/n
self.db.progress('INFO', 'ubiquity/install/hardware')
ParentInstall.configure_hardware(self)
def configure_ir(self):
"""Configures the remote & transmitter per user choices"""
#configure lircd for remote and transmitter
ir_device={"modules":"","driver":"","device":"","lircd_conf":"","remote":"","transmitter":""}
self.chroot_setup()
self.chrex('dpkg-divert', '--package', 'ubiquity', '--rename',
'--quiet', '--add', '/sbin/udevd')
try:
os.symlink('/bin/true', '/target/sbin/udevd')
except OSError:
pass
try:
ir_device["remote"] = self.db.get('lirc/remote')
self.set_debconf('lirc/remote',ir_device["remote"])
ir_device["modules"] = ""
ir_device["driver"] = ""
ir_device["device"] = ""
ir_device["lircd_conf"] = ""
self.lirc.set_device(ir_device,"remote")
except debconf.DebconfError:
pass
try:
ir_device["transmitter"] = self.db.get('lirc/transmitter')
self.set_debconf('lirc/transmitter',ir_device["transmitter"])
ir_device["modules"] = ""
ir_device["driver"] = ""
ir_device["device"] = ""
ir_device["lircd_conf"] = ""
self.lirc.set_device(ir_device,"transmitter")
except debconf.DebconfError:
pass
self.lirc.write_hardware_conf(self.target + '/etc/lirc/hardware.conf')
try:
self.reconfigure('lirc')
finally:
try:
os.unlink('/target/sbin/udevd')
except OSError:
pass
self.chrex('dpkg-divert', '--package', 'ubiquity', '--rename',
'--quiet', '--remove', '/sbin/udevd')
self.chroot_cleanup()
#configure lircrc
home = '/target/home/' + self.db.get('passwd/username')
os.putenv('HOME',home)
self.lirc.create_lircrc(self.target + "/etc/lirc/lircd.conf",False)
os.system('chown ' + str(self.uid) + ':' + str(self.gid) + ' -R ' + home + '/.lirc*')
def enable_amd(self,type,format):
if type == 'Composite Video Output':
self.chrex('/usr/bin/aticonfig','--tvs VIDEO', '--tvf ' + format)
elif type == 'S-Video Video Output':
self.chrex('/usr/bin/aticonfig','--tvs VIDEO', '--tvf ' + format)
elif type == 'Component Video Output':
self.chrex('/usr/bin/aticonfig','--tvs YUV', '--tvf ' + format)
else:
self.chrex('/usr/bin/aticonfig')
def enable_nvidia(self,type,format):
"""Enables an NVIDIA graphics driver using XKit"""
xorg_conf=XKit.xutils.XUtils("/etc/X11/xorg.conf")
extra_conf_options={'NoLogo': '1',
'DPI': '100x100',
'UseEvents': '1'}
if type == 'Composite Video Output':
extra_conf_options["ConnectedMonitor"]="TV"
extra_conf_options["TVOutFormat"]="COMPOSITE"
extra_conf_options["TVStandard"]=format
elif type == 'S-Video Video Output':
extra_conf_options["ConnectedMonitor"]="TV"
extra_conf_options["TVOutFormat"]="SVIDEO"
extra_conf_options["TVStandard"]=format
elif type == 'Component Video Output':
extra_conf_options["ConnectedMonitor"]="TV"
extra_conf_options["TVOutFormat"]="COMPONENT"
extra_conf_options["TVStandard"]=format
#Set up device section
relevant_devices = []
if len(xorg_conf.globaldict['Device']) == 0:
device = xorg_conf.makeSection('Device', identifier='Default Device')
relevant_devices.append(device)
xorg_conf.setDriver('Device', 'nvidia', device)
else:
devices = xorg_conf.getDevicesInUse()
if len(devices) > 0:
relevant_devices = devices
else:
relevant_devices = xorg_conf.globaldict['Device'].keys()
for device in relevant_devices:
xorg_conf.setDriver('Device', 'nvidia', device)
for device_section in relevant_devices:
for k, v in extra_conf_options.iteritems():
xorg_conf.addOption('Device', k, v, optiontype='Option', position=device_section)
#Set up screen section
if len(xorg_conf.globaldict['Screen']) == 0:
screen = xorg_conf.makeSection('Screen', identifier='Default Screen')
xorg_conf.addOption('Screen', 'DefaultDepth', '24', position=0, prefix='')
xorg_conf.writeFile(self.target + "/etc/X11/xorg.conf")
def remove_extras(self):
"""Try to remove packages that are installed on the live CD but not on
the installed system."""
#First remove normal live-desktop packages
ParentInstall.remove_extras(self)
#now take care of mythbuntu specifics
packages=set()
## system role
if 'Slave' in self.type or self.type == 'Frontend':
packages.add('mythtv-backend-master')
if 'Frontend' not in self.type:
packages.add('mythtv-frontend')
## services that are installed by default
for service in ['samba','openssh-server']:
if self.db.get('mythbuntu/' + service) == "false":
packages.add(service)
if len(packages) >= 0:
#recursively remove to make sure we get plugins and services that
#aren't necessary anymore
self.do_remove(packages,True)
class RemotePlugin(MCCPlugin):
"""A GUI configuration tool for LIRC"""
def __init__(self):
#Initialize parent class
information = {}
information["name"] = "Infrared"
information["icon"] = "gtk-media-record"
information["ui"] = "tab_remote_control"
MCCPlugin.__init__(self, information)
self.count = {}
self.count["remote"] = 0
self.count["transmitter"] = 0
#Helper functions
def populate_lirc(self):
"""Fills the lirc pages with the appropriate data"""
def fill_array(list, possible_items):
"""Fills an individual array up"""
count = 0
for item in possible_items:
list.append([item])
count = count + 1
return count
for type in ('remote', 'transmitter'):
list = self.builder.get_object(type + '_list')
model = list.get_model()
self.count[type]=fill_array(model, \
self.lirc.get_possible_devices(type))
list.set_active_iter(model.get_iter(Gtk.TreePath([0, 0])))
def find_lircrc(self):
"""Determines if there is current a lircrc for the current user"""
return os.path.exists(os.getenv('HOME') + '/.lircrc')
#Inherited, overridden functions
def captureState(self):
"""Determines the state of the items on managed by this plugin"""
#Parent functionality for state capturing
MCCPlugin.clearParentState(self)
#If this is a first run of capturing, we might need to fill
#in our remote_count
self.state = {}
for item in ['lirc', 'mythbuntu-lirc-generator']:
self.state[item] = self.query_installed(item)
#TODO, detect smartphone type somehow.
self.state['type'] = 'native'
if self.state['lirc']:
self.state['type'] = 'lirc'
if self.count["remote"] is 0:
self.lirc = LircHandler()
self.populate_lirc()
#Read in our /etc/lirc/hardware.conf
self.lirc.read_hardware_conf()
def applyStateToGUI(self):
"""Takes the current state in formation and sets the GUI"""
def match_object(saved_setting, list, count):
"""Attempts to match a saved object to a GTK list of objects"""
if saved_setting is "Custom":
return True
elif saved_setting != "None":
for item in range(count):
model = list.get_model()
iter = model.get_iter(Gtk.TreePath([item, 0]))
list.set_active_iter(iter)
if model[iter][0] == saved_setting:
return True
return False
def load_custom(type, dictionary):
"""Loads a custom remote or transmitter into the GUI"""
modules = self.builder.get_object(type + '_modules')
device = self.builder.get_object(type + '_device')
driver = self.builder.get_object(type + '_driver')
conf = self.builder.get_object('browse_' + type + '_lircd_conf')
modules.set_text(dictionary[type + "_modules"])
driver.set_text(dictionary[type + "_driver"])
device.set_text(dictionary[type + "_device"])
conf.select_filename("/usr/share/lirc/" + type)
if os.path.exists("/usr/share/lirc/" + type + '/' +
dictionary[type + "_lircd_conf"]):
conf.select_filename("/usr/share/lirc/" + type + '/' +
dictionary[type + "_lircd_conf"])
if self.state['type'] == 'lirc':
self.smartphone_vbox.set_sensitive(False)
self.lirc_vbox.set_sensitive(True)
self.lirc_support.set_active(True)
for type in ('remote', 'transmitter'):
dict = self.lirc.get_device_dictionary(type)
list = self.builder.get_object(type + '_list')
checkbox = self.builder.get_object(type + 'control')
found = match_object(dict[type], list, self.count[type])
checkbox.set_active(found)
self.toggle_ir(checkbox, True)
#"Custom" support
load_custom(type, dict)
elif self.state['type'] == 'native':
self.lirc_vbox.set_sensitive(False)
self.smartphone_vbox.set_sensitive(False)
else:
self.lirc_vbox.set_sensitive(False)
self.smartphone_vbox.set_sensitive(True)
def compareState(self):
"""Determines what items have been modified on this plugin"""
def test_basic_changes(type):
"""Test for changes in a regular remote or transmitter"""
old = self.lirc.get_device_dictionary(type)[type]
list = self.builder.get_object(type + '_list')
model = list.get_model()
current = model[list.get_active_iter()][0]
if old != current:
self._markReconfigureRoot(type, current)
return current
def test_custom_changes(type):
"""Tests for changes in a custom remote or transmitter"""
old = {}
new = {}
old['modules'] = self.lirc.get_device_dictionary(type)[type +
"_modules"]
old['device'] = self.lirc.get_device_dictionary(type)[type +
"_device"]
old['driver'] = self.lirc.get_device_dictionary(type)[type +
"_driver"]
old['lircd_conf'] = self.lirc.get_device_dictionary(type)[
type + "_lircd_conf"]
new['modules'] = self.builder.get_object(type +
'_modules').get_text()
new['device'] = self.builder.get_object(type +
'_device').get_text()
new['driver'] = self.builder.get_object(type +
'_driver').get_text()
new['lircd_conf'] = self.builder.get_object(
'browse_' + type + '_lircd_conf').get_filename()
for item in old:
if old[item] != new[item]:
self._markReconfigureRoot(type + '_' + item, new[item])
#Prepare for state capturing
MCCPlugin.clearParentState(self)
#check for type changes
if self.native_support.get_active():
radio = 'native'
elif self.lirc_support.get_active():
radio = 'lirc'
else:
radio = 'smartphone'
#figure out if we are installing lirc or removing it
if self.state['type'] != radio:
if radio == 'lirc' and not self.state['lirc']:
self._markInstall('lirc')
elif self.state['lirc']:
self._markRemove('lirc')
if self.state['lirc']:
for type in ('remote', 'transmitter'):
value = test_basic_changes(type)
if value == 'Custom':
test_custom_changes(type)
if self.generate_lircrc_checkbox.get_active():
if not self.state['mythbuntu-lirc-generator']:
self._markInstall('mythbuntu-lirc-generator')
if self.enable_irexec_checkbox.get_active():
self._markReconfigureUser("generate_lircrc_irexec", True)
else:
self._markReconfigureUser("generate_lircrc", True)
elif self.enable_irexec_checkbox.get_active():
if not self.state['mythbuntu-lirc-generator']:
self._markInstall('mythbuntu-lirc-generator')
self._markReconfigureUser("generate_lircrc_irexec_only", True)
def toggle_ir(self, widget, internal=False):
"""Callback used for any widgets in the remote plugin"""
def toggle_active_section(widget, type):
"""Turns on or off an IR remote"""
hbox = self.builder.get_object(type + '_hbox')
list = self.builder.get_object(type + '_list')
hbox.set_sensitive(widget.get_active())
if widget.get_active():
if list.get_active() == 0:
list.set_active(1)
else:
list.set_active(0)
def toggle_active_object_selection(widget, type):
"""Toggles the active device selection and related items"""
control = self.builder.get_object(type + 'control')
list = self.builder.get_object(type + '_list')
driver = self.builder.get_object(type + '_driver_hbox')
modules = self.builder.get_object(type + '_modules_hbox')
device = self.builder.get_object(type + '_device_hbox')
config = self.builder.get_object(type + '_configuration_hbox')
if list.get_model()[list.get_active_iter()][0] == "Custom":
custom = True
else:
custom = False
if list.get_active() == 0:
control.set_active(False)
return False
for item in (driver, modules, device, config):
if custom:
item.show()
else:
item.hide()
return True
if internal and self.find_lircrc():
self.generate_lircrc_checkbox.set_active(False)
self.enable_irexec_checkbox.set_active(False)
if widget is not None:
#toggle types on the page
if type(widget) is Gtk.RadioButton:
#they all have callbacks, only use the active one
if widget.get_active():
name = widget.get_name()
if name == 'native_support':
self.smartphone_vbox.set_sensitive(False)
self.lirc_vbox.set_sensitive(False)
elif name == 'smartphone_support':
self.smartphone_vbox.set_sensitive(True)
self.lirc_vbox.set_sensitive(False)
self.emit_progress(
"Smartphone support selected.\n\nYou must enable the 'Network Remote Control interface' in the frontend\n\nSetup > General > Remote Control (6th screen)",
100)
#the lirc package needs to be installed to show this
elif self.state['lirc']:
self.smartphone_vbox.set_sensitive(False)
self.lirc_vbox.set_sensitive(True)
#turn on/off IR remote
elif widget.get_name() == 'remotecontrol':
toggle_active_section(widget, "remote")
#turn on/off IR transmitter
elif widget.get_name() == "transmittercontrol":
toggle_active_section(widget, "transmitter")
#if our selected remote itself changed
elif widget.get_name() == 'remote_list':
if toggle_active_object_selection(widget, "remote"):
self.generate_lircrc_checkbox.set_active(True)
else:
self.generate_lircrc_checkbox.set_active(False)
#if our selected transmitter itself changed
elif widget.get_name() == 'transmitter_list':
toggle_active_object_selection(widget, "transmitter")
def user_scripted_changes(self, reconfigure):
"""Local changes that can be performed by the user account.
This function will be ran by the frontend."""
for item in reconfigure:
if item == "generate_lircrc":
self.lirc.create_lircrc(change_permissions=False)
elif item == "generate_lircrc_irexec":
self.lirc.create_lircrc(change_permissions=False, irexec=True)
elif item == "generate_lircrc_irexec_only":
self.lirc.create_lircrc(change_permissions=False,
irexec=True,
irexec_only=True)
def root_scripted_changes(self, reconfigure):
"""System-wide changes that need root access to be applied.
This function is ran by the dbus backend"""
lirc = LircHandler()
found = False
for item in reconfigure:
if item == "remote" or item == "transmitter":
logging.debug("Setting item %s to %s." %
(item, reconfigure[item]))
lirc.set_device({item: reconfigure[item]}, item)
found = True
if found:
logging.debug("Writing out /etc/lirc/hardware.conf")
lirc.write_hardware_conf()
logging.debug("Reconfiguring LIRC package")
lirc.reconfigure_lirc(interactive=False)
return found
class Wizard(ParentFrontend.Wizard):
#Overriden Methods
def __init__(self, distro):
#Remove migration assistant
if 'UBIQUITY_MIGRATION_ASSISTANT' in os.environ:
del os.environ['UBIQUITY_MIGRATION_ASSISTANT']
place=ParentFrontend.BREADCRUMB_STEPS["stepReady"]
#Max steps
ParentFrontend.BREADCRUMB_MAX_STEP = place + len(MYTHPAGES)
#update location of summary page
ParentFrontend.BREADCRUMB_STEPS["stepReady"]=place+len(MYTHPAGES)-1
#Add in final page
final_page=MYTHPAGES.pop()
ParentFrontend.BREADCRUMB_STEPS[final_page]=place+len(MYTHPAGES)+1
ParentFrontend.SUBPAGES.append(final_page)
#Add in individual mythpages pages
for string in MYTHPAGES:
ParentFrontend.BREADCRUMB_STEPS[string]=place
ParentFrontend.SUBPAGES.insert(len(ParentFrontend.SUBPAGES)-2,string)
place+=1
ParentFrontend.Wizard.__init__(self,distro)
def customize_installer(self):
"""Initial UI setup."""
#Default to auto login, but don't make it mandatory
#This requires disabling encrypted FS
self.set_auto_login(True)
self.login_encrypt.set_sensitive(False)
#Remove their summary page. ours is better
self.pages.pop()
#Insert all of our pages
for page in [mythbuntu.MythbuntuInstallType, mythbuntu.MythbuntuServices,
mythbuntu.MythbuntuRemote, mythbuntu.MythbuntuDrivers,
mythbuntu.MythbuntuPasswords, mythbuntu_install.Summary]:
self.pages.append(page)
#Prepopulate some dynamic pages
self.populate_lirc()
self.populate_video()
self.populate_mysql()
self.backup=False
ParentFrontend.Wizard.customize_installer(self)
def run_success_cmd(self):
"""Runs mythbuntu post post install GUI step"""
if not 'UBIQUITY_AUTOMATIC' in os.environ and self.get_installtype() != "Frontend":
self.live_installer.show()
self.installing = False
self.steps.next_page()
self.back.hide()
self.quit.hide()
self.next.set_label("Finish")
gtk.main()
self.live_installer.hide()
ParentFrontend.Wizard.run_success_cmd(self)
def set_page(self, n):
if n == 'MythbuntuRemote':
cur = self.tab_remote_control
elif n == 'MythbuntuDrivers':
cur = self.mythbuntu_stepDrivers
elif n == 'MythbuntuInstallType':
cur = self.mythbuntu_stepCustomInstallType
elif n == 'MythbuntuPasswords':
cur = self.mythbuntu_stepPasswords
if "Master" not in self.get_installtype():
self.allow_go_forward(False)
elif n == 'MythbuntuServices':
cur = self.mythbuntu_stepServices
self.vnc_option_hbox.set_sensitive(len(self.get_password()) >= 6)
else:
ParentFrontend.Wizard.set_page(self,n)
return
self.run_automation_error_cmd()
self.backup = False
self.live_installer.show()
self.set_current_page(self.steps.page_num(cur))
####################
#Helper Functions #
####################
#Called for initialization and calculation on a page
def populate_lirc(self):
"""Fills the lirc pages with the appropriate data"""
self.remote_count = 0
self.transmitter_count = 0
self.lirc=LircHandler()
for item in self.lirc.get_possible_devices("remote"):
if "Custom" not in item and "Blaster" not in item:
self.remote_list.append_text(item)
self.remote_count = self.remote_count + 1
for item in self.lirc.get_possible_devices("transmitter"):
if "Custom" not in item:
self.transmitter_list.append_text(item)
self.transmitter_count = self.transmitter_count + 1
self.remote_list.set_active(0)
self.transmitter_list.set_active(0)
def populate_video(self):
"""Finds the currently active video driver"""
dictionary=get_graphics_dictionary()
if len(dictionary) > 0:
for driver in dictionary:
self.video_driver.append_text(driver)
self.video_driver.append_text("Open Source Driver")
self.video_driver.set_active(len(dictionary))
self.tvoutstandard.set_active(0)
self.tvouttype.set_active(0)
else:
for step in ParentFrontend.BREADCRUMB_STEPS:
if (ParentFrontend.BREADCRUMB_STEPS[step] >
ParentFrontend.BREADCRUMB_STEPS[VIDEOPAGE]):
ParentFrontend.BREADCRUMB_STEPS[step] -= 1
ParentFrontend.BREADCRUMB_MAX_STEP -= 1
self.steps.remove_page(self.steps.page_num(self.mythbuntu_stepDrivers))
self.pages.remove(mythbuntu.MythbuntuDrivers)
def populate_mysql(self):
"""Puts a new random mysql password into the UI for each run
This ensures that passwords don't ever get cached"""
self.mysql=MySQLHandler()
new_pass_caller = subprocess.Popen(['pwgen','-s','8'],stdout=subprocess.PIPE)
self.mysql_password.set_text(string.split(new_pass_caller.communicate()[0])[0])
def do_mythtv_setup(self,widget):
"""Spawn MythTV-Setup binary."""
self.live_installer.hide()
self.refresh()
execute_root("/usr/share/ubiquity/mythbuntu-setup")
self.live_installer.show()
def do_connection_test(self,widget):
"""Tests to make sure that the backend is accessible"""
config={}
config["user"]=self.mysql_user.get_text()
config["password"]=self.mysql_password.get_text()
config["server"]=self.mysql_server.get_text()
config["database"]=self.mysql_database.get_text()
self.mysql.update_config(config)
result=self.mysql.do_connection_test()
self.allow_go_forward(True)
self.connection_results_label.show()
self.connection_results.set_text(result)
#####################
#Preseeding Functions#
#####################
#Used to preset the status of an element in the GUI
def set_installtype(self,type):
"""Preseeds the type of custom install"""
if type == "Set Top Box":
self.stb.set_active(True)
elif type == "Frontend":
self.fe.set_active(True)
elif type == "Slave Backend":
self.slave_be.set_active(True)
elif type == "Master Backend":
self.master_be.set_active(True)
elif type == "Slave Backend/Frontend":
self.slave_be_fe.set_active(True)
else:
self.master_be_fe.set_active(True)
def set_service(self,name,value):
"""Preseeds the status of a service"""
lists = [get_services_dictionary(self)]
self._preseed_list(lists,name,value)
def set_driver(self,name,value):
"""Preseeds the status of a driver"""
lists = [{'video_driver': self.video_driver,
'tvout': self.tvouttype,
'tvstandard': self.tvoutstandard}]
self._preseed_list(lists,name,value)
def set_password(self,name,value):
"""Preseeds a password"""
lists = [{'mysql_mythtv_user':self.mysql_user,
'mysql_mythtv_password':self.mysql_password,
'mysql_mythtv_dbname':self.mysql_database,
'mysql_host':self.mysql_server}]
self._preseed_list(lists,name,value)
def set_lirc(self,question,answer):
"""Preseeds a lirc configuration item"""
if question == "remote":
for i in range(0,self.remote_count):
self.remote_list.set_active(i)
found=False
if self.remote_list.get_active_text() == answer:
found = True
break
if not found:
self.remote_list.set_active(0)
if question == "transmitter":
for i in range(0,self.transmitter_count):
self.transmitter_list.set_active(i)
found=False
if self.transmitter_list.get_active_text() == answer:
found = True
break
if not found:
self.transmitter_list.set_active(0)
def _preseed_list(self,lists,names,value):
"""Helper function for preseeding dictionary based lists"""
new_value = create_bool(value)
for list in lists:
for item in list:
for name in string.split(names):
if item == name:
#be careful what type of item we are deealing with
if type(list[item]) == gtk.CheckButton:
list[item].set_active(new_value)
elif type(list[item]) == gtk.Entry:
list[item].set_text(new_value)
elif type(list[item]) == gtk.ComboBox:
for iteration in range(len(list[item]),0):
list[item].set_active(iteration)
if list[item].get_active_text() == new_value:
break
else:
list[item].set_active_text(new_value)
##################
#Status Reading #
##################
#Functions for reading the status of Frontend elements
def get_installtype(self):
"""Returns the current custom installation type"""
if self.master_be_fe.get_active():
return "Master Backend/Frontend"
elif self.slave_be_fe.get_active():
return "Slave Backend/Frontend"
elif self.master_be.get_active():
return "Master Backend"
elif self.slave_be.get_active():
return "Slave Backend"
elif self.fe.get_active():
return "Frontend"
elif self.stb.get_active():
return "Set Top Box"
def _build_static_list(self,lists):
"""Creates a flat list"""
total_list= {}
for list in lists:
for item in list:
if type(list[item]) == str:
total_list[item]=list[item]
elif type(list[item]) == gtk.CheckButton:
total_list[item]=list[item].get_active()
elif type(list[item]) == gtk.Entry:
total_list[item]=list[item].get_text()
else:
total_list[item]=list[item].get_active_text()
return total_list
def get_services(self):
"""Returns the status of all installable services"""
return self._build_static_list([get_services_dictionary(self)])
def get_drivers(self):
video_drivers=get_graphics_dictionary()
active_video_driver=self.video_driver.get_active_text()
for item in video_drivers:
if (active_video_driver == item):
active_video_driver=video_drivers[item]
break
return self._build_static_list([{'video_driver': active_video_driver,
'tvout': self.tvouttype,
'tvstandard': self.tvoutstandard}])
def get_mythtv_passwords(self):
return self._build_static_list([{'mysql_mythtv_user':self.mysql_user,
'mysql_mythtv_password':self.mysql_password,
'mysql_mythtv_dbname':self.mysql_database,
'mysql_host':self.mysql_server}])
def get_lirc(self,type):
item = {"modules":"","device":"","driver":"","lircd_conf":""}
if type == "remote":
item["remote"]=self.remote_list.get_active_text()
elif type == "transmitter":
item["transmitter"]=self.transmitter_list.get_active_text()
return item
##################
#Toggle functions#
##################
#Called when a widget changes and other GUI elements need to react
def toggle_tv_out (self,widget):
"""Called when the tv-out type is toggled"""
if (self.tvouttype.get_active() == 0):
self.tvoutstandard.set_active(0)
elif ((self.tvouttype.get_active() == 1 or self.tvouttype.get_active() == 2) and (self.tvoutstandard.get_active() == 0 or self.tvoutstandard.get_active() >= 11 )):
self.tvoutstandard.set_active(10)
elif self.tvouttype.get_active() == 3:
self.tvoutstandard.set_active(11)
def toggle_tv_standard(self,widget):
"""Called when the tv standard is toggled"""
if (self.tvoutstandard.get_active() >= 11):
self.tvouttype.set_active(3)
elif (self.tvoutstandard.get_active() < 11 and self.tvoutstandard.get_active() > 0 and self.tvouttype.get_active() == 0):
self.tvouttype.set_active(1)
elif (self.tvoutstandard.get_active() < 11 and self.tvouttype.get_active() ==3):
self.tvouttype.set_active(1)
elif (self.tvoutstandard.get_active() == 0):
self.tvouttype.set_active(0)
def video_changed (self,widget):
"""Called whenever the modify video driver option is toggled or its kids"""
drivers=get_graphics_dictionary()
if (widget is not None and widget.get_name() == 'video_driver'):
type = widget.get_active()
if (type < len(drivers)):
self.tvout_vbox.set_sensitive(True)
else:
self.tvout_vbox.set_sensitive(False)
self.tvoutstandard.set_active(0)
self.tvouttype.set_active(0)
def toggle_customtype (self,widget):
"""Called whenever a custom type is toggled"""
if "Master" in self.get_installtype():
self.mysql_option_hbox.show()
else:
self.enablemysql.set_active(False)
self.mysql_option_hbox.hide()
if "Backend" in self.get_installtype():
self.samba_option_hbox.show()
self.nfs_option_hbox.show()
else:
self.enablesamba.set_active(False)
self.enablenfs.set_active(False)
self.samba_option_hbox.hide()
self.nfs_option_hbox.hide()
def toggle_ir(self,widget):
"""Called whenever a request to enable/disable remote is called"""
if widget is not None:
#turn on/off IR remote
if widget.get_name() == 'remotecontrol':
self.remote_hbox.set_sensitive(widget.get_active())
self.generate_lircrc_checkbox.set_sensitive(widget.get_active())
if widget.get_active() and self.remote_list.get_active() == 0:
self.remote_list.set_active(1)
else:
self.remote_list.set_active(0)
#turn on/off IR transmitter
elif widget.get_name() == "transmittercontrol":
self.transmitter_hbox.set_sensitive(widget.get_active())
if widget.get_active():
if self.transmitter_list.get_active() == 0:
self.transmitter_list.set_active(1)
else:
self.transmitter_list.set_active(0)
#if our selected remote itself changed
elif widget.get_name() == 'remote_list':
self.generate_lircrc_checkbox.set_active(True)
if self.remote_list.get_active() == 0:
self.remotecontrol.set_active(False)
self.generate_lircrc_checkbox.set_active(False)
#if our selected transmitter itself changed
elif widget.get_name() == 'transmitter_list':
if self.transmitter_list.get_active() == 0:
self.transmittercontrol.set_active(False)
