PageRenderTime 41ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://github.com/kdsdevs/live-installer
Python | 1924 lines | 1656 code | 145 blank | 123 comment | 110 complexity | 1309701ba8b6163aaf8b5c5446c15f36 MD5 | raw 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.     import math    
    17. 

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

  18.     from PIL import Image
    19. 

  19.     import pango
    20. 

  20.     import threading
    21. 

  21.     import xml.dom.minidom
    22. 

  22.     from xml.dom.minidom import parse
    23. 

  23.     import gobject
    24. 

  24.     import time
    25. 

  25.     import webkit
    26. 

  26.     import GeoIP
    27. 

  27.     import urllib
    28. 

  28.     import string
    29. 

  29.     import parted    
    30. 

  30. except Exception, detail:
    31. 

  31.     print detail
    32. 

  32. 

  33. from slideshow import Slideshow
    34. 

  34. 

  35. gettext.install("live-installer", "/usr/share/linuxmint/locale")
    36. 

  36. gtk.gdk.threads_init()
    37. 

  37. 

  38. INDEX_PARTITION_PATH=0
    39. 

  39. INDEX_PARTITION_TYPE=1
    40. 

  40. INDEX_PARTITION_DESCRIPTION=2
    41. 

  41. INDEX_PARTITION_FORMAT_AS=3
    42. 

  42. INDEX_PARTITION_MOUNT_AS=4
    43. 

  43. INDEX_PARTITION_SIZE=5
    44. 

  44. INDEX_PARTITION_FREE_SPACE=6
    45. 

  45. INDEX_PARTITION_OBJECT=7
    46. 

  46. 

  47. class ProgressDialog:
    48. 

  48. 	
    49. 

  49. 	def __init__(self):
    50. 

  50. 		self.glade = '/usr/share/live-installer/interface.glade'
    51. 

  51. 		self.dTree = gtk.glade.XML(self.glade, 'progress_window')
    52. 

  52. 		self.window = self.dTree.get_widget('progress_window')
    53. 

  53. 		self.progressbar = self.dTree.get_widget('progressbar_operation')
    54. 

  54. 		self.label = self.dTree.get_widget('label_operation')
    55. 

  55. 		self.should_pulse = False
    56. 

  56. 		
    57. 

  57. 	def show(self, label=None, title=None):
    58. 

  58. 		def pbar_pulse():
    59. 

  59. 			if(not self.should_pulse):
    60. 

  60. 				return False
    61. 

  61. 			self.progressbar.pulse()
    62. 

  62. 			return self.should_pulse
    63. 

  63. 		if(label is not None):
    64. 

  64. 			self.label.set_markup(label)
    65. 

  65. 		if(title is not None):
    66. 

  66. 			self.window.set_title(title)
    67. 

  67. 		self.should_pulse = True
    68. 

  68. 		self.window.show_all()
    69. 

  69. 		gobject.timeout_add(100, pbar_pulse)
    70. 

  70. 		
    71. 

  71. 	def hide(self):
    72. 

  72. 		self.should_pulse = False
    73. 

  73. 		self.window.hide()	
    74. 

  74. 

  75. ''' Handy. Makes message dialogs easy :D '''
    76. 

  76. class MessageDialog(object):
    77. 

  77. 

  78.     def __init__(self, title, message, style, parent=None):
    79. 

  79.         self.title = title
    80. 

  80.         self.message = message
    81. 

  81.         self.style = style
    82. 

  82.         self.parent = parent
    83. 

  83. 

  84.     ''' Show me on screen '''
    85. 

  85.     def show(self):
    86. 

  86. 

  87.         dialog = gtk.MessageDialog(self.parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, self.style, gtk.BUTTONS_OK, self.message)
    88. 

  88.         dialog.set_title(self.title)
    89. 

  89.         dialog.set_position(gtk.WIN_POS_CENTER)
    90. 

  90.         dialog.set_icon_from_file("/usr/share/icons/live-installer.png")
    91. 

  91.         dialog.run()
    92. 

  92.         dialog.destroy()
    93. 

  93.         
    94. 

  94. class QuestionDialog(object):
    95. 

  95.     def __init__(self, title, message, parent=None):
    96. 

  96.         self.title = title
    97. 

  97.         self.message = message       
    98. 

  98.         self.parent = parent
    99. 

  99. 

  100.     ''' Show me on screen '''
    101. 

  101.     def show(self):    
    102. 

  102.         dialog = gtk.MessageDialog(self.parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, self.message)
    103. 

  103.         dialog.set_title(self.title)
    104. 

  104.         dialog.set_position(gtk.WIN_POS_CENTER)
    105. 

  105.         dialog.set_icon_from_file("/usr/share/icons/live-installer.png")
    106. 

  106.         answer = dialog.run()
    107. 

  107.         if answer==gtk.RESPONSE_YES:
    108. 

  108.             return_value = True
    109. 

  109.         else:
    110. 

  110.             return_value = False
    111. 

  111.         dialog.destroy()
    112. 

  112.         return return_value    
    113. 

  113. 

  114. class WizardPage:
    115. 

  115. 

  116.     def __init__(self, help_text, icon):
    117. 

  117.         self.help_text = help_text    
    118. 

  118.         self.icon = icon    
    119. 

  119.         
    120. 

  120. class Timezone:
    121. 

  121.     def __init__(self, name, country_code, coordinates):
    122. 

  122.         self.height = 409 # Height of the map
    123. 

  123.         self.width = 800 # Width of the map
    124. 

  124.         self.name = name
    125. 

  125.         self.country_code = country_code
    126. 

  126.         self.coordinates = coordinates
    127. 

  127.         latlongsplit = coordinates.find('-', 1)
    128. 

  128.         if latlongsplit == -1:
    129. 

  129.             latlongsplit = coordinates.find('+', 1)
    130. 

  130.         if latlongsplit != -1:
    131. 

  131.             self.latitude = coordinates[:latlongsplit]
    132. 

  132.             self.longitude = coordinates[latlongsplit:]
    133. 

  133.         else:
    134. 

  134.             self.latitude = coordinates
    135. 

  135.             self.longitude = '+0'
    136. 

  136.         
    137. 

  137.         self.latitude = self.parse_position(self.latitude, 2)
    138. 

  138.         self.longitude = self.parse_position(self.longitude, 3)
    139. 

  139.         
    140. 

  140.         (self.x, self.y) = self.getPosition(self.latitude, self.longitude)            
    141. 

  141.     
    142. 

  142.     def parse_position(self, position, wholedigits):
    143. 

  143.         if position == '' or len(position) < 4 or wholedigits > 9:
    144. 

  144.             return 0.0
    145. 

  145.         wholestr = position[:wholedigits + 1]
    146. 

  146.         fractionstr = position[wholedigits + 1:]
    147. 

  147.         whole = float(wholestr)
    148. 

  148.         fraction = float(fractionstr)
    149. 

  149.         if whole >= 0.0:
    150. 

  150.             return whole + fraction / pow(10.0, len(fractionstr))
    151. 

  151.         else:
    152. 

  152.             return whole - fraction / pow(10.0, len(fractionstr))            
    153. 

  153.         
    154. 

  154.     # @return pixel coordinate of a latitude and longitude for self
    155. 

  155.     # map uses Miller Projection, but is also clipped
    156. 

  156.     def getPosition(self, la, lo):
    157. 

  157.         # need to add/sub magic numbers because the map doesn't actually go from -180...180, -90...90
    158. 

  158.         # thus the upper corner is not -180, -90 and we have to compensate
    159. 

  159.         # we need a better method of determining the actually range so we can better place citites (shtylman)
    160. 

  160.         xdeg_offset = -6
    161. 

  161.         # the 180 - 35) accounts for the fact that the map does not span the entire -90 to 90
    162. 

  162.         # the map does span the entire 360 though, just offset
    163. 

  163.         x = (self.width * (180.0 + lo) / 360.0) + (self.width * xdeg_offset/ 180.0)
    164. 

  164.         x = x % self.width
    165. 

  165. 

  166.         #top and bottom clipping latitudes
    167. 

  167.         topLat = 81
    168. 

  168.         bottomLat = -59
    169. 

  169. 

  170.         #percent of entire possible range
    171. 

  171.         topPer = topLat/180.0
    172. 

  172. 

  173.         # get the y in rectangular coordinates
    174. 

  174.         y = 1.25 * math.log(math.tan(math.pi/4.0 + 0.4 * math.radians(la)))
    175. 

  175. 

  176.         # calculate the map range (smaller than full range because the map is clipped on top and bottom
    177. 

  177.         fullRange = 4.6068250867599998
    178. 

  178.         # the amount of the full range devoted to the upper hemisphere
    179. 

  179.         topOffset = fullRange*topPer
    180. 

  180.         mapRange = abs(1.25 * math.log(math.tan(math.pi/4.0 + 0.4 * math.radians(bottomLat))) - topOffset)
    181. 

  181. 

  182.         # Convert to a percentage of the map range
    183. 

  183.         y = abs(y - topOffset)
    184. 

  184.         y = y / mapRange
    185. 

  185. 

  186.         # this then becomes the percentage of the height
    187. 

  187.         y = y * self.height
    188. 

  188. 

  189.         return (int(x), int(y))        
    190. 

  190. 		
    191. 

  191. class InstallerWindow:
    192. 

  192. 

  193.     def __init__(self, fullscreen=False):
    194. 

  194.         
    195. 

  195.         #Build the Setup object (where we put all our choices)
    196. 

  196.         self.setup = Setup()
    197. 

  197.         
    198. 

  198.         self.resource_dir = '/usr/share/live-installer/'
    199. 

  199.         #self.glade = 'interface.glade'
    200. 

  200.         self.glade = os.path.join(self.resource_dir, 'interface.glade')
    201. 

  201.         self.wTree = gtk.glade.XML(self.glade, 'main_window')
    202. 

  202. 

  203.         # should be set early
    204. 

  204.         self.done = False
    205. 

  205.         self.fail = False
    206. 

  206.         self.paused = False
    207. 

  207. 

  208.         # here comes the installer engine
    209. 

  209.         self.installer = InstallerEngine()
    210. 

  210.         # the distribution name
    211. 

  211.         DISTRIBUTION_NAME = self.installer.get_distribution_name()
    212. 

  212.         # load the window object
    213. 

  213.         self.window = self.wTree.get_widget("main_window")
    214. 

  214.         if "--debug" in sys.argv:
    215. 

  215.             self.window.set_title((_("%s Installer") % DISTRIBUTION_NAME) + " (debug)")
    216. 

  216.         else:
    217. 

  217.             self.window.set_title(_("%s Installer") % DISTRIBUTION_NAME)
    218. 

  218.         self.window.connect("destroy", self.quit_cb)
    219. 

  219. 

  220.         # Wizard pages
    221. 

  221.         [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, self.PAGE_CUSTOMWARNING, self.PAGE_CUSTOMPAUSED] = range(11)
    222. 

  222.         self.wizard_pages = range(11)
    223. 

  223.         self.wizard_pages[self.PAGE_LANGUAGE] = WizardPage(_("Language"), "locales.png")
    224. 

  224.         self.wizard_pages[self.PAGE_TIMEZONE] = WizardPage(_("Timezone"), "time.png")
    225. 

  225.         self.wizard_pages[self.PAGE_KEYBOARD] = WizardPage(_("Keyboard layout"), "keyboard.png")
    226. 

  226.         self.wizard_pages[self.PAGE_USER] = WizardPage(_("User info"), "user.png")
    227. 

  227.         self.wizard_pages[self.PAGE_HDD] = WizardPage(_("Hard drive"), "hdd.svg")
    228. 

  228.         self.wizard_pages[self.PAGE_PARTITIONS] = WizardPage(_("Partitioning"), "hdd.svg")
    229. 

  229.         self.wizard_pages[self.PAGE_CUSTOMWARNING] = WizardPage(_("Please make sure you wish to manually manage partitions"), "hdd.svg")
    230. 

  230.         self.wizard_pages[self.PAGE_ADVANCED] = WizardPage(_("Advanced options"), "advanced.png")
    231. 

  231.         self.wizard_pages[self.PAGE_OVERVIEW] = WizardPage(_("Summary"), "summary.png")
    232. 

  232.         self.wizard_pages[self.PAGE_INSTALL] = WizardPage(_("Installing Linux Mint..."), "install.png")
    233. 

  233.         self.wizard_pages[self.PAGE_CUSTOMPAUSED] = WizardPage(_("Installation is Paused: Please finish the custom installation"), "install.png")
    234. 

  234.         
    235. 

  235.         # set the button events (wizard_cb)
    236. 

  236.         self.wTree.get_widget("button_next").connect("clicked", self.wizard_cb, False)
    237. 

  237.         self.wTree.get_widget("button_back").connect("clicked", self.wizard_cb, True)
    238. 

  238.         self.wTree.get_widget("button_quit").connect("clicked", self.quit_cb)
    239. 

  239. 

  240.         ren = gtk.CellRendererPixbuf()
    241. 

  241.         column = gtk.TreeViewColumn("Flags", ren)
    242. 

  242.         column.add_attribute(ren, "pixbuf", 2)
    243. 

  243.         self.wTree.get_widget("treeview_language_list").append_column(column)
    244. 

  244. 

  245.         ren = gtk.CellRendererText()
    246. 

  246.         column = gtk.TreeViewColumn("Languages", ren)
    247. 

  247.         column.add_attribute(ren, "text", 0)
    248. 

  248.         self.wTree.get_widget("treeview_language_list").append_column(column)
    249. 

  249.         self.wTree.get_widget("treeview_language_list").connect("cursor-changed", self.assign_language)
    250. 

  250. 

  251.         # build user info page
    252. 

  252.         self.wTree.get_widget("face_select_picture_button").connect( "button-release-event", self.face_select_picture_button_clicked)        
    253. 

  253.         self.wTree.get_widget("face_take_picture_button").connect( "button-release-event", self.face_take_picture_button_clicked)           
    254. 

  254.         os.system("convert /usr/share/pixmaps/faces/user-generic.png -resize x96 /tmp/live-installer-face.png")
    255. 

  255.         self.wTree.get_widget("face_image").set_from_file("/tmp/live-installer-face.png")   
    256. 

  256.         
    257. 

  257.         webcam_detected = False
    258. 

  258.         try:
    259. 

  259.             import cv
    260. 

  260.             capture = cv.CaptureFromCAM(-1) 
    261. 

  261.             for i in range(10):
    262. 

  262.                 img = cv.QueryFrame(capture)        
    263. 

  263.                 if img != None:                    
    264. 

  264.                     webcam_detected = True   
    265. 

  265.         except Exception, detail:
    266. 

  266.             print detail
    267. 

  267. 

  268.         if webcam_detected:
    269. 

  269.             self.wTree.get_widget("face_take_picture_button").set_tooltip_text(_("Click this button to take a new picture of yourself with the webcam"))
    270. 

  270.         else:
    271. 

  271.             self.wTree.get_widget("face_take_picture_button").set_sensitive(False)
    272. 

  272.             self.wTree.get_widget("face_take_picture_button").set_tooltip_text(_("The installer did not detect any webcam"))
    273. 

  273.         
    274. 

  274.         # build the language list
    275. 

  275.         self.build_lang_list()        
    276. 

  276. 

  277.         self.build_timezones()
    278. 

  278. 

  279.         # disk view
    280. 

  280.         ren = gtk.CellRendererText()
    281. 

  281.         self.column1 = gtk.TreeViewColumn("Hard drive", ren)
    282. 

  282.         self.column1.add_attribute(ren, "text", 0)
    283. 

  283.         self.wTree.get_widget("treeview_hdds").append_column(self.column1)
    284. 

  284.         self.column2 = gtk.TreeViewColumn("Description", ren)
    285. 

  285.         self.column2.add_attribute(ren, "text", 1)
    286. 

  286.         self.wTree.get_widget("treeview_hdds").append_column(self.column2)
    287. 

  287.         self.wTree.get_widget("treeview_hdds").connect("cursor-changed", self.assign_hdd)
    288. 

  288.         self.build_hdds()
    289. 

  289.         #self.build_grub_partitions()
    290. 

  290. 

  291.         self.wTree.get_widget("radio_hdd").set_group(self.wTree.get_widget("radio_custom"))
    292. 

  292.         self.wTree.get_widget("radio_hdd").connect("toggled", self.hdd_pane_toggled)
    293. 

  293.         self.wTree.get_widget("radio_hdd").set_active(True)
    294. 

  294.         
    295. 

  295.         self.wTree.get_widget("button_edit").connect("clicked", self.edit_partitions)        
    296. 

  296.         self.wTree.get_widget("button_refresh").connect("clicked", self.refresh_partitions)
    297. 

  297.         self.wTree.get_widget("treeview_disks").connect("row_activated", self.assign_partition)
    298. 

  298.         self.wTree.get_widget("treeview_disks").connect( "button-release-event", self.partitions_popup_menu)
    299. 

  299.         
    300. 

  300.         # device
    301. 

  301.         ren = gtk.CellRendererText()
    302. 

  302.         self.column3 = gtk.TreeViewColumn(_("Device"), ren)
    303. 

  303.         self.column3.add_attribute(ren, "markup", INDEX_PARTITION_PATH)
    304. 

  304.         self.wTree.get_widget("treeview_disks").append_column(self.column3)
    305. 

  305.         # Type
    306. 

  306.         ren = gtk.CellRendererText()
    307. 

  307.         self.column4 = gtk.TreeViewColumn(_("Type"), ren)
    308. 

  308.         self.column4.add_attribute(ren, "markup", INDEX_PARTITION_TYPE)
    309. 

  309.         self.wTree.get_widget("treeview_disks").append_column(self.column4)
    310. 

  310.         # description
    311. 

  311.         ren = gtk.CellRendererText()
    312. 

  312.         self.column5 = gtk.TreeViewColumn(_("Operating system"), ren)
    313. 

  313.         self.column5.add_attribute(ren, "markup", INDEX_PARTITION_DESCRIPTION)
    314. 

  314.         self.wTree.get_widget("treeview_disks").append_column(self.column5)        
    315. 

  315.         # mount point
    316. 

  316.         ren = gtk.CellRendererText()
    317. 

  317.         self.column6 = gtk.TreeViewColumn(_("Mount point"), ren)
    318. 

  318.         self.column6.add_attribute(ren, "markup", INDEX_PARTITION_MOUNT_AS)
    319. 

  319.         self.wTree.get_widget("treeview_disks").append_column(self.column6)
    320. 

  320.         # format
    321. 

  321.         ren = gtk.CellRendererText()
    322. 

  322.         self.column7 = gtk.TreeViewColumn(_("Format?"), ren)
    323. 

  323.         self.column7.add_attribute(ren, "markup", INDEX_PARTITION_FORMAT_AS)        
    324. 

  324.         self.wTree.get_widget("treeview_disks").append_column(self.column7)
    325. 

  325.         # size
    326. 

  326.         ren = gtk.CellRendererText()
    327. 

  327.         self.column8 = gtk.TreeViewColumn(_("Size"), ren)
    328. 

  328.         self.column8.add_attribute(ren, "markup", INDEX_PARTITION_SIZE)
    329. 

  329.         self.wTree.get_widget("treeview_disks").append_column(self.column8)
    330. 

  330.         # Used space
    331. 

  331.         ren = gtk.CellRendererText()
    332. 

  332.         self.column9 = gtk.TreeViewColumn(_("Free space"), ren)
    333. 

  333.         self.column9.add_attribute(ren, "markup", INDEX_PARTITION_FREE_SPACE)
    334. 

  334.         self.wTree.get_widget("treeview_disks").append_column(self.column9)
    335. 

  335. 

  336.         self.wTree.get_widget("entry_your_name").connect("notify::text", self.assign_realname)        
    337. 

  337.         self.wTree.get_widget("entry_username").connect("notify::text", self.assign_username)    
    338. 

  338.         self.wTree.get_widget("entry_hostname").connect("notify::text", self.assign_hostname)    
    339. 

  339. 

  340.         # events for detecting password mismatch..        
    341. 

  341.         self.wTree.get_widget("entry_userpass1").connect("changed", self.assign_password)
    342. 

  342.         self.wTree.get_widget("entry_userpass2").connect("changed", self.assign_password)
    343. 

  343. 

  344.         # link the checkbutton to the combobox
    345. 

  345.         grub_check = self.wTree.get_widget("checkbutton_grub")
    346. 

  346.         grub_box = self.wTree.get_widget("combobox_grub")
    347. 

  347.         grub_check.connect("clicked", self.assign_grub_install, grub_box)        
    348. 

  348.         grub_box.connect("changed", self.assign_grub_device)
    349. 

  349. 

  350.         # Install Grub by default
    351. 

  351.         grub_check.set_active(True)
    352. 

  352.         grub_box.set_sensitive(True)
    353. 

  353.         
    354. 

  354.         # kb models
    355. 

  355.         cell = gtk.CellRendererText()
    356. 

  356.         self.wTree.get_widget("combobox_kb_model").pack_start(cell, True)
    357. 

  357.         self.wTree.get_widget("combobox_kb_model").add_attribute(cell, 'text', 0)        
    358. 

  358.         self.wTree.get_widget("combobox_kb_model").connect("changed", self.assign_keyboard_model)
    359. 

  359. 

  360.         # kb layouts
    361. 

  361.         ren = gtk.CellRendererText()
    362. 

  362.         self.column10 = gtk.TreeViewColumn(_("Layout"), ren)
    363. 

  363.         self.column10.add_attribute(ren, "text", 0)
    364. 

  364.         self.wTree.get_widget("treeview_layouts").append_column(self.column10)
    365. 

  365.         self.wTree.get_widget("treeview_layouts").connect("cursor-changed", self.assign_keyboard_layout)
    366. 

  366.         
    367. 

  367.         ren = gtk.CellRendererText()
    368. 

  368.         self.column11 = gtk.TreeViewColumn(_("Variant"), ren)
    369. 

  369.         self.column11.add_attribute(ren, "text", 0)
    370. 

  370.         self.wTree.get_widget("treeview_variants").append_column(self.column11)
    371. 

  371.         self.wTree.get_widget("treeview_variants").connect("cursor-changed", self.assign_keyboard_variant)
    372. 

  372.         
    373. 

  373.         self.build_kb_lists()
    374. 

  374. 

  375.         # 'about to install' aka overview
    376. 

  376.         ren = gtk.CellRendererText()
    377. 

  377.         self.column12 = gtk.TreeViewColumn(_("Overview"), ren)
    378. 

  378.         self.column12.add_attribute(ren, "markup", 0)
    379. 

  379.         self.wTree.get_widget("treeview_overview").append_column(self.column12)
    380. 

  380.         # install page
    381. 

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

  382.     
    383. 

  383.         #i18n
    384. 

  384.         self.i18n()
    385. 

  385. 

  386.         # build partition list
    387. 

  387.         self.should_pulse = False
    388. 

  388. 

  389.         # make sure we're on the right page (no pun.)
    390. 

  390.         self.activate_page(0)
    391. 

  391. 

  392.         # this is a hack atm to steal the menubar's background color
    393. 

  393.         self.wTree.get_widget("menubar").realize()
    394. 

  394.         style = self.wTree.get_widget("menubar").style.copy()
    395. 

  395.         self.wTree.get_widget("menubar").hide()
    396. 

  396.         # apply to the header       
    397. 

  397.         self.title_box = self.wTree.get_widget("title_eventbox")
    398. 

  398.         bgColor = gtk.gdk.color_parse('#585858')
    399. 

  399.         self.title_box.modify_bg(gtk.STATE_NORMAL, bgColor)
    400. 

  400.         fgColor = gtk.gdk.color_parse('#FFFFFF')
    401. 

  401.         self.help_label = self.wTree.get_widget("help_label")
    402. 

  402.         self.help_label.modify_fg(gtk.STATE_NORMAL, fgColor)            
    403. 

  403.         if(fullscreen):
    404. 

  404.             # dedicated installer mode thingum
    405. 

  405.             self.window.maximize()
    406. 

  406.             self.window.fullscreen()        
    407. 

  407.         
    408. 

  408.         #''' Launch the Slideshow '''
    409. 

  409.         #if ("_" in self.setup.language):
    410. 

  410.         #    locale_code = self.setup.language.split("_")[0]
    411. 

  411.         #else:
    412. 

  412.         #     locale_code = self.setup.language
    413. 

  413.         
    414. 

  414.         #slideshow_path = "/usr/share/live-installer-slideshow/slides/index.html"
    415. 

  415.         #if os.path.exists(slideshow_path):            
    416. 

  416.         #    browser = webkit.WebView()
    417. 

  417.         #    s = browser.get_settings()
    418. 

  418.         #    s.set_property('enable-file-access-from-file-uris', True)
    419. 

  419.         #    s.set_property('enable-default-context-menu', False)
    420. 

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

  421.         #    self.wTree.get_widget("vbox_install").add(browser)
    422. 

  422.         #    self.wTree.get_widget("vbox_install").show_all()         
    423. 

  423.         # Initiate the slide show
    424. 

  424.         self.slideshow_path = "/usr/share/live-installer/slideshow"
    425. 

  425.         if os.path.exists(self.slideshow_path):
    426. 

  426.             self.slideshow_browser = webkit.WebView()
    427. 

  427.             s = self.slideshow_browser.get_settings()
    428. 

  428.             s.set_property('enable-file-access-from-file-uris', True)
    429. 

  429.             s.set_property('enable-default-context-menu', False)            
    430. 

  430.             self.slideshow_browser.open("file://" + os.path.join(self.slideshow_path, 'template.html'))
    431. 

  431.             self.wTree.get_widget("vbox_install").add(self.slideshow_browser)
    432. 

  432.             self.wTree.get_widget("vbox_install").show_all()                                                            
    433. 

  433.         
    434. 

  434.         self.browser = webkit.WebView()
    435. 

  435.         s = self.browser.get_settings()
    436. 

  436.         s.set_property('enable-file-access-from-file-uris', True)
    437. 

  437.         s.set_property('enable-default-context-menu', False)     
    438. 

  438.         self.wTree.get_widget("scrolled_partitions").add(self.browser)   
    439. 

  439.         
    440. 

  440.         self.window.show_all()
    441. 

  441. 

  442.         # fix text wrap
    443. 

  443.         self.fix_text_wrap()
    444. 

  444.         
    445. 

  445.     def face_select_picture_button_clicked(self, widget, event):
    446. 

  446.         image = gtk.Image()
    447. 

  447.         preview = gtk.ScrolledWindow()
    448. 

  448.         preview.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
    449. 

  449.         preview.set_size_request(150, 150)
    450. 

  450.         preview.add_with_viewport(image)
    451. 

  451.         image.show()
    452. 

  452.         preview.show()
    453. 

  453.         chooser = gtk.FileChooserDialog(title=None, parent=self.window,
    454. 

  454.                                         action=gtk.FILE_CHOOSER_ACTION_OPEN,
    455. 

  455.                                         buttons=(gtk.STOCK_CANCEL,
    456. 

  456.                                                  gtk.RESPONSE_CANCEL,
    457. 

  457.                                                  gtk.STOCK_OPEN,
    458. 

  458.                                                  gtk.RESPONSE_OK),
    459. 

  459.                                         backend=None)
    460. 

  460.         chooser.set_default_response(gtk.RESPONSE_OK)
    461. 

  461.         chooser.set_current_folder("/usr/share/pixmaps/faces")
    462. 

  462.         if os.path.exists("/home/mint"):
    463. 

  463.             chooser.add_shortcut_folder("/home/mint")
    464. 

  464.         filter = gtk.FileFilter()
    465. 

  465.         filter.set_name(_('Images'))
    466. 

  466.         filter.add_mime_type('image/png')
    467. 

  467.         filter.add_mime_type('image/jpeg')
    468. 

  468.         filter.add_mime_type('image/gif')
    469. 

  469.         filter.add_mime_type('bitmap/bmp')        
    470. 

  470.         chooser.add_filter(filter)        
    471. 

  471.         chooser.set_preview_widget(preview)
    472. 

  472.         chooser.connect("update-preview", self.update_preview_cb, preview)
    473. 

  473.         response = chooser.run()
    474. 

  474.         if response == gtk.RESPONSE_OK:
    475. 

  475.             filename = chooser.get_filename()
    476. 

  476.             os.system("convert %s -resize x96 /tmp/live-installer-face.png" % filename)
    477. 

  477.             self.wTree.get_widget("face_image").set_from_file("/tmp/live-installer-face.png")
    478. 

  478.         chooser.destroy()
    479. 

  479.     
    480. 

  480.     def update_preview_cb(self, file_chooser, preview):
    481. 

  481.         filename = file_chooser.get_preview_filename()
    482. 

  482.         try:
    483. 

  483.             if filename:
    484. 

  484.                 pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
    485. 

  485.                 preview.child.child.set_from_pixbuf(pixbuf)
    486. 

  486.                 have_preview = True
    487. 

  487.             else:
    488. 

  488.                 have_preview = False
    489. 

  489.         except Exception, e:
    490. 

  490.             #print e
    491. 

  491.             have_preview = False
    492. 

  492.         file_chooser.set_preview_widget_active(have_preview)
    493. 

  493.         return	
    494. 

  494.             
    495. 

  495.     def face_take_picture_button_clicked(self, widget, event):
    496. 

  496.         try:
    497. 

  497.             import cv
    498. 

  498.             capture = cv.CaptureFromCAM(-1) 
    499. 

  499.             for i in range(10):
    500. 

  500.                 img = cv.QueryFrame(capture)        
    501. 

  501.                 if img != None:
    502. 

  502.                     cv.SaveImage("/tmp/live-installer-webcam.png", img)
    503. 

  503.                     os.system("convert /tmp/live-installer-webcam.png -resize x96 /tmp/live-installer-face.png")
    504. 

  504.                     self.wTree.get_widget("face_image").set_from_file("/tmp/live-installer-face.png")
    505. 

  505.         except Exception, detail:
    506. 

  506.             print detail
    507. 

  507. 

  508.     def fix_text_wrap(self):
    509. 

  509.         while gtk.events_pending():
    510. 

  510.             gtk.main_iteration_do(False)
    511. 

  511. 

  512.         # this looks bad on resize, but to handle it on resize gracefully requires quite a bit of code (to keep from lagging)
    513. 

  513.         width = self.window.get_size()[0] - 75
    514. 

  514. 

  515.         # custom install warning
    516. 

  516.         self.wTree.get_widget("label_custom_install_directions_1").set_size_request(width, -1)
    517. 

  517.         self.wTree.get_widget("label_custom_install_directions_1").set_size_request(width, -1)
    518. 

  518.         self.wTree.get_widget("label_custom_install_directions_2").set_size_request(width, -1)
    519. 

  519.         self.wTree.get_widget("label_custom_install_directions_3").set_size_request(width, -1)
    520. 

  520.         self.wTree.get_widget("label_custom_install_directions_4").set_size_request(width, -1)
    521. 

  521.         self.wTree.get_widget("label_custom_install_directions_5").set_size_request(width, -1)
    522. 

  522.         self.wTree.get_widget("label_custom_install_directions_6").set_size_request(width, -1)
    523. 

  523. 

  524.         # custom install installation paused directions
    525. 

  525.         self.wTree.get_widget("label_custom_install_paused_1").set_size_request(width, -1)
    526. 

  526.         self.wTree.get_widget("label_custom_install_paused_2").set_size_request(width, -1)
    527. 

  527.         self.wTree.get_widget("label_custom_install_paused_3").set_size_request(width, -1)
    528. 

  528.         self.wTree.get_widget("label_custom_install_paused_4").set_size_request(width, -1)
    529. 

  529.         self.wTree.get_widget("label_custom_install_paused_5").set_size_request(width, -1)
    530. 

  530.         
    531. 

  531.     def i18n(self):
    532. 

  532.         # about you
    533. 

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

  534.         self.wTree.get_widget("label_your_name_help").set_markup("<span fgcolor='#3C3C3C'><sub><i>%s</i></sub></span>" % _("This will be shown in the About Me application"))
    535. 

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

  536.         self.wTree.get_widget("label_username_help").set_markup("<span fgcolor='#3C3C3C'><sub><i>%s</i></sub></span>" % _("This is the name you will use to login to your computer"))
    537. 

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

  538.         self.wTree.get_widget("label_pass_help").set_markup("<span fgcolor='#3C3C3C'><sub><i>%s</i></sub></span>" % _("Please enter your password twice to ensure it is correct"))
    539. 

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

  540.         self.wTree.get_widget("label_hostname_help").set_markup("<span fgcolor='#3C3C3C'><sub><i>%s</i></sub></span>" % _("This hostname will be the computers name on the network"))
    541. 

  541.                 
    542. 

  542.         self.wTree.get_widget("face_label").set_markup("<b>%s</b>" % _("Your picture"))
    543. 

  543.         self.wTree.get_widget("face_description").set_markup("<span fgcolor='#3C3C3C'><sub><i>%s</i></sub></span>" % _("This picture represents your user account. It is used in the login screen and a few other places."))
    544. 

  544.         self.wTree.get_widget("face_take_picture_button").set_label(_("Take a photo"))        
    545. 

  545.         
    546. 

  546.         self.wTree.get_widget("face_select_picture_button").set_label(_("Select a picture"))
    547. 

  547.         self.wTree.get_widget("face_select_picture_button").set_tooltip_text(_("Click this button to choose a picture for your account"))
    548. 

  548.                 
    549. 

  549.         # timezones
    550. 

  550.         self.wTree.get_widget("label_timezones").set_label(_("Selected timezone:"))
    551. 

  551.         
    552. 

  552.         # grub
    553. 

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

  554.         self.wTree.get_widget("checkbutton_grub").set_label(_("Install GRUB"))
    555. 

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

  556.         
    557. 

  557.         # keyboard page
    558. 

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

  559.         self.wTree.get_widget("label_kb_model").set_label(_("Model"))        
    560. 

  560.         
    561. 

  561.         # custom install warning
    562. 

  562.         self.wTree.get_widget("label_custom_install_directions_1").set_label(_("You have selected to manage your partitions manually, this feature is for ADVANCED USERS ONLY."))
    563. 

  563.         self.wTree.get_widget("label_custom_install_directions_2").set_label(_("Before continuing, please mount your target filesystem(s) at /target."))
    564. 

  564.         self.wTree.get_widget("label_custom_install_directions_3").set_label(_("Do NOT mount virtual devices such as /dev, /proc, /sys, etc on /target/."))
    565. 

  565.         self.wTree.get_widget("label_custom_install_directions_4").set_label(_("During the install, you will be given time to chroot into /target and install any pacakges that will be needed to boot your new system."))
    566. 

  566.         self.wTree.get_widget("label_custom_install_directions_5").set_label(_("During the install, you will be required to write your own /etc/fstab."))
    567. 

  567.         self.wTree.get_widget("label_custom_install_directions_6").set_label(_("If you arent sure what any of this means, please go back and deselect manual partition management."))
    568. 

  568. 

  569.         # custom install installation paused directions
    570. 

  570.         self.wTree.get_widget("label_custom_install_paused_1").set_label(_("Please do the following and then click Forward to finish Installation:"))
    571. 

  571.         self.wTree.get_widget("label_custom_install_paused_2").set_label(_("Create /target/etc/fstab for the filesystems as they will be mounted in your new system, matching those currently mounted at /target (without using the /target prefix in the mount paths themselves)."))
    572. 

  572.         self.wTree.get_widget("label_custom_install_paused_3").set_label(_("Install any packages that may be needed for first boot (mdadm, cryptsetup, dmraid, etc) by calling \"sudo chroot /target\" followed by the relevant apt-get/aptitude installations."))
    573. 

  573.         self.wTree.get_widget("label_custom_install_paused_4").set_label(_("Note that in order for update-initramfs to work properly in some cases (such as dm-crypt), you may need to have drives currently mounted using the same block device name as they appear in /target/etc/fstab."))
    574. 

  574.         self.wTree.get_widget("label_custom_install_paused_5").set_label(_("Double-check that your /target/etc/fstab is correct, matches what your new system will have at first boot, and matches what is currently mounted at /target."))
    575. 

  575. 

  576.         # hdd page
    577. 

  577.         self.wTree.get_widget("label_radio_hdd").set_label(_("Install Linux Mint on the selected drive:"))
    578. 

  578.         self.wTree.get_widget("label_radio_custom").set_label(_("Manually mount partitions (ADVANCED USERS ONLY)."))
    579. 

  579.         
    580. 

  580.         #Columns
    581. 

  581.         self.column1.set_title(_("Hard drive")) 
    582. 

  582.         self.column2.set_title(_("Description")) 
    583. 

  583.         self.column3.set_title(_("Device")) 
    584. 

  584.         self.column4.set_title(_("Type")) 
    585. 

  585.         self.column5.set_title(_("Operating system")) 
    586. 

  586.         self.column6.set_title(_("Mount point")) 
    587. 

  587.         self.column7.set_title(_("Format?")) 
    588. 

  588.         self.column8.set_title(_("Size")) 
    589. 

  589.         self.column9.set_title(_("Free space")) 
    590. 

  590.         self.column10.set_title(_("Layout")) 
    591. 

  591.         self.column11.set_title(_("Variant")) 
    592. 

  592.         self.column12.set_title(_("Overview")) 
    593. 

  593.         
    594. 

  594.         #Partitions
    595. 

  595.         self.wTree.get_widget("label_edit_partitions").set_label(_("Edit partitions"))
    596. 

  596. 

  597.     def assign_realname(self, entry, prop):
    598. 

  598.         self.setup.real_name = entry.props.text
    599. 

  599.         text = entry.props.text.strip().lower()
    600. 

  600.         if " " in entry.props.text:
    601. 

  601.             elements = text.split()
    602. 

  602.             text = elements[0]
    603. 

  603.         self.setup.username = text
    604. 

  604.         self.wTree.get_widget("entry_username").set_text(text)   
    605. 

  605.         self.setup.print_setup()    
    606. 

  606. 

  607.     def assign_username(self, entry, prop):
    608. 

  608.         self.setup.username = entry.props.text
    609. 

  609.         self.setup.print_setup()       
    610. 

  610. 

  611.     def assign_hostname(self, entry, prop):
    612. 

  612.         self.setup.hostname = entry.props.text
    613. 

  613.         self.setup.print_setup()
    614. 

  614.         
    615. 

  615.     def quit_cb(self, widget, data=None):
    616. 

  616.         ''' ask whether we should quit. because touchpads do happen '''
    617. 

  617.         gtk.main_quit()
    618. 

  618. 

  619.     def assign_partition(self, widget, data=None, data2=None):
    620. 

  620.         ''' assign the partition ... '''
    621. 

  621.         model, iter = self.wTree.get_widget("treeview_disks").get_selection().get_selected()
    622. 

  622.         if iter is not None:
    623. 

  623.             row = model[iter]
    624. 

  624.             partition = row[INDEX_PARTITION_OBJECT]            
    625. 

  625.             if not partition.partition.type == parted.PARTITION_EXTENDED and not partition.partition.number == -1:            
    626. 

  626.                 dlg = PartitionDialog(row[INDEX_PARTITION_PATH], row[INDEX_PARTITION_MOUNT_AS], row[INDEX_PARTITION_FORMAT_AS], row[INDEX_PARTITION_TYPE])
    627. 

  627.                 (mount_as, format_as) = dlg.show()                
    628. 

  628.                 self.assign_mount_point(partition, mount_as, format_as)
    629. 

  629.                 
    630. 

  630.     def partitions_popup_menu( self, widget, event ):
    631. 

  631.         if event.button == 3:
    632. 

  632.             model, iter = self.wTree.get_widget("treeview_disks").get_selection().get_selected()
    633. 

  633.             if iter is not None:
    634. 

  634.                 partition = model.get_value(iter, INDEX_PARTITION_OBJECT)
    635. 

  635.                 partition_type = model.get_value(iter, INDEX_PARTITION_TYPE)
    636. 

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

  637.                     menu = gtk.Menu()
    638. 

  638.                     menuItem = gtk.MenuItem(_("Edit"))
    639. 

  639.                     menuItem.connect( "activate", self.assign_partition, partition)
    640. 

  640.                     menu.append(menuItem)
    641. 

  641.                     menuItem = gtk.SeparatorMenuItem()
    642. 

  642.                     menu.append(menuItem)
    643. 

  643.                     menuItem = gtk.MenuItem(_("Assign to /"))
    644. 

  644.                     menuItem.connect( "activate", self.assign_mount_point_context_menu_wrapper, partition, "/", "ext4")
    645. 

  645.                     menu.append(menuItem)
    646. 

  646.                     menuItem = gtk.MenuItem(_("Assign to /home"))
    647. 

  647.                     menuItem.connect( "activate", self.assign_mount_point_context_menu_wrapper, partition, "/home", "")
    648. 

  648.                     menu.append(menuItem)
    649. 

  649.                     menu.show_all()
    650. 

  650.                     menu.popup( None, None, None, event.button, event.time )
    651. 

  651. 

  652.     def assign_mount_point_context_menu_wrapper(self, menu, partition, mount_point, filesystem):
    653. 

  653.         self.assign_mount_point(partition, mount_point, filesystem)
    654. 

  654. 

  655.     def assign_mount_point(self, partition, mount_point, filesystem):
    656. 

  656.         
    657. 

  657.         #Assign it in the treeview
    658. 

  658.         model = self.wTree.get_widget("treeview_disks").get_model()
    659. 

  659.         iter = model.get_iter_first()
    660. 

  660.         while iter is not None:
    661. 

  661.             iter_partition = model.get_value(iter, INDEX_PARTITION_OBJECT)
    662. 

  662.             if iter_partition == partition:
    663. 

  663.                 model.set_value(iter, INDEX_PARTITION_MOUNT_AS, mount_point)         
    664. 

  664.                 model.set_value(iter, INDEX_PARTITION_FORMAT_AS, filesystem)
    665. 

  665.             else:
    666. 

  666.                 mountpoint = model.get_value(iter, INDEX_PARTITION_MOUNT_AS)
    667. 

  667.                 if mountpoint == mount_point:
    668. 

  668.                     model.set_value(iter, INDEX_PARTITION_MOUNT_AS, "")
    669. 

  669.                     model.set_value(iter, INDEX_PARTITION_FORMAT_AS, "")
    670. 

  670.             iter = model.iter_next(iter)
    671. 

  671.         #Assign it in our setup
    672. 

  672.         for apartition in self.setup.partitions:
    673. 

  673.             if (apartition.partition.path == partition.partition.path):
    674. 

  674.                 apartition.mount_as = mount_point
    675. 

  675.                 apartition.format_as = filesystem
    676. 

  676.             else:                
    677. 

  677.                 if apartition.mount_as == mount_point:
    678. 

  678.                     apartition.mount_as = None
    679. 

  679.                     apartition.format_as = None
    680. 

  680.         self.setup.print_setup()
    681. 

  681.                 
    682. 

  682. 

  683.     def refresh_partitions(self, widget, data=None):
    684. 

  684.         ''' refresh the partitions ... '''
    685. 

  685.         self.build_partitions()
    686. 

  686. 

  687.     def edit_partitions(self, widget, data=None):
    688. 

  688.         ''' edit the partitions ... '''
    689. 

  689.         os.popen("gparted &")
    690. 

  690. 

  691.     def build_lang_list(self):
    692. 

  692. 

  693.         #Try to find out where we're located...
    694. 

  694.         cur_country_code = None
    695. 

  695.         try:
    696. 

  696.             whatismyip = 'http://debian.linuxmint.com/installer/show_my_ip.php'
    697. 

  697.             ip = urllib.urlopen(whatismyip).readlines()[0]
    698. 

  698.             gi = GeoIP.new(GeoIP.GEOIP_MEMORY_CACHE)
    699. 

  699.             cur_country_code = gi.country_code_by_addr(ip)
    700. 

  700.         except:
    701. 

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

    703. 

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

  704.         cur_lang = os.environ['LANG']
    705. 

  705.         if("." in cur_lang):
    706. 

  706.             cur_lang = cur_lang.split(".")[0]
    707. 

  707. 

  708.         model = gtk.ListStore(str,str,gtk.gdk.Pixbuf)
    709. 

  709.         model.set_sort_column_id(0, gtk.SORT_ASCENDING)
    710. 

  710. 

  711.         #Load countries into memory
    712. 

  712.         countries = {}
    713. 

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

  714.         for line in file:
    715. 

  715.             line = line.strip()
    716. 

  716.             split = line.split("=")
    717. 

  717.             if len(split) == 2:
    718. 

  718.                 countries[split[0]] = split[1]
    719. 

  719.         file.close()
    720. 

  720. 

  721.         #Load languages into memory
    722. 

  722.         languages = {}
    723. 

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

  724.         for line in file:
    725. 

  725.             line = line.strip()
    726. 

  726.             split = line.split("=")
    727. 

  727.             if len(split) == 2:
    728. 

  728.                 languages[split[0]] = split[1]
    729. 

  729.         file.close()
    730. 

  730. 

  731.         path = os.path.join(self.resource_dir, 'locales')
    732. 

  732.         locales = open(path, "r")
    733. 

  733.         cur_index = -1 # find the locale :P
    734. 

  734.         set_index = None
    735. 

  735.         for line in locales:
    736. 

  736.             cur_index += 1
    737. 

  737.             if "UTF-8" in line:
    738. 

  738.                 locale_code = line.replace("UTF-8", "")
    739. 

  739.                 locale_code = locale_code.replace(".", "")
    740. 

  740.                 locale_code = locale_code.strip()
    741. 

  741.                 if "_" in locale_code:
    742. 

  742.                     split = locale_code.split("_")
    743. 

  743.                     if len(split) == 2:
    744. 

  744.                         language_code = split[0]
    745. 

  745.                         if language_code in languages:
    746. 

  746.                             language = languages[language_code]
    747. 

  747.                         else:
    748. 

  748.                             language = language_code
    749. 

  749. 

  750.                         country_code = split[1].lower()
    751. 

  751.                         if country_code in countries:
    752. 

  752.                             country = countries[country_code]
    753. 

  753.                         else:
    754. 

  754.                             country = country_code
    755. 

  755. 

  756.                         language_label = "%s (%s)" % (language, country)
    757. 

  757.                         #language_label = "%s - %s" % (country, language)
    758. 

  758. 

  759.                         iter = model.append()
    760. 

  760.                         model.set_value(iter, 0, language_label)
    761. 

  761.                         model.set_value(iter, 1, locale_code)
    762. 

  762.                         flag_path = self.resource_dir + '/flags/16/' + country_code + '.png'
    763. 

  763.                         if os.path.exists(flag_path):
    764. 

  764.                             model.set_value(iter, 2, gtk.gdk.pixbuf_new_from_file(flag_path))
    765. 

  765.                         else:
    766. 

  766.                             flag_path = self.resource_dir + '/flags/16/generic.png'
    767. 

  767.                             model.set_value(iter, 2, gtk.gdk.pixbuf_new_from_file(flag_path))
    768. 

  768.                         # If it's matching our country code, that's our language right there.. 
    769. 

  769.                         if ((cur_country_code is not None) and (cur_country_code.lower() == country_code)):                            
    770. 

  770.                             if (set_index is None):
    771. 

  771.                                 set_index = iter                                
    772. 

  772.                             else:
    773. 

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

  774.                                 if (language_code == "en"):
    775. 

  775.                                     set_index = iter                 
    776. 

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

  777.                                 elif (country_code == language_code):
    778. 

  778.                                     set_index = iter
    779. 

  779.                                     
    780. 

  780.                         # as a plan B... use the locale (USA)
    781. 

  781.                         if((set_index is None) and (locale_code == cur_lang)):
    782. 

  782.                             set_index = iter
    783. 

  783.                             #print "Set via locale: " + cur_lang
    784. 

  784. 

  785.         treeview = self.wTree.get_widget("treeview_language_list")
    786. 

  786.         treeview.set_model(model)
    787. 

  787.         if(set_index is not None):
    788. 

  788.             column = treeview.get_column(0)
    789. 

  789.             path = model.get_path(set_index)
    790. 

  790.             treeview.set_cursor(path, focus_column=column)
    791. 

  791.             treeview.scroll_to_cell(path, column=column)
    792. 

  792.         treeview.set_search_column(0)
    793. 

  793. 

  794.     def build_timezones(self):
    795. 

  795.         
    796. 

  796.         self.combo_timezones = self.wTree.get_widget("combo_timezones")
    797. 

  797.         self.combo_timezones.connect('changed', self.timezone_combo_selected)
    798. 

  798.         
    799. 

  799.         self.timezone_colors = {}
    800. 

  800.         self.timezone_colors["2b0000"] = "-11.0"
    801. 

  801.         self.timezone_colors["550000"] = "-10.0"
    802. 

  802.         self.timezone_colors["66ff00"] = "-9.5"
    803. 

  803.         self.timezone_colors["800000"] = "-9.0"
    804. 

  804.         self.timezone_colors["aa0000"] = "-8.0"
    805. 

  805.         self.timezone_colors["d40000"] = "-7.0"
    806. 

  806.         self.timezone_colors["ff0001"] = "-6.0"
    807. 

  807.         self.timezone_colors["66ff00"] = "-5.5"
    808. 

  808.         self.timezone_colors["ff2a2a"] = "-5.0"
    809. 

  809.         self.timezone_colors["c0ff00"] = "-4.5"
    810. 

  810.         self.timezone_colors["ff5555"] = "-4.0"
    811. 

  811.         self.timezone_colors["00ff00"] = "-3.5"
    812. 

  812.         self.timezone_colors["ff8080"] = "-3.0"
    813. 

  813.         self.timezone_colors["ffaaaa"] = "-2.0"
    814. 

  814.         self.timezone_colors["ffd5d5"] = "-1.0"
    815. 

  815.         self.timezone_colors["2b1100"] = "0.0"
    816. 

  816.         self.timezone_colors["552200"] = "1.0"
    817. 

  817.         self.timezone_colors["803300"] = "2.0"
    818. 

  818.         self.timezone_colors["aa4400"] = "3.0"
    819. 

  819.         self.timezone_colors["00ff66"] = "3.5"
    820. 

  820.         self.timezone_colors["d45500"] = "4.0"
    821. 

  821.         self.timezone_colors["00ccff"] = "4.5"
    822. 

  822.         self.timezone_colors["ff6600"] = "5.0"
    823. 

  823.         self.timezone_colors["0066ff"] = "5.5"        
    824. 

  824.         self.timezone_colors["00ffcc"] = "5.75"
    825. 

  825.         self.timezone_colors["ff7f2a"] = "6.0"
    826. 

  826.         self.timezone_colors["cc00ff"] = "6.5"
    827. 

  827.         self.timezone_colors["ff9955"] = "7.0"
    828. 

  828.         self.timezone_colors["ffb380"] = "8.0"
    829. 

  829.         self.timezone_colors["ffccaa"] = "9.0"
    830. 

  830.         self.timezone_colors["a90345"] = "9.5"
    831. 

  831.         self.timezone_colors["ffe6d5"] = "10.0"
    832. 

  832.         self.timezone_colors["d10255"] = "10.5"
    833. 

  833.         self.timezone_colors["d4aa00"] = "11.0"
    834. 

  834.         self.timezone_colors["fc0266"] = "11.5"
    835. 

  835.         self.timezone_colors["ffcc00"] = "12.0"
    836. 

  836.         self.timezone_colors["fd2c80"] = "12.75"
    837. 

  837.         self.timezone_colors["fc5598"] = "13.0"
    838. 

  838.         
    839. 

  839.         #Add some timezones for cities which are located on borders (for which the color doesn't match the color of the rest of the timezone)
    840. 

  840.         self.timezone_colors["6771a9"] = "5.5" # Calcutta, India
    841. 

  841.         self.timezone_colors["ff7b7b"] = "-3.0" # Buenos Aires, Argentina
    842. 

  842.         self.timezone_colors["ff7f7f"] = "-3.0" # Rio Gallegos, Argentina
    843. 

  843.         self.timezone_colors["d45c27"] = "11.0" # Lord Howe, Australia
    844. 

  844.         self.timezone_colors["b71f54"] = "10.5" # Adelaide, Australia        
    845. 

  845.         self.timezone_colors["d29130"] = "-4.0" # Aruba
    846. 

  846.         self.timezone_colors["ee5f00"] = "4.0" # Baku, Azerbaidjan
    847. 

  847.         self.timezone_colors["6a2a00"] = "2.0" # Sofia, Bulgaria
    848. 

  848.         self.timezone_colors["3c1800"] = "" # Porto Novo
    849. 

  849.         self.timezone_colors["3c1800"] = "1.0" # Benin
    850. 

  850.         self.timezone_colors["ff9898"] = "-3.0" # Maceio, Brazil
    851. 

  851.         self.timezone_colors["ff3f3f"] = "-4.0" # Rio Branco, Brazil
    852. 

  852.         self.timezone_colors["ff802c"] = "6.0" # Thimphu, Bhutan
    853. 

  853.         self.timezone_colors["ff0000"] = "-6.0" # Belize
    854. 

  854.         self.timezone_colors["11f709"] = "-3.5" # St Johns, Canada
    855. 

  855.         self.timezone_colors["e56347"] = "-4.0" # Curacao
    856. 

  856.         self.timezone_colors["cd5200"] = "4.0" # Tbilisi, Georgia
    857. 

  857.         self.timezone_colors["2f1300"] = "0.0" # Guernsey. UK
    858. 

  858.         self.timezone_colors["cea7a3"] = "0.0" # Danmarkshavn, Greenland
    859. 

  859.         self.timezone_colors["ff2b2b"] = "-4.0" # Thule, Greenland
    860. 

  860.         self.timezone_colors["79594e"] = "0.0" # Banjul, Gambia
    861. 

  861.         self.timezone_colors["c7a19d"] = "0.0" # Conakry, Guinea
    862. 

  862.         self.timezone_colors["5b3e31"] = "0.0" # Bissau, Guinea-Bissau
    863. 

  863.         self.timezone_colors["3f2314"] = "0.0" # Monrovia, Liberia
    864. 

  864.         self.timezone_colors["d515db"] = "6.5" # Rangoon, Myanmar
    865. 

  865.         self.timezone_colors["fd0000"] = "-7.0" # Bahia_Banderas, Mexico
    866. 

  866.         self.timezone_colors["ffb37f"] = "8.0" # Kuching, Malaysia
    867. 

  867.         self.timezone_colors["ff0066"] = "11.5" # Norfolk
    868. 

  868.         self.timezone_colors["351500"] = "1.0" # Lagos, Nigeria
    869. 

  869.         self.timezone_colors["ff8935"] = "12.75" # Chatham, New Zealand
    870. 

  870.         self.timezone_colors["913a00"] = "2.0" # Kigali, Rwanda
    871. 

  871.         self.timezone_colors["ffb17d"] = "8.0" # Singapore
    872. 

  872.         self.timezone_colors["ddb6b3"] = "0.0" # Freetown, Sierra Leone
    873. 

  873.         self.timezone_colors["ffb482"] = "9.0" # Dili, East Timor
    874. 

  874.         self.timezone_colors["ff5599"] = "13.0" # Tongatapu, Tonga
    875. 

  875.         self.timezone_colors["ff2020"] = "-5.0" # Monticello, USA        
    876. 

  876.         self.timezone_colors["ff2525"] = "-5.0" # Marengo, USA
    877. 

  877.         self.timezone_colors["9d0000"] = "-9.0" # Metlakatla, Alaska/USA
    878. 

  878.         
    879. 

  879.         self.timezones = []        
    880. 

  880.         model = gtk.ListStore(str, object)
    881. 

  881.         model.set_sort_column_id(0, gtk.SORT_ASCENDING)                   
    882. 

  882.         timezones = open("/usr/share/zoneinfo/zone.tab", "r")
    883. 

  883.         for line in timezones:
    884. 

  884.             if not line.strip().startswith("#"):                
    885. 

  885.                 content = line.strip().split("\t")
    886. 

  886.                 if len(content) >= 2:                    
    887. 

  887.                     country_code = content[0]
    888. 

  888.                     coordinates = content[1]
    889. 

  889.                     timezone = content[2]
    890. 

  890.                     tz = Timezone(timezone, country_code, coordinates)
    891. 

  891.                     self.timezones.append(tz)
    892. 

  892.                     iter = model.append()
    893. 

  893.                     model.set_value(iter, 0, timezone)
    894. 

  894.                     model.set_value(iter, 1, tz)  
    895. 

  895. 

  896.                     # Uncomment the code below to check that each timezone has a corresponding color code (the code is here for debugging only)
    897. 

  897.                     #print "Timezone: %s, X: %s, Y: %s" % (tz.name, tz.x, tz.y)
    898. 

  898.                     #if (tz.x <= 800 and tz.y <= 409):
    899. 

  899.                     #    im = Image.open('/usr/share/live-installer/timezone/cc.png')
    900. 

  900.                     #    rgb_im = im.convert('RGB')                    
    901. 

  901.                     #    hexcolor = '%02x%02x%02x' % rgb_im.getpixel((tz.x, tz.y))
    902. 

  902.                     #    print " Color: #%s" % (hexcolor)
    903. 

  903.                     #    image = "/usr/share/live-installer/timezone/timezone_%s.png" % self.timezone_colors[hexcolor]
    904. 

  904.                     #    print "Image: %s" % image
    905. 

  905.             
    906. 

  906.         cell = gtk.CellRendererText()
    907. 

  907.         self.combo_timezones.pack_start(cell, True)
    908. 

  908.         self.combo_timezones.add_attribute(cell, 'text', 0)
    909. 

  909.         
    910. 

  910.         self.combo_timezones.set_model(model)
    911. 

  911.         self.timezone_map = self.wTree.get_widget("image_timezones")
    912. 

  912.         timezone_event = self.wTree.get_widget("event_timezones")
    913. 

  913.         self.timezone_map.set_from_file("/usr/share/live-installer/timezone/bg.png")
    914. 

  914.         timezone_event.connect("button-release-event", self.timezone_map_clicked)   
    915. 

  915.                      
    916. 

  916.     def timezone_combo_selected(self, combobox):
    917. 

  917.         model = combobox.get_model()
    918. 

  918.         index = combobox.get_active()
    919. 

  919.         if index:
    920. 

  920.             timezone = model[index][1]
    921. 

  921.             self.timezone_select(timezone)            
    922. 

  922.     
    923. 

  923.     def timezone_map_clicked(self, widget, event):
    924. 

  924.         x = event.x
    925. 

  925.         y = event.y
    926. 

  926.         print "Coords: %s %s" % (x, y)
    927. 

  927.         
    928. 

  928.         min_distance = 1000 # Looking for min, starting with a large number
    929. 

  929.         closest_timezone = None
    930. 

  930.         for timezone in self.timezones:
    931. 

  931.             distance = abs(x - timezone.x) + abs(y - timezone.y)
    932. 

  932.             if distance < min_distance:
    933. 

  933.                 min_distance = distance
    934. 

  934.                 closest_timezone = timezone
    935. 

  935.         
    936. 

  936.         print "Closest timezone %s" % closest_timezone.name
    937. 

  937.         self.timezone_select(closest_timezone)
    938. 

  938.                 
    939. 

  939.         model = self.combo_timezones.get_model()
    940. 

  940.         iter = model.get_iter_first()
    941. 

  941.         while iter is not None:            
    942. 

  942.             if closest_timezone.name == model.get_value(iter, 1).name:
    943. 

  943.                 self.combo_timezones.set_active_iter(iter)
    944. 

  944.                 break
    945. 

  945.             iter = model.iter_next(iter)
    946. 

  946.         
    947. 

  947.     def timezone_select(self, timezone):        
    948. 

  948.         im = Image.open('/usr/share/live-installer/timezone/cc.png')
    949. 

  949.         rgb_im = im.convert('RGB')
    950. 

  950.         hexcolor = '%02x%02x%02x' % rgb_im.getpixel((timezone.x, timezone.y))
    951. 

  951.         print "Color: #%s" % (hexcolor)
    952. 

  952.         
    953. 

  953.         overlay_path = "/usr/share/live-installer/timezone/timezone_%s.png" % self.timezone_colors[hexcolor]
    954. 

  954.         print "Image: %s" % overlay_path
    955. 

  955.         
    956. 

  956.         # Superpose the picture of the timezone on the map
    957. 

  957.         background = Image.open("/usr/share/live-installer/timezone/bg.png")
    958. 

  958.         dot = Image.open("/usr/share/live-installer/timezone/dot.png")
    959. 

  959.         overlay = Image.open(overlay_path)
    960. 

  960.         background = background.convert("RGBA")
    961. 

  961.         overlay = overlay.convert("RGBA")
    962. 

  962.         dot = dot.convert("RGBA")
    963. 

  963.         background.paste(overlay, (0,0), overlay)
    964. 

  964.         background.paste(dot, (timezone.x-3, timezone.y-3), dot)
    965. 

  965.         background.save("/tmp/live-installer-map.png","PNG")
    966. 

  966.         self.timezone_map.set_from_file("/tmp/live-installer-map.png")
    967. 

  967.         
    968. 

  968.         # Save the selection
    969. 

  969.         self.setup.timezone = timezone.name
    970. 

  970.         self.setup.timezone_code = timezone.name
    971. 

  971.                 
    972. 

  972.                 
    973. 

  973.     def build_hdds(self):
    974. 

  974.         self.setup.disks = []
    975. 

  975.         model = gtk.ListStore(str, str)            
    976. 

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

  977.         for line in inxi.stdout:
    978. 

  978.             line = line.rstrip("\r\n")
    979. 

  979.             if(line.startswith("Disks:")):
    980. 

  980.                 line = line.replace("Disks:", "")            
    981. 

  981.             sections = line.split(":")
    982. 

  982.             for section in sections:
    983. 

  983.                 section = section.strip()
    984. 

  984.                 if("/dev/" in section):                    
    985. 

  985.                     elements = section.split()
    986. 

  986.                     for element in elements:
    987. 

  987.                         if "/dev/" in element: 
    988. 

  988.                             self.setup.disks.append(element)
    989. 

  989.                             description = section.replace(element, "").strip()
    990. 

  990.                             iter = model.append([element, description]);
    991. 

  991.                 
    992. 

  992.         self.wTree.get_widget("treeview_hdds").set_model(model)
    993. 

  993.         
    994. 

  994.         if(len(self.setup.disks) > 0):
    995. 

  995.             # select the first HDD
    996. 

  996.             treeview = self.wTree.get_widget("treeview_hdds")            
    997. 

  997.             column = treeview.get_column(0)
    998. 

  998.             path = model.get_path(model.get_iter_first())
    999. 

  999.             treeview.set_cursor(path, focus_column=column)
    1000. 

  1000.             treeview.scroll_to_cell(path, column=column)
    1001. 

  1001.             self.setup.target_disk = model.get_value(model.get_iter_first(), 0) 
    1002. 

  1002.     
    1003. 

  1003.     def build_grub_partitions(self):
    1004. 

  1004.         grub_model = gtk.ListStore(str)
    1005. 

  1005.         # Add disks
    1006. 

  1006.         for disk in self.setup.disks:
    1007. 

  1007.             grub_model.append([disk])
    1008. 

  1008.         # Add partitions
    1009. 

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

  1010.         for partition in partitions:
    1011. 

  1011.             try:
    1012. 

  1012.                 partition = partition.split()[0].strip()
    1013. 

  1013.                 if partition.startswith("/dev/"):
    1014. 

  1014.                     grub_model.append([partition])
    1015. 

  1015.             except Exception, detail:
    1016. 

  1016.                 print detail
    1017. 

  1017.         self.wTree.get_widget("combobox_grub").set_model(grub_model)
    1018. 

  1018.         self.wTree.get_widget("combobox_grub").set_active(0)
    1019. 

  1019.   
    1020. 

  1020.     def build_partitions(self):        
    1021. 

  1021.         self.window.set_sensitive(False)
    1022. 

  1022.         # "busy" cursor.
    1023. 

  1023.         cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
    1024. 

  1024.         self.window.window.set_cursor(cursor)        
    1025. 

  1025.         
    1026. 

  1026.         os.popen('mkdir -p /tmp/live-installer/tmpmount')
    1027. 

  1027.         
    1028. 

  1028.         try:                                                                                            
    1029. 

  1029.             #grub_model = gtk.ListStore(str)
    1030. 

  1030.             self.setup.partitions = []
    1031. 

  1031.             
    1032. 

  1032.             html_partitions = ""        
    1033. 

  1033.             model = gtk.ListStore(str,str,str,str,str,str,str, object, bool, str, str, bool)
    1034. 

  1034.             model2 = gtk.ListStore(str)
    1035. 

  1035.             
    1036. 

  1036.             swap_found = False
    1037. 

  1037.             
    1038. 

  1038.             if self.setup.target_disk is not None:
    1039. 

  1039.                 path =  self.setup.target_disk # i.e. /dev/sda
    1040. 

  1040.                 #grub_model.append([path])
    1041. 

  1041.                 device = parted.getDevice(path)                
    1042. 

  1042.                 try:
    1043. 

  1043.                     disk = parted.Disk(device)
    1044. 

  1044.                 except Exception:
    1045. 

  1045.                     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."), self.window)
    1046. 

  1046.                     if (dialog.show()):
    1047. 

  1047.                         # Create a default partition set up                        
    1048. 

  1048.                         disk = parted.freshDisk(device, 'msdos')
    1049. 

  1049.                         disk.commit()
    1050. 

  1050. 

  1051.                         #Swap
    1052. 

  1052.                         regions = disk.getFreeSpaceRegions()
    1053. 

  1053.                         if len(regions) > 0:
    1054. 

  1054.                             region = regions[-1]    
    1055. 

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

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

  1057.                             start = post_mbr_gap
    1058. 

  1058.                             num_sectors = parted.sizeToSectors(ram_size, "KiB", device.sectorSize)
    1059. 

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

  1060.                             end = start + num_sectors
    1061. 

  1061.                             cylinder = device.endSectorToCylinder(end)
    1062. 

  1062.                             end = device.endCylinderToSector(cylinder)
    1063. 

  1063.                             geometry = parted.Geometry(device=device, start=start, end=end)
    1064. 

  1064.                             if end < region.length:
    1065. 

  1065.                                 partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL, geometry=geometry)
    1066. 

  1066.                                 constraint = parted.Constraint(exactGeom=geometry)
    1067. 

  1067.                                 disk.addPartition(partition=partition, constraint=constraint)
    1068. 

  1068.                                 disk.commit()
    1069. 

  1069.                                 os.system("mkswap %s" % partition.path)                                
    1070. 

  1070. 

  1071.                         #Root
    1072. 

  1072.                         regions = disk.getFreeSpaceRegions()
    1073. 

  1073.                         if len(regions) > 0:
    1074. 

  1074.                             region = regions[-1]
    1075. 

  1075.                             partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL, geometry=region)
    1076. 

  1076.                             constraint = parted.Constraint(exactGeom=region)
    1077. 

  1077.                             disk.addPartition(partition=partition, constraint=constraint)
    1078. 

  1078.                             disk.commit()                            
    1079. 

  1079.                             os.system("mkfs.ext4 %s" % partition.path)
    1080. 

  1080.                        
    1081. 

  1081.                         self.build_partitions()
    1082. 

  1082.                         return
    1083. 

  1083.                     else:
    1084. 

  1084.                         # Do nothing... just get out of here..
    1085. 

  1085.                         raise
    1086. 

  1086.                 partition = disk.getFirstPartition()
    1087. 

  1087.                 last_added_partition = PartitionSetup(partition)
    1088. 

  1088.                 #self.setup.partitions.append(last_added_partition)
    1089. 

  1089.                 partition = partition.nextPartition()
    1090. 

  1090.                 html_partitions = html_partitions + "<table width='100%'><tr>"
    1091. 

  1091.                 while (partition is not None):
    1092. 

  1092.                     if last_added_partition.partition.number == -1 and partition.number == -1:
    1093. 

  1093.                         last_added_partition.add_partition(partition)
    1094. 

  1094.                     else:                        
    1095. 

  1095.                         last_added_partition = PartitionSetup(partition)
    1096. 

  1096.                                         
    1097. 

  1097.                         if "swap" in last_added_partition.type:
    1098. 

  1098.                             last_added_partition.type = "swap"                                                            
    1099. 

  1099. 

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

  1101.                             
    1102. 

  1102.                             #grub_model.append([partition.path])
    1103. 

  1103. 

  1104.                             #Umount temp folder
    1105. 

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

  1106.                                 os.popen('umount /tmp/live-installer/tmpmount')
    1107. 

  1107. 

  1108.                             #Mount partition if not mounted
    1109. 

  1109.                             if (partition.path not in commands.getoutput('mount')):                                
    1110. 

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

  1111. 

  1112.                             #Identify partition's description and used space
    1113. 

  1113.                             if (partition.path in commands.getoutput('mount')):
    1114. 

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

  1115.                                 for df_line in df_lines:
    1116. 

  1116.                                     df_elements = df_line.split()
    1117. 

  1117.                                     if df_elements[0] == partition.path:
    1118. 

  1118.                                         last_added_partition.used_space = df_elements[4]  
    1119. 

  1119.                                         mount_point = df_elements[5]                              
    1120. 

  1120.                                         if "%" in last_added_partition.used_space:
    1121. 

  1121.                                             used_space_pct = int(last_added_partition.used_space.replace("%", "").strip())
    1122. 

  1122.                                             last_added_partition.free_space = int(float(last_added_partition.size) * (float(100) - float(used_space_pct)) / float(100))                                            
    1123. 

  1123.                                                                             
    1124. 

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

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

  1126.                                         if os.path.exists(os.path.join(mount_point, 'etc/issue')):
    1127. 

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

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

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

  1130.                                             if version.startswith("6.1"):
    1131. 

  1131.                                                 last_added_partition.description = "Windows 7"
    1132. 

  1132.                                             elif version.startswith("6.0"):
    1133. 

  1133.                                                 last_added_partition.description = "Windows Vista"
    1134. 

  1134.                                             elif version.startswith("5.1") or version.startswith("5.2"):
    1135. 

  1135.                                                 last_added_partition.description = "Windows XP"
    1136. 

  1136.                                             elif version.startswith("5.0"):
    1137. 

  1137.                                                 last_added_partition.description = "Windows 2000"
    1138. 

  1138.                                             elif version.startswith("4.90"):
    1139. 

  1139.                                                 last_added_partition.description = "Windows Me"
    1140. 

  1140.                                             elif version.startswith("4.1"):
    1141. 

  1141.                                                 last_added_partition.description = "Windows 98"
    1142. 

  1142.                                             elif version.startswith("4.0.1381"):
    1143. 

  1143.                                                 last_added_partition.description = "Windows NT"
    1144. 

  1144.                                             elif version.startswith("4.0.950"):
    1145. 

  1145.                                                 last_added_partition.description = "Windows 95"
    1146. 

  1146.                                         elif os.path.exists(os.path.join(mount_point, 'Boot/BCD')):
    1147. 

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

  1148.                                                 last_added_partition.description = "Windows Vista bootloader"
    1149. 

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

  1150.                                                 last_added_partition.description = "Windows 7 bootloader"
    1151. 

  1151.                                             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:
    1152. 

  1152.                                                 last_added_partition.description = "Windows recovery"
    1153. 

  1153.                                             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:
    1154. 

  1154.                                                 last_added_partition.description = "Windows Server 2008 bootloader"
    1155. 

  1155.                                             else:
    1156. 

  1156.                                                 last_added_partition.description = "Windows bootloader"
    1157. 

  1157.                                         elif os.path.exists(os.path.join(mount_point, 'Windows/System32')):
    1158. 

  1158.                                             last_added_partition.description = "Windows"
    1159. 

  1159.                                         break
    1160. 

  1160.                             else:
    1161. 

  1161.                                 print "Failed to mount %s" % partition.path
    1162. 

  1162. 

  1163.                             
    1164. 

  1164.                             #Umount temp folder
    1165. 

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

  1166.                                 os.popen('umount /tmp/live-installer/tmpmount')
    1167. 

  1167.                                 
    1168. 

  1168.                     if last_added_partition.size > 1.0:
    1169. 

  1169.                         if last_added_partition.partition.type == parted.PARTITION_LOGICAL:
    1170. 

  1170.                             display_name = "  " + last_added_partition.name
    1171. 

  1171.                         else:
    1172. 

  1172.                             display_name = last_added_partition.name
    1173. 

  1173. 

  1174.                         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]);
    1175. 

  1175.                         if last_added_partition.partition.number == -1:                     
    1176. 

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

  1177.                         elif last_added_partition.partition.type == parted.PARTITION_EXTENDED:                    
    1178. 

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

  1179.                         else:                                        
    1180. 

  1180.                             if last_added_partition.type == "ntfs":
    1181. 

  1181.                                 color = "#42e5ac"
    1182. 

  1182.                             elif last_added_partition.type == "fat32":
    1183. 

  1183.                                 color = "#18d918"
    1184. 

  1184.                             elif last_added_partition.type == "ext4":
    1185. 

  1185.                                 color = "#4b6983"
    1186. 

  1186.                             elif last_added_partition.type == "ext3":
    1187. 

  1187.                                 color = "#7590ae"
    1188. 

  1188.                             elif last_added_partition.type in ["linux-swap", "swap"]:
    1189. 

  1189.                                 color = "#c1665a"
    1190. 

  1190.                                 last_added_partition.mount_as = "swap"
    1191. 

  1191.                                 model.set_value(iter, INDEX_PARTITION_MOUNT_AS, "swap")
    1192. 

  1192.                             else:
    1193. 

  1193.                                 color = "#a9a9a9"
    1194. 

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

  1195.                             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>"        
    1196. 

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

  1197.                             space = int((float(partition.getSize()) / deviceSize) * float(80))                            
    1198. 

  1198.                             subs = {}
    1199. 

  1199.                             if (space >= 10):
    1200. 

  1200.                                 subs['path'] = display_name.replace("/dev/", "")                            
    1201. 

  1201.                                 subs['OS'] = last_added_partition.description
    1202. 

  1202.                             elif (space >= 5):
    1203. 

  1203.                                 subs['path'] = display_name.replace("/dev/", "")                            
    1204. 

  1204.                                 subs['OS'] = ""                            
    1205. 

  1205.                             else:
    1206. 

  1206.                                 #Not enough space, don't write the name
    1207. 

  1207.                                 subs['path'] = ""                          
    1208. 

  1208.                                 subs['OS'] = ""
    1209. 

  1209.                             subs['color'] = color                            
    1210. 

  1210.                             if (space == 0):
    1211. 

  1211.                                 space = 1
    1212. 

  1212.                             subs['space'] = space
    1213. 

  1213.                             subs['title'] = display_name + "\n" + last_added_partition.description
    1214. 

  1214.                             if "%" in last_added_partition.used_space:               
    1215. 

  1215.                                 subs['usage'] = last_added_partition.used_space.strip()
    1216. 

  1216.                             html_partition = string.Template(html_partition).safe_substitute(subs)                     
    1217. 

  1217.                             html_partitions = html_partitions + html_partition
    1218. 

  1218.                             self.setup.partitions.append(last_added_partition)
    1219. 

  1219.                             
    1220. 

  1220.                     partition = partition.nextPartition()
    1221. 

  1221.                 html_partitions = html_partitions + "</tr></table>"
    1222. 

  1222.             #self.wTree.get_widget("combobox_grub").set_model(grub_model)
    1223. 

  1223.             #self.wTree.get_widget("combobox_grub").set_active(0)
    1224. 

  1224.                         
    1225. 

  1225.             import tempfile            
    1226. 

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

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

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

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

  1230.             .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>"
    1231. 

  1231.             html_footer = "</body></html>"
    1232. 

  1232.             html = html_header + html_partitions + html_footer
    1233. 

  1233.            
    1234. 

  1234.             # create temporary file
    1235. 

  1235.             f = tempfile.NamedTemporaryFile(delete=False)
    1236. 

  1236.             f.write(html)
    1237. 

  1237.             f.close()  
    1238. 

  1238.                                    
    1239. 

  1239.             self.browser.open(f.name)            
    1240. 

  1240.             #browser.load_html_string(html, "file://")                 
    1241. 

  1241.             self.wTree.get_widget("scrolled_partitions").show_all()                                                                        
    1242. 

  1242.             self.wTree.get_widget("treeview_disks").set_model(model)                                
    1243. 

  1243.             
    1244. 

  1244.             
    1245. 

  1245.         except Exception, detail:
    1246. 

  1246.             print detail  
    1247. 

  1247.                 
    1248. 

  1248.         self.window.set_sensitive(True)
    1249. 

  1249.         self.window.window.set_cursor(None)        
    1250. 

  1250.         
    1251. 

  1251. 

  1252.     def build_kb_lists(self):
    1253. 

  1253.         ''' Do some xml kung-fu and load the keyboard stuffs '''
    1254. 

  1254. 

  1255.         # firstly we'll determine the layouts in use
    1256. 

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

  1257.         for line in p.stdout:
    1258. 

  1258.             # strip it
    1259. 

  1259.             line = line.rstrip("\r\n")
    1260. 

  1260.             line = line.replace("{","")
    1261. 

  1261.             line = line.replace("}","")
    1262. 

  1262.             line = line.replace(";","")
    1263. 

  1263.             if("xkb_symbols" in line):
    1264. 

  1264.                 # decipher the layout in use
    1265. 

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

  1266.                 self.setup.keyboard_layout = section.split("+")[1]
    1267. 

  1267.             if("xkb_geometry" in line):
    1268. 

  1268.                 first_bracket = line.index("(") +1
    1269. 

  1269.                 substr = line[first_bracket:]
    1270. 

  1270.                 last_bracket = substr.index(")")
    1271. 

  1271.                 substr = substr[0:last_bracket]
    1272. 

  1272.                 keyboard_geom = substr
    1273. 

  1273.         p.poll()
    1274. 

  1274. 

  1275.         xml_file = '/usr/share/X11/xkb/rules/xorg.xml'
    1276. 

  1276.         model_models = gtk.ListStore(str,str)
    1277. 

  1277.         model_models.set_sort_column_id(0, gtk.SORT_ASCENDING)
    1278. 

  1278.         model_layouts = gtk.ListStore(str,str)
    1279. 

  1279.         model_layouts.set_sort_column_id(0, gtk.SORT_ASCENDING)        
    1280. 

  1280.         dom = parse(xml_file)
    1281. 

  1281. 

  1282.         # if we find the users keyboard info we can set it in the list
    1283. 

  1283.         set_keyboard_model = None
    1284. 

  1284.         set_keyboard_layout = None
    1285. 

  1285.         set_keyboard_variant = None
    1286. 

  1286. 

  1287.         # grab the root element
    1288. 

  1288.         root = dom.getElementsByTagName('xkbConfigRegistry')[0]
    1289. 

  1289.         # build the list of models
    1290. 

  1290.         root_models = root.getElementsByTagName('modelList')[0]
    1291. 

  1291.         for element in root_models.getElementsByTagName('model'):
    1292. 

  1292.             conf = element.getElementsByTagName('configItem')[0]
    1293. 

  1293.             name = conf.getElementsByTagName('name')[0]
    1294. 

  1294.             desc = conf.getElementsByTagName('description')[0]
    1295. 

  1295.             #vendor = conf.getElementsByTagName('vendor')[0] # presently unused..
    1296. 

  1296.             iter_model = model_models.append([self.getText(desc.childNodes), self.getText(name.childNodes)])
    1297. 

  1297.             item = self.getText(name.childNodes)
    1298. 

  1298.             if(item == keyboard_geom):
    1299. 

  1299.                 set_keyboard_model = iter_model
    1300. 

  1300.         root_layouts = root.getElementsByTagName('layoutList')[0]
    1301. 

  1301.         for element in root_layouts.getElementsByTagName('layout'):
    1302. 

  1302.             conf = element.getElementsByTagName('configItem')[0]
    1303. 

  1303.             name = conf.getElementsByTagName('name')[0]
    1304. 

  1304.             desc = conf.getElementsByTagName('description')[0]
    1305. 

  1305.             iter_layout = model_layouts.append([self.getText(desc.childNodes), self.getText(name.childNodes)])
    1306. 

  1306.             item = self.getText(name.childNodes)
    1307. 

  1307.             if(item == self.setup.keyboard_layout):
    1308. 

  1308.                 set_keyboard_layout = iter_layout
    1309. 

  1309.         # now set the model        
    1310. 

  1310.         self.wTree.get_widget("combobox_kb_model").set_model(model_models)
    1311. 

  1311.         self.wTree.get_widget("treeview_layouts").set_model(model_layouts)
    1312. 

  1312. 

  1313.         if(set_keyboard_layout is not None):
    1314. 

  1314.             # show it in the list
    1315. 

  1315.             treeview = self.wTree.get_widget("treeview_layouts")
    1316. 

  1316.             model = treeview.get_model()
    1317. 

  1317.             column = treeview.get_column(0)
    1318. 

  1318.             path = model.get_path(set_keyboard_layout)
    1319. 

  1319.             treeview.set_cursor(path, focus_column=column)
    1320. 

  1320.             treeview.scroll_to_cell(path, column=column)
    1321. 

  1321.         if(set_keyboard_model is not None):         
    1322. 

  1322.              # show it in the combo
    1323. 

  1323.             combo = self.wTree.get_widget("combobox_kb_model")
    1324. 

  1324.             model = combo.get_model()                    
    1325. 

  1325.             combo.set_active_iter(set_keyboard_model)            
    1326. 

  1326.             
    1327. 

  1327.     def build_kb_variant_lists(self):
    1328. 

  1328.         # firstly we'll determine the layouts in use
    1329. 

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

  1330.         for line in p.stdout:
    1331. 

  1331.             # strip it
    1332. 

  1332.             line = line.rstrip("\r\n")
    1333. 

  1333.             line = line.replace("{","")
    1334. 

  1334.             line = line.replace("}","")
    1335. 

  1335.             line = line.replace(";","")
    1336. 

  1336.             if("xkb_symbols" in line):
    1337. 

  1337.                 # decipher the layout in use
    1338. 

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

  1339.                 self.setup.keyboard_layout = section.split("+")[1]
    1340. 

  1340.         p.poll()
    1341. 

  1341. 

  1342.         xml_file = '/usr/share/X11/xkb/rules/xorg.xml'      
    1343. 

  1343.         model_variants = gtk.ListStore(str,str)
    1344. 

  1344.         model_variants.set_sort_column_id(0, gtk.SORT_ASCENDING)        
    1345. 

  1345.         dom = parse(xml_file)
    1346. 

  1346.         
    1347. 

  1347.         # grab the root element
    1348. 

  1348.         root = dom.getElementsByTagName('xkbConfigRegistry')[0]
    1349. 

  1349.         # build the list of variants       
    1350. 

  1350.         root_layouts = root.getElementsByTagName('layoutList')[0]
    1351. 

  1351.         for layout in root_layouts.getElementsByTagName('layout'):
    1352. 

  1352.             conf = layout.getElementsByTagName('configItem')[0]
    1353. 

  1353.             layout_name = self.getText(conf.getElementsByTagName('name')[0].childNodes)            
    1354. 

  1354.             layout_description = self.getText(conf.getElementsByTagName('description')[0].childNodes)            
    1355. 

  1355.             if (layout_name == self.setup.keyboard_layout):
    1356. 

  1356.                 iter_variant = model_variants.append([layout_description, None])  
    1357. 

  1357.                 variants_list = layout.getElementsByTagName('variantList')
    1358. 

  1358.                 if len(variants_list) > 0:
    1359. 

  1359.                     root_variants = layout.getElementsByTagName('variantList')[0]   
    1360. 

  1360.                     for variant in root_variants.getElementsByTagName('variant'):                    
    1361. 

  1361.                         variant_conf = variant.getElementsByTagName('configItem')[0]
    1362. 

  1362.                         variant_name = self.getText(variant_conf.getElementsByTagName('name')[0].childNodes)
    1363. 

  1363.                         variant_description = "%s - %s" % (layout_description, self.getText(variant_conf.getElementsByTagName('description')[0].childNodes))
    1364. 

  1364.                         iter_variant = model_variants.append([variant_description, variant_name])                                                    
    1365. 

  1365.                 break
    1366. 

  1366.                                                                                 
    1367. 

  1367.         # now set the model        
    1368. 

  1368.         self.wTree.get_widget("treeview_variants").set_model(model_variants)
    1369. 

  1369.         
    1370. 

  1370.         # select the first item (standard variant layout)
    1371. 

  1371.         treeview = self.wTree.get_widget("treeview_variants")
    1372. 

  1372.         model = treeview.get_model()
    1373. 

  1373.         column = treeview.get_column(0)
    1374. 

  1374.         path = model.get_path(model.get_iter_first())
    1375. 

  1375.         treeview.set_cursor(path, focus_column=column)
    1376. 

  1376. 

  1377.     def getText(self, nodelist):
    1378. 

  1378.         rc = []
    1379. 

  1379.         for node in nodelist:
    1380. 

  1380.             if node.nodeType == node.TEXT_NODE:
    1381. 

  1381.                 rc.append(node.data)
    1382. 

  1382.         return ''.join(rc)
    1383. 

  1383.     
    1384. 

  1384. 

  1385.     def assign_language(self, treeview, data=None):
    1386. 

  1386.         ''' Called whenever someone updates the language '''
    1387. 

  1387.         model = treeview.get_model()
    1388. 

  1388.         active = treeview.get_selection().get_selected_rows()
    1389. 

  1389.         if(len(active) < 1):
    1390. 

  1390.             return
    1391. 

  1391.         active = active[1][0]
    1392. 

  1392.         if(active is None):
    1393. 

  1393.             return
    1394. 

  1394.         row = model[active]
    1395. 

  1395.         self.setup.language = row[1]
    1396. 

  1396.         self.setup.print_setup()
    1397. 

  1397.         try:            
    1398. 

  1398.             self.translation = gettext.translation('live-installer', "/usr/share/linuxmint/locale", languages=[self.setup.language])
    1399. 

  1399.             self.translation.install()
    1400. 

  1400.         except Exception, detail:
    1401. 

  1401.             print "No translation found, switching back to English"
    1402. 

  1402.             self.translation = gettext.translation('live-installer', "/usr/share/linuxmint/locale", languages=['en'])
    1403. 

  1403.             self.translation.install()        
    1404. 

  1404.         try:
    1405. 

  1405.             self.i18n()
    1406. 

  1406.         except:
    1407. 

  1407.             pass # Best effort. Fails the first time as self.column1 doesn't exist yet.
    1408. 

    1409. 

  1409.     def assign_hdd(self, treeview, data=None):
    1410. 

  1410.         ''' Called whenever someone updates the HDD '''
    1411. 

  1411.         model = treeview.get_model()
    1412. 

  1412.         active = treeview.get_selection().get_selected_rows()
    1413. 

  1413.         if(len(active) < 1):
    1414. 

  1414.             return
    1415. 

  1415.         active = active[1][0]
    1416. 

  1416.         if(active is None):
    1417. 

  1417.             return
    1418. 

  1418.         row = model[active]
    1419. 

  1419.         self.setup.target_disk = row[0] 
    1420. 

  1420. 

  1421.     def hdd_pane_toggled(self, hdd_button):
    1422. 

  1422.         ''' Called whenever the radio buttons on the hdd page toggle ''' 
    1423. 

  1423.         if(hdd_button.get_active()):
    1424. 

  1424.             self.wTree.get_widget("treeview_hdds").set_sensitive(True)
    1425. 

  1425.             self.setup.skip_mount = False
    1426. 

  1426.         else:
    1427. 

  1427.             self.wTree.get_widget("treeview_hdds").set_sensitive(False)
    1428. 

  1428.             self.setup.skip_mount = True
    1429. 

  1429.         self.setup.print_setup()
    1430. 

  1430.         
    1431. 

  1431.     def assign_grub_install(self, checkbox, grub_box, data=None):
    1432. 

  1432.         grub_box.set_sensitive(checkbox.get_active())
    1433. 

  1433.         if checkbox.get_active():
    1434. 

  1434.             self.assign_grub_device(grub_box)
    1435. 

  1435.         else:
    1436. 

  1436.             self.setup.grub_device = None
    1437. 

  1437.         self.setup.print_setup()    
    1438. 

  1438. 

  1439.     def assign_grub_device(self, combobox, data=None):
    1440. 

  1440.         ''' Called whenever someone updates the grub device '''
    1441. 

  1441.         model = combobox.get_model()
    1442. 

  1442.         active = combobox.get_active()
    1443. 

  1443.         if(active > -1):
    1444. 

  1444.             row = model[active]            
    1445. 

  1445.             self.setup.grub_device = row[0]  
    1446. 

  1446.         self.setup.print_setup()
    1447. 

  1447.        
    1448. 

  1448.     def assign_keyboard_model(self, combobox, data=None):
    1449. 

  1449.         ''' Called whenever someone updates the keyboard model '''
    1450. 

  1450.         model = combobox.get_model()
    1451. 

  1451.         active = combobox.get_active()
    1452. 

  1452.         if(active > -1):
    1453. 

  1453.             row = model[active]
    1454. 

  1454.             os.system("setxkbmap -model %s" % row[1])
    1455. 

  1455.             self.setup.keyboard_model = row[1]
    1456. 

  1456.             self.setup.keyboard_model_description = row[0]
    1457. 

  1457.         self.setup.print_setup()
    1458. 

  1458. 

  1459.     def assign_keyboard_layout(self, treeview, data=None):
    1460. 

  1460.         ''' Called whenever someone updates the keyboard layout '''
    1461. 

  1461.         model = treeview.get_model()
    1462. 

  1462.         active = treeview.get_selection().get_selected_rows()
    1463. 

  1463.         if(len(active) < 1):
    1464. 

  1464.             return
    1465. 

  1465.         active = active[1][0]
    1466. 

  1466.         if(active is None):
    1467. 

  1467.             return
    1468. 

  1468.         row = model[active]
    1469. 

  1469.         os.system("setxkbmap -layout %s" % row[1])
    1470. 

  1470.         self.setup.keyboard_layout = row[1]
    1471. 

  1471.         self.setup.keyboard_layout_description = row[0]
    1472. 

  1472.         self.build_kb_variant_lists()
    1473. 

  1473.         self.setup.print_setup()
    1474. 

  1474. 

  1475.     def assign_keyboard_variant(self, treeview, data=None):
    1476. 

  1476.         ''' Called whenever someone updates the keyboard layout '''
    1477. 

  1477.         model = treeview.get_model()
    1478. 

  1478.         active = treeview.get_selection().get_selected_rows()
    1479. 

  1479.         if(len(active) < 1):
    1480. 

  1480.             return
    1481. 

  1481.         active = active[1][0]
    1482. 

  1482.         if(active is None):
    1483. 

  1483.             return
    1484. 

  1484.         row = model[active]
    1485. 

  1485.         if (row[1] is None):
    1486. 

  1486.             os.system("setxkbmap -layout %s" % self.setup.keyboard_layout)
    1487. 

  1487.         else:
    1488. 

  1488.             os.system("setxkbmap -variant %s" % row[1])
    1489. 

  1489.         self.setup.keyboard_variant = row[1]
    1490. 

  1490.         self.setup.keyboard_variant_description = row[0]
    1491. 

  1491.         self.setup.print_setup()
    1492. 

  1492.         
    1493. 

  1493.         filename = "/tmp/live-install-keyboard-layout.png"
    1494. 

  1494.         os.system("python /usr/lib/live-installer/frontend/generate_keyboard_layout.py %s %s %s" % (self.setup.keyboard_layout, self.setup.keyboard_variant, filename))
    1495. 

  1495.         self.wTree.get_widget("image_keyboard").set_from_file(filename)        
    1496. 

  1496. 

  1497.     def assign_password(self, widget):
    1498. 

  1498.         ''' Someone typed into the entry '''
    1499. 

  1499.         self.setup.password1 = self.wTree.get_widget("entry_userpass1").get_text()
    1500. 

  1500.         self.setup.password2 = self.wTree.get_widget("entry_userpass2").get_text()        
    1501. 

  1501.         if(self.setup.password1 == "" and self.setup.password2 == ""):
    1502. 

  1502.             self.wTree.get_widget("image_mismatch").hide()
    1503. 

  1503.             self.wTree.get_widget("label_mismatch").hide()
    1504. 

  1504.         else:
    1505. 

  1505.             self.wTree.get_widget("image_mismatch").show()
    1506. 

  1506.             self.wTree.get_widget("label_mismatch").show()
    1507. 

  1507.         if(self.setup.password1 != self.setup.password2):
    1508. 

  1508.             self.wTree.get_widget("image_mismatch").set_from_stock(gtk.STOCK_NO, gtk.ICON_SIZE_BUTTON)            
    1509. 

  1509.             self.wTree.get_widget("label_mismatch").set_label(_("Passwords do not match"))            
    1510. 

  1510.         else:
    1511. 

  1511.             self.wTree.get_widget("image_mismatch").set_from_stock(gtk.STOCK_OK, gtk.ICON_SIZE_BUTTON)            
    1512. 

  1512.             self.wTree.get_widget("label_mismatch").set_label(_("Passwords match"))                    
    1513. 

  1513.         self.setup.print_setup()
    1514. 

  1514.         
    1515. 

  1515.     def activate_page(self, index):
    1516. 

  1516.         help_text = _(self.wizard_pages[index].help_text)        
    1517. 

  1517.         self.wTree.get_widget("help_label").set_markup("<big><b>%s</b></big>" % help_text)
    1518. 

  1518.         self.wTree.get_widget("help_icon").set_from_file("/usr/share/live-installer/icons/%s" % self.wizard_pages[index].icon)
    1519. 

  1519.         self.wTree.get_widget("notebook1").set_current_page(index)
    1520. 

  1520. 

  1521.     def wizard_cb(self, widget, goback, data=None):
    1522. 

  1522.         ''' wizard buttons '''
    1523. 

  1523.         sel = self.wTree.get_widget("notebook1").get_current_page()
    1524. 

  1524.         self.wTree.get_widget("button_next").set_label(_("Forward"))
    1525. 

  1525.         self.wTree.get_widget("button_back").set_sensitive(True)
    1526. 

  1526.         
    1527. 

  1527.         # check each page for errors
    1528. 

  1528.         if(not goback):
    1529. 

  1529.             if(sel == self.PAGE_LANGUAGE):
    1530. 

  1530.                 if ("_" in self.setup.language):
    1531. 

  1531.                     country_code = self.setup.language.split("_")[1]                    
    1532. 

  1532.                 else:
    1533. 

  1533.                     country_code = self.setup.language
    1534. 

  1534.                 combo = self.wTree.get_widget("combo_timezones")
    1535. 

  1535.                 model = combo.get_model()
    1536. 

  1536.                 iter = model.get_iter_first()
    1537. 

  1537.                 while iter is not None:
    1538. 

  1538.                     iter_country_code = model.get_value(iter, 1).country_code
    1539. 

  1539.                     if iter_country_code == country_code:
    1540. 

  1540.                         combo.set_active_iter(iter)                        
    1541. 

  1541.                         break
    1542. 

  1542.                     iter = model.iter_next(iter)
    1543. 

  1543.                 self.activate_page(self.PAGE_TIMEZONE)
    1544. 

  1544.             elif (sel == self.PAGE_TIMEZONE):
    1545. 

  1545.                 if ("_" in self.setup.language):
    1546. 

  1546.                     country_code = self.setup.language.split("_")[1]
    1547. 

  1547.                 else:
    1548. 

  1548.                     country_code = self.setup.language
    1549. 

  1549.                 treeview = self.wTree.get_widget("treeview_layouts")
    1550. 

  1550.                 model = treeview.get_model()
    1551. 

  1551.                 iter = model.get_iter_first()                
    1552. 

  1552.                 while iter is not None:
    1553. 

  1553.                     iter_country_code = model.get_value(iter, 1)
    1554. 

  1554.                     if iter_country_code.lower() == country_code.lower():
    1555. 

  1555.                         column = treeview.get_column(0)
    1556. 

  1556.                         path = model.get_path(iter)
    1557. 

  1557.                         treeview.set_cursor(path, focus_column=column)
    1558. 

  1558.                         treeview.scroll_to_cell(path, column=column)
    1559. 

  1559.                         break
    1560. 

  1560.                     iter = model.iter_next(iter)
    1561. 

  1561.                 self.activate_page(self.PAGE_KEYBOARD)
    1562. 

  1562.             elif(sel == self.PAGE_KEYBOARD):
    1563. 

  1563.                 self.activate_page(self.PAGE_USER)
    1564. 

  1564.             elif(sel == self.PAGE_USER):
    1565. 

  1565.                 errorFound = False
    1566. 

  1566.                 errorMessage = ""
    1567. 

  1567.                                 
    1568. 

  1568.                 if(self.setup.real_name is None or self.setup.real_name == ""):
    1569. 

  1569.                     errorFound = True
    1570. 

  1570.                     errorMessage = _("Please provide your full name")
    1571. 

  1571.                 elif(self.setup.username is None or self.setup.username == ""):
    1572. 

  1572.                     errorFound = True
    1573. 

  1573.                     errorMessage = _("Please provide a username")                
    1574. 

  1574.                 elif(self.setup.password1 is None or self.setup.password1 == ""):
    1575. 

  1575.                     errorFound = True
    1576. 

  1576.                     errorMessage = _("Please provide a password for your user account")
    1577. 

  1577.                 elif(self.setup.password1 != self.setup.password2):
    1578. 

  1578.                     errorFound = True
    1579. 

  1579.                     errorMessage = _("Your passwords do not match")
    1580. 

  1580.                 elif(self.setup.hostname is None or self.setup.hostname == ""):
    1581. 

  1581.                     errorFound = True
    1582. 

  1582.                     errorMessage = _("Please provide a hostname")
    1583. 

  1583.                 else:
    1584. 

  1584.                     for char in self.setup.username:
    1585. 

  1585.                         if(char.isupper()):
    1586. 

  1586.                             errorFound = True
    1587. 

  1587.                             errorMessage = _("Your username must be lower case")
    1588. 

  1588.                             break
    1589. 

  1589.                         elif(char.isspace()):
    1590. 

  1590.                             errorFound = True
    1591. 

  1591.                             errorMessage = _("Your username may not contain whitespace")
    1592. 

  1592.                     
    1593. 

  1593.                     for char in self.setup.hostname:
    1594. 

  1594.                         if(char.isupper()):
    1595. 

  1595.                             errorFound = True
    1596. 

  1596.                             errorMessage = _("Your hostname must be lower case")
    1597. 

  1597.                             break
    1598. 

  1598.                         elif(char.isspace()):
    1599. 

  1599.                             errorFound = True
    1600. 

  1600.                             errorMessage = _("Your hostname may not contain whitespace")
    1601. 

  1601.                     
    1602. 

  1602.                 if (errorFound):
    1603. 

  1603.                     MessageDialog(_("Installation Tool"), errorMessage, gtk.MESSAGE_WARNING, self.window).show()
    1604. 

  1604.                 else:
    1605. 

  1605.                     self.activate_page(self.PAGE_HDD)                
    1606. 

  1606.             elif(sel == self.PAGE_HDD):
    1607. 

  1607.                 if (self.setup.skip_mount):
    1608. 

  1608.                     self.activate_page(self.PAGE_CUSTOMWARNING)
    1609. 

  1609.                 else:
    1610. 

  1610.                     self.activate_page(self.PAGE_PARTITIONS)
    1611. 

  1611.                     self.build_partitions()
    1612. 

  1612.             elif(sel == self.PAGE_PARTITIONS):                
    1613. 

  1613.                 model = self.wTree.get_widget("treeview_disks").get_model()
    1614. 

  1614.                 error = True
    1615. 

  1615.                 errorMessage = _("Please select a root (/) partition before proceeding")
    1616. 

  1616.                 for partition in self.setup.partitions:                    
    1617. 

  1617.                     if(partition.mount_as == "/"):
    1618. 

  1618.                         error = False                        
    1619. 

  1619.                         if partition.format_as is None or partition.format_as == "":
    1620. 

  1620.                             error = True
    1621. 

  1621.                             errorMessage = _("Please indicate a filesystem to format the root (/) partition before proceeding")                        
    1622. 

  1622.                 if(error):
    1623. 

  1623.                     MessageDialog(_("Installation Tool"), errorMessage, gtk.MESSAGE_ERROR, self.window).show()
    1624. 

  1624.                 else:
    1625. 

  1625.                     self.build_grub_partitions()
    1626. 

  1626.                     self.activate_page(self.PAGE_ADVANCED)
    1627. 

  1627.             elif(sel == self.PAGE_CUSTOMWARNING):
    1628. 

  1628.                 self.build_grub_partitions()
    1629. 

  1629.                 self.activate_page(self.PAGE_ADVANCED)
    1630. 

  1630.             elif(sel == self.PAGE_ADVANCED):
    1631. 

  1631.                 self.activate_page(self.PAGE_OVERVIEW)
    1632. 

  1632.                 self.show_overview()
    1633. 

  1633.                 self.wTree.get_widget("treeview_overview").expand_all()
    1634. 

  1634.                 self.wTree.get_widget("button_next").set_label(_("Install"))
    1635. 

  1635.             elif(sel == self.PAGE_OVERVIEW):
    1636. 

  1636.                 self.activate_page(self.PAGE_INSTALL)
    1637. 

  1637.                 # do install
    1638. 

  1638.                 self.wTree.get_widget("button_next").set_sensitive(False)
    1639. 

  1639.                 self.wTree.get_widget("button_back").set_sensitive(False)
    1640. 

  1640.                 self.wTree.get_widget("button_quit").set_sensitive(False)
    1641. 

  1641.                 thr = threading.Thread(name="live-install", group=None, args=(), kwargs={}, target=self.do_install)
    1642. 

  1642.                 thr.start()
    1643. 

  1643.             elif(sel == self.PAGE_CUSTOMPAUSED):
    1644. 

  1644.                 self.activate_page(self.PAGE_INSTALL)
    1645. 

  1645.                 self.wTree.get_widget("button_next").hide()
    1646. 

  1646.                 self.paused = False            
    1647. 

  1647.         else:
    1648. 

  1648.             self.wTree.get_widget("button_back").set_sensitive(True)
    1649. 

  1649.             if(sel == self.PAGE_OVERVIEW):
    1650. 

  1650.                 self.activate_page(self.PAGE_ADVANCED)
    1651. 

  1651.             elif(sel == self.PAGE_ADVANCED):
    1652. 

  1652.                 if (self.setup.skip_mount):
    1653. 

  1653.                     self.activate_page(self.PAGE_CUSTOMWARNING)
    1654. 

  1654.                 else:
    1655. 

  1655.                     self.activate_page(self.PAGE_PARTITIONS)              
    1656. 

  1656.             elif(sel == self.PAGE_CUSTOMWARNING):
    1657. 

  1657.                 self.activate_page(self.PAGE_HDD)
    1658. 

  1658.             elif(sel == self.PAGE_PARTITIONS):
    1659. 

  1659.                 self.activate_page(self.PAGE_HDD)
    1660. 

  1660.             elif(sel == self.PAGE_HDD):
    1661. 

  1661.                 self.activate_page(self.PAGE_USER)
    1662. 

  1662.             elif(sel == self.PAGE_USER):
    1663. 

  1663.                 self.activate_page(self.PAGE_KEYBOARD)  
    1664. 

  1664.             elif(sel == self.PAGE_KEYBOARD):
    1665. 

  1665.                 self.activate_page(self.PAGE_TIMEZONE)
    1666. 

  1666.             elif(sel == self.PAGE_TIMEZONE):
    1667. 

  1667.                 self.activate_page(self.PAGE_LANGUAGE)                
    1668. 

  1668. 

  1669.     def show_overview(self):
    1670. 

  1670.         ''' build the summary page '''
    1671. 

  1671.         model = gtk.TreeStore(str)        
    1672. 

  1672.         top = model.append(None)
    1673. 

  1673.         model.set(top, 0, _("Localization"))
    1674. 

  1674.         iter = model.append(top)
    1675. 

  1675.         model.set(iter, 0, _("Language: ") + "<b>%s</b>" % self.setup.language)        
    1676. 

  1676.         iter = model.append(top)
    1677. 

  1677.         model.set(iter, 0, _("Timezone: ") + "<b>%s</b>" % self.setup.timezone)        
    1678. 

  1678.         iter = model.append(top)
    1679. 

  1679.         if (self.setup.keyboard_variant_description is None):
    1680. 

  1680.             model.set(iter, 0, _("Keyboard layout: ") + "<b>%s - %s</b>" % (self.setup.keyboard_model_description, self.setup.keyboard_layout_description))       
    1681. 

  1681.         else:
    1682. 

  1682.             model.set(iter, 0, _("Keyboard layout: ") + "<b>%s - %s (%s)</b>" % (self.setup.keyboard_model_description, self.setup.keyboard_layout_description, self.setup.keyboard_variant_description))
    1683. 

  1683.         top = model.append(None)
    1684. 

  1684.         model.set(top, 0, _("User settings"))       
    1685. 

  1685.         iter = model.append(top)
    1686. 

  1686.         model.set(iter, 0, _("Real name: ") + "<b>%s</b>" % self.setup.real_name)        
    1687. 

  1687.         iter = model.append(top)
    1688. 

  1688.         model.set(iter, 0, _("Username: ") + "<b>%s</b>" % self.setup.username)
    1689. 

  1689.         top = model.append(None)
    1690. 

  1690.         model.set(top, 0, _("System settings"))
    1691. 

  1691.         iter = model.append(top)
    1692. 

  1692.         model.set(iter, 0, _("Hostname: ") + "<b>%s</b>" % self.setup.hostname)       
    1693. 

  1693.         iter = model.append(top)
    1694. 

  1694.         if(self.setup.grub_device is not None):
    1695. 

  1695.             model.set(iter, 0, _("Install bootloader in %s") % ("<b>%s</b>" % self.setup.grub_device))
    1696. 

  1696.         else:
    1697. 

  1697.             model.set(iter, 0, _("Do not install bootloader"))
    1698. 

  1698.         top = model.append(None)
    1699. 

  1699.         model.set(top, 0, _("Filesystem operations"))  
    1700. 

  1700.         if(self.setup.skip_mount):
    1701. 

  1701.             iter = model.append(top)
    1702. 

  1702.             model.set(iter, 0, "<b>Use already-mounted /target.</b>")
    1703. 

  1703.         else:      
    1704. 

  1704.             for partition in self.setup.partitions:
    1705. 

  1705.                 if(partition.format_as is not None and partition.format_as != ""):
    1706. 

  1706.                     # format it
    1707. 

  1707.                     iter = model.append(top)
    1708. 

  1708.                     model.set(iter, 0, "<b>%s</b>" % (_("Format %(partition)s as %(format)s") % {'partition':partition.partition.path, 'format':partition.format_as}))
    1709. 

  1709.             for partition in self.setup.partitions:
    1710. 

  1710.                 if(partition.mount_as is not None and partition.mount_as != ""):
    1711. 

  1711.                     # mount point
    1712. 

  1712.                     iter = model.append(top)
    1713. 

  1713.                     model.set(iter, 0, "<b>%s</b>" % (_("Mount %(partition)s as %(mountpoint)s") % {'partition':partition.partition.path, 'mountpoint':partition.mount_as}))
    1714. 

  1714.         self.wTree.get_widget("treeview_overview").set_model(model)
    1715. 

  1715. 

  1716.     def do_install(self):        
    1717. 

  1717.         try:        
    1718. 

  1718.             print " ## INSTALLATION "
    1719. 

  1719.             ''' Actually perform the installation .. '''
    1720. 

  1720.             inst = self.installer            
    1721. 

  1721. 

  1722.             if "--debug" in sys.argv:
    1723. 

  1723.                 print " ## DEBUG MODE - INSTALLATION PROCESS NOT LAUNCHED"            
    1724. 

  1724.                 sys.exit(0)
    1725. 

  1725.                                    
    1726. 

  1726.             inst.set_progress_hook(self.update_progress)
    1727. 

  1727.             inst.set_error_hook(self.error_message)
    1728. 

  1728. 

  1729.             # do we dare? ..
    1730. 

  1730.             self.critical_error_happened = False
    1731. 

  1731. 

  1732.             # Now it's time to load the slide show
    1733. 

  1733.             if os.path.exists(self.slideshow_path):                        
    1734. 

  1734.                 slideThr = Slideshow(self.slideshow_browser, self.slideshow_path, self.setup.language)
    1735. 

  1735.                 # Let the slide-thread die when the parent thread dies
    1736. 

  1736.                 slideThr.daemon = True
    1737. 

  1737.                 slideThr.start()
    1738. 

  1738. 

  1739.             # Start installing
    1740. 

  1740.             do_try_finish_install = True
    1741. 

  1741.             
    1742. 

  1742.             try:
    1743. 

  1743.                 inst.init_install(self.setup)
    1744. 

  1744.             except Exception, detail1:
    1745. 

  1745.                 print detail1
    1746. 

  1746.                 do_try_finish_install = False
    1747. 

  1747.                 try:
    1748. 

  1748.                     gtk.gdk.threads_enter()
    1749. 

  1749.                     MessageDialog(_("Installation error"), str(detail1), gtk.MESSAGE_ERROR, self.window).show()
    1750. 

  1750.                     gtk.gdk.threads_leave()
    1751. 

  1751.                 except Exception, detail2:
    1752. 

  1752.                     print detail2
    1753. 

  1753. 

  1754.             if self.critical_error_happened:
    1755. 

  1755.                 gtk.gdk.threads_enter()
    1756. 

  1756.                 MessageDialog(_("Installation error"), self.critical_error_message, gtk.MESSAGE_ERROR, self.window).show()
    1757. 

  1757.                 gtk.gdk.threads_leave()
    1758. 

  1758.                 do_try_finish_install = False
    1759. 

  1759. 

  1760.             if do_try_finish_install:
    1761. 

  1761.                 if(self.setup.skip_mount):
    1762. 

  1762.                     gtk.gdk.threads_enter()
    1763. 

  1763.                     self.paused = True
    1764. 

  1764.                     self.activate_page(self.PAGE_CUSTOMPAUSED)
    1765. 

  1765.                     self.wTree.get_widget("button_next").show()
    1766. 

  1766.                     MessageDialog(_("Installation Paused"), _("Installation is now paused. Please read the instructions on the page carefully and click Forward to finish installation."), gtk.MESSAGE_INFO, self.window).show()
    1767. 

  1767.                     gtk.gdk.threads_leave()
    1768. 

  1768. 

  1769.                     while(self.paused):
    1770. 

  1770.                         time.sleep(0.1)
    1771. 

  1771. 

  1772.                 try:
    1773. 

  1773.                     inst.finish_install(self.setup)
    1774. 

  1774.                 except Exception, detail1:
    1775. 

  1775.                     print detail1
    1776. 

  1776.                     try:
    1777. 

  1777.                         gtk.gdk.threads_enter()
    1778. 

  1778.                         MessageDialog(_("Installation error"), str(detail1), gtk.MESSAGE_ERROR, self.window).show()
    1779. 

  1779.                         gtk.gdk.threads_leave()
    1780. 

  1780.                     except Exception, detail2:
    1781. 

  1781.                         print detail2
    1782. 

  1782. 

  1783.                 # show a message dialog thingum
    1784. 

  1784.                 while(not self.done):
    1785. 

  1785.                     time.sleep(0.1)
    1786. 

  1786.             
    1787. 

  1787.                 if self.critical_error_happened:
    1788. 

  1788.                     gtk.gdk.threads_enter()
    1789. 

  1789.                     MessageDialog(_("Installation error"), self.critical_error_message, gtk.MESSAGE_ERROR, self.window).show()
    1790. 

  1790.                     gtk.gdk.threads_leave()                
    1791. 

  1791.                 else:
    1792. 

  1792.                     gtk.gdk.threads_enter()                    
    1793. 

  1793.                     dialog = QuestionDialog(_("Installation finished"), _("Installation is now complete. Do you want to restart your computer to use the new system?"), self.window)
    1794. 

  1794.                     if (dialog.show()):
    1795. 

  1795.                         # Reboot now
    1796. 

  1796.                         os.system('reboot')
    1797. 

  1797.                     gtk.gdk.threads_leave()
    1798. 

  1798.                 
    1799. 

  1799.                 print " ## INSTALLATION COMPLETE "
    1800. 

  1800.             
    1801. 

  1801.         except Exception, detail:
    1802. 

  1802.             print "!!!! General exception"
    1803. 

  1803.             print detail
    1804. 

  1804.             
    1805. 

  1805.         # safe??
    1806. 

  1806.         gtk.main_quit()
    1807. 

  1807.         # you are now..
    1808. 

  1808.         sys.exit(0)
    1809. 

  1809. 

  1810.     def error_message(self, message=""):
    1811. 

  1811.         self.critical_error_happened = True
    1812. 

  1812.         self.critical_error_message = message
    1813. 

  1813. 

  1814.     def update_progress(self, fail=False, done=False, pulse=False, total=0,current=0,message=""):
    1815. 

  1815.         
    1816. 

  1816.         #print "%d/%d: %s" % (current, total, message)
    1817. 

  1817.         
    1818. 

  1818.         # TODO: ADD FAIL CHECKS..
    1819. 

  1819.         if(pulse):
    1820. 

  1820.             gtk.gdk.threads_enter()
    1821. 

  1821.             self.wTree.get_widget("label_install_progress").set_label(message)
    1822. 

  1822.             gtk.gdk.threads_leave()
    1823. 

  1823.             self.do_progress_pulse(message)
    1824. 

  1824.             return
    1825. 

  1825.         if(done):
    1826. 

  1826.             # cool, finished :D
    1827. 

  1827.             self.should_pulse = False
    1828. 

  1828.             self.done = done
    1829. 

  1829.             gtk.gdk.threads_enter()
    1830. 

  1830.             self.wTree.get_widget("progressbar").set_fraction(1)
    1831. 

  1831.             self.wTree.get_widget("label_install_progress").set_label(message)
    1832. 

  1832.             gtk.gdk.threads_leave()
    1833. 

  1833.             return
    1834. 

  1834.         self.should_pulse = False
    1835. 

  1835.         _total = float(total)
    1836. 

  1836.         _current = float(current)
    1837. 

  1837.         pct = float(_current/_total)
    1838. 

  1838.         szPct = int(pct)
    1839. 

  1839.         # thread block
    1840. 

  1840.         gtk.gdk.threads_enter()
    1841. 

  1841.         self.wTree.get_widget("progressbar").set_fraction(pct)
    1842. 

  1842.         self.wTree.get_widget("label_install_progress").set_label(message)
    1843. 

  1843.         gtk.gdk.threads_leave()
    1844. 

  1844. 

  1845.         # end thread block
    1846. 

  1846. 

  1847.     def do_progress_pulse(self, message):
    1848. 

  1848.         def pbar_pulse():
    1849. 

  1849.             if(not self.should_pulse):
    1850. 

  1850.                 return False
    1851. 

  1851.             gtk.gdk.threads_enter()
    1852. 

  1852.             self.wTree.get_widget("progressbar").pulse()
    1853. 

  1853.             gtk.gdk.threads_leave()
    1854. 

  1854.             return self.should_pulse
    1855. 

  1855.         if(not self.should_pulse):
    1856. 

  1856.             self.should_pulse = True
    1857. 

  1857.             gobject.timeout_add(100, pbar_pulse)
    1858. 

  1858.         else:
    1859. 

  1859.             # asssume we're "pulsing" already
    1860. 

  1860.             self.should_pulse = True
    1861. 

  1861.             pbar_pulse()
    1862. 

  1862. 

  1863. class PartitionDialog:
    1864. 

  1864. 

  1865.     def __init__(self, path, mount_as, format_as, type):
    1866. 

  1866.         self.resource_dir = '/usr/share/live-installer/'
    1867. 

  1867.         self.glade = os.path.join(self.resource_dir, 'interface.glade')
    1868. 

  1868.         self.dTree = gtk.glade.XML(self.glade, 'dialog')
    1869. 

  1869.         self.window = self.dTree.get_widget("dialog")
    1870. 

  1870.         self.window.set_title(_("Edit partition"))
    1871. 

  1871.                
    1872. 

  1872.         ''' Build supported filesystems list '''
    1873. 

  1873.         model = gtk.ListStore(str)        
    1874. 

  1874.         model.append([""])
    1875. 

  1875.         if "swap" in type:        
    1876. 

  1876.             model.append(["swap"])
    1877. 

  1877.         else:
    1878. 

  1878.             try:
    1879. 

  1879.                 for item in os.listdir("/sbin"):
    1880. 

  1880.                     if(item.startswith("mkfs.")):
    1881. 

  1881.                         fstype = item.split(".")[1]
    1882. 

  1882.                         model.append([fstype])
    1883. 

  1883.             except Exception, detail:
    1884. 

  1884.                 print detail
    1885. 

  1885.                 print _("Could not build supported filesystems list!")
    1886. 

  1886.         self.dTree.get_widget("combobox_use_as").set_model(model)
    1887. 

  1887.         
    1888. 

  1888.         if "swap" in type:
    1889. 

  1889.             mounts = ["", "swap"]
    1890. 

  1890.         else:
    1891. 

  1891.             mounts = ["", "/", "/boot", "/tmp", "/home", "/srv"]
    1892. 

  1892.         model = gtk.ListStore(str)
    1893. 

  1893.         for mount in mounts:
    1894. 

  1894.             model.append([mount])
    1895. 

  1895.         self.dTree.get_widget("comboboxentry_mount_point").set_model(model)  
    1896. 

  1896.                 
    1897. 

  1897.         # i18n
    1898. 

  1898.         self.dTree.get_widget("label_partition").set_markup("<b>%s</b>" % _("Device:"))
    1899. 

  1899.         self.dTree.get_widget("label_partition_value").set_label(path)        
    1900. 

  1900.         
    1901. 

  1901.         self.dTree.get_widget("label_use_as").set_markup(_("Format as:"))        
    1902. 

  1902.         cur = -1
    1903. 

  1903.         model = self.dTree.get_widget("combobox_use_as").get_model()
    1904. 

  1904.         for item in model:
    1905. 

  1905.             cur += 1
    1906. 

  1906.             if(item[0] == format_as):
    1907. 

  1907.                 self.dTree.get_widget("combobox_use_as").set_active(cur)
    1908. 

  1908.                 break
    1909. 

  1909.                 
    1910. 

  1910.         self.dTree.get_widget("label_mount_point").set_markup(_("Mount point:"))
    1911. 

  1911.         self.dTree.get_widget("comboboxentry_mount_point").child.set_text(mount_as)         
    1912. 

  1912. 

  1913.     def show(self):
    1914. 

  1914.         self.window.run()
    1915. 

  1915.         self.window.hide()        
    1916. 

  1916.         w = self.dTree.get_widget("comboboxentry_mount_point")
    1917. 

  1917.         w.child.get_text().replace(" ","")
    1918. 

  1918.         mount_as = w.child.get_text()
    1919. 

  1919.         w = self.dTree.get_widget("combobox_use_as")
    1920. 

  1920.         # find filesystem ..
    1921. 

  1921.         active = w.get_active()
    1922. 

  1922.         model = w.get_model()[active]
    1923. 

  1923.         format_as = model[0]
    1924. 

  1924.         return (mount_as, format_as)
    1925. 

  1925.