PageRenderTime 55ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/usr/lib/live-installer/frontend/gtk_interface.py

https://github.com/taem/live-installer
Python | 1480 lines | 1298 code | 95 blank | 87 comment | 70 complexity | fab6603d186f99e0a33750414eff2f93 MD5 | raw file
Possible License(s): BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. #!/usr/bin/env python
    2. 

  2. import sys
    3. 

  3. sys.path.append('/usr/lib/live-installer')
    4. 

  4. from installer import InstallerEngine, Setup, PartitionSetup
    5. 

  5. 

  6. try:
    7. 

  7.     import pygtk
    8. 

  8.     pygtk.require("2.0")
    9. 

  9.     import gtk
    10. 

  10.     import gtk.glade
    11. 

  11.     import gettext
    12. 

  12.     import os
    13. 

  13.     import commands
    14. 

  14.     import subprocess
    15. 

  15.     import sys
    16. 

  16.     sys.path.append('/usr/lib/live-installer')
    17. 

  17.     import pango
    18. 

  18.     import threading
    19. 

  19.     import xml.dom.minidom
    20. 

  20.     from xml.dom.minidom import parse
    21. 

  21.     import gobject
    22. 

  22.     import time
    23. 

  23.     import webkit
    24. 

  24.     import GeoIP
    25. 

  25.     import urllib
    26. 

  26.     import string
    27. 

  27.     import parted
    28. 

  28. except Exception, detail:
    29. 

  29.     print detail
    30. 

  30. 

  31. 

  32. gettext.install("live-installer", "/usr/share/locale")
    33. 

  33. gtk.gdk.threads_init()
    34. 

  34. 

  35. INDEX_PARTITION_PATH=0
    36. 

  36. INDEX_PARTITION_TYPE=1
    37. 

  37. INDEX_PARTITION_DESCRIPTION=2
    38. 

  38. INDEX_PARTITION_FORMAT_AS=3
    39. 

  39. INDEX_PARTITION_MOUNT_AS=4
    40. 

  40. INDEX_PARTITION_SIZE=5
    41. 

  41. INDEX_PARTITION_FREE_SPACE=6
    42. 

  42. INDEX_PARTITION_OBJECT=7
    43. 

  43. 

  44. class ProgressDialog:
    45. 

  45. 	
    46. 

  46. 	def __init__(self):
    47. 

  47. 		self.glade = '/usr/share/live-installer/interface.glade'
    48. 

  48. 		self.dTree = gtk.glade.XML(self.glade, 'progress_window')
    49. 

  49. 		self.window = self.dTree.get_widget('progress_window')
    50. 

  50. 		self.progressbar = self.dTree.get_widget('progressbar_operation')
    51. 

  51. 		self.label = self.dTree.get_widget('label_operation')
    52. 

  52. 		self.should_pulse = False
    53. 

  53. 		
    54. 

  54. 	def show(self, label=None, title=None):
    55. 

  55. 		def pbar_pulse():
    56. 

  56. 			if(not self.should_pulse):
    57. 

  57. 				return False
    58. 

  58. 			self.progressbar.pulse()
    59. 

  59. 			return self.should_pulse
    60. 

  60. 		if(label is not None):
    61. 

  61. 			self.label.set_markup(label)
    62. 

  62. 		if(title is not None):
    63. 

  63. 			self.window.set_title(title)
    64. 

  64. 		self.should_pulse = True
    65. 

  65. 		self.window.show_all()
    66. 

  66. 		gobject.timeout_add(100, pbar_pulse)
    67. 

  67. 		
    68. 

  68. 	def hide(self):
    69. 

  69. 		self.should_pulse = False
    70. 

  70. 		self.window.hide()	
    71. 

  71. 

  72. ''' Handy. Makes message dialogs easy :D '''
    73. 

  73. class MessageDialog(object):
    74. 

  74. 

  75.     def __init__(self, title, message, style):
    76. 

  76.         self.title = title
    77. 

  77.         self.message = message
    78. 

  78.         self.style = style
    79. 

  79. 

  80.     ''' Show me on screen '''
    81. 

  81.     def show(self):
    82. 

  82. 

  83.         dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, self.style, gtk.BUTTONS_OK, self.message)
    84. 

  84.         dialog.set_title(self.title)
    85. 

  85.         dialog.set_position(gtk.WIN_POS_CENTER)
    86. 

  86.         dialog.set_icon_from_file("/usr/share/icons/live-installer.png")
    87. 

  87.         dialog.run()
    88. 

  88.         dialog.destroy()
    89. 

  89.         
    90. 

  90. class QuestionDialog(object):
    91. 

  91.     def __init__(self, title, message):
    92. 

  92.         self.title = title
    93. 

  93.         self.message = message       
    94. 

  94. 

  95.     ''' Show me on screen '''
    96. 

  96.     def show(self):    
    97. 

  97.         dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, self.message)
    98. 

  98.         dialog.set_title(self.title)
    99. 

  99.         dialog.set_position(gtk.WIN_POS_CENTER)
    100. 

  100.         dialog.set_icon_from_file("/usr/share/icons/live-installer.png")
    101. 

  101.         answer = dialog.run()
    102. 

  102.         if answer==gtk.RESPONSE_YES:
    103. 

  103.             return_value = True
    104. 

  104.         else:
    105. 

  105.             return_value = False
    106. 

  106.         dialog.destroy()
    107. 

  107.         return return_value    
    108. 

  108. 

  109. class WizardPage:
    110. 

  110. 

  111.     def __init__(self, help_text, icon):
    112. 

  112.         self.help_text = help_text    
    113. 

  113.         self.icon = icon    
    114. 

  114. 		
    115. 

  115. class InstallerWindow:
    116. 

  116. 

  117.     def __init__(self, fullscreen=False):
    118. 

  118.         
    119. 

  119.         #Build the Setup object (where we put all our choices)
    120. 

  120.         self.setup = Setup()
    121. 

  121.         
    122. 

  122.         self.resource_dir = '/usr/share/live-installer/'
    123. 

  123.         #self.glade = 'interface.glade'
    124. 

  124.         self.glade = os.path.join(self.resource_dir, 'interface.glade')
    125. 

  125.         self.wTree = gtk.glade.XML(self.glade, 'main_window')
    126. 

  126. 

  127.         # should be set early
    128. 

  128.         self.done = False
    129. 

  129.         self.fail = False
    130. 

  130. 

  131.         # here comes the installer engine
    132. 

  132.         self.installer = InstallerEngine()
    133. 

  133.         # the distribution name
    134. 

  134.         DISTRIBUTION_NAME = self.installer.get_distribution_name()
    135. 

  135.         # load the window object
    136. 

  136.         self.window = self.wTree.get_widget("main_window")
    137. 

  137.         if "--debug" in sys.argv:
    138. 

  138.             self.window.set_title((_("%s Installer") % DISTRIBUTION_NAME) + " (debug)")
    139. 

  139.         else:
    140. 

  140.             self.window.set_title(_("%s Installer") % DISTRIBUTION_NAME)
    141. 

  141.         self.window.connect("destroy", self.quit_cb)
    142. 

  142. 

  143.         # Wizard pages
    144. 

  144.         [self.PAGE_LANGUAGE, self.PAGE_PARTITIONS, self.PAGE_USER, self.PAGE_ADVANCED, self.PAGE_KEYBOARD, self.PAGE_OVERVIEW, self.PAGE_INSTALL, self.PAGE_TIMEZONE, self.PAGE_HDD] = range(9)
    145. 

  145.         self.wizard_pages = range(9)
    146. 

  146.         self.wizard_pages[self.PAGE_LANGUAGE] = WizardPage(_("Choose your language"), "locales.png")
    147. 

  147.         self.wizard_pages[self.PAGE_TIMEZONE] = WizardPage(_("Choose your timezone"), "time.png")
    148. 

  148.         self.wizard_pages[self.PAGE_KEYBOARD] = WizardPage(_("Choose your keyboard layout"), "keyboard.png")
    149. 

  149.         self.wizard_pages[self.PAGE_HDD] = WizardPage(_("On which hard drive do you want to install Kazsid?"), "hdd.svg")
    150. 

  150.         self.wizard_pages[self.PAGE_PARTITIONS] = WizardPage(_("Select where you want to install Kazsid"), "hdd.svg")
    151. 

  151.         self.wizard_pages[self.PAGE_USER] = WizardPage(_("Please indicate your name and select a username, a password and a hostname"), "user.png")
    152. 

  152.         self.wizard_pages[self.PAGE_ADVANCED] = WizardPage(_("Please review the following advanced options"), "advanced.png")
    153. 

  153.         self.wizard_pages[self.PAGE_OVERVIEW] = WizardPage(_("Please review this summary and make sure everything is correct"), "summary.png")
    154. 

  154.         self.wizard_pages[self.PAGE_INSTALL] = WizardPage(_("Please wait while Kazsid is being installed on your computer"), "install.png")
    155. 

  155.         
    156. 

  156.         # set the button events (wizard_cb)
    157. 

  157.         self.wTree.get_widget("button_next").connect("clicked", self.wizard_cb, False)
    158. 

  158.         self.wTree.get_widget("button_back").connect("clicked", self.wizard_cb, True)
    159. 

  159.         self.wTree.get_widget("button_quit").connect("clicked", self.quit_cb)
    160. 

  160. 

  161.         ren = gtk.CellRendererPixbuf()
    162. 

  162.         column = gtk.TreeViewColumn("Flags", ren)
    163. 

  163.         column.add_attribute(ren, "pixbuf", 2)
    164. 

  164.         self.wTree.get_widget("treeview_language_list").append_column(column)
    165. 

  165. 

  166.         ren = gtk.CellRendererText()
    167. 

  167.         column = gtk.TreeViewColumn("Languages", ren)
    168. 

  168.         column.add_attribute(ren, "text", 0)
    169. 

  169.         self.wTree.get_widget("treeview_language_list").append_column(column)
    170. 

  170.         self.wTree.get_widget("treeview_language_list").connect("cursor-changed", self.assign_language)
    171. 

  171. 

  172.         # build the language list
    173. 

  173.         self.build_lang_list()
    174. 

  174.         ren = gtk.CellRendererText()
    175. 

  175.         column = gtk.TreeViewColumn("Timezones", ren)
    176. 

  176.         column.add_attribute(ren, "text", 0)
    177. 

  177.         self.wTree.get_widget("treeview_timezones").append_column(column)
    178. 

  178.         self.wTree.get_widget("treeview_timezones").connect("cursor-changed", self.assign_timezone)
    179. 

  179. 

  180.         self.build_timezones()
    181. 

  181. 

  182.         # disk view
    183. 

  183.         ren = gtk.CellRendererText()
    184. 

  184.         self.column1 = gtk.TreeViewColumn("Hard drive", ren)
    185. 

  185.         self.column1.add_attribute(ren, "text", 0)
    186. 

  186.         self.wTree.get_widget("treeview_hdds").append_column(self.column1)
    187. 

  187.         self.column2 = gtk.TreeViewColumn("Description", ren)
    188. 

  188.         self.column2.add_attribute(ren, "text", 1)
    189. 

  189.         self.wTree.get_widget("treeview_hdds").append_column(self.column2)
    190. 

  190.         self.wTree.get_widget("treeview_hdds").connect("cursor-changed", self.assign_hdd)
    191. 

  191.         self.build_hdds()
    192. 

  192.         #self.build_grub_partitions()
    193. 

  193.         
    194. 

  194.         self.wTree.get_widget("button_edit").connect("clicked", self.edit_partitions)
    195. 

  195.         self.wTree.get_widget("label_edit_partitions").set_label(_("Edit partitions"))
    196. 

  196.         self.wTree.get_widget("button_refresh").connect("clicked", self.refresh_partitions)
    197. 

  197.         self.wTree.get_widget("treeview_disks").connect("row_activated", self.assign_partition)
    198. 

  198.         self.wTree.get_widget("treeview_disks").connect( "button-release-event", self.partitions_popup_menu)
    199. 

  199.         
    200. 

  200.         # device
    201. 

  201.         ren = gtk.CellRendererText()
    202. 

  202.         self.column3 = gtk.TreeViewColumn(_("Device"), ren)
    203. 

  203.         self.column3.add_attribute(ren, "markup", INDEX_PARTITION_PATH)
    204. 

  204.         self.wTree.get_widget("treeview_disks").append_column(self.column3)
    205. 

  205.         # Type
    206. 

  206.         ren = gtk.CellRendererText()
    207. 

  207.         self.column4 = gtk.TreeViewColumn(_("Type"), ren)
    208. 

  208.         self.column4.add_attribute(ren, "markup", INDEX_PARTITION_TYPE)
    209. 

  209.         self.wTree.get_widget("treeview_disks").append_column(self.column4)
    210. 

  210.         # description
    211. 

  211.         ren = gtk.CellRendererText()
    212. 

  212.         self.column5 = gtk.TreeViewColumn(_("Operating system"), ren)
    213. 

  213.         self.column5.add_attribute(ren, "markup", INDEX_PARTITION_DESCRIPTION)
    214. 

  214.         self.wTree.get_widget("treeview_disks").append_column(self.column5)        
    215. 

  215.         # mount point
    216. 

  216.         ren = gtk.CellRendererText()
    217. 

  217.         self.column6 = gtk.TreeViewColumn(_("Mount point"), ren)
    218. 

  218.         self.column6.add_attribute(ren, "markup", INDEX_PARTITION_MOUNT_AS)
    219. 

  219.         self.wTree.get_widget("treeview_disks").append_column(self.column6)
    220. 

  220.         # format
    221. 

  221.         ren = gtk.CellRendererText()
    222. 

  222.         self.column7 = gtk.TreeViewColumn(_("Format?"), ren)
    223. 

  223.         self.column7.add_attribute(ren, "markup", INDEX_PARTITION_FORMAT_AS)        
    224. 

  224.         self.wTree.get_widget("treeview_disks").append_column(self.column7)
    225. 

  225.         # size
    226. 

  226.         ren = gtk.CellRendererText()
    227. 

  227.         self.column8 = gtk.TreeViewColumn(_("Size"), ren)
    228. 

  228.         self.column8.add_attribute(ren, "markup", INDEX_PARTITION_SIZE)
    229. 

  229.         self.wTree.get_widget("treeview_disks").append_column(self.column8)
    230. 

  230.         # Used space
    231. 

  231.         ren = gtk.CellRendererText()
    232. 

  232.         self.column9 = gtk.TreeViewColumn(_("Free space"), ren)
    233. 

  233.         self.column9.add_attribute(ren, "markup", INDEX_PARTITION_FREE_SPACE)
    234. 

  234.         self.wTree.get_widget("treeview_disks").append_column(self.column9)
    235. 

  235. 

  236.         self.wTree.get_widget("entry_your_name").connect("notify::text", self.assign_realname)        
    237. 

  237.         self.wTree.get_widget("entry_username").connect("notify::text", self.assign_username)    
    238. 

  238.         self.wTree.get_widget("entry_hostname").connect("notify::text", self.assign_hostname)    
    239. 

  239. 

  240.         # events for detecting password mismatch..        
    241. 

  241.         self.wTree.get_widget("entry_userpass1").connect("changed", self.assign_password)
    242. 

  242.         self.wTree.get_widget("entry_userpass2").connect("changed", self.assign_password)
    243. 

  243. 

  244.         # link the checkbutton to the combobox
    245. 

  245.         grub_check = self.wTree.get_widget("checkbutton_grub")
    246. 

  246.         grub_box = self.wTree.get_widget("combobox_grub")
    247. 

  247.         grub_check.connect("clicked", self.assign_grub_install, grub_box)        
    248. 

  248.         grub_box.connect("changed", self.assign_grub_device)
    249. 

  249. 

  250.         # Install Grub by default
    251. 

  251.         grub_check.set_active(True)
    252. 

  252.         grub_box.set_sensitive(True)
    253. 

  253.         
    254. 

  254.         # kb models
    255. 

  255.         cell = gtk.CellRendererText()
    256. 

  256.         self.wTree.get_widget("combobox_kb_model").pack_start(cell, True)
    257. 

  257.         self.wTree.get_widget("combobox_kb_model").add_attribute(cell, 'text', 0)        
    258. 

  258.         self.wTree.get_widget("combobox_kb_model").connect("changed", self.assign_keyboard_model)
    259. 

  259. 

  260.         # kb layouts
    261. 

  261.         ren = gtk.CellRendererText()
    262. 

  262.         self.column10 = gtk.TreeViewColumn(_("Layout"), ren)
    263. 

  263.         self.column10.add_attribute(ren, "text", 0)
    264. 

  264.         self.wTree.get_widget("treeview_layouts").append_column(self.column10)
    265. 

  265.         self.wTree.get_widget("treeview_layouts").connect("cursor-changed", self.assign_keyboard_layout)
    266. 

  266.         
    267. 

  267.         ren = gtk.CellRendererText()
    268. 

  268.         self.column11 = gtk.TreeViewColumn(_("Variant"), ren)
    269. 

  269.         self.column11.add_attribute(ren, "text", 0)
    270. 

  270.         self.wTree.get_widget("treeview_variants").append_column(self.column11)
    271. 

  271.         self.wTree.get_widget("treeview_variants").connect("cursor-changed", self.assign_keyboard_variant)
    272. 

  272.         
    273. 

  273.         #self.build_kb_lists()
    274. 

  274. 

  275.         # 'about to install' aka overview
    276. 

  276.         ren = gtk.CellRendererText()
    277. 

  277.         self.column12 = gtk.TreeViewColumn(_("Overview"), ren)
    278. 

  278.         self.column12.add_attribute(ren, "markup", 0)
    279. 

  279.         self.wTree.get_widget("treeview_overview").append_column(self.column12)
    280. 

  280.         # install page
    281. 

  281.         self.wTree.get_widget("label_install_progress").set_markup("<i>%s</i>" % _("Calculating file indexes..."))
    282. 

  282.     
    283. 

  283.         #i18n
    284. 

  284.         self.i18n()
    285. 

  285. 

  286.         # build partition list
    287. 

  287.         self.should_pulse = False
    288. 

  288. 

  289.         # make sure we're on the right page (no pun.)
    290. 

  290.         self.activate_page(0)
    291. 

  291. 

  292.         # this is a hack atm to steal the menubar's background color
    293. 

  293.         self.wTree.get_widget("menubar").realize()
    294. 

  294.         style = self.wTree.get_widget("menubar").style.copy()
    295. 

  295.         self.wTree.get_widget("menubar").hide()
    296. 

  296.         # apply to the header       
    297. 

  297.         self.wTree.get_widget("help_label").realize()
    298. 

  298.         self.wTree.get_widget("help_label").modify_fg(gtk.STATE_NORMAL, style.fg[gtk.STATE_NORMAL])       
    299. 

  299.         if(fullscreen):
    300. 

  300.             # dedicated installer mode thingum
    301. 

  301.             self.window.maximize()
    302. 

  302.             self.window.fullscreen()        
    303. 

  303.         
    304. 

  304.         #''' Launch the Slideshow '''
    305. 

  305.         #if ("_" in self.setup.language):
    306. 

  306.         #    locale_code = self.setup.language.split("_")[0]
    307. 

  307.         #else:
    308. 

  308.         #     locale_code = self.setup.language
    309. 

  309.         
    310. 

  310.         #slideshow_path = "/usr/share/live-installer-slideshow/slides/index.html"
    311. 

  311.         #if os.path.exists(slideshow_path):            
    312. 

  312.         #    browser = webkit.WebView()
    313. 

  313.         #    s = browser.get_settings()
    314. 

  314.         #    s.set_property('enable-file-access-from-file-uris', True)
    315. 

  315.         #    s.set_property('enable-default-context-menu', False)
    316. 

  316.         #    browser.open("file://" + slideshow_path  + "#?locale=" + locale_code)
    317. 

  317.         #    self.wTree.get_widget("vbox_install").add(browser)
    318. 

  318.         #    self.wTree.get_widget("vbox_install").show_all()                                                            
    319. 

  319.         
    320. 

  320.         self.browser = webkit.WebView()
    321. 

  321.         s = self.browser.get_settings()
    322. 

  322.         s.set_property('enable-file-access-from-file-uris', True)
    323. 

  323.         s.set_property('enable-default-context-menu', False)     
    324. 

  324.         self.wTree.get_widget("scrolled_partitions").add(self.browser)   
    325. 

  325.         
    326. 

  326.         self.window.show_all()
    327. 

  327.         
    328. 

  328.     def i18n(self):
    329. 

  329.         # about you
    330. 

  330.         self.wTree.get_widget("label_your_name").set_markup("<b>%s</b>" % _("Your full name"))
    331. 

  331.         self.wTree.get_widget("label_your_name_help").set_label(_("This will be shown in the About Me application"))
    332. 

  332.         self.wTree.get_widget("label_username").set_markup("<b>%s</b>" % _("Your username"))
    333. 

  333.         self.wTree.get_widget("label_username_help").set_label(_("This is the name you will use to login to your computer"))
    334. 

  334.         self.wTree.get_widget("label_choose_pass").set_markup("<b>%s</b>" % _("Your password"))
    335. 

  335.         self.wTree.get_widget("label_pass_help").set_label(_("Please enter your password twice to ensure it is correct"))
    336. 

  336.         self.wTree.get_widget("label_hostname").set_markup("<b>%s</b>" % _("Hostname"))
    337. 

  337.         self.wTree.get_widget("label_hostname_help").set_label(_("This hostname will be the computers name on the network"))
    338. 

  338.         
    339. 

  339.         # grub
    340. 

  340.         self.wTree.get_widget("label_grub").set_markup("<b>%s</b>" % _("Bootloader"))
    341. 

  341.         self.wTree.get_widget("checkbutton_grub").set_label(_("Install GRUB"))
    342. 

  342.         self.wTree.get_widget("label_grub_help").set_label(_("GRUB is a bootloader used to load the Linux kernel"))
    343. 

  343.         
    344. 

  344.         # keyboard page
    345. 

  345.         self.wTree.get_widget("label_test_kb").set_label(_("Use this box to test your keyboard layout"))
    346. 

  346.         self.wTree.get_widget("label_kb_model").set_label(_("Model"))
    347. 

  347.         
    348. 

  348.         #Installation
    349. 

  349.         self.wTree.get_widget("label_install_1").set_label(_("Please wait while the operating system is installed on your computer."))
    350. 

  350.         self.wTree.get_widget("label_install_2").set_label(_("The installation should take approximately 10 minutes."))
    351. 

  351.         self.wTree.get_widget("label_install_3").set_label(_("We hope you enjoy this new release. Thank you for choosing Kazsid."))    
    352. 

  352.         
    353. 

  353.         #Columns
    354. 

  354.         self.column1.set_title(_("Hard drive")) 
    355. 

  355.         self.column2.set_title(_("Description")) 
    356. 

  356.         self.column3.set_title(_("Device")) 
    357. 

  357.         self.column4.set_title(_("Type")) 
    358. 

  358.         self.column5.set_title(_("Operating system")) 
    359. 

  359.         self.column6.set_title(_("Mount point")) 
    360. 

  360.         self.column7.set_title(_("Format?")) 
    361. 

  361.         self.column8.set_title(_("Size")) 
    362. 

  362.         self.column9.set_title(_("Free space")) 
    363. 

  363.         self.column10.set_title(_("Layout")) 
    364. 

  364.         self.column11.set_title(_("Variant")) 
    365. 

  365.         self.column12.set_title(_("Overview")) 
    366. 

  366. 

  367.     def assign_realname(self, entry, prop):
    368. 

  368.         self.setup.real_name = entry.props.text
    369. 

  369.         text = entry.props.text.strip().lower()
    370. 

  370.         if " " in entry.props.text:
    371. 

  371.             elements = text.split()
    372. 

  372.             text = elements[0]
    373. 

  373.         self.setup.username = text
    374. 

  374.         self.wTree.get_widget("entry_username").set_text(text)   
    375. 

  375.         self.setup.print_setup()    
    376. 

  376. 

  377.     def assign_username(self, entry, prop):
    378. 

  378.         self.setup.username = entry.props.text
    379. 

  379.         self.setup.print_setup()       
    380. 

  380. 

  381.     def assign_hostname(self, entry, prop):
    382. 

  382.         self.setup.hostname = entry.props.text
    383. 

  383.         self.setup.print_setup()
    384. 

  384.         
    385. 

  385.     def quit_cb(self, widget, data=None):
    386. 

  386.         ''' ask whether we should quit. because touchpads do happen '''
    387. 

  387.         gtk.main_quit()
    388. 

  388. 

  389.     def assign_partition(self, widget, data=None, data2=None):
    390. 

  390.         ''' assign the partition ... '''
    391. 

  391.         model, iter = self.wTree.get_widget("treeview_disks").get_selection().get_selected()
    392. 

  392.         if iter is not None:
    393. 

  393.             row = model[iter]
    394. 

  394.             partition = row[INDEX_PARTITION_OBJECT]            
    395. 

  395.             if not partition.partition.type == parted.PARTITION_EXTENDED and not partition.partition.number == -1:            
    396. 

  396.                 dlg = PartitionDialog(row[INDEX_PARTITION_PATH], row[INDEX_PARTITION_MOUNT_AS], row[INDEX_PARTITION_FORMAT_AS], row[INDEX_PARTITION_TYPE])
    397. 

  397.                 (mount_as, format_as) = dlg.show()                
    398. 

  398.                 self.assign_mount_point(partition, mount_as, format_as)
    399. 

  399.                 
    400. 

  400.     def partitions_popup_menu( self, widget, event ):
    401. 

  401.         if event.button == 3:
    402. 

  402.             model, iter = self.wTree.get_widget("treeview_disks").get_selection().get_selected()
    403. 

  403.             if iter is not None:
    404. 

  404.                 partition = model.get_value(iter, INDEX_PARTITION_OBJECT)
    405. 

  405.                 partition_type = model.get_value(iter, INDEX_PARTITION_TYPE)
    406. 

  406.                 if not partition.partition.type == parted.PARTITION_EXTENDED and not partition.partition.number == -1 and "swap" not in partition_type:
    407. 

  407.                     menu = gtk.Menu()
    408. 

  408.                     menuItem = gtk.MenuItem(_("Edit"))
    409. 

  409.                     menuItem.connect( "activate", self.assign_partition, partition)
    410. 

  410.                     menu.append(menuItem)
    411. 

  411.                     menuItem = gtk.SeparatorMenuItem()
    412. 

  412.                     menu.append(menuItem)
    413. 

  413.                     menuItem = gtk.MenuItem(_("Assign to /"))
    414. 

  414.                     menuItem.connect( "activate", self.assign_mount_point_context_menu_wrapper, partition, "/", "ext4")
    415. 

  415.                     menu.append(menuItem)
    416. 

  416.                     menuItem = gtk.MenuItem(_("Assign to /home"))
    417. 

  417.                     menuItem.connect( "activate", self.assign_mount_point_context_menu_wrapper, partition, "/home", "")
    418. 

  418.                     menu.append(menuItem)
    419. 

  419.                     menu.show_all()
    420. 

  420.                     menu.popup( None, None, None, event.button, event.time )
    421. 

  421. 

  422.     def assign_mount_point_context_menu_wrapper(self, menu, partition, mount_point, filesystem):
    423. 

  423.         self.assign_mount_point(partition, mount_point, filesystem)
    424. 

  424. 

  425.     def assign_mount_point(self, partition, mount_point, filesystem):
    426. 

  426.         
    427. 

  427.         #Assign it in the treeview
    428. 

  428.         model = self.wTree.get_widget("treeview_disks").get_model()
    429. 

  429.         iter = model.get_iter_first()
    430. 

  430.         while iter is not None:
    431. 

  431.             iter_partition = model.get_value(iter, INDEX_PARTITION_OBJECT)
    432. 

  432.             if iter_partition == partition:
    433. 

  433.                 model.set_value(iter, INDEX_PARTITION_MOUNT_AS, mount_point)         
    434. 

  434.                 model.set_value(iter, INDEX_PARTITION_FORMAT_AS, filesystem)
    435. 

  435.             else:
    436. 

  436.                 mountpoint = model.get_value(iter, INDEX_PARTITION_MOUNT_AS)
    437. 

  437.                 if mountpoint == mount_point:
    438. 

  438.                     model.set_value(iter, INDEX_PARTITION_MOUNT_AS, "")
    439. 

  439.                     model.set_value(iter, INDEX_PARTITION_FORMAT_AS, "")
    440. 

  440.             iter = model.iter_next(iter)
    441. 

  441.         #Assign it in our setup
    442. 

  442.         for apartition in self.setup.partitions:
    443. 

  443.             if (apartition.partition.path == partition.partition.path):
    444. 

  444.                 apartition.mount_as = mount_point
    445. 

  445.                 apartition.format_as = filesystem
    446. 

  446.             else:                
    447. 

  447.                 if apartition.mount_as == mount_point:
    448. 

  448.                     apartition.mount_as = None
    449. 

  449.                     apartition.format_as = None
    450. 

  450.         self.setup.print_setup()
    451. 

  451.                 
    452. 

  452. 

  453.     def refresh_partitions(self, widget, data=None):
    454. 

  454.         ''' refresh the partitions ... '''
    455. 

  455.         self.build_partitions()
    456. 

  456. 

  457.     def edit_partitions(self, widget, data=None):
    458. 

  458.         ''' edit the partitions ... '''
    459. 

  459.         os.popen("gparted &")
    460. 

  460. 

  461.     def build_lang_list(self):
    462. 

  462. 

  463.         #Try to find out where we're located...
    464. 

  464.         cur_country_code = None
    465. 

  465.         # try:
    466. 

  466.         #     whatismyip = 'http://debian.linuxmint.com/installer/show_my_ip.php'
    467. 

  467.         #     ip = urllib.urlopen(whatismyip).readlines()[0]
    468. 

  468.         #     gi = GeoIP.new(GeoIP.GEOIP_MEMORY_CACHE)
    469. 

  469.         #     cur_country_code = gi.country_code_by_addr(ip)
    470. 

  470.         # except:
    471. 

  471.         #     pass #best effort, we get here if we're not connected to the Internet            
    472. 

    473. 

  473.         #Plan B... find out what locale we're in (i.e. USA on the live session)
    474. 

  474.         cur_lang = os.environ['LANG']
    475. 

  475.         if("." in cur_lang):
    476. 

  476.             cur_lang = cur_lang.split(".")[0]
    477. 

  477. 

  478.         model = gtk.ListStore(str,str,gtk.gdk.Pixbuf)
    479. 

  479.         model.set_sort_column_id(0, gtk.SORT_ASCENDING)
    480. 

  480. 

  481.         #Load countries into memory
    482. 

  482.         countries = {}
    483. 

  483.         file = open(os.path.join(self.resource_dir, 'countries'), "r")
    484. 

  484.         for line in file:
    485. 

  485.             line = line.strip()
    486. 

  486.             split = line.split("=")
    487. 

  487.             if len(split) == 2:
    488. 

  488.                 countries[split[0]] = split[1]
    489. 

  489.         file.close()
    490. 

  490. 

  491.         #Load languages into memory
    492. 

  492.         languages = {}
    493. 

  493.         file = open(os.path.join(self.resource_dir, 'languages'), "r")
    494. 

  494.         for line in file:
    495. 

  495.             line = line.strip()
    496. 

  496.             split = line.split("=")
    497. 

  497.             if len(split) == 2:
    498. 

  498.                 languages[split[0]] = split[1]
    499. 

  499.         file.close()
    500. 

  500. 

  501.         path = os.path.join(self.resource_dir, 'locales')
    502. 

  502.         locales = open(path, "r")
    503. 

  503.         cur_index = -1 # find the locale :P
    504. 

  504.         set_index = None
    505. 

  505.         for line in locales:
    506. 

  506.             cur_index += 1
    507. 

  507.             if "UTF-8" in line:
    508. 

  508.                 locale_code = line.replace("UTF-8", "")
    509. 

  509.                 locale_code = locale_code.replace(".", "")
    510. 

  510.                 locale_code = locale_code.strip()
    511. 

  511.                 if "_" in locale_code:
    512. 

  512.                     split = locale_code.split("_")
    513. 

  513.                     if len(split) == 2:
    514. 

  514.                         language_code = split[0]
    515. 

  515.                         if language_code in languages:
    516. 

  516.                             language = languages[language_code]
    517. 

  517.                         else:
    518. 

  518.                             language = language_code
    519. 

  519. 

  520.                         country_code = split[1].lower()
    521. 

  521.                         if country_code in countries:
    522. 

  522.                             country = countries[country_code]
    523. 

  523.                         else:
    524. 

  524.                             country = country_code
    525. 

  525. 

  526.                         language_label = "%s (%s)" % (language, country)
    527. 

  527.                         #language_label = "%s - %s" % (country, language)
    528. 

  528. 

  529.                         iter = model.append()
    530. 

  530.                         model.set_value(iter, 0, language_label)
    531. 

  531.                         model.set_value(iter, 1, locale_code)
    532. 

  532.                         flag_path = self.resource_dir + '/flags/16/' + country_code + '.png'
    533. 

  533.                         if os.path.exists(flag_path):
    534. 

  534.                             model.set_value(iter, 2, gtk.gdk.pixbuf_new_from_file(flag_path))
    535. 

  535.                         else:
    536. 

  536.                             flag_path = self.resource_dir + '/flags/16/generic.png'
    537. 

  537.                             model.set_value(iter, 2, gtk.gdk.pixbuf_new_from_file(flag_path))
    538. 

  538.                         # If it's matching our country code, that's our language right there.. 
    539. 

  539.                         if ((cur_country_code is not None) and (cur_country_code.lower() == country_code)):                            
    540. 

  540.                             if (set_index is None):
    541. 

  541.                                 set_index = iter                                
    542. 

  542.                             else:
    543. 

  543.                                 # If we find more than one language for a particular country, one of them being English, go for English by default.
    544. 

  544.                                 if (language_code == "en"):
    545. 

  545.                                     set_index = iter                 
    546. 

  546.                                 # Guesswork... handy for countries which have their own language (fr_FR, de_DE, es_ES.. etc. )
    547. 

  547.                                 elif (country_code == language_code):
    548. 

  548.                                     set_index = iter
    549. 

  549.                                     
    550. 

  550.                         # as a plan B... use the locale (USA)
    551. 

  551.                         if((set_index is None) and (locale_code == cur_lang)):
    552. 

  552.                             set_index = iter
    553. 

  553.                             #print "Set via locale: " + cur_lang
    554. 

  554. 

  555.         treeview = self.wTree.get_widget("treeview_language_list")
    556. 

  556.         treeview.set_model(model)
    557. 

  557.         if(set_index is not None):
    558. 

  558.             column = treeview.get_column(0)
    559. 

  559.             path = model.get_path(set_index)
    560. 

  560.             treeview.set_cursor(path, focus_column=column)
    561. 

  561.             treeview.scroll_to_cell(path, column=column)
    562. 

  562.         treeview.set_search_column(0)
    563. 

  563. 

  564.     def build_timezones(self):
    565. 

  565.         model = gtk.ListStore(str, str)
    566. 

  566.         model.set_sort_column_id(0, gtk.SORT_ASCENDING)
    567. 

  567. 

  568.         path = os.path.join(self.resource_dir, 'timezones')
    569. 

  569.         timezones = open(path, "r")
    570. 

  570.         cur_index = -1 # find the timezone :P
    571. 

  571.         set_index = None
    572. 

  572.         for line in timezones:
    573. 

  573.             cur_index += 1
    574. 

  574.             content = line.strip().split()
    575. 

  575.             if len(content) == 2:
    576. 

  576.                 country_code = content[0]
    577. 

  577.                 timezone = content[1]
    578. 

  578.                 iter = model.append()
    579. 

  579.                 model.set_value(iter, 0, timezone)
    580. 

  580.                 model.set_value(iter, 1, country_code)
    581. 

  581. 

  582.         treeview = self.wTree.get_widget("treeview_timezones")
    583. 

  583.         treeview.set_model(model)
    584. 

  584.         treeview.set_search_column(0)
    585. 

  585.         
    586. 

  586.     def build_hdds(self):
    587. 

  587.         self.setup.disks = []
    588. 

  588.         model = gtk.ListStore(str, str)            
    589. 

  589.         inxi = subprocess.Popen("inxi -c0 -D", shell=True, stdout=subprocess.PIPE)      
    590. 

  590.         for line in inxi.stdout:
    591. 

  591.             line = line.rstrip("\r\n")
    592. 

  592.             if(line.startswith("Disks:")):
    593. 

  593.                 line = line.replace("Disks:", "")            
    594. 

  594.             sections = line.split(":")
    595. 

  595.             for section in sections:
    596. 

  596.                 section = section.strip()
    597. 

  597.                 if("/dev/" in section):                    
    598. 

  598.                     elements = section.split()
    599. 

  599.                     for element in elements:
    600. 

  600.                         if "/dev/" in element: 
    601. 

  601.                             self.setup.disks.append(element)
    602. 

  602.                             description = section.replace(element, "").strip()
    603. 

  603.                             iter = model.append([element, description]);
    604. 

  604.                 
    605. 

  605.         self.wTree.get_widget("treeview_hdds").set_model(model)
    606. 

  606.         
    607. 

  607.         if(len(self.setup.disks) > 0):
    608. 

  608.             # select the first HDD
    609. 

  609.             treeview = self.wTree.get_widget("treeview_hdds")            
    610. 

  610.             column = treeview.get_column(0)
    611. 

  611.             path = model.get_path(model.get_iter_first())
    612. 

  612.             treeview.set_cursor(path, focus_column=column)
    613. 

  613.             treeview.scroll_to_cell(path, column=column)
    614. 

  614.             self.setup.target_disk = model.get_value(model.get_iter_first(), 0) 
    615. 

  615.     
    616. 

  616.     def build_grub_partitions(self):
    617. 

  617.         grub_model = gtk.ListStore(str)
    618. 

  618.         # Add disks
    619. 

  619.         for disk in self.setup.disks:
    620. 

  620.             grub_model.append([disk])
    621. 

  621.         # Add partitions
    622. 

  622.         partitions = commands.getoutput("fdisk -l | grep ^/dev/").split("\n")
    623. 

  623.         for partition in partitions:
    624. 

  624.             try:
    625. 

  625.                 partition = partition.split()[0].strip()
    626. 

  626.                 if partition.startswith("/dev/"):
    627. 

  627.                     grub_model.append([partition])
    628. 

  628.             except Exception, detail:
    629. 

  629.                 print detail
    630. 

  630.         self.wTree.get_widget("combobox_grub").set_model(grub_model)
    631. 

  631.         self.wTree.get_widget("combobox_grub").set_active(0)
    632. 

  632.   
    633. 

  633.     def build_partitions(self):        
    634. 

  634.         self.window.set_sensitive(False)
    635. 

  635.         # "busy" cursor.
    636. 

  636.         cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
    637. 

  637.         self.window.window.set_cursor(cursor)        
    638. 

  638.         
    639. 

  639.         os.popen('mkdir -p /tmp/live-installer/tmpmount')
    640. 

  640.         
    641. 

  641.         try:                                                                                            
    642. 

  642.             #grub_model = gtk.ListStore(str)
    643. 

  643.             self.setup.partitions = []
    644. 

  644.             
    645. 

  645.             html_partitions = ""        
    646. 

  646.             model = gtk.ListStore(str,str,str,str,str,str,str, object, bool, str, str, bool)
    647. 

  647.             model2 = gtk.ListStore(str)
    648. 

  648.             
    649. 

  649.             swap_found = False
    650. 

  650.             
    651. 

  651.             if self.setup.target_disk is not None:
    652. 

  652.                 path =  self.setup.target_disk # i.e. /dev/sda
    653. 

  653.                 #grub_model.append([path])
    654. 

  654.                 device = parted.getDevice(path)                
    655. 

  655.                 try:
    656. 

  656.                     disk = parted.Disk(device)
    657. 

  657.                 except Exception:
    658. 

  658.                     dialog = QuestionDialog(_("Installation Tool"), _("No partition table was found on the hard drive. Do you want the installer to create a set of partitions for you? Note: This will erase any data present on the disk."))
    659. 

  659.                     if (dialog.show()):
    660. 

  660.                         # Create a default partition set up                        
    661. 

  661.                         disk = parted.freshDisk(device, 'msdos')
    662. 

  662.                         disk.commit()
    663. 

  663. 

  664.                         #Swap
    665. 

  665.                         regions = disk.getFreeSpaceRegions()
    666. 

  666.                         if len(regions) > 0:
    667. 

  667.                             region = regions[-1]    
    668. 

  668.                             ram_size = int(commands.getoutput("cat /proc/meminfo | grep MemTotal | awk {'print $2'}")) # in KiB
    669. 

  669.                             post_mbr_gap = parted.sizeToSectors(1, "MiB", device.sectorSize) # Grub2 requires a post-MBR gap
    670. 

  670.                             start = post_mbr_gap
    671. 

  671.                             num_sectors = parted.sizeToSectors(ram_size, "KiB", device.sectorSize)
    672. 

  672.                             num_sectors = int(float(num_sectors) * 1.5) # Swap is 1.5 times bigger than RAM
    673. 

  673.                             end = start + num_sectors
    674. 

  674.                             cylinder = device.endSectorToCylinder(end)
    675. 

  675.                             end = device.endCylinderToSector(cylinder)
    676. 

  676.                             geometry = parted.Geometry(device=device, start=start, end=end)
    677. 

  677.                             if end < region.length:
    678. 

  678.                                 partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL, geometry=geometry)
    679. 

  679.                                 constraint = parted.Constraint(exactGeom=geometry)
    680. 

  680.                                 disk.addPartition(partition=partition, constraint=constraint)
    681. 

  681.                                 disk.commit()
    682. 

  682.                                 os.system("mkswap %s" % partition.path)                                
    683. 

  683. 

  684.                         #Root
    685. 

  685.                         regions = disk.getFreeSpaceRegions()
    686. 

  686.                         if len(regions) > 0:
    687. 

  687.                             region = regions[-1]
    688. 

  688.                             partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL, geometry=region)
    689. 

  689.                             constraint = parted.Constraint(exactGeom=region)
    690. 

  690.                             disk.addPartition(partition=partition, constraint=constraint)
    691. 

  691.                             disk.commit()                            
    692. 

  692.                             os.system("mkfs.ext4 %s" % partition.path)
    693. 

  693.                        
    694. 

  694.                         self.build_partitions()
    695. 

  695.                         return
    696. 

  696.                     else:
    697. 

  697.                         # Do nothing... just get out of here..
    698. 

  698.                         raise
    699. 

  699.                 partition = disk.getFirstPartition()
    700. 

  700.                 last_added_partition = PartitionSetup(partition)
    701. 

  701.                 #self.setup.partitions.append(last_added_partition)
    702. 

  702.                 partition = partition.nextPartition()
    703. 

  703.                 html_partitions = html_partitions + "<table width='100%'><tr>"
    704. 

  704.                 while (partition is not None):
    705. 

  705.                     if last_added_partition.partition.number == -1 and partition.number == -1:
    706. 

  706.                         last_added_partition.add_partition(partition)
    707. 

  707.                     else:                        
    708. 

  708.                         last_added_partition = PartitionSetup(partition)
    709. 

  709.                                         
    710. 

  710.                         if "swap" in last_added_partition.type:
    711. 

  711.                             last_added_partition.type = "swap"                                                            
    712. 

  712. 

  713.                         if partition.number != -1 and "swap" not in last_added_partition.type and partition.type != parted.PARTITION_EXTENDED:
    714. 

  714.                             
    715. 

  715.                             #grub_model.append([partition.path])
    716. 

  716. 

  717.                             #Umount temp folder
    718. 

  718.                             if ('/tmp/live-installer/tmpmount' in commands.getoutput('mount')):
    719. 

  719.                                 os.popen('umount /tmp/live-installer/tmpmount')
    720. 

  720. 

  721.                             #Mount partition if not mounted
    722. 

  722.                             if (partition.path not in commands.getoutput('mount')):                                
    723. 

  723.                                 os.system("mount %s /tmp/live-installer/tmpmount" % partition.path)
    724. 

  724. 

  725.                             #Identify partition's description and used space
    726. 

  726.                             if (partition.path in commands.getoutput('mount')):
    727. 

  727.                                 df_lines = commands.getoutput("df 2>/dev/null | grep %s" % partition.path).split('\n')
    728. 

  728.                                 for df_line in df_lines:
    729. 

  729.                                     df_elements = df_line.split()
    730. 

  730.                                     if df_elements[0] == partition.path:
    731. 

  731.                                         last_added_partition.used_space = df_elements[4]  
    732. 

  732.                                         mount_point = df_elements[5]                              
    733. 

  733.                                         if "%" in last_added_partition.used_space:
    734. 

  734.                                             used_space_pct = int(last_added_partition.used_space.replace("%", "").strip())
    735. 

  735.                                             last_added_partition.free_space = int(float(last_added_partition.size) * (float(100) - float(used_space_pct)) / float(100))                                            
    736. 

  736.                                                                             
    737. 

  737.                                         if os.path.exists(os.path.join(mount_point, 'etc/lsb-release')):
    738. 

  738.                                             last_added_partition.description = commands.getoutput("cat " + os.path.join(mount_point, 'etc/lsb-release') + " | grep DISTRIB_DESCRIPTION").replace('DISTRIB_DESCRIPTION', '').replace('=', '').replace('"', '').strip()                                    
    739. 

  739.                                         if os.path.exists(os.path.join(mount_point, 'etc/issue')):
    740. 

  740.                                             last_added_partition.description = commands.getoutput("cat " + os.path.join(mount_point, 'etc/issue')).replace('\\n', '').replace('\l', '').strip()                                    
    741. 

  741.                                         if os.path.exists(os.path.join(mount_point, 'Windows/servicing/Version')):
    742. 

  742.                                             version = commands.getoutput("ls %s" % os.path.join(mount_point, 'Windows/servicing/Version'))                                    
    743. 

  743.                                             if version.startswith("6.1"):
    744. 

  744.                                                 last_added_partition.description = "Windows 7"
    745. 

  745.                                             elif version.startswith("6.0"):
    746. 

  746.                                                 last_added_partition.description = "Windows Vista"
    747. 

  747.                                             elif version.startswith("5.1") or version.startswith("5.2"):
    748. 

  748.                                                 last_added_partition.description = "Windows XP"
    749. 

  749.                                             elif version.startswith("5.0"):
    750. 

  750.                                                 last_added_partition.description = "Windows 2000"
    751. 

  751.                                             elif version.startswith("4.90"):
    752. 

  752.                                                 last_added_partition.description = "Windows Me"
    753. 

  753.                                             elif version.startswith("4.1"):
    754. 

  754.                                                 last_added_partition.description = "Windows 98"
    755. 

  755.                                             elif version.startswith("4.0.1381"):
    756. 

  756.                                                 last_added_partition.description = "Windows NT"
    757. 

  757.                                             elif version.startswith("4.0.950"):
    758. 

  758.                                                 last_added_partition.description = "Windows 95"
    759. 

  759.                                         elif os.path.exists(os.path.join(mount_point, 'Boot/BCD')):
    760. 

  760.                                             if os.system("grep -qs \"V.i.s.t.a\" " + os.path.join(mount_point, 'Boot/BCD')) == 0:
    761. 

  761.                                                 last_added_partition.description = "Windows Vista bootloader"
    762. 

  762.                                             elif os.system("grep -qs \"W.i.n.d.o.w.s. .7\" " + os.path.join(mount_point, 'Boot/BCD')) == 0:
    763. 

  763.                                                 last_added_partition.description = "Windows 7 bootloader"
    764. 

  764.                                             elif os.system("grep -qs \"W.i.n.d.o.w.s. .R.e.c.o.v.e.r.y. .E.n.v.i.r.o.n.m.e.n.t\" " + os.path.join(mount_point, 'Boot/BCD')) == 0:
    765. 

  765.                                                 last_added_partition.description = "Windows recovery"
    766. 

  766.                                             elif os.system("grep -qs \"W.i.n.d.o.w.s. .S.e.r.v.e.r. .2.0.0.8\" " + os.path.join(mount_point, 'Boot/BCD')) == 0:
    767. 

  767.                                                 last_added_partition.description = "Windows Server 2008 bootloader"
    768. 

  768.                                             else:
    769. 

  769.                                                 last_added_partition.description = "Windows bootloader"
    770. 

  770.                                         elif os.path.exists(os.path.join(mount_point, 'Windows/System32')):
    771. 

  771.                                             last_added_partition.description = "Windows"
    772. 

  772.                                         break
    773. 

  773.                             else:
    774. 

  774.                                 print "Failed to mount %s" % partition.path
    775. 

  775. 

  776.                             
    777. 

  777.                             #Umount temp folder
    778. 

  778.                             if ('/tmp/live-installer/tmpmount' in commands.getoutput('mount')):
    779. 

  779.                                 os.popen('umount /tmp/live-installer/tmpmount')
    780. 

  780.                                 
    781. 

  781.                     if last_added_partition.size > 1.0:
    782. 

  782.                         if last_added_partition.partition.type == parted.PARTITION_LOGICAL:
    783. 

  783.                             display_name = "  " + last_added_partition.name
    784. 

  784.                         else:
    785. 

  785.                             display_name = last_added_partition.name
    786. 

  786. 

  787.                         iter = model.append([display_name, last_added_partition.type, last_added_partition.description, "", "", '%.0f' % round(last_added_partition.size, 0), last_added_partition.free_space, last_added_partition, False, last_added_partition.start, last_added_partition.end, False]);
    788. 

  788.                         if last_added_partition.partition.number == -1:                     
    789. 

  789.                             model.set_value(iter, INDEX_PARTITION_TYPE, "<span foreground='#a9a9a9'>%s</span>" % last_added_partition.type)                                    
    790. 

  790.                         elif last_added_partition.partition.type == parted.PARTITION_EXTENDED:                    
    791. 

  791.                             model.set_value(iter, INDEX_PARTITION_TYPE, "<span foreground='#a9a9a9'>%s</span>" % _("Extended"))  
    792. 

  792.                         else:                                        
    793. 

  793.                             if last_added_partition.type == "ntfs":
    794. 

  794.                                 color = "#42e5ac"
    795. 

  795.                             elif last_added_partition.type == "fat32":
    796. 

  796.                                 color = "#18d918"
    797. 

  797.                             elif last_added_partition.type == "ext4":
    798. 

  798.                                 color = "#4b6983"
    799. 

  799.                             elif last_added_partition.type == "ext3":
    800. 

  800.                                 color = "#7590ae"
    801. 

  801.                             elif last_added_partition.type in ["linux-swap", "swap"]:
    802. 

  802.                                 color = "#c1665a"
    803. 

  803.                                 last_added_partition.mount_as = "swap"
    804. 

  804.                                 model.set_value(iter, INDEX_PARTITION_MOUNT_AS, "swap")
    805. 

  805.                             else:
    806. 

  806.                                 color = "#a9a9a9"
    807. 

  807.                             model.set_value(iter, INDEX_PARTITION_TYPE, "<span foreground='%s'>%s</span>" % (color, last_added_partition.type))                                            
    808. 

  808.                             html_partition = "<td class='partition-cell' title='$title' style='border: 3px solid $color;' width='$space%'><div class='partition'>\n  <div style='width: $usage; background-color: #f8f8ba; height: 50px'></div>\n <div class='partition-text'>$path</div><div class='partition-os'>$OS</div>\n</div>\n</td>"        
    809. 

  809.                             deviceSize = float(device.getSize()) * float(0.9) # Hack.. reducing the real size to 90% of what it is, to make sure our partitions fit..
    810. 

  810.                             space = int((float(partition.getSize()) / deviceSize) * float(80))                            
    811. 

  811.                             subs = {}
    812. 

  812.                             if (space >= 10):
    813. 

  813.                                 subs['path'] = display_name.replace("/dev/", "")                            
    814. 

  814.                                 subs['OS'] = last_added_partition.description
    815. 

  815.                             elif (space >= 5):
    816. 

  816.                                 subs['path'] = display_name.replace("/dev/", "")                            
    817. 

  817.                                 subs['OS'] = ""                            
    818. 

  818.                             else:
    819. 

  819.                                 #Not enough space, don't write the name
    820. 

  820.                                 subs['path'] = ""                          
    821. 

  821.                                 subs['OS'] = ""
    822. 

  822.                             subs['color'] = color                            
    823. 

  823.                             if (space == 0):
    824. 

  824.                                 space = 1
    825. 

  825.                             subs['space'] = space
    826. 

  826.                             subs['title'] = display_name + "\n" + last_added_partition.description
    827. 

  827.                             if "%" in last_added_partition.used_space:               
    828. 

  828.                                 subs['usage'] = last_added_partition.used_space.strip()
    829. 

  829.                             html_partition = string.Template(html_partition).safe_substitute(subs)                     
    830. 

  830.                             html_partitions = html_partitions + html_partition
    831. 

  831.                             self.setup.partitions.append(last_added_partition)
    832. 

  832.                             
    833. 

  833.                     partition = partition.nextPartition()
    834. 

  834.                 html_partitions = html_partitions + "</tr></table>"
    835. 

  835.             #self.wTree.get_widget("combobox_grub").set_model(grub_model)
    836. 

  836.             #self.wTree.get_widget("combobox_grub").set_active(0)
    837. 

  837.                         
    838. 

  838.             import tempfile            
    839. 

  839.             html_header = "<html><head><style>body {background-color:#d6d6d6;} \
    840. 

  840.             .partition{position:relative; width:100%; float: left; background: white;} \
    841. 

  841.             .partition-cell{ position:relative; margin: 2px 5px 2px 0; padding: 1px; float: left; background: white;} \
    842. 

  842.             .partition-text{ position:absolute; top:10; text-align: center; width=100px; left: 0; right: 0; margin: 0 auto; font-size:12px; } \
    843. 

  843.             .partition-os{ position:absolute; top:30; text-align: center; width=100px; left: 0; right: 0; margin: 0 auto; font-size:10px; font-style:italic;color:#555555;} </style></head><body>"
    844. 

  844.             html_footer = "</body></html>"
    845. 

  845.             html = html_header + html_partitions + html_footer
    846. 

  846.            
    847. 

  847.             # create temporary file
    848. 

  848.             f = tempfile.NamedTemporaryFile(delete=False)
    849. 

  849.             f.write(html)
    850. 

  850.             f.close()  
    851. 

  851.                                    
    852. 

  852.             self.browser.open(f.name)            
    853. 

  853.             #browser.load_html_string(html, "file://")                 
    854. 

  854.             self.wTree.get_widget("scrolled_partitions").show_all()                                                                        
    855. 

  855.             self.wTree.get_widget("treeview_disks").set_model(model)                                
    856. 

  856.             
    857. 

  857.             
    858. 

  858.         except Exception, detail:
    859. 

  859.             print detail  
    860. 

  860.                 
    861. 

  861.         self.window.set_sensitive(True)
    862. 

  862.         self.window.window.set_cursor(None)        
    863. 

  863.         
    864. 

  864. 

  865.     def build_kb_lists(self):
    866. 

  866.         ''' Do some xml kung-fu and load the keyboard stuffs '''
    867. 

  867. 

  868.         # firstly we'll determine the layouts in use
    869. 

  869.         p = subprocess.Popen("setxkbmap -print",shell=True,stdout=subprocess.PIPE)
    870. 

  870.         for line in p.stdout:
    871. 

  871.             # strip it
    872. 

  872.             line = line.rstrip("\r\n")
    873. 

  873.             line = line.replace("{","")
    874. 

  874.             line = line.replace("}","")
    875. 

  875.             line = line.replace(";","")
    876. 

  876.             if("xkb_symbols" in line):
    877. 

  877.                 # decipher the layout in use
    878. 

  878.                 section = line.split("\"")[1] # split by the " mark
    879. 

  879.                 self.setup.keyboard_layout = section.split("+")[1]
    880. 

  880.             if("xkb_geometry" in line):
    881. 

  881.                 first_bracket = line.index("(") +1
    882. 

  882.                 substr = line[first_bracket:]
    883. 

  883.                 last_bracket = substr.index(")")
    884. 

  884.                 substr = substr[0:last_bracket]
    885. 

  885.                 keyboard_geom = substr
    886. 

  886.         p.poll()
    887. 

  887. 

  888.         xml_file = '/usr/share/X11/xkb/rules/xorg.xml'
    889. 

  889.         model_models = gtk.ListStore(str,str)
    890. 

  890.         model_models.set_sort_column_id(0, gtk.SORT_ASCENDING)
    891. 

  891.         model_layouts = gtk.ListStore(str,str)
    892. 

  892.         model_layouts.set_sort_column_id(0, gtk.SORT_ASCENDING)        
    893. 

  893.         dom = parse(xml_file)
    894. 

  894. 

  895.         # if we find the users keyboard info we can set it in the list
    896. 

  896.         set_keyboard_model = None
    897. 

  897.         set_keyboard_layout = None
    898. 

  898.         set_keyboard_variant = None
    899. 

  899. 

  900.         # grab the root element
    901. 

  901.         root = dom.getElementsByTagName('xkbConfigRegistry')[0]
    902. 

  902.         # build the list of models
    903. 

  903.         root_models = root.getElementsByTagName('modelList')[0]
    904. 

  904.         for element in root_models.getElementsByTagName('model'):
    905. 

  905.             conf = element.getElementsByTagName('configItem')[0]
    906. 

  906.             name = conf.getElementsByTagName('name')[0]
    907. 

  907.             desc = conf.getElementsByTagName('description')[0]
    908. 

  908.             #vendor = conf.getElementsByTagName('vendor')[0] # presently unused..
    909. 

  909.             iter_model = model_models.append([self.getText(desc.childNodes), self.getText(name.childNodes)])
    910. 

  910.             item = self.getText(name.childNodes)
    911. 

  911.             if(item == keyboard_geom):
    912. 

  912.                 set_keyboard_model = iter_model
    913. 

  913.         root_layouts = root.getElementsByTagName('layoutList')[0]
    914. 

  914.         for element in root_layouts.getElementsByTagName('layout'):
    915. 

  915.             conf = element.getElementsByTagName('configItem')[0]
    916. 

  916.             name = conf.getElementsByTagName('name')[0]
    917. 

  917.             desc = conf.getElementsByTagName('description')[0]
    918. 

  918.             iter_layout = model_layouts.append([self.getText(desc.childNodes), self.getText(name.childNodes)])
    919. 

  919.             item = self.getText(name.childNodes)
    920. 

  920.             if(item == self.setup.keyboard_layout):
    921. 

  921.                 set_keyboard_layout = iter_layout
    922. 

  922.         # now set the model        
    923. 

  923.         self.wTree.get_widget("combobox_kb_model").set_model(model_models)
    924. 

  924.         self.wTree.get_widget("treeview_layouts").set_model(model_layouts)
    925. 

  925. 

  926.         if(set_keyboard_layout is not None):
    927. 

  927.             # show it in the list
    928. 

  928.             treeview = self.wTree.get_widget("treeview_layouts")
    929. 

  929.             model = treeview.get_model()
    930. 

  930.             column = treeview.get_column(0)
    931. 

  931.             path = model.get_path(set_keyboard_layout)
    932. 

  932.             treeview.set_cursor(path, focus_column=column)
    933. 

  933.             treeview.scroll_to_cell(path, column=column)
    934. 

  934.         if(set_keyboard_model is not None):         
    935. 

  935.              # show it in the combo
    936. 

  936.             combo = self.wTree.get_widget("combobox_kb_model")
    937. 

  937.             model = combo.get_model()                    
    938. 

  938.             combo.set_active_iter(set_keyboard_model)       …
    939.

Large files files are truncated, but you can click here to view the full file