#coding:utf-8
#!/usr/bin/python3
#
# Copyright (c) 2007-2009 Canonical Ltd.
#
# Author: Oliver Grawert <ogra@ubuntu.com>
#
# Modifications 2013 from papoteur <papoteur@mageialinux-online.org>
# and Geiger David <david.david@mageialinux-online.org>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
# Requires python3-parted
# ensure we're using the latest build, if called from our build environment
import sys
import imp
sys.path.insert(0,'../../../build/swig/python3')
imp.reload(sys)
###########
# imports #
###########
import yui
#import locale
import time
####################################
# LOCALE (important for TERMINAL!) #
####################################
# set the locale to de/utf-8
#locale.setlocale(locale.LC_ALL, "")
#log = yui.YUILog.instance()
#log.setLogFileName("debug.log")
#log.enableDebugLogging( True )
import os, re
import io
import gettext
from gettext import gettext as _
from subprocess import call, Popen, PIPE
import dbus
class NoUDisks2(Exception):
pass
class UDisks2(object):
BLOCK = 'org.freedesktop.UDisks2.Block'
DRIVE = 'org.freedesktop.UDisks2.Drive'
def __init__(self):
self.bus = dbus.SystemBus()
try:
self.bus.get_object('org.freedesktop.UDisks2',
'/org/freedesktop/UDisks2')
except dbus.exceptions.DBusException as e:
if getattr(e, '_dbus_error_name', None) == 'org.freedesktop.DBus.Error.ServiceUnknown':
raise NoUDisks2()
raise
def find_devices(self):
proxy = self.bus.get_object("org.freedesktop.UDisks2", "/org/freedesktop/UDisks2")
iface = dbus.Interface(proxy, "org.freedesktop.UDisks2")
_udisks2_obj_manager = dbus.Interface(iface, "org.freedesktop.DBus.ObjectManager")
objects=_udisks2_obj_manager.GetManagedObjects()
re_drive = re.compile('(?P<path>.*?/drives/(?P<id>.*))')
re_block = re.compile('(?P<path>.*?/block_devices/(?P<id>.*))')
devs= [m.groupdict() for m in
[re_drive.match(path) for path in (objects.keys())]
if m]
blocks = [m.groupdict() for m in
[re_block.match(path) for path in (objects.keys())]
if m]
list=[]
for dev in devs:
dev_obj =objects[dev['path']][self.DRIVE]
if (dev_obj['ConnectionBus'] == 'usb' or dev_obj['ConnectionBus'] == 'sdio') and \
(dev_obj['Removable'] == 1 or dev_obj['MediaRemovable'] == 1 ):
item=[]
vend = dev_obj['Vendor']
name = dev_obj['Model']
for block in blocks:
if dev['path'] == objects[block['path']][self.BLOCK]['Drive']:
dev_name = block['path'].split('/')[-1]
path = ''.join([i for i in dev_name if not i.isdigit()])
path = '/dev/' + path
break
size = dev_obj['Size']
item.append(vend+" "+name)
item.append(path)
item.append(size)
list.append(item)
return list
class Info(object):
def __init__(self,title,richtext,text):
self.title=title
self.richtext=richtext
self.text=text
class IsoDumper(object):
def get_devices(self):
self.list=self.u.find_devices()
while len(self.list)==0:
if self.nodevDialog():
self.list = self.u.find_devices()
else:
return False
break
self.devicelist.addItem("",False)
if len(self.list)>0:
for name, path, size in self.list:
if size != 0 :
# convert in Mbytes
sizeM=str(int(size)/(1024*1024))
self.devicelist.addItem(str(name+' ('+path.lstrip()+') '+sizeM+_('Mb')),False)
return True
def update_list(self ):
self.devicelist.deleteAllItems()
self.get_devices()
self.img_name = ""
self.ima.setLabel(self.ChooseImage)
self.backup_select.setLabel(self.ChooseImage)
self.dialog.recalcLayout()
self.restore()
def device_selected(self):
selitem = self.devicelist.selectedItem()
if selitem != None:
self.dev = selitem.label()
for name, path, size in self.list:
if self.dev.startswith(name):
self.deviceSize=size
self.device_name=name.rstrip().replace(' ', '')
self.logger(_('Target Device: ')+ self.dev)
self.formatbt.setEnabled()
self.ima.setEnabled()
self.backup_select.setEnabled()
break
def backup_sel(self):
if self.backup_bname.get_current_folder_uri() == None :
self.backup_bname.set_current_folder_uri('file:///home/'+self.user)
self.backup_bname.set_current_name(self.device_name+".img")
self.choose.run()
def backup_choosed(self):
# Add .img if not specified
if not self.backup_img_name.lower().endswith('.img'):
self.backup_img_name=self.backup_img_name+".img"
head, tail = os.path.split(self.backup_img_name)
self.backup_dest=self.backup_img_name
self.backup_select.setLabel(tail)
self.dialog.recalcLayout()
self.backupbt.setEnabled()
#self.backup_select.set_tooltip_text(self.backup_img_name)
self.logger(_('Backup to: ')+ self.backup_img_name)
def do_format(self,format_type,name) :
target = self.dev.split('(')[1].split(')')[0]
info = Info(_("Formatting confirmation"),True,self.warning)
if self.ask_YesOrNo(info):
rc=self.raw_format(target, format_type, name)
self.operation=False
if rc == 0:
message = _('The device was formatted successfully.')
self.logger(message)
self.success()
elif rc == 5:
message = _("An error occurred while creating a partition.")
self.logger(message)
self.emergency(message)
elif rc == 127:
message = _('Authentication error.')
self.logger(message)
self.emergency(message)
else:
message = _('An error occurred.')
self.emergency(message)
def restore(self):
self.backup_select.setDisabled()
self.backupbt.setDisabled()
self.formatbt.setDisabled()
self.ima.setDisabled()
self.writebt.setDisabled()
self.devicelist.setEnabled()
self.progress.setLabel("")
self.progress.setValue(0)
self.progress.setDisabled()
self.refreshbt.setEnabled()
def raw_format(self, usb_path, fstype, label):
self.operation=True
if os.geteuid() > 0:
launcher='pkexec'
self.process = Popen([launcher,'/usr/bin/python3', '-u', '/usr/lib/isodumper/raw_format.py','-d',usb_path,'-f',fstype, '-l', label, '-u', str(os.geteuid()), '-g', str(os.getgid())], shell=False, stdout=PIPE, preexec_fn=os.setsid)
else:
self.process = Popen(['/usr/bin/python3', '-u', '/usr/lib/isodumper/raw_format.py','-d',usb_path,'-f',fstype, '-l', label, '-u', str(os.geteuid()), '-g', str(os.getgid())], shell=False, stdout=PIPE, preexec_fn=os.setsid)
working=True
while working:
time.sleep(0.5)
self.process.poll()
rc=self.process.returncode
if rc is None:
working=True
else:
self.process = None
working= False
return rc
def backup_go(self):
dest = self.backup_img_name
if os.path.exists(dest):
info = Info(_("Backup confirmation"),True,_("Do you want to overwrite the file?"))
if not(self.ask_YesOrNo(info)):
self.returncode = 1
return True
st = os.statvfs(os.path.dirname(dest))
free = st.f_bavail * st.f_frsize
if free<self.deviceSize :
sizeM=str(self.deviceSize/(1024*1024))
message=_("The destination directory is too small to receive the backup (%s Mb needed)")%(sizeM)
self.logger(message)
self.emergency(message)
else:
self.returncode=0
source = self.dev.split('(')[1].split(')')[0]
self.logger(_('Backup to:')+' '+dest)
self.raw_write(source, dest, self.deviceSize)
if self.returncode==0:
self.success()
def do_write(self):
self.returncode = 0
self.writebt.setDisabled()
self.devicelist.setDisabled()
self.formatbt.setDisabled()
self.backupbt.setDisabled()
self.backup_select.setDisabled()
self.progress.setEnabled()
source = self.img_name
target = self.dev.split('(')[1].split(')')[0]
# self.logger(_('Image: ')+source)
# self.logger(_('Target Device: ')+self.dev)
b = os.path.getsize(source)
if b > (self.deviceSize):
message = _('The device is too small to contain the ISO file.')
self.logger(message)
self.emergency(message)
else:
info = Info(_("Writing confirmation"),True,self.warning)
if self.ask_YesOrNo(info):
if self.deviceSize> 1024*1024*1024*32 :
info = Info(_("Warning"),True,_('The device is bigger than 32 Gbytes. Are you sure you want use it?'))
if self.ask_YesOrNo(info):
pass
else:
self.emergency(message)
return
self.ima.setDisabled()
self.writebt.setDisabled()
self.do_umount(target)
if self.returncode != 1:
# Writing step
#Dump mode
self.returncode=0
b=os.path.getsize(source)
self.raw_write(source, target, b)
if self.returncode == 0:
self.check_write(target, b)
self.success()
else:
self.restore()
else:
self.restore()
def do_umount(self, target):
mounts = self.get_mounted(target)
if mounts:
self.logger(_('Unmounting all partitions of ')+target+':')
for mount in mounts:
self.logger(_('Trying to unmount ')+mount[0]+'...')
try:
retcode = call('umount '+mount[0], shell=True)
if retcode == 32:
message = _('Partition %s is busy')%mount[0]
self.logger(message)
self.emergency(message)
elif retcode< 0:
message = _('Error, umount ')+mount[0]+_(' was terminated by signal ')+str(retcode)
self.logger(message)
self.emergency(message)
elif retcode == 0:
self.logger(mount[0]+_(' successfully unmounted'))
else:
message = _('Error, umount ')+mount[0]+_(' returned ')+str(retcode)
self.logger(message)
self.emergency(message)
except OSError as e:
message = _('Execution failed: ')+str(e)
self.logger(message)
self.emergency(message)
def get_mounted(self, target):
try:
lines = [line.strip("\n").split(" ") for line in open ("/etc/mtab", "r").readlines()]
return [mount for mount in lines if mount[0].startswith(target)]
except:
message = _('Could not read mtab !')
self.logger(message)
self.emergency(message)
def raw_write(self, source, target, b):
self.operation=True
bs=4096*128
try:
ifc=io.open(source, "rb",1)
except:
message = _('Reading error.')+ source
self.logger(message)
self.emergency(message)
return
else:
try:
ofc= io.open(target, 'wb',0)
except:
message = _("You don't have permission to write to the device") +" "+ target
self.logger(message)
self.emergency(message)
self.close()
else:
self.progress.setLabel(_('Writing ')+source.split('/')[-1]+_(' to ')+target.split('/')[-1])
self.logger(_('Executing copy from ')+source+_(' to ')+target)
steps=list(range(0, b+1, int(b/100)))
steps.append(b)
indice=1
written=0
ncuts=int(b/bs)
while ncuts <= 100:
bs=int(bs/2)
ncuts=int(b/bs)
for i in range(0,int(ncuts)+1):
try:
buf=ifc.read(bs)
except:
message = _("Reading error.")
self.logger(message)
self.emergency(message)
return
try:
ofc.write(buf)
except:
message = _("Writing error.")
self.logger(message)
self.emergency(message)
return
written+=len(buf)
if written > steps[indice]:
if indice%1==0:
self.logger(_('Wrote: ')+str(indice)+'% '+str(written)+' bytes')
self.progress.setValue(indice)
self.dialog.pollEvent()
indice +=1
try:
os.fsync(ofc)
except:
message = _("Writing error.")
self.logger(message)
self.emergency(message)
return
self.progress.setValue(100)
self.logger(_('Image ')+source.split('/')[-1]+_(' successfully written to ')+target)
self.logger(_('Bytes written: ')+str(written))
try:
ofc.close()
except:
message = _("Writing error.")
self.logger(message)
self.emergency(message)
ifc.close()
def check_write(self, target, b):
import hashlib
self.progress.setEnabled()
self.progress.setLabel(_('Checking ')+target.split('/')[-1])
self.progress.setValue(0)
steps=list(range(0, b+1, int(b/100)))
steps.append(b)
indice=0
checked=0
sha1func=hashlib.sha1()
md5func=hashlib.md5()
ncuts=int(b/1024)
try:
with open(target, 'rb') as f:
for x in range(0,ncuts):
block = f.read(1024)
sha1func.update(block)
md5func.update(block)
if checked > steps[indice]:
self.progress.setValue(indice)
self.dialog.pollEvent()
indice +=1
checked+=1024
block = f.read(b-ncuts*1024)
sha1func.update(block)
md5func.update(block)
sha1sumcalc=sha1func.hexdigest()
md5sumcalc=md5func.hexdigest()
self.logger(_('SHA1 sum: ')+sha1sumcalc)
self.logger(_('MD5 sum: ')+md5sumcalc)
f.close()
except:
pass
self.progress.setValue(100)
def success(self):
self.operation=False
self.final_unsensitive()
info = Info(_("Success"),True,_("The operation completed successfully.\n\
You are free to unplug it now, a logfile \n\
(/home/-user- or /root)/.isodumper/isodumper.log will be saved when\n\
you close the application."))
if self.ask_OK(info) :
return
def confirm_close(self, *args):
if self.operation==False: # no writing , backup nor format running
self.close()
else: # writing , backup or format running
info = Info(_("Warning"),True,_("Writing is in progress. Exiting during writing \n\
will make the device or the backup unusable.\n\
Are you sure you want to quit during writing?"))
if self.ask_YesOrNo(info) :
return True
else:
return False
def emergency(self,message):
self.operation=False
self.returncode=1
self.final_unsensitive()
info = Info(_("Error"),True,message)
self.ask_OK(info)
def final_unsensitive(self):
self.ima.setDisabled()
self.devicelist.setDisabled()
self.writebt.setDisabled()
self.progress.setDisabled()
self.backup_select.setDisabled()
def wip_unsensitive(self):
self.ima.setDisabled()
self.devicelist.setDisabled()
self.writebt.setDisabled()
self.backup_select.setDisabled()
self.backupbt.setDisabled()
self.refreshbt.setDisabled()
def close(self):
self.write_logfile()
self.dialog.destroy()
#exit(0)
def write_logfile(self):
import pwd
pw = pwd.getpwnam(self.user)
uid = pw.pw_uid
gid=pw.pw_gid
if (self.user != 'root') and (self.user !=''):
logpath='/home/'+self.user+'/.isodumper'
os.setgid(gid)
os.setuid(uid)
if not(os.path.isdir(logpath)):
os.mkdir(logpath)
else:
logpath='/root'
logfile=open(logpath+'/isodumper.log',"w", encoding="utf-8")
logfile.write(self.logview.logText())
logfile.close()
print((self.logview.logText()))
def logger(self, text):
self.logview.appendLines(text+"\n")
def activate_devicelist(self):
self.devicelist.setEnabled()
self.logger(_('Image ')+": "+ self.img_name)
# self.chooser.set_tooltip_text(self.img_name)
def help_dialog(self):
info = Info(_("IsoDumper"),True,_("Mageia IsoDumper<BR />\
----------------<BR />\
This GUI program is primarily for safely writing a bootable ISO image to a USB flash drive, \
an operation devious & potentially hazardous when done by hand. As a bonus, it can also back up the\
entire previous<BR />contents of the flash drive onto the hard disc, and restore the flash drive \
to its previous state subsequently.<BR />\
It gives also a feature for formatting the USB device.<BR />\
<BR />\
IsoDumper can be launched either from the menus, or a user or root console with the command 'isodumper'.<BR />\
For normal users, the root password is solicited; this is necessary for the program's operation. <BR />\
The flash drive can be inserted beforehand or once the program is started. In the latter case, a \
dialogue will say that there is no flash drive inserted, and allow a 'retry' to find it once it is. <BR />\
(You may have to close any automatically opened File Manager window).<BR />\
<BR />\
The fields of the main window are as follows:<BR />\
- Device to work on: the device of the USB flash drive, a drop-down list to choose from.<BR />\
- Write Image: to choose the source ISO image *.iso (or flash drive backup file *.img) to write out.<BR />\
- Write to device: This button launches the operation - with a prior warning dialogue. <BR />\
The operation is shown in the progress bar beneath.<BR />\
- Backup to: define the name and placement of the backup image file. The current flash drive \
will be backed up to a disc file. Note that the entire flash drive is preserved, regardless of its \
actual contents; ensure that you have the necessary free disc space (the same size as the USB device). \
This backup file can be used later to restore the flash drive by selecting it as the source *.img file to write out.<BR />\
- Backup the device: launch the backup operation.<BR />\
- Format the device: create an unique partition on the entire volume in the specified format in FAT, \
NTFS or ext. You can specify a volume name and the format in a new dialog box.<BR />"))
if self.ask_OK(info) :
return
def __init__(self,user):
APP="isodumper"
DIR="/usr/share/locale"
self.RELEASE="v0.59"
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
# for the localisation of log file
self.user = user
# define size of the selected device
self.deviceSize=0
# Operation running
self.operation=False
self.ChooseImage = _("Choose an image")
self.warning = _("Warning\nThis will destroy all data on the target device,\n\
are you sure you want to proceed?\n\
If you say ok here, please <b>do not unplug</b>\
the device during the following operation.")
"""
Init/Constructor for the 'widgets'
"""
yui.YUI.app().setApplicationTitle(_("IsoDumper")+" "+self.RELEASE)
yui.YUI.app().setApplicationIcon("/usr/share/icons/isodumper.png")
self.atelier = yui.YUI.widgetFactory()
self.dialog = self.atelier.createPopupDialog()
# create the main gui
# +---+-----------------+
# + banner +
# +---+-----------------+
# | devicelist |
# +---+-----+------+----+
# + L | ima | writebt |
# +---+-----+------+----+
# + L | backup_select | backupbt |
# +---+-----+------+----+
# + F | formatbt |
# +----------------+----+
# | progress |
# +---------------------+
# | report |
# +---------------------+
# | refreshbt | aboutbt | helpbt | quitbt |
# +---------------------+
self.ancrage = self.atelier.createReplacePoint(self.dialog)
self.box = self.atelier.createVBox(self.ancrage)
self.bannerbox = self.atelier.createHBox(self.box)
self.banner=self.atelier.createImage(self.bannerbox,"/usr/share/isodumper/header.svg")
self.devicebox = self.atelier.createHBox(self.box)
self.devicebox.setWeight(1,10)
self.devicelist=self.atelier.createComboBox(self.devicebox,_("Device to work on:"),False)
self.devicelist.setNotify()
self.devicelist.setStretchable(0,True)
self.writebox = self.atelier.createHBox(self.box)
self.atelier.createLabel(self.writebox,_("Write Image:"))
# add file picker for image file
self.ima=self.atelier.createPushButton(self.writebox,self.ChooseImage)
self.ima.setStretchable(0,True)
self.ima.setDisabled()
self.atelier.createHStretch(self.writebox)
self.writebt = self.atelier.createPushButton(self.writebox, _("&Write to device" ))
self.writebt.setDisabled()
self.backupbox = self.atelier.createHBox(self.box)
self.atelier.createLabel(self.backupbox,_("Backup to:"))
# add file picker for backup file name
self.backup_select=self.atelier.createPushButton(self.backupbox,self.ChooseImage)
self.backup_select.setStretchable(0,True)
self.backup_select.setDisabled()
self.atelier.createHStretch(self.backupbox)
self.backupbt = self.atelier.createPushButton(self.backupbox, _("&Backup the device" ))
self.backupbt.setDisabled()
self.formatbox = self.atelier.createHBox(self.box)
#self.formatbox.setWeight(1,10)
self.atelier.createLabel(self.formatbox,_("Format the device in FAT, NTFS or ext:"))
self.atelier.createHStretch(self.formatbox)
self.formatbt = self.atelier.createPushButton(self.formatbox, _("&Format the device" ))
self.formatbt.setDisabled()
self.progressbox = self.atelier.createHBox(self.box)
self.progressbox.setWeight(1,10)
self.progress = self.atelier.createProgressBar(self.progressbox,_("Progress"),100)
self.progress.setStretchable(0,True)
self.reportbox = self.atelier.createHBox(self.box)
#self.reportbox.setWeight(1,10)
self.logview = self.atelier.createLogView(self.reportbox,_("Report"), 10)
self.logview.setStretchable(0,True)
#self.reportbox.setWeight(1,20)
self.buttonsbox = self.atelier.createHBox(self.box)
#self.buttonsbox.setWeight(1,10)
self.refreshbt = self.atelier.createPushButton(self.buttonsbox, _("&Refresh" ))
self.refreshbt.setStretchable(0,True)
self.aboutbt = self.atelier.createPushButton(self.buttonsbox, _("&About" ))
self.aboutbt.setStretchable(0,True)
self.helpbt = self.atelier.createPushButton(self.buttonsbox, _("&Help" ))
self.helpbt.setStretchable(0,True)
self.quitbt = self.atelier.createPushButton(self.buttonsbox, _("&Quit" ))
self.quitbt.setStretchable(0,True)
self.u = None
try:
self.u = UDisks2()
except :
message = _('UDisks2 is not available on your system')
self.logger(message)
self.emergency(message)
if not self.get_devices():
self.dialog.destroy()
yui.YUILoader.deleteUI()
exit()
self.device_selected()
self.dialog.recalcLayout()
self.ancrage.showChild()
def ask_format(self):
self.ima.setDisabled()
self.formatbt.setDisabled()
self.backup_select.setDisabled()
self.writebt.setDisabled()
self.devicelist.setDisabled()
atelier = yui.YUI.widgetFactory()
dialog = atelier.createPopupDialog()
# dialog.setTitle(_("Choose format"))
vb=atelier.createVBox(dialog)
label = atelier.createInputField(vb,_("Label for the device:"))
cr = atelier.createRadioButtonGroup(vb)
vb_c = atelier.createVBox(cr)
vb_c1 = atelier.createHBox(vb_c)
format_fat = atelier.createRadioButton(atelier.createLeft(vb_c1),_("FAT 32 (Windows)"))
vb_c2 = atelier.createHBox(vb_c)
format_ntfs = atelier.createRadioButton(atelier.createLeft(vb_c2),_("NTFS (Windows)"))
vb_c3 = atelier.createHBox(vb_c)
format_ext = atelier.createRadioButton(atelier.createLeft(vb_c3),_("ext4 (Linux)"))
bb = atelier.createHBox(vb)
executebt = atelier.createPushButton(bb,_("Execute"))
cancelbt = atelier.createPushButton(bb,_("Cancel"))
dialog.open()
returncode = True
while True:
event = dialog.waitForEvent()
if event.eventType() == yui.YEvent.CancelEvent:
returncode = False
break
if event.widget() == executebt:
if format_fat.value():
format_type = 'fat32'
format_label = label.value().upper()[:11]
break
if format_ntfs.value():
format_type = 'ntfs'
format_label = label.value()[:32]
break
if format_ext.value():
format_type = 'ext4'
format_label = label.value()
break
if event.widget() == cancelbt:
self.restore()
returncode = False
break
dialog.destroy()
if returncode:
return True,format_type,format_label
else:
return False," "," "
def ask_OK(self, info):
yui.YUI.widgetFactory
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_ONE)
dlg.setTitle(info.title)
dlg.setText(info.text, info.richtext)
dlg.setButtonLabel("OK", yui.YMGAMessageBox.B_ONE)
dlg.setMinSize(60, 10);
return dlg.show() == yui.YMGAMessageBox.B_ONE
def ask_YesOrNo(self, info):
yui.YUI.widgetFactory
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_TWO)
dlg.setTitle(info.title)
dlg.setText(info.text, info.richtext)
dlg.setButtonLabel("Yes", yui.YMGAMessageBox.B_ONE)
dlg.setButtonLabel("No", yui.YMGAMessageBox.B_TWO)
dlg.setMinSize(60, 8);
return dlg.show() == yui.YMGAMessageBox.B_ONE
def aboutDialog(self):
yui.YUI.widgetFactory;
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
dlg = mgafactory.createAboutDialog("Isodumper", self.RELEASE, "GPLv2",
"Oliver Grawert<BR />Papoteur<BR />Pictures : Timothée Giet", _("A tool for writing ISO images to a device")+"<BR />http://gitweb.mageia.org/software/isodumper", "")
dlg.show();
def nodevDialog(self):
yui.YUI.widgetFactory
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_TWO)
dlg.setTitle("IsoDumper")
dlg.setText(_("Warning\nNo target devices were found.\nYou need to plug in a USB Key to which the image can be written."))
dlg.setButtonLabel(_("&Refresh"), yui.YMGAMessageBox.B_ONE)
dlg.setButtonLabel(_("Cancel"), yui.YMGAMessageBox.B_TWO)
dlg.setMinSize(60, 8);
return dlg.show() == yui.YMGAMessageBox.B_ONE
def handleevent(self):
self.traitement=None
while True:
event = self.dialog.waitForEvent()
if event.eventType() == yui.YEvent.CancelEvent:
self.close()
break
if event.widget() == self.quitbt:
self.close()
break
if event.widget() == self.ima:
self.img_name=yui.YUI.app().askForExistingFile('file:///home/'+self.user,"*.iso *.img",self.ChooseImage)
self.ima.setLabel(os.path.basename(self.img_name))
self.dialog.recalcLayout()
self.writebt.setEnabled()
self.activate_devicelist()
if event.widget() == self.writebt:
self.wip_unsensitive()
self.do_write()
self.restore()
if event.widget() == self.backupbt:
self.wip_unsensitive()
self.backup_go()
self.restore()
if event.widget() == self.backup_select:
self.backup_img_name=yui.YUI.app().askForSaveFileName('file:///home/'+self.user,"*.img",_("Backup to:"))
if self.backup_img_name != '':
self.backup_choosed()
if event.widget() == self.formatbt:
self.wip_unsensitive()
code,format_type,name = self.ask_format()
if code:
self.do_format(format_type,name)
self.restore()
if event.widget() == self.devicelist:
self.device_selected()
try:
if event.widget() == self.refreshbt:
self.update_list()
except:
pass
try:
if event.widget() == self.helpbt:
self.help_dialog()
except:
pass
try:
if event.widget() == self.quitbt:
self.confirm_close()
except:
pass
if event.widget() == self.aboutbt:
self.aboutDialog()
if __name__ == "__main__":
import sys
user=sys.argv[1]
app = IsoDumper(user)
try:
app.handleevent()
except:
yui.YDialog.deleteAllDialogs()
finally:
# next line seems to be a workaround to prevent the qt-app from crashing
# see https://github.com/libyui/libyui-qt/issues/41
yui.YUILoader.deleteUI()