PageRenderTime 52ms CodeModel.GetById 11ms 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

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

    

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

  2. import sys
    3. 

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

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

  5. 

  6. try:
    7. 

  7.     import pygtk
    8. 

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

  9.     import gtk
    10. 

  10.     import gtk.glade
    11. 

  11.     import gettext
    12. 

  12.     import os
    13. 

  13.     import commands
    14. 

  14.     import subprocess
    15. 

  15.     import sys
    16. 

  16.     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. …
    1007.

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