« back to all changes in this revision
Viewing changes to src/bootloader-manager/application.py
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Tomé Vardasca
- Date: 2007-08-14 14:46:47 UTC
- Revision ID: cacau.pt@gmail.com-20070814144647-o9ozx251yfve4zri
change on package structure
- files added:
- AUTHORS
- src
- src/bootloader-manager
added
removed
src/bootloader-manager/application.py
1
# -*- coding: UTF-8 -*-
2
###########################################################################
3
# application.py - Main file of Bootloader Manager #
4
# ------------------------------ #
5
# begin : Wed May 30 2007 #
6
# copyright : (C) 2007 by Tomé Vardasca #
7
# email : cacau.pt@gmail.com #
8
# #
9
###########################################################################
10
# #
11
# This program is free software; you can redistribute it and/or modify #
12
# it under the terms of the GNU General Public License as published by #
13
# the Free Software Foundation; either version 2 of the License, or #
14
# (at your option) any later version. #
15
# #
16
###########################################################################
17
18
import pygtk
19
pygtk.require("2.0")
20
import gtk, gtk.glade, os, re, gzip, tempfile, gobject, sys, glob, cairo
21
import grubconfig_backend
22
from bootloader_manager import SHARED_FILES
23
FILE_DIR = os.path.join(SHARED_FILES, 'lib', 'bootloader_manager')
24
GLADE_FILE = os.path.join(SHARED_FILES, 'glade', 'bootloader-manager.glade')
25
26
class GrubConfig:
27
28
def __init__(self):
29
self.gcb = grubconfig_backend.grubconfig_backend()
30
31
def load( self, config_file):
32
#clean the object
33
self.gcb = grubconfig_backend.grubconfig_backend()
34
self.gcb.set_menulst_location(config_file)
35
self.gcb.load()
36
37
def save(self, config_file):
38
self.gcb.set_menulst_location(config_file)
39
result = self.gcb.save()
40
self.save_error = self.gcb.save_error
41
return result
42
43
def get_default(self):
44
if 'default' in self.gcb.globalslist.keys():
45
if self.gcb.globalslist['default'] == "saved":
46
return -1
47
return int(self.gcb.globalslist['default'])
48
return None
49
50
def set_default(self, default):
51
if default == 'saved':
52
self.gcb.globalslist['default'] = default
53
else:
54
self.gcb.globalslist['default'] = str(default)
55
56
def get_timeout(self):
57
if 'timeout' in self.gcb.globalslist.keys():
58
return int(self.gcb.globalslist['timeout'])
59
return None
60
61
def set_timeout(self, timeout):
62
self.gcb.globalslist['timeout'] = str(timeout)
63
64
def hiddenmenu(self):
65
if 'hiddenmenu' in self.gcb.globalslist.keys():
66
return True
67
return False
68
69
def set_hiddenmenu(self, hiddenmenu):
70
if 'hiddenmenu' in self.gcb.globalslist.keys() and not hiddenmenu:
71
del self.gcb.globalslist['hiddenmenu']
72
else:
73
self.gcb.globalslist['hiddenmenu'] = None
74
75
def has_password(self):
76
if 'password' in self.gcb.globalslist.keys():
77
self.has_password = True
78
return False
79
80
def set_password(self, password):
81
if password is None and 'password' in self.gcb.globalslist.keys():
82
del self.gcb.globalslist['password']
83
elif password is not None:
84
self.gcb.globalslist['password'] = ['--md5', generate_grub_password(password)]
85
86
def get_colors(self):
87
colors = []
88
blink = []
89
if 'color' in self.gcb.globalslist.keys():
90
if type(self.gcb.globalslist['color']) == type(""):
91
colors += self.gcb.globalslist['color'].split('/')
92
else:
93
colors += self.gcb.globalslist['color'][0].split('/')
94
colors += self.gcb.globalslist['color'][1].split('/')
95
if colors[2].startswith("blink-"):
96
blink.append("highlight")
97
colors[2] = colors[2][len("blink-"):]
98
if colors[0].startswith("blink-"):
99
blink.append("normal")
100
colors[0] = colors[0][len("blink-"):]
101
return colors, blink
102
103
def set_colors(self, colors, blink):
104
self.gcb.globalslist['color'] = []
105
if "normal" in blink:
106
colors[0] = "blink-"+colors[0]
107
if len(colors) == 2:
108
self.gcb.globalslist['color'] = colors[0]+'/'+colors[1]
109
else:
110
if "highlight" in blink:
111
colors[2] = "blink-"+colors[2]
112
self.gcb.globalslist['color'].append(colors[0]+'/'+colors[1])
113
self.gcb.globalslist['color'].append(colors[2]+'/'+colors[3])
114
115
def get_splash_image(self):
116
splashimage_re = re.compile('splashimage=(\([\d\w,]+\))+(.+)\s*')
117
splashimage = ""
118
for option in self.gcb.globalslist.keys():
119
if splashimage_re.search(option) is not None:
120
splashimage = splashimage_re.search(option).group(2)
121
return splashimage
122
123
def set_splash_image(self, splash_image_path):
124
splashkey = None
125
for option in self.gcb.globalslist.keys():
126
if option.startswith("splashimage="):
127
splashkey = option
128
if splashkey is not None:
129
del splashkey
130
if splash_image_path is not None:
131
self.gcb.globalslist["splashimage="+splash_image_path] = None
132
133
def get_fallback(self):
134
if 'fallback' in self.gcb.globalslist.keys():
135
return self.gcb.globalslist['fallback']
136
return None
137
138
def set_fallback(self, fallback):
139
if fallback is None and 'fallback' in self.gcb.globalslist.keys():
140
del self.gcb.globalslist['fallback']
141
else:
142
self.gcb.globalslist['fallback'] = fallback
143
144
def get_oslist(self):
145
return self.gcb.kernelslist
146
147
def set_os(self, kernel, kernel_index):
148
self.gcb.kernelslist[kernel_index] = kernel
149
150
def new_os(self, kernel):
151
self.gcb.kernelslist.append(kernel)
152
153
def del_os(self, kernel_i):
154
del self.gcb.kernelslist[kernel_i]
155
156
def swap_os(self, i_kernel_a, i_kernel_b):
157
aux = self.gcb.kernelslist[i_kernel_a]
158
self.gcb.kernelslist[i_kernel_a] = self.gcb.kernelslist[i_kernel_b]
159
self.gcb.kernelslist[i_kernel_b] = aux
160
161
def get_alternative(self):
162
for option in self.gcb.magicslist:
163
if option == "alternative=true":
164
return True
165
return False
166
167
def set_alternative(self, alternative):
168
i=0
169
for option in self.gcb.magicslist:
170
if option[0].startswith("alternative="):
171
del self.gcb.magicslist[i]
172
i=i+1
173
if alternative:
174
self.gcb.magicslist.append(['alternative=true', None])
175
else:
176
self.gcb.magicslist.append(['alternative=false', None])
177
178
def get_memtest86(self):
179
for option in self.gcb.magicslist:
180
if option == "alternative=true":
181
return True
182
return False
183
184
def set_memtest86(self, memtest86):
185
i=0
186
for option in self.gcb.magicslist:
187
if option[0].startswith("memtest86="):
188
del self.gcb.magicslist[i]
189
i=i+1
190
if memtest86:
191
self.gcb.magicslist.append(['memtest86=true', None])
192
else:
193
self.gcb.magicslist.append(['memtest86=false', None])
194
195
def os_prober(self):
196
kernels_found = []
197
os_founds = []
198
disks = Disks()
199
os.system("sudo umount -a")
200
put, get = os.popen4("sudo os-prober")
201
put.close()
202
for line in get.readlines():
203
os_founds.append(line.strip().split(':'))
204
205
for os_found in os_founds:
206
if os_found[3] == 'linux':
207
put, get = os.popen4("sudo linux-boot-prober "+os_found[0])
208
put.close()
209
for line in get.readlines():
210
options = line.strip().split(':')
211
if options[0] == '':
212
kernels_found.append(grubconfig_backend.menu_item(options[2],
213
{
214
'root': disks.get_grub_partition(options[0]).grub_device,
215
'kernel': options[3]+options[5]
216
}))
217
else:
218
kernels_found.append(grubconfig_backend.menu_item(options[2],
219
{
220
'root': disks.get_grub_partition(options[0]).grub_device,
221
'kernel': options[3]+options[5],
222
'initrd': options[4]
223
}))
224
elif os_found[3] == 'chain':
225
kernels_found.append(grubconfig_backend.menu_item(os_found[1],{
226
'root': disks.get_grub_partition(os_found[0]).grub_device,
227
'chainloader': '+1',
228
'makeactive': None
229
}))
230
os.system("sudo mount -a")
231
kernels_found_dir = glob.glob('/boot/vmlinuz-*') + glob.glob('/boot/memtest*')
232
233
for kernel in kernels_found_dir:
234
if kernel.find("vmlinuz") != -1:
235
put, get = os.popen4("lsb_release -is")
236
put.close()
237
title = get.readline().strip()+', kernel '+kernel[len("/boot/vmlinuz-"):]
238
kernels_found.append(grubconfig_backend.menu_item(title,
239
{
240
'root': disks.get_root_partition().grub_device,
241
'kernel': [kernel, "root="+disks.get_root_partition().uuid, "ro", "quiet", "splash"],
242
'initrd': kernel[:kernel.find("vmlinuz")]+"initrd.img"+kernel[len("vmlinuz")+kernel.find("vmlinuz"):],
243
'savedeafault' : None,
244
'quiet' : None
245
}))
246
title = title + " (recovery mode)"
247
kernels_found.append(grubconfig_backend.menu_item(title,
248
{
249
'root': disks.get_root_partition().grub_device,
250
'kernel': [kernel, "root="+disks.get_root_partition().uuid, "ro", "single"],
251
'initrd': kernel[:kernel.find("vmlinuz")]+"initrd.img"+kernel[len("vmlinuz")+kernel.find("vmlinuz"):]
252
}))
253
elif kernel.find("memtest") != -1:
254
title = "memtest86"
255
kernels_found.append(grubconfig_backend.menu_item(title,
256
{
257
'root': disks.get_root_partition().grub_device,
258
'kernel': kernel
259
}))
260
261
return kernels_found
262
263
def remove_existing_kernels(self, kernels_found):
264
remaining_kernels = []
265
for found in kernels_found:
266
for kernel in self.gcb.kernelslist:
267
if 'kernel' in kernel.main_options and 'kernel' in found.main_options:
268
if type(kernel.main_options['kernel']) == type("") and type(found.main_options['kernel']) == type(""):
269
if kernel.main_options['kernel'] == found.main_options['kernel'] \
270
and kernel.main_options['root'] == found.main_options['root']:
271
remaining_kernels.append(found)
272
elif type(kernel.main_options['kernel']) == type(""):
273
if kernel.main_options['kernel'] == found.main_options['kernel'][0] \
274
and kernel.main_options['root'] == found.main_options['root']:
275
remaining_kernels.append(found)
276
elif type(found.main_options['kernel']) == type(""):
277
if kernel.main_options['kernel'][0] == found.main_options['kernel'] \
278
and kernel.main_options['root'] == found.main_options['root']:
279
del kernels_found[i]
280
elif kernel.main_options['kernel'][0] == found.main_options['kernel'][0] \
281
and kernel.main_options['root'] == found.main_options['root'] \
282
and 'single' in kernel.main_options['kernel'] \
283
and 'single' in found.main_options['kernel']:
284
remaining_kernels.append(found)
285
elif kernel.main_options['kernel'][0] == found.main_options['kernel'][0] \
286
and kernel.main_options['root'] == found.main_options['root'] \
287
and 'single' not in kernel.main_options['kernel'] \
288
and 'single' not in found.main_options['kernel']:
289
remaining_kernels.append(found)
290
291
else:
292
if kernel.main_options['root'] == found.main_options['root']:
293
remaining_kernels.append(found)
294
295
for remaining in remaining_kernels:
296
i=0
297
for found in kernels_found:
298
if remaining == found:
299
del kernels_found[i]
300
i=i+1
301
return kernels_found
302
303
304
class BootloaderManagerUI:
305
306
SIMPLE = 0
307
ADVANCED = 1
308
MODE = -1
309
310
def __init__(self):
311
#the color for the menu
312
self.colors = {
313
"black":0x000000ffL,
314
"blue":0x0000ffffL,
315
"green":0x00ff00ffL,
316
"cyan":0x00ffffffL,
317
"red":0xff0000ffL,
318
"magenta":0xff00ffffL,
319
"brown":0x8b4513ffL,
320
"light-gray":0xaaaaaaffL
321
}
322
self.colors_foreground_only = {
323
"dark-gray":0x555555ffL,
324
"light-blue":0x7f7fffffL,
325
"light-green":0x7fff7fffL,
326
"light-cyan":0x7fffffffL,
327
"light-red":0xff7f7fffL,
328
"light-magenta":0xff7fffffL,
329
"yellow":0xffff00ffL,
330
"white":0xffffffffL
331
}
332
333
self.gc = GrubConfig()
334
self.d = Disks()
335
self.d.partition_grub_installed()
336
self.mount_point = self.d.mount_partition()
337
if self.mount_point is None:
338
show_error_dialog(_("Grub aren't instaled in system"))
339
self.umount_partition()
340
sys.exit(1)
341
342
#ubuntu specific
343
self.filename = self.mount_point+"/boot/grub/menu.lst"
344
self.gc.load(self.filename)
345
346
#Set the Glade file
347
self.wTree = gtk.glade.XML(GLADE_FILE, "mainWindow")
348
349
self.wTree.signal_autoconnect(self)
350
351
#get widgets
352
self.menubar = self.wTree.get_widget("menubar")
353
self.main_notebook = self.wTree.get_widget("main_notebook")
354
self.load_last_cfg = self.wTree.get_widget("load_last_cfg")
355
self.rd_simple_mode = self.wTree.get_widget("rd_simple_mode")
356
self.rd_advanced_mode = self.wTree.get_widget("rd_advanced_mode")
357
self.show_menu = self.wTree.get_widget("show_menu")
358
self.use_home = self.wTree.get_widget("use_home")
359
self.os_list = self.wTree.get_widget("lst_os")
360
self.btn_edit = self.wTree.get_widget("btn_edit")
361
self.spin_timeout = self.wTree.get_widget("spin_timeout")
362
self.main_button_box = self.wTree.get_widget("main_button_box")
363
self.preview_box = self.wTree.get_widget("preview_box")
364
self.cmb_nf_color = self.wTree.get_widget("cmb_nf_color")
365
self.cmb_nb_color = self.wTree.get_widget("cmb_nb_color")
366
self.cmb_hf_color = self.wTree.get_widget("cmb_hf_color")
367
self.cmb_hb_color = self.wTree.get_widget("cmb_hb_color")
368
self.chk_nf_blink_color = self.wTree.get_widget("chk_nf_blink_color")
369
self.chk_hf_blink_color = self.wTree.get_widget("chk_hf_blink_color")
370
self.chk_invert_color = self.wTree.get_widget("chk_invert_color")
371
self.frame_higlight_colors = self.wTree.get_widget("frame_higlight_colors")
372
self.chk_background_image = self.wTree.get_widget("chk_background_image")
373
self.btn_background_image = self.wTree.get_widget("btn_background_image")
374
self.password_locked = self.wTree.get_widget("password_locked")
375
self.pass_msg_error = self.wTree.get_widget("pass_msg_error")
376
self.en_password = self.wTree.get_widget("en_password")
377
self.en_rpassword = self.wTree.get_widget("en_rpassword")
378
#edit
379
self.os_detected_list = self.wTree.get_widget("os_detected")
380
self.back_save_edit = self.wTree.get_widget("back_save_edit")
381
self.cancel_edit = self.wTree.get_widget("cancel_edit")
382
self.en_title_edit = self.wTree.get_widget("en_title_edit")
383
self.exp_device_edit = self.wTree.get_widget("exp_device_edit")
384
self.cmb_device_edit = self.wTree.get_widget("cmb_device_edit")
385
self.cmb_kernel_edit = self.wTree.get_widget("cmb_kernel_edit")
386
self.exp_kernel_fl_edit = self.wTree.get_widget("exp_kernel_fl_edit")
387
self.btn_kernel_fl_edit = self.wTree.get_widget("btn_kernel_fl_edit")
388
self.exp_kernel_ops_edit = self.wTree.get_widget("exp_kernel_ops_edit")
389
self.notebook_kernel_type_edit = self.wTree.get_widget("notebook_kernel_type_edit")
390
self.en_root_linux_edit = self.wTree.get_widget("en_root_linux_edit")
391
self.chk_ro_edit = self.wTree.get_widget("chk_ro_edit")
392
self.chk_quiet_edit = self.wTree.get_widget("chk_quiet_edit")
393
self.chk_debug_edit = self.wTree.get_widget("chk_debug_edit")
394
self.chk_splash_image_edit = self.wTree.get_widget("chk_splash_image_edit")
395
self.chk_acpi_edit = self.wTree.get_widget("chk_acpi_edit")
396
self.chk_single_edit = self.wTree.get_widget("chk_single_edit")
397
self.en_locale_edit = self.wTree.get_widget("en_locale_edit")
398
self.en_other_ops_edit = self.wTree.get_widget("en_other_ops_edit")
399
self.exp_sec_edit = self.wTree.get_widget("exp_sec_edit")
400
self.chk_lock_edit = self.wTree.get_widget("chk_lock_edit")
401
self.en_kernel_ops_edit = self.wTree.get_widget("en_kernel_ops_edit")
402
self.en_password_edit = self.wTree.get_widget("en_password_edit")
403
self.en_rpassword_edit = self.wTree.get_widget("en_rpassword_edit")
404
self.pass_msg_error_edit = self.wTree.get_widget("pass_msg_error_edit")
405
#edit
406
self.notebook_add_os = self.wTree.get_widget("notebook_add_os")
407
self.next_add = self.wTree.get_widget("next_add")
408
self.back_add = self.wTree.get_widget("back_add")
409
self.finish_add = self.wTree.get_widget("finish_add")
410
self.cancel_add = self.wTree.get_widget("cancel_add")
411
self.rd_linux = self.wTree.get_widget("rd_linux")
412
self.rd_multi = self.wTree.get_widget("rd_multi")
413
self.rd_non_multi = self.wTree.get_widget("rd_non_multi")
414
self.en_title_add = self.wTree.get_widget("en_title_add")
415
self.exp_device_add = self.wTree.get_widget("exp_device_add")
416
self.cmb_device_add = self.wTree.get_widget("cmb_device_add")
417
self.cmb_kernel_add = self.wTree.get_widget("cmb_kernel_add")
418
self.exp_kernel_fl_add = self.wTree.get_widget("exp_kernel_fl_add")
419
self.btn_kernel_fl_add = self.wTree.get_widget("btn_kernel_fl_add")
420
self.exp_kernel_ops_add = self.wTree.get_widget("exp_kernel_ops_add")
421
self.notebook_kernel_type_add = self.wTree.get_widget("notebook_kernel_type_add")
422
self.en_root_linux_add = self.wTree.get_widget("en_root_linux_add")
423
self.chk_ro_add = self.wTree.get_widget("chk_ro_add")
424
self.chk_quiet_add = self.wTree.get_widget("chk_quiet_add")
425
self.chk_debug_add = self.wTree.get_widget("chk_debug_add")
426
self.chk_splash_image_add = self.wTree.get_widget("chk_splash_image_add")
427
self.chk_acpi_add = self.wTree.get_widget("chk_acpi_add")
428
self.chk_single_add = self.wTree.get_widget("chk_single_add")
429
self.en_locale_add = self.wTree.get_widget("en_locale_add")
430
self.en_other_ops_add = self.wTree.get_widget("en_other_ops_add")
431
self.exp_sec_add = self.wTree.get_widget("exp_sec_add")
432
self.chk_lock_add = self.wTree.get_widget("chk_lock_add")
433
self.en_kernel_ops_add = self.wTree.get_widget("en_kernel_ops_add")
434
self.en_password_add = self.wTree.get_widget("en_password_add")
435
self.en_rpassword_add = self.wTree.get_widget("en_rpassword_add")
436
self.pass_msg_error_add = self.wTree.get_widget("pass_msg_error_add")
437
438
self.os_list_store = gtk.ListStore('gboolean', str, 'gboolean')
439
440
# OS list
441
self.os_list.set_model(self.os_list_store)
442
renderer=gtk.CellRendererToggle()
443
renderer.set_property('activatable', True)
444
renderer.set_property('radio', True)
445
renderer.connect( 'toggled', self.toggle_os_default, self.os_list_store)
446
column = gtk.TreeViewColumn(_("Default"),renderer , active=0)
447
self.os_list.append_column(column)
448
renderer = gtk.CellRendererText()
449
renderer.set_property('editable', True)
450
renderer.connect('edited', self.edited_title, self.os_list_store)
451
column = gtk.TreeViewColumn(_("Title"), renderer, text=1)
452
self.os_list.append_column(column)
453
renderer=gtk.CellRendererToggle()
454
renderer.set_property('activatable', True)
455
renderer.connect( 'toggled', self.toggle_os_active, self.os_list_store)
456
column = gtk.TreeViewColumn(_("Active"),renderer , active=2)
457
self.os_list.append_column(column)
458
459
self.os_detected_store = gtk.ListStore(str, str)
460
461
# OS detected list
462
self.os_detected_list.set_model(self.os_detected_store)
463
renderer = gtk.CellRendererText()
464
column = gtk.TreeViewColumn(_("Name"),renderer , text=0)
465
self.os_detected_list.append_column(column)
466
column = gtk.TreeViewColumn(_("Device"), renderer, text=1)
467
self.os_detected_list.append_column(column)
468
469
470
#combobox device store
471
self.device_store = gtk.ListStore(str)
472
for partition in self.d.partitions:
473
self.device_store.append([partition.device])
474
475
#combobox device edit
476
self.cmb_device_edit.set_model(self.device_store)
477
cell = gtk.CellRendererText()
478
self.cmb_device_edit.pack_start(cell, True)
479
self.cmb_device_edit.add_attribute(cell, 'text', 0)
480
481
#combobox device add
482
self.cmb_device_add.set_model(self.device_store)
483
cell = gtk.CellRendererText()
484
self.cmb_device_add.pack_start(cell, True)
485
self.cmb_device_add.add_attribute(cell, 'text', 0)
486
487
#combobox kernel file store
488
self.kernel_file_store = gtk.ListStore(str)
489
for kernel in glob.glob('/boot/vmlinuz-*')+glob.glob('/boot/memtest*'):
490
self.kernel_file_store.append([kernel])
491
492
#combobox kernel file edit
493
self.cmb_kernel_edit.set_model(self.kernel_file_store)
494
cell = gtk.CellRendererText()
495
self.cmb_kernel_edit.pack_start(cell, True)
496
self.cmb_kernel_edit.add_attribute(cell, 'text', 0)
497
498
#combobox kernel file add
499
self.cmb_kernel_add.set_model(self.kernel_file_store)
500
cell = gtk.CellRendererText()
501
self.cmb_kernel_add.pack_start(cell, True)
502
self.cmb_kernel_add.add_attribute(cell, 'text', 0)
503
504
505
506
#colors
507
self.cmb_color_f_store = gtk.ListStore(gtk.gdk.Pixbuf, str)
508
self.cmb_color_b_store = gtk.ListStore(gtk.gdk.Pixbuf, str)
509
self.cmb_nf_color.set_model(self.cmb_color_f_store)
510
self.cmb_nb_color.set_model(self.cmb_color_b_store)
511
self.cmb_hf_color.set_model(self.cmb_color_f_store)
512
self.cmb_hb_color.set_model(self.cmb_color_b_store)
513
self.fill_cmb_store(self.cmb_color_f_store, self.colors)
514
self.fill_cmb_store(self.cmb_color_f_store, self.colors_foreground_only)
515
self.fill_cmb_store(self.cmb_color_b_store, self.colors)
516
self.add_cells(self.cmb_nf_color)
517
self.add_cells(self.cmb_nb_color)
518
self.add_cells(self.cmb_hf_color)
519
self.add_cells(self.cmb_hb_color)
520
521
#preview
522
self.preview = Preview()
523
self.preview.gc = self.gc
524
self.preview.mount_point = self.mount_point
525
526
self.apply_setting_to_gui()
527
528
self.preview_box.pack_start(self.preview, True, True, 0)
529
self.preview.set_property('height-request', 315)
530
self.preview.set_property('width-request', 570)
531
self.preview.show()
532
533
if not os.path.exists(self.filename+'~'):
534
self.load_last_cfg.set_sensitive(False)
535
536
if self.rd_simple_mode.get_active():
537
self.btn_edit.hide()
538
self.MODE = self.SIMPLE
539
else:
540
self.btn_edit.show()
541
self.MODE = self.ADVANCED
542
543
if self.use_home.get_active():
544
self.filename = os.environ['HOME']+"/.menu.lst"
545
546
def apply_setting_to_gui(self):
547
548
# kernels list
549
self.os_list_store.clear()
550
i = 0
551
for kernel in self.gc.get_oslist():
552
if i==self.gc.get_default():
553
self.os_list_store.append([True, kernel.title, not kernel.commented])
554
else:
555
self.os_list_store.append([False, kernel.title, not kernel.commented])
556
i=i+1
557
558
#hiddenmenu
559
if self.gc.hiddenmenu():
560
self.show_menu.set_active(False)
561
else:
562
self.show_menu.set_active(True)
563
564
#timeout
565
self.spin_timeout.set_value(self.gc.get_timeout())
566
567
#passwords
568
if self.gc.has_password():
569
self.en_password.set_text("********")
570
self.en_rpassword.set_text("********")
571
self.password_locked.set_active(True)
572
573
#color
574
colors, blink = self.gc.get_colors()
575
if len (colors) <2:
576
self.set_active_cmb_color(self.cmb_nf_color, 'white')
577
self.set_active_cmb_color(self.cmb_nb_color, 'black')
578
if len(colors) >= 2:
579
self.set_active_cmb_color(self.cmb_nf_color, colors[0])
580
self.set_active_cmb_color(self.cmb_nb_color, colors[1])
581
if len(colors) == 4:
582
self.set_active_cmb_color(self.cmb_hf_color, colors[2])
583
self.set_active_cmb_color(self.cmb_hb_color, colors[3])
584
if len (colors) <=2:
585
self.chk_invert_color.set_active(True)
586
if 'normal' in blink:
587
self.chk_nf_blink_color.set_active(True)
588
if 'highlight' in blink:
589
self.chk_hf_blink_color.set_active(True)
590
591
#splashimage
592
if self.gc.get_splash_image() == "":
593
self.chk_background_image.set_active(False)
594
self.btn_background_image.set_sensitive(False)
595
596
def add_cells(self, cmb_box):
597
cell = gtk.CellRendererPixbuf()
598
cmb_box.pack_start(cell)
599
cmb_box.add_attribute(cell,'pixbuf',0)
600
601
def fill_cmb_store(self, store, color_list):
602
for color_name in color_list.keys():
603
pix = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,True,8,24,16)
604
pix.fill(color_list[color_name])
605
store.append([pix, color_name])
606
607
def set_active_cmb_color(self, cmb_box, color):
608
for i in range(len(cmb_box.get_model())):
609
if(cmb_box.get_model()[i][1]==color):
610
cmb_box.set_active(i)
611
612
def open_new_configuration(self, widget):
613
filename=FileDialogs().open_file_dialog(_("Select a configuration file ..."), "*", _("Grub config file"))
614
if filename == "":
615
return None
616
self.gc.load(filename)
617
self.apply_setting_to_gui()
618
619
def save_configuration(self, widget):
620
filename=FileDialogs().save_file_dialog(_("Select a name for the configuration file ..."), "*", _("Grub config file"))
621
if filename == "":
622
return None
623
if not self.gc.save(filename):
624
show_error_dialog(str(self.gc.save_error))
625
626
def load_last_configuration(self, widget):
627
self.gc.load(self.filename+'~')
628
self.apply_setting_to_gui()
629
630
def quit_save(self, widget):
631
if not self.gc.save(self.filename):
632
show_error_dialog(str(self.gc.save_error))
633
self.d.umount_partition()
634
quit(widget)
635
636
def quit(self, widget):
637
self.d.umount_partition()
638
gtk.main_quit()
639
sys.exit(0)
640
641
def mode_changed(self, widget):
642
if self.rd_simple_mode.get_active():
643
self.btn_edit.hide()
644
self.MODE = self.SIMPLE
645
else:
646
self.btn_edit.show()
647
self.MODE = self.ADVANCED
648
649
def toggle_menu(self, widget):
650
if self.show_menu.get_active():
651
self.gc.set_hiddenmenu(False)
652
else:
653
self.gc.set_hiddenmenu(True)
654
655
def toggle_user_home(self, widget):
656
if self.use_home.get_active():
657
self.filename = os.environ['HOME']+"/.menu.lst"
658
else:
659
self.filename = self.mount_point+"/boot/grub/menu.lst"
660
661
def os_up(self, widget):
662
selection = self.os_list.get_selection()
663
model, iter = selection.get_selected()
664
iter_path=self.os_list_store.get_path(iter)
665
if iter_path == (0,):
666
return None
667
new_iter=self.os_list_store.get_iter(iter_path[0]-1)
668
self.os_list_store.move_before(iter,new_iter)
669
if self.os_list_store[iter_path[0]-1][0]==True:
670
self.gc.set_default(iter_path[0]-1)
671
self.gc.swap_os(iter_path[0],iter_path[0]-1)
672
673
def os_down(self, widget):
674
selection = self.os_list.get_selection()
675
model, iter = selection.get_selected()
676
iter_path=self.os_list_store.get_path(iter)
677
if iter_path[0] == len(self.os_list_store)-1:
678
return None
679
new_iter=self.os_list_store.get_iter(iter_path[0]+1)
680
self.os_list_store.move_after(iter,new_iter)
681
if self.os_list_store[iter_path[0]+1][0]==True:
682
self.gc.set_default(iter_path[0]+1)
683
self.gc.swap_os(iter_path[0],iter_path[0]+1)
684
685
def toggle_os_default(self, cell, path, list_store):
686
list_store[self.gc.get_default()][0] = False
687
list_store[path][0] = not list_store[path][0]
688
self.gc.set_default(int(path))
689
690
def toggle_os_active(self, cell, path, list_store):
691
kernel = self.gc.get_oslist()[int(path)]
692
if list_store[path][2]:
693
kernel.commented = 2
694
else:
695
kernel.commented = 0
696
self.gc.set_os(kernel, int(path))
697
list_store[path][2] = not list_store[path][2]
698
699
def edited_title(self, cell, path, new_text, list_store):
700
path = int(path)
701
list_store[path][1] = new_text
702
kernel = self.gc.get_oslist()[path]
703
kernel.title = new_text
704
self.gc.set_os(kernel,path)
705
self.gc.set_default(path)
706
707
def add_os(self, widget):
708
self.menubar.hide()
709
self.main_button_box.hide()
710
self.main_notebook.set_current_page(2)
711
self.notebook_add_os.set_current_page(0)
712
self.next_add.hide()
713
self.back_add.hide()
714
self.finish_add.hide()
715
self.cancel_add.show()
716
self.os_detected = []
717
self.os_detected = self.gc.os_prober()
718
self.os_detected = self.gc.remove_existing_kernels(self.os_detected)
719
self.os_detected_store.clear()
720
if len(self.os_detected)>0:
721
for kernel in self.os_detected:
722
self.os_detected_store.append([kernel.title, self.d.get_device(kernel.main_options['root']).device])
723
self.next_add.show()
724
else:
725
self.os_detected_store.append([_("There is no operating system detected"), ""])
726
if self.MODE == self.ADVANCED:
727
self.os_detected_store.append([_("Add another not listed"), ""])
728
self.next_add.show()
729
730
731
def next_add_clicked(self, widget):
732
if self.notebook_add_os.get_current_page() == 0:
733
selection = self.os_detected_list.get_selection()
734
model, iter = selection.get_selected()
735
iter_path=self.os_detected_store.get_path(iter)
736
if iter_path[0] == len(self.os_detected_store)-1 and self.MODE == self.ADVANCED:
737
self.reset_add()
738
self.notebook_add_os.set_current_page(1)
739
else:
740
self.reset_add()
741
self.apply_kernel_add(self.os_detected[iter_path[0]])
742
self.notebook_add_os.set_current_page(2)
743
if self.MODE == self.SIMPLE:
744
self.exp_kernel_fl_add.hide()
745
self.exp_kernel_ops_add.hide()
746
self.exp_device_add.hide()
747
self.exp_sec_add.hide()
748
self.back_add.show()
749
elif self.notebook_add_os.get_current_page() == 1:
750
self.back_add.show()
751
if self.rd_linux.get_active():
752
self.notebook_kernel_type_add.set_current_page(0)
753
elif self.rd_multi.get_active():
754
self.notebook_kernel_type_add.set_current_page(1)
755
elif self.rd_non_multi.get_active():
756
self.exp_kernel_fl_add.hide()
757
self.exp_kernel_ops_add.hide()
758
self.reset_add()
759
self.notebook_add_os.set_current_page(2)
760
elif self.notebook_add_os.get_current_page() == 2:
761
self.finish_add.show()
762
self.next_add.hide()
763
self.back_add.hide()
764
self.cancel_add.hide()
765
kernel = self.get_kernel_added()
766
self.gc.new_os(kernel)
767
self.os_list_store.append([False, kernel.title, not kernel.commented])
768
self.notebook_add_os.set_current_page(3)
769
770
def back_add_clicked(self, widget):
771
if self.notebook_add_os.get_current_page() == 1:
772
self.back_add.hide()
773
self.notebook_add_os.set_current_page(0)
774
elif self.notebook_add_os.get_current_page() == 2:
775
if self.MODE == self.ADVANCED:
776
self.back_add.show()
777
self.notebook_add_os.set_current_page(1)
778
else:
779
self.back_add.hide()
780
self.notebook_add_os.set_current_page(0)
781
782
def cancel_clicked(self, widget):
783
self.menubar.show()
784
self.main_button_box.show()
785
self.main_notebook.set_current_page(0)
786
787
def toggle_password_add(self, widget):
788
if not self.chk_lock_add.get_active():
789
self.en_password_add.set_text("")
790
self.en_rpassword_add.set_text("")
791
792
def passwords_changed_add(self, widget):
793
if self.en_password_add.get_text()!=self.en_rpassword_add.get_text():
794
self.pass_msg_error_add.show()
795
if self.en_password_add.get_text()==self.en_rpassword_add.get_text()!="":
796
self.pass_msg_error_add.hide()
797
self.chk_lock_add.set_active(True)
798
if self.en_rpassword_add.get_text()=="":
799
self.pass_msg_error_add.hide()
800
801
def reset_add(self):
802
self.en_title_add.set_text("")
803
self.cmb_device_add.set_active(-1)
804
self.cmb_kernel_add.set_active(-1)
805
self.exp_kernel_fl_add.show()
806
self.exp_kernel_ops_add.show()
807
self.exp_device_add.show()
808
self.exp_sec_add.show()
809
self.en_root_linux_add.set_text("")
810
self.chk_ro_add.set_active(False)
811
self.chk_quiet_add.set_active(False)
812
self.chk_debug_add.set_active(False)
813
self.chk_single_add.set_active(False)
814
self.chk_splash_image_add.set_active(False)
815
self.chk_acpi_add.set_active(False)
816
self.en_locale_add.set_text("")
817
self.en_other_ops_add.set_text("")
818
self.en_kernel_ops_add.set_text("")
819
self.chk_lock_add.set_active(False)
820
self.en_password_add.set_text("")
821
self.en_rpassword_add.set_text("")
822
self.chk_lock_add.set_active(False)
823
824
825
def apply_kernel_add(self, kernel):
826
self.en_title_add.set_text(kernel.title)
827
device = self.d.get_device(kernel.main_options['root']).device
828
for i in range(len(self.device_store)):
829
if self.device_store[i][0] == device:
830
self.cmb_device_add.set_active(i)
831
if 'kernel' in kernel.main_options.keys():
832
if type(kernel.main_options['kernel'])== type(""):
833
kernel_file = kernel.main_options['kernel']
834
else:
835
kernel_file = kernel.main_options['kernel'][0]
836
position = -1
837
for i in range(len(self.kernel_file_store)):
838
if self.kernel_file_store[i][0] == kernel_file:
839
position = i
840
if position == -1:
841
self.device_store.append(kernel_file)
842
self.cmb_kernel_add.set_active(len(self.device_store)-1)
843
else:
844
self.cmb_kernel_add.set_active(position)
845
if kernel_file.find("vmlinuz") != -1:
846
self.notebook_kernel_type_add.set_current_page(0)
847
other_options = ""
848
self.chk_acpi_add.set_active(True)
849
for option in kernel.main_options['kernel']:
850
if option.startswith('root='):
851
self.en_root_linux_add.set_text(option[5:])
852
elif option=='ro':
853
self.chk_ro_add.set_active(True)
854
elif option=='quiet':
855
self.chk_quiet_add.set_active(True)
856
elif option=='debug':
857
self.chk_debug_add.set_active(True)
858
elif option=='single':
859
self.chk_single_add.set_active(True)
860
elif option=='splash':
861
self.chk_splash_image_add.set_active(True)
862
elif option==('acpi=off'):
863
self.chk_acpi_add.set_active(False)
864
elif option.startswith('locale='):
865
self.en_locale_add.set_text(option[7:])
866
elif option is not kernel.main_options['kernel'][0]:
867
other_options = other_options + " " + option
868
self.en_other_ops_add.set_text(other_options)
869
else:
870
self.notebook_kernel_type_add.set_current_page(1)
871
options = ''
872
if type(kernel.main_options['kernel'])==type([]):
873
for option in kernel.main_options['kernel']:
874
if option is not kernel.main_options['kernel'][0]:
875
options = options + " " + option
876
self.en_kernel_ops_add.set_text(options)
877
else:
878
self.exp_kernel_fl_add.hide()
879
self.exp_kernel_ops_add.hide()
880
if 'lock' in kernel.other_options.keys():
881
self.chk_lock_add.set_active(True)
882
if 'password' in kernel.other_options.keys():
883
self.en_password_add.set_text("********")
884
self.en_rpassword_add.set_text("********")
885
self.chk_lock_add.set_active(True)
886
887
def get_kernel_added(self):
888
kernel_options = {}
889
kernel_title=self.en_title_add.get_text()
890
891
if(self.chk_lock_add.get_active() and self.en_password_add.get_text()==self.en_rpassword_add.get_text()==""):
892
kernel_options['lock']=None
893
894
if self.en_password_add.get_text()==self.en_rpassword_add.get_text()!="********" \
895
and self.en_password_add.get_text()==self.en_rpassword_add.get_text()!="":
896
kernel_options['password'] = ['--md5', generate_grub_password(self.en_password_add.get_text())]
897
898
kernel_options['root'] = self.d.get_grub_partition(self.device_store[self.cmb_device_add.get_active()][0]).grub_device
899
900
if self.exp_kernel_fl_add.get_property("visible"):
901
if self.notebook_kernel_type_add.get_current_page() == 0:
902
kernel_options['kernel'] = []
903
904
kernel_options['kernel'].append(self.kernel_file_store[self.cmb_kernel_add.get_active()][0])
905
906
if os.path.exists(kernel_options['kernel'][0].replace("vmlinuz","initrd.img")):
907
kernel_options['initrd'] = kernel_options['kernel'][0].replace("vmlinuz","initrd.img")
908
909
kernel_options['kernel'].append('root='+self.en_root_linux_add.get_text())
910
if self.chk_ro_add.get_active():
911
kernel_options['kernel'].append('ro')
912
if self.chk_quiet_add.get_active():
913
kernel_options['kernel'].append('quiet')
914
if self.chk_debug_add.get_active():
915
kernel_options['kernel'].append('debug')
916
if self.chk_single_add.get_active():
917
kernel_options['kernel'].append('single')
918
if self.chk_splash_image_add.get_active():
919
kernel_options['kernel'].append('splash')
920
if self.chk_acpi_add.get_active()==False:
921
kernel_options['kernel'].append('acpi=off')
922
if(self.en_locale_add.get_text().strip()!=""):
923
kernel_options['kernel'].append('locale=' + self.en_locale.get_text().strip())
924
if(self.en_other_ops_add.get_text().strip()!=""):
925
for option in self.en_other_ops_add.get_text().strip().split():
926
kernel_options['kernel'].append(option.strip())
927
928
else:
929
930
if self.en_kernel_ops_add.get_text().strip() == '':
931
kernel_options['kernel'] = self.kernel_file_store[self.cmb_kernel_add.get_active()][0]
932
else:
933
kernel_options['kernel'] = []
934
kernel_options['kernel'].append(self.kernel_file_store[self.cmb_kernel_add.get_active()][0])
935
for option in self.en_kernel_ops_add.get_text().split():
936
kernel_options['kernel'].append(option.strip())
937
938
else:
939
kernel_options['makeactive'] = None
940
kernel_options['chainloader'] = '+1'
941
942
if "kernel" in kernel_options and "quiet" in kernel_options['kernel']:
943
kernel_options['quiet'] = None
944
kernel = grubconfig_backend.menu_item(kernel_title, kernel_options)
945
return kernel
946
947
def btn_kernel_fl_add_clicked(self, widget):
948
filename=FileDialogs().open_file_dialog(_("Select a kernel file ..."), "*", _("kernel file"))
949
if filename == "":
950
return None
951
position = -1
952
for i in range(len(self.kernel_file_store)):
953
if self.kernel_file_store[i][0] == filename:
954
position = i
955
if position == -1:
956
self.device_store.append(filename)
957
self.cmb_kernel_add.set_active(len(self.device_store)-1)
958
else:
959
self.cmb_kernel_add.set_active(position)
960
961
def remove_os(self, widget):
962
selection = self.os_list.get_selection()
963
model, iter = selection.get_selected()
964
iter_path=self.os_list_store.get_path(iter)
965
self.gc.del_os(iter_path[0])
966
self.os_list_store.remove(iter)
967
if len(self.os_list_store)>0:
968
self.os_list_store[self.gc.get_default()][0] = True
969
970
def edit_os(self, widget):
971
self.menubar.hide()
972
self.main_button_box.hide()
973
self.main_notebook.set_current_page(1)
974
selection = self.os_list.get_selection()
975
model, iter = selection.get_selected()
976
iter_path=self.os_list_store.get_path(iter)
977
self.reset_edit()
978
kernel = self.gc.get_oslist()[iter_path[0]]
979
self.apply_kernel_edit(kernel)
980
981
def back_save_edit_clicked(self, widget):
982
selection = self.os_list.get_selection()
983
model, iter = selection.get_selected()
984
iter_path=self.os_list_store.get_path(iter)
985
kernel = self.get_kernel_edited()
986
self.gc.set_os(kernel, iter_path[0])
987
self.os_list_store[iter_path[0]][0] = False
988
self.os_list_store[iter_path[0]][1] = kernel.title
989
self.menubar.show()
990
self.main_button_box.show()
991
self.main_notebook.set_current_page(0)
992
993
def toggle_password_edit(self, widget):
994
if not self.chk_lock_edit.get_active():
995
self.en_password_edit.set_text("")
996
self.en_rpassword_edit.set_text("")
997
998
def passwords_changed_edit(self, widget):
999
if self.en_password_edit.get_text()!=self.en_rpassword_edit.get_text():
1000
self.pass_msg_error_edit.show()
1001
if self.en_password_edit.get_text()==self.en_rpassword_edit.get_text()!="":
1002
self.pass_msg_error_edit.hide()
1003
self.chk_lock_edit.set_active(True)
1004
if self.en_rpassword_edit.get_text()=="":
1005
self.pass_msg_error_edit.hide()
1006
1007
def reset_edit(self):
1008
self.en_title_edit.set_text("")
1009
self.cmb_device_edit.set_active(-1)
1010
self.cmb_kernel_edit.set_active(-1)
1011
self.exp_kernel_fl_edit.show()
1012
self.exp_kernel_ops_edit.show()
1013
self.en_root_linux_edit.set_text("")
1014
self.chk_ro_edit.set_active(False)
1015
self.chk_quiet_edit.set_active(False)
1016
self.chk_debug_edit.set_active(False)
1017
self.chk_single_edit.set_active(False)
1018
self.chk_splash_image_edit.set_active(False)
1019
self.chk_acpi_edit.set_active(False)
1020
self.en_locale_edit.set_text("")
1021
self.en_other_ops_edit.set_text("")
1022
self.en_kernel_ops_edit.set_text("")
1023
self.chk_lock_edit.set_active(False)
1024
self.en_password_edit.set_text("")
1025
self.en_rpassword_edit.set_text("")
1026
self.chk_lock_edit.set_active(False)
1027
1028
1029
def apply_kernel_edit(self, kernel):
1030
self.en_title_edit.set_text(kernel.title)
1031
device = self.d.get_device(kernel.main_options['root']).device
1032
for i in range(len(self.device_store)):
1033
if self.device_store[i][0] == device:
1034
self.cmb_device_edit.set_active(i)
1035
if 'kernel' in kernel.main_options.keys():
1036
if type(kernel.main_options['kernel'])== type(""):
1037
kernel_file = kernel.main_options['kernel']
1038
else:
1039
kernel_file = kernel.main_options['kernel'][0]
1040
position = -1
1041
for i in range(len(self.kernel_file_store)):
1042
if self.kernel_file_store[i][0] == kernel_file:
1043
position = i
1044
if position == -1:
1045
self.device_store.append(kernel_file)
1046
self.cmb_kernel_edit.set_active(len(self.device_store)-1)
1047
else:
1048
self.cmb_kernel_edit.set_active(position)
1049
if kernel_file.find("vmlinuz") != -1:
1050
self.notebook_kernel_type_edit.set_current_page(0)
1051
other_options = ""
1052
self.chk_acpi_edit.set_active(True)
1053
for option in kernel.main_options['kernel']:
1054
if option.startswith('root='):
1055
self.en_root_linux_edit.set_text(option[5:])
1056
elif option=='ro':
1057
self.chk_ro_edit.set_active(True)
1058
elif option=='quiet':
1059
self.chk_quiet_edit.set_active(True)
1060
elif option=='debug':
1061
self.chk_debug_edit.set_active(True)
1062
elif option=='single':
1063
self.chk_single_edit.set_active(True)
1064
elif option=='splash':
1065
self.chk_splash_image_edit.set_active(True)
1066
elif option==('acpi=off'):
1067
self.chk_acpi_edit.set_active(False)
1068
elif option.startswith('locale='):
1069
self.en_locale_edit.set_text(option[7:])
1070
elif option is not kernel.main_options['kernel'][0]:
1071
other_options = other_options + " " + option
1072
self.en_other_ops_edit.set_text(other_options)
1073
else:
1074
self.notebook_kernel_type_edit.set_current_page(1)
1075
options = ''
1076
if type(kernel.main_options['kernel'])==type([]):
1077
for option in kernel.main_options['kernel']:
1078
if option is not kernel.main_options['kernel'][0]:
1079
options = options + " " + option
1080
self.en_kernel_ops_edit.set_text(options)
1081
else:
1082
self.exp_kernel_fl_edit.hide()
1083
self.exp_kernel_ops_edit.hide()
1084
if 'lock' in kernel.other_options.keys():
1085
self.chk_lock_edit.set_active(True)
1086
if 'password' in kernel.other_options.keys():
1087
self.en_password_edit.set_text("********")
1088
self.en_rpassword_edit.set_text("********")
1089
self.chk_lock_edit.set_active(True)
1090
1091
def get_kernel_edited(self):
1092
kernel_options = {}
1093
kernel_title=self.en_title_edit.get_text()
1094
1095
if self.chk_lock_edit.get_active() \
1096
and self.en_password_edit.get_text()==self.en_rpassword_edit.get_text()=="":
1097
kernel_options['lock']=None
1098
1099
if self.en_password_edit.get_text()==self.en_rpassword_edit.get_text()!="********" \
1100
and self.en_password_edit.get_text()==self.en_rpassword_edit.get_text()!="":
1101
kernel_options['password'] = ['--md5', generate_grub_password(self.en_password_edit.get_text())]
1102
1103
kernel_options['root'] = self.d.get_grub_partition(self.device_store[self.cmb_device_edit.get_active()][0]).grub_device
1104
1105
if self.exp_kernel_fl_edit.get_property("visible"):
1106
if self.notebook_kernel_type_edit.get_current_page() == 0:
1107
kernel_options['kernel'] = []
1108
1109
kernel_options['kernel'].append(self.kernel_file_store[self.cmb_kernel_edit.get_active()][0])
1110
1111
if os.path.exists(kernel_options['kernel'][0].replace("vmlinuz","initrd.img")):
1112
kernel_options['initrd'] = kernel_options['kernel'][0].replace("vmlinuz","initrd.img")
1113
1114
kernel_options['kernel'].append('root='+self.en_root_linux_edit.get_text())
1115
if self.chk_ro_edit.get_active():
1116
kernel_options['kernel'].append('ro')
1117
if self.chk_quiet_edit.get_active():
1118
kernel_options['kernel'].append('quiet')
1119
if self.chk_debug_edit.get_active():
1120
kernel_options['kernel'].append('debug')
1121
if self.chk_single_edit.get_active():
1122
kernel_options['kernel'].append('single')
1123
if self.chk_splash_image_edit.get_active():
1124
kernel_options['kernel'].append('splash')
1125
if self.chk_acpi_edit.get_active()==False:
1126
kernel_options['kernel'].append('acpi=off')
1127
if(self.en_locale_edit.get_text().strip()!=""):
1128
kernel_options['kernel'].append('locale=' + self.en_locale.get_text().strip())
1129
if(self.en_other_ops_edit.get_text().strip()!=""):
1130
for option in self.en_other_ops_edit.get_text().strip().split():
1131
kernel_options['kernel'].append(option.strip())
1132
1133
else:
1134
1135
if self.en_kernel_ops_edit.get_text().strip() == '':
1136
kernel_options['kernel'] = self.kernel_file_store[self.cmb_kernel_edit.get_active()][0]
1137
else:
1138
kernel_options['kernel'] = []
1139
kernel_options['kernel'].append(self.kernel_file_store[self.cmb_kernel_edit.get_active()][0])
1140
for option in self.en_kernel_ops_edit.get_text().split():
1141
kernel_options['kernel'].append(option.strip())
1142
1143
else:
1144
kernel_options['makeactive'] = None
1145
kernel_options['chainloader'] = '+1'
1146
1147
if "quiet" in kernel_options['kernel']:
1148
kernel_options['quiet'] = None
1149
1150
kernel = grubconfig_backend.menu_item(kernel_title, kernel_options)
1151
return kernel
1152
1153
def btn_kernel_fl_edit_clicked(self, widget):
1154
filename=FileDialogs().open_file_dialog(_("Select a kernel file ..."), "*", _("kernel file"))
1155
if filename == "":
1156
return None
1157
position = -1
1158
for i in range(len(self.kernel_file_store)):
1159
if self.kernel_file_store[i][0] == filename:
1160
position = i
1161
if position == -1:
1162
self.device_store.append(filename)
1163
self.cmb_kernel_edit.set_active(len(self.device_store)-1)
1164
else:
1165
self.cmb_kernel_edit.set_active(position)
1166
1167
def change_timeout(self, widget):
1168
self.gc.set_timeout(self.spin_timeout.get_value_as_int())
1169
1170
def cmb_color_changed(self, widget):
1171
colors = []
1172
blink = []
1173
colors.append(self.cmb_color_f_store[self.cmb_nf_color.get_active()][1])
1174
colors.append(self.cmb_color_b_store[self.cmb_nb_color.get_active()][1])
1175
if self.chk_nf_blink_color.get_active():
1176
blink.append("normal")
1177
self.frame_higlight_colors.set_sensitive(False)
1178
if not self.chk_invert_color.get_active():
1179
colors.append(self.cmb_color_f_store[self.cmb_hf_color.get_active()][1])
1180
colors.append(self.cmb_color_b_store[self.cmb_hb_color.get_active()][1])
1181
if self.chk_hf_blink_color.get_active():
1182
blink.append("highlight")
1183
self.frame_higlight_colors.set_sensitive(True)
1184
self.gc.set_colors(colors, blink)
1185
1186
def splashimage_toggle(self, widget):
1187
if not self.chk_background_image.get_active():
1188
self.btn_background_image.set_sensitive(False)
1189
self.gc.set_splash_image(None)
1190
else:
1191
self.btn_background_image.set_sensitive(True)
1192
self.splashimage_clicked(widget)
1193
if self.gc.get_splash_image() == "":
1194
self.chk_background_image.set_active(False)
1195
self.btn_background_image.set_sensitive(False)
1196
1197
def splashimage_clicked(self, widget):
1198
filename=FileDialogs().open_file_dialog(_("Select a Image file ..."), "*.xpm.gz", _("XPM Gziped Image"))
1199
if(filename!=""):
1200
new_filename = "/boot/grub/splash.xpm.gz"
1201
f=open(new_filename, "w")
1202
f.write(open(filename, "r").read())
1203
f.close()
1204
self.gc.set_splash_image(self.d.get_root_partition().grub_device+new_filename)
1205
1206
def toggle_password(self, widget):
1207
if not self.password_locked.get_active():
1208
self.en_password.set_text("")
1209
self.en_rpassword.set_text("")
1210
1211
def passwords_changed(self, widget):
1212
if self.en_password.get_text()!=self.en_rpassword.get_text():
1213
self.pass_msg_error.show()
1214
if self.en_password.get_text()==self.en_rpassword.get_text()!="":
1215
self.pass_msg_error.hide()
1216
self.password_locked.set_active(True)
1217
if self.en_rpassword.get_text()=="":
1218
self.pass_msg_error.hide()
1219
1220
def main_ok(self, widget):
1221
#check if the password was modified, an then change in grubconfig
1222
if self.en_password.get_text()==self.en_rpassword.get_text()!="********" \
1223
and self.en_password.get_text()==self.en_rpassword.get_text()!="":
1224
self.gc.set_password(self.en_password.get_text())
1225
1226
#if there is no recovery kernel the alternative automagic value
1227
# is turned false
1228
alternative = True
1229
for kernel in self.gc.get_oslist():
1230
if 'kernel' in kernel.main_options.keys() \
1231
and 'single' in kernel.main_options['kernel']:
1232
alternative = True
1233
if alternative != self.gc.get_alternative():
1234
self.gc.set_alternative(alternative)
1235
1236
#if there is no memtest86 kernel the memtest86 automagic value
1237
# is turned false
1238
memtest86 = False
1239
for kernel in self.gc.get_oslist():
1240
if 'kernel' in kernel.main_options.keys() \
1241
and type(kernel.main_options['kernel']) == type("") \
1242
and kernel.main_options['kernel'].find('memtest86'):
1243
memtest86 = True
1244
if memtest86 != self.gc.get_memtest86():
1245
self.gc.set_memtest86(memtest86)
1246
1247
self.quit_save(widget)
1248
1249
def about(self, widget):
1250
self.wTree = gtk.glade.XML(GLADE_FILE, "AboutDialog")
1251
self.dlg = self.wTree.get_widget("AboutDialog")
1252
self.dlg.run()
1253
self.dlg.destroy()
1254
1255
def run(self):
1256
gtk.main()
1257
1258
class Disks:
1259
def __init__(self):
1260
disk_re = re.compile('\s+/dev/([\w]{3,3}):\s+')
1261
self.partitions = []
1262
partition_start = []
1263
disk = -1
1264
disk_str = None
1265
1266
put, get = os.popen4("sudo fdisk -l")
1267
put.close()
1268
for line in get.readlines():
1269
if disk_re.search(line) is not None:
1270
disk_str = disk_re.search(line).group(1)
1271
disk += 1
1272
partition = -1
1273
partition_start.append([])
1274
if disk_str is not None:
1275
partition_re = re.compile('(/dev/'+disk_str+'(\d*))[*\s]+(\d+)\s+')
1276
if partition_re.search(line) is not None:
1277
partition += 1
1278
partition_start[disk].append(partition_re.search(line).group(3))
1279
self.partitions.append(Partition(partition_re.search(line).group(1), disk))
1280
# if is an extended partition delete it
1281
if partition>0 and partition_start[disk][partition] == partition_start[disk][partition-1]:
1282
del self.partitions[-2]
1283
get.close()
1284
1285
def partition_grub_installed(self):
1286
partition_disk_re = re.compile("\s*(\(hd[\d]+,[\d]+\))\s*$")
1287
self.grub_partition = None
1288
put, get = os.popen4("sudo sh "+FILE_DIR+"/find_grub.sh")
1289
put.close()
1290
for line in get.readlines():
1291
if partition_disk_re.search(line) is not None:
1292
grub_device = partition_disk_re.search(line).group(1)
1293
get.close()
1294
for partition in self.partitions:
1295
if(grub_device == partition.grub_device):
1296
self.grub_partition = partition
1297
return self.grub_partition
1298
1299
1300
def mount_partition(self):
1301
self.partition_grub_installed()
1302
if self.grub_partition is None:
1303
return None
1304
1305
self.mounted = False
1306
1307
partition_disk_re = re.compile("^\s*"+self.grub_partition.device+"\s+\w+\s+/(\w*)\s+.+$")
1308
1309
put, get = os.popen4("sudo mount -l")
1310
put.close()
1311
for line in get.readlines():
1312
if partition_disk_re.search(line) is not None:
1313
self.mounted = True
1314
mount_point = partition_disk_re.search(line).group(1)
1315
1316
get.close()
1317
1318
if self.mounted:
1319
return mount_point
1320
else:
1321
mount_point = "/tmp/"+self.grub_partition.uuid
1322
os.system("mkdir "+mount_point)
1323
os.system("sudo mount "+self.grub_partition.device+" "+mount_point)
1324
return mount_point
1325
1326
def umount_partition(self):
1327
if not self.mounted:
1328
os.system("sudo umount "+self.grub_partition.device)
1329
os.system("rmdir /tmp/"+self.grub_partition.uuid)
1330
1331
1332
def get_grub_partition(self, device):
1333
for partition in self.partitions:
1334
if partition.device == device:
1335
return partition
1336
1337
def get_device(self, grub_device):
1338
for partition in self.partitions:
1339
if partition.grub_device == grub_device:
1340
return partition
1341
1342
def get_root_partition(self):
1343
for partition in self.partitions:
1344
if partition.root_device:
1345
return partition
1346
1347
class Partition:
1348
def __init__(self, device, disk_number):
1349
if len(device) == 8:
1350
self.partiton_number = 0
1351
self.disk_device = device
1352
else:
1353
self.partiton_number = int(device[-1:])-1
1354
self.disk_device = device[:-1]
1355
1356
self.grub_device = "(hd"+str(disk_number)+","+str(self.partiton_number)+")"
1357
self.device = device
1358
self.disk_number = disk_number
1359
put, get = os.popen4("sudo sudo vol_id -u "+self.device)
1360
put.close()
1361
self.uuid = get.readline().strip()
1362
get.close()
1363
root_device_re = re.compile(self.device+'\s+/\s+.+$')
1364
root_device_uuid_re = re.compile('UUID='+self.uuid+'\s+/\s+.+$')
1365
self.root_device = False
1366
f = open("/etc/fstab", 'r')
1367
for line in f.readlines():
1368
if root_device_re.search(line) is not None \
1369
or root_device_uuid_re.search(line):
1370
self.root_device = True
1371
f.close()
1372
1373
class FileDialogs:
1374
def open_file_dialog(self, dlg_title, filter_pattern, filter_name):
1375
dialog_buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)
1376
file_dialog = gtk.FileChooserDialog(title=dlg_title, action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=dialog_buttons)
1377
filter = gtk.FileFilter()
1378
filter.set_name(filter_name)
1379
filter.add_pattern(filter_pattern)
1380
file_dialog.add_filter(filter)
1381
filename = ""
1382
if file_dialog.run() == gtk.RESPONSE_OK:
1383
filename = file_dialog.get_filename()
1384
file_dialog.destroy()
1385
return filename
1386
1387
def save_file_dialog(self, dlg_title, filter_pattern, filter_name):
1388
dialog_buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)
1389
file_dialog = gtk.FileChooserDialog(title=dlg_title, action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=dialog_buttons)
1390
filter = gtk.FileFilter()
1391
filter.set_name(filter_name)
1392
filter.add_pattern(filter_pattern)
1393
file_dialog.add_filter(filter)
1394
filename = ""
1395
if file_dialog.run() == gtk.RESPONSE_OK:
1396
filename = file_dialog.get_filename()
1397
file_dialog.destroy()
1398
return filename
1399
1400
def generate_grub_password(password):
1401
put, get = os.popen4("sh "+FILE_DIR+"/md5_crypt_grub.sh "+password)
1402
put.close()
1403
hash=get.readlines()[0]
1404
get.close()
1405
return hash
1406
1407
class Preview(gtk.DrawingArea):
1408
1409
# Draw in response to an expose-event
1410
__gsignals__ = { "expose-event": "override" }
1411
1412
default = 0
1413
titles = []
1414
splashimage = ""
1415
colors = []
1416
gc = None
1417
mount_point = ""
1418
1419
# Handle the expose-event by drawing
1420
def do_expose_event(self, event):
1421
colors, blink = self.gc.get_colors()
1422
self.titles = []
1423
self.colors = colors
1424
for kernel in self.gc.get_oslist():
1425
self.titles.append(kernel.title)
1426
self.default = self.gc.get_default()
1427
self.splashimage = self.gc.get_splash_image()
1428
1429
# Create the cairo context
1430
self.cr = self.window.cairo_create()
1431
1432
# Restrict Cairo to the exposed area; avoid extra work
1433
self.cr.rectangle(0, 0,570, 315)
1434
self.cr.clip()
1435
self.draw()
1436
1437
def draw(self):
1438
1439
colors = self.prepare_colors()
1440
if self.splashimage != "":
1441
splash_image_pixbuf = self.prepare_splashimage()
1442
1443
if self.splashimage == "":
1444
#main rectangle
1445
self.cr.set_source_rgb(0, 0, 0)
1446
self.cr.rectangle(0, 0, 570, 315)
1447
self.cr.fill()
1448
#menu rectangle
1449
self.cr.set_source_rgb(*colors[1])
1450
self.cr.rectangle(6, 39, 534, 180)
1451
self.cr.fill()
1452
else:
1453
self.cr.set_source_pixbuf(splash_image_pixbuf, 0, 0)
1454
self.cr.paint()
1455
1456
#menu line
1457
self.cr.set_line_width(1)
1458
self.cr.set_source_rgb(*colors[0])
1459
self.cr.rectangle(9, 45, 525, 165)
1460
self.cr.stroke()
1461
1462
#default rectangle
1463
self.cr.set_source_rgb(*colors[3])
1464
self.cr.rectangle(15, 51+12*self.default, 512, 12)
1465
self.cr.fill()
1466
1467
i = 0
1468
for title in self.titles:
1469
if i<13:
1470
if i == self.default:
1471
#default text
1472
self.cr.set_source_rgb(*colors[2])
1473
else:
1474
self.cr.set_source_rgb(*colors[0])
1475
self.cr.select_font_face("Courier", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
1476
self.cr.set_font_size(11)
1477
self.cr.move_to(21, 60.5+12*i)
1478
self.cr.show_text(title)
1479
i = i+1
1480
1481
#help text
1482
self.cr.set_source_rgb(1, 1, 1)
1483
self.cr.select_font_face("Courier",
1484
cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
1485
self.cr.set_font_size(11)
1486
self.cr.move_to(27, 227)
1487
self.cr.show_text("You can change the appearence of the menu by setting")
1488
self.cr.move_to(27, 239)
1489
self.cr.show_text("the foreground and background color, of the highlighted")
1490
self.cr.move_to(27, 251)
1491
self.cr.show_text("or normal option, or change the splash image.")
1492
1493
#timeout
1494
self.cr.move_to(27, 290)
1495
self.cr.show_text("The highlightedntry will be booted automatically in 10 seconds.")
1496
1497
def prepare_colors(self):
1498
colors = []
1499
if self.splashimage == "" and colors>=2:
1500
colors_list = { "black": [0,0,0],
1501
"blue":[0,0,1],
1502
"green":[0,1,0],
1503
"cyan":[0,1,1],
1504
"red":[1,0,0],
1505
"magenta":[1,0,1],
1506
"brown":[0.55,0.27,0.7],
1507
"light-gray":[0.67,0.67,0.67],
1508
"dark-gray":[0.33,0.33,0.33],
1509
"light-blue":[0.5,0.5,0.5],
1510
"light-green":[0.5,1,0.5],
1511
"light-cyan":[0.5,1,1],
1512
"light-red":[1,0.5,0.5],
1513
"light-magenta":[1,0.5,0.5],
1514
"yellow":[1,1,0],
1515
"white":[1,1,1]
1516
}
1517
1518
for color in self.colors:
1519
colors.append(colors_list[color])
1520
1521
#create the inverted colors
1522
if len(self.colors) == 2:
1523
colors.append([abs(colors[0][0]-1), abs(colors[0][1]-1), abs(colors[0][2]-1)])
1524
colors.append([abs(colors[1][0]-1), abs(colors[1][1]-1), abs(colors[1][2]-1)])
1525
else:
1526
colors.append([1,1,1])
1527
colors.append([0,0,0])
1528
colors.append([1,1,1])
1529
colors.append([0,0,0])
1530
return colors
1531
1532
def prepare_splashimage(self):
1533
fn = tempfile.mktemp()
1534
f = open(fn, 'w')
1535
f.write(gzip.open(self.mount_point+self.splashimage, 'r').read())
1536
f.close()
1537
pixbuf = gtk.gdk.pixbuf_new_from_file(fn).scale_simple(570 ,315, gtk.gdk.INTERP_BILINEAR)
1538
return pixbuf
1539
1540
def show_error_dialog(error_string):
1541
error_dlg = gtk.MessageDialog(type=gtk.MESSAGE_ERROR
1542
, message_format=error_string
1543
, buttons=gtk.BUTTONS_OK)
1544
error_dlg.run()
1545
error_dlg.destroy()
1546
1547
def main():
1548
BootloaderManagerUI().run()
1549
1550
Loggerhead is a web-based interface for Breezy
Version: 2.0.1