def __init__(self, *args):
QtGui.QWidget.__init__(self,None)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.connect(self.ui.newButton, SIGNAL("clicked()"),self.createDevice)
self.connect(self.ui.editButton, SIGNAL("clicked()"),self.editDevice)
self.connect(self.ui.deleteButton, SIGNAL("clicked()"),self.deleteDevice)
self.connect(self.ui.resetButton, SIGNAL("clicked()"),self.reset)
self.connect(self.ui.deviceTree, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.activateButtons)
self.connect(self.menu, SIGNAL("triggered(QAction*)"), self.createDevice)
# self.ui.deviceTree.hide()
self._active_device = None
self.ui.GGdeviceTree = BlockGroup(self, _("Hard Drives"))
self.ui.verticalLayout.addWidget(self.ui.GGdeviceTree)
self.ui.GGVdeviceTree = BlockGroup(self, _("Volume Groups"))
self.ui.verticalLayout.addWidget(self.ui.GGVdeviceTree)
self.ui.GGRdeviceTree = BlockGroup(self, _("Raid Arrays"))
self.ui.verticalLayout.addWidget(self.ui.GGRdeviceTree)
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.connect(self.ui.newButton, SIGNAL("clicked()"),self.createDevice)
self.connect(self.ui.editButton, SIGNAL("clicked()"),self.editDevice)
self.connect(self.ui.deleteButton, SIGNAL("clicked()"),self.deleteDevice)
self.connect(self.ui.resetButton, SIGNAL("clicked()"),self.reset)
self.connect(self.ui.deviceTree, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.activateButtons)
self.connect(self.menu, SIGNAL("triggered(QAction*)"), self.createDevice)
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.ui.newButtonclicked.connect(self.createDevice)
self.ui.editButton.clicked.connect(self.editDevice)
self.ui.deleteButton.clicked.connect(self.deleteDevice)
self.ui.resetButton.clicked.connect(self.reset)
self.ui.deviceTree.itemClicked[QTreeWidgetItem,
int].connect(self.activateButtons)
self.menu.triggered[QAction].connect(self.createDevice)
def __init__(self, *args):
QtGui.QWidget.__init__(self,None)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.connect(self.ui.newButton, SIGNAL("clicked()"),self.createDevice)
self.connect(self.ui.editButton, SIGNAL("clicked()"),self.editDevice)
self.connect(self.ui.deleteButton, SIGNAL("clicked()"),self.deleteDevice)
self.connect(self.ui.resetButton, SIGNAL("clicked()"),self.reset)
self.connect(self.ui.deviceTree, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.activateButtons)
self.connect(self.menu, SIGNAL("triggered(QAction*)"), self.createDevice)
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.ui.newButtonclicked.connect(self.createDevice)
self.ui.editButton.clicked.connect(self.editDevice)
self.ui.deleteButton.clicked.connect(self.deleteDevice)
self.ui.resetButton.clicked.connect(self.reset)
self.ui.deviceTree.itemClicked[QTreeWidgetItem , int].connect(self.activateButtons)
self.menu.triggered[QAction].connect(self.createDevice)
class Widget(QtGui.QWidget, ScreenWidget):
title = _('Manual Partitioning')
desc = _('You can easily configure your partitions...')
icon = "iconPartition"
helpSummary = _("Partition manual summary")
help = _('''
<p>
In this screen, you can manually partition your disk. You can select
existing partitions and resize or delete them. You can create new
partition(s) in the empty parts, make Pardus use them for system files,
users' home directories, swap space or general use. The changes that you
make will not be applied until you go on with the installation,
which means you can revert if you make any unwanted changes or change your configuration.
</p>
<p>
Please refer to Pardus Installing and Using Guide for more information
about disk partitioning.
</font>
''')
def __init__(self, *args):
QtGui.QWidget.__init__(self,None)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.connect(self.ui.newButton, SIGNAL("clicked()"),self.createDevice)
self.connect(self.ui.editButton, SIGNAL("clicked()"),self.editDevice)
self.connect(self.ui.deleteButton, SIGNAL("clicked()"),self.deleteDevice)
self.connect(self.ui.resetButton, SIGNAL("clicked()"),self.reset)
self.connect(self.ui.deviceTree, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.activateButtons)
self.connect(self.menu, SIGNAL("triggered(QAction*)"), self.createDevice)
def shown(self):
checkForSwapNoMatch(self.intf, self.storage)
self.populate()
(errors, warnings) = self.storage.sanityCheck()
if errors or warnings:
ctx.mainScreen.disableNext()
else:
ctx.mainScreen.enableNext()
def execute(self):
ctx.logger.info("Manual Partitioning selected...")
ctx.mainScreen.processEvents()
check = self.nextCheck()
if not check:
ctx.mainScreen.enableBack()
elif check is None:
ctx.mainScreen.enableNext()
return check
def update(self):
if self.storage.storageset.rootDevice:
ctx.mainScreen.enableNext()
else:
ctx.mainScreen.disableNext()
self.updateMenus()
def activateButtons(self, item, index):
if item:
if isinstance(item.device, Device) and not isinstance(item.device, parted.partition.Partition):
self.ui.editButton.setEnabled(True)
self.ui.deleteButton.setEnabled(True)
else:
self.ui.editButton.setEnabled(False)
self.ui.deleteButton.setEnabled(False)
def nextCheck(self):
(errors, warnings) = self.storage.sanityCheck()
if errors:
detailed = _("The partitioning scheme you requested\n"
"caused the following critical errors.\n"
"You must correct these errors before\n"
"you continue your installation of %s." %
yali.util.product_name())
comments = "\n\n".join(errors)
self.intf.detailedMessageWindow(_("Partitioning Errors"),
detailed, comments, type="ok")
return False
if warnings:
detailed = _("The partitioning scheme you requested generated the \n"
"following warnings. Would you like to continue with \n"
"your requested partitioning "
"scheme?")
comments = "\n\n".join(warnings)
rc = self.intf.detailedMessageWindow(_("Partitioning Warnings"),
detailed, comments, type="custom",
customButtons=[_("Ok"), _("Cancel")], default=1)
if rc == 1:
return False
formatWarnings = getPreExistFormatWarnings(self.storage)
if formatWarnings:
detailed = _("The following pre-existing devices have\n"
"been selected to be formatted, destroying\n"
"all data.")
comments = ""
for (device, type, mountpoint) in formatWarnings:
comments = comments + "%s %s %s\n" % (device, type, mountpoint)
rc = self.intf.detailedMessageWindow(_("Format Warnings"),
detailed, comments, type="custom",
customButtons=[_("Format"), _("Cancel")], default=1)
if rc:
return False
return True
def backCheck(self):
rc = self.intf.messageWindow(_("Warning"), _("All Changes that you made will be removed"),
type="custom", customIcon="question",
customButtons=[_("Ok"), _("Cancel")], default=1)
if not rc:
self.storage.reset()
return True
return False
def setupMenu(self):
self.menu = QtGui.QMenu("New")
self.standardDevices = self.menu.addMenu(_("Standard"))
self.lvmDevices = self.menu.addMenu(_("LVM"))
self.raidDevices = self.menu.addMenu(_("RAID"))
self.createPartition = self.standardDevices.addAction(_("Partition"))
self.createPartition.setWhatsThis(_("General purpose of partition creation"))
self.createPartition.setVisible(False)
self.createPhysicalVolume = self.lvmDevices.addAction(_("Physical Volume"))
self.createPhysicalVolume.setWhatsThis(_("Create LVM formatted partition"))
self.createPhysicalVolume.setVisible(False)
self.createVolumeGroup = self.lvmDevices.addAction(_("Volume Group"))
self.createVolumeGroup.setWhatsThis(_("Requires at least 1 free LVM formatted partition"))
self.createVolumeGroup.setVisible(False)
self.createLogicalVolume = self.lvmDevices.addAction(_("Logical Volume"))
self.createLogicalVolume.setWhatsThis(_("Create Logical Volume on selected Volume Group"))
self.createLogicalVolume.setVisible(False)
self.createRaidMember = self.raidDevices.addAction(_("Member"))
self.createRaidMember.setWhatsThis(_("Create Raid formatted partition"))
self.createRaidMember.setVisible(False)
self.createRaidArray= self.raidDevices.addAction(_("Array"))
self.createRaidArray.setWhatsThis(_("Requires at least 2 free Raid formatted partition"))
self.createRaidArray.setVisible(False)
self.ui.newButton.setMenu(self.menu)
def addDevice(self, device, item):
if device.format.hidden:
return
format = device.format
if not format.exists:
formatIcon = QtGui.QIcon(":/images/tick.png")
else:
formatIcon = QtGui.QIcon(":/images/dialog-error.png")
# mount point string
if format.type == "lvmpv":
vg = None
for _vg in self.storage.vgs:
if _vg.dependsOn(device):
vg = _vg
break
mountpoint = getattr(vg, "name", "")
elif format.type == "mdmember":
array = None
for _array in self.storage.raidArrays:
if _array.dependsOn(device):
array = _array
break
mountpoint = getattr(array, "name", "")
else:
mountpoint = getattr(format, "mountpoint", "")
if mountpoint is None:
mountpoint = ""
# device name
name = getattr(device, "lvname", device.name)
# label
label = getattr(format, "label", "")
if label is None:
label = ""
item.setDevice(device)
item.setName(name)
item.setMountpoint(mountpoint)
item.setLabel(label)
item.setType(format.name)
item.setSize("%Ld" % device.size)
item.setFormat(formatIcon)
def populate(self):
# Clear device tree
self.ui.deviceTree.clear()
# first do LVM
vgs = self.storage.vgs
if vgs:
volumeGroupsItem = DeviceTreeItem(self.ui.deviceTree)
volumeGroupsItem.setName(_("Volume Groups"))
for vg in vgs:
volumeGroupItem = DeviceTreeItem(volumeGroupsItem)
self.addDevice(vg, volumeGroupItem)
volumeGroupItem.setType("")
for lv in vg.lvs:
logicalVolumeItem = DeviceTreeItem(volumeGroupItem)
self.addDevice(lv, logicalVolumeItem)
# We add a row for the VG free space.
if vg.freeSpace > 0:
freeLogicalVolumeItem = DeviceTreeItem(volumeGroupItem)
freeLogicalVolumeItem.setName(_("Free"))
freeLogicalVolumeItem.setSize("%Ld" % vg.freeSpace)
freeLogicalVolumeItem.setDevice(None)
freeLogicalVolumeItem.setMountpoint("")
# handle RAID next
raidarrays = self.storage.raidArrays
if raidarrays:
raidArraysItem = DeviceTreeItem(self.ui.deviceTree)
raidArraysItem.setName(_("Raid Arrays"))
for array in raidarrays:
raidArrayItem = DeviceTreeItem(raidArraysItem)
self.addDevice(array, raidArrayItem)
# now normal partitions
disks = self.storage.partitioned
# also include unpartitioned disks that aren't mpath or biosraid
whole = filter(lambda d: not d.partitioned and not d.format.hidden,
self.storage.disks)
disks.extend(whole)
disks.sort(key=lambda d: d.name)
# Disk&Partitions
drivesItem = DeviceTreeItem(self.ui.deviceTree)
drivesItem.setName(_("Hard Drives"))
for disk in disks:
diskItem = DeviceTreeItem(drivesItem)
diskItem.setName("%s - %s" % (disk.model, disk.name))
#self.ui.deviceTree.expandItem(diskItem)
if disk.partitioned:
partition = disk.format.firstPartition
extendedItem = None
while partition:
if partition.type & parted.PARTITION_METADATA:
partition = partition.nextPartition()
continue
partName = devicePathToName(partition.getDeviceNodeName())
device = self.storage.devicetree.getDeviceByName(partName)
if not device and not partition.type & parted.PARTITION_FREESPACE:
ctx.logger.debug("can't find partition %s in device tree" % partName)
# Force partitions tree item not to be less than 12 MB
if partition.getSize(unit="MB") <= 12.0:
if not partition.active or not partition.getFlag(parted.PARTITION_BOOT):
partition = partition.nextPartition()
continue
if device and device.isExtended:
if extendedItem:
raise RuntimeError, _("Can't handle more than "
"one extended partition per disk")
extendedItem = partItem = DeviceTreeItem(diskItem)
partitionItem = extendedItem
elif device and device.isLogical:
if not extendedItem:
raise RuntimeError, _("Crossed logical partition before extended")
partitionItem = DeviceTreeItem(extendedItem)
else:
# Free space item
if partition.type & parted.PARTITION_LOGICAL:
partitionItem = DeviceTreeItem(extendedItem)
else:
partitionItem = DeviceTreeItem(diskItem)
if device and not device.isExtended:
self.addDevice(device, partitionItem)
else:
# either extended or freespace
if partition.type & parted.PARTITION_FREESPACE:
deviceName = _("Free")
device = partition
deviceType = ""
else:
deviceName = device.name
deviceType = _("Extended")
partitionItem.setName(deviceName)
partitionItem.setType(deviceType)
size = partition.getSize(unit="MB")
if size < 1.0:
size = "< 1"
else:
size = "%Ld" % (size)
partitionItem.setSize(size)
partitionItem.setDevice(device)
partition = partition.nextPartition()
else:
self.addDevice(disk, diskItem)
#Expands all item in selected device tree item
for index in range(self.ui.deviceTree.topLevelItemCount()):
self.ui.deviceTree.topLevelItem(index).setExpanded(True)
childItem = self.ui.deviceTree.topLevelItem(index)
for childIndex in range(childItem.childCount()):
childItem.child(childIndex).setExpanded(True)
def refresh(self, justRedraw=None):
ctx.logger.debug("refresh: justRedraw=%s" % justRedraw)
self.ui.deviceTree.clear()
if justRedraw:
rc = 0
else:
try:
doPartitioning(self.storage)
rc = 0
except PartitioningError, msg:
self.intf.messageWindow(_("Error Partitioning"),
_("Could not allocate requested partitions: %s." % msg),
customIcon="error")
rc = -1
except PartitioningWarning, msg:
rc = self.intf.messageWindow(_("Warning Partitioning"),
_("Warning: %s." % msg),
customButtons=[_("Modify Partition"), _("Continue")],
customIcon="warning")
if rc == 1:
rc = -1
else:
rc = 0
all_devices = self.storage.devicetree.devices
bootDevs = [d for d in all_devices if d.bootable]
class Widget(QWidget, ScreenWidget):
name = "manualPartitioning"
def __init__(self):
QWidget.__init__(self)
self.ui = Ui_ManualPartWidget()
self.ui.setupUi(self)
self.storage = ctx.storage
self.intf = ctx.interface
# New Device Popup Menu
self.setupMenu()
#self.ui.newButtonclicked.connect(self.createDevice)
self.ui.editButton.clicked.connect(self.editDevice)
self.ui.deleteButton.clicked.connect(self.deleteDevice)
self.ui.resetButton.clicked.connect(self.reset)
self.ui.deviceTree.itemClicked[QTreeWidgetItem,
int].connect(self.activateButtons)
self.menu.triggered[QAction].connect(self.createDevice)
def shown(self):
checkForSwapNoMatch(self.intf, self.storage)
self.populate()
(errors, warnings) = self.storage.sanityCheck()
if errors or warnings:
ctx.mainScreen.disableNext()
else:
ctx.mainScreen.enableNext()
self.update()
def execute(self):
ctx.logger.info("Manual Partitioning selected...")
ctx.mainScreen.processEvents()
check = self.nextCheck()
if not check:
ctx.mainScreen.enableBack()
elif check is None:
ctx.mainScreen.enableNext()
return check
def update(self):
if self.storage.storageset.rootDevice:
ctx.mainScreen.enableNext()
else:
ctx.mainScreen.disableNext()
self.updateMenus()
def activateButtons(self, item, index):
if item:
if isinstance(item.device, Device) and not isinstance(
item.device, parted.partition.Partition):
self.ui.editButton.setEnabled(True)
self.ui.deleteButton.setEnabled(True)
else:
self.ui.editButton.setEnabled(False)
self.ui.deleteButton.setEnabled(False)
def nextCheck(self):
(errors, warnings) = self.storage.sanityCheck()
if errors:
detailed = _("The partitioning scheme you requested "
"caused the following critical errors."
"You must correct these errors before "
"you continue your installation of %s.") \
% yali.util.product_name()
comments = "\n\n".join(errors)
self.intf.detailedMessageWindow(_("Partitioning Errors"),
detailed,
comments,
type="error")
return False
if warnings:
detailed = _("The partitioning scheme you requested generated the "
"following warnings. Would you like to continue with "
"your requested partitioning "
"scheme?")
comments = "\n\n".join(warnings)
rc = self.intf.detailedMessageWindow(
_("Partitioning Warnings"),
detailed,
comments,
type="custom",
customIcon="warning",
customButtons=[_("Ok"), _("Cancel")],
default=1)
if rc:
return False
formatWarnings = getPreExistFormatWarnings(self.storage)
if formatWarnings:
detailed = _("The following pre-existing devices have "
"been selected to be formatted, destroying "
"all data.")
comments = ""
for (device, type, mountpoint) in formatWarnings:
comments = comments + "%s %s %s\n" % (
device, type, mountpoint)
rc = self.intf.detailedMessageWindow(
_("Format Warnings"),
detailed,
comments,
type="custom",
customIcon="warning",
customButtons=[_("Format"), _("Cancel")],
default=1)
if rc:
return False
return True
def backCheck(self):
rc = self.intf.messageWindow(
_("Warning"),
_("All Changes that you made will be removed"),
type="custom",
customIcon="warning",
customButtons=[_("Ok"), _("Cancel")],
default=1)
if not rc:
self.storage.reset()
return True
return False
def setupMenu(self):
self.menu = QMenu("New")
self.standardDevices = self.menu.addMenu(_("Standard"))
self.lvmDevices = self.menu.addMenu(_("LVM"))
self.raidDevices = self.menu.addMenu(_("RAID"))
self.createPartition = self.standardDevices.addAction(_("Partition"))
self.createPartition.setWhatsThis(
_("General purpose of partition creation"))
self.createPartition.setVisible(False)
self.createPhysicalVolume = self.lvmDevices.addAction(
_("Physical Volume"))
self.createPhysicalVolume.setWhatsThis(
_("Create LVM formatted partition"))
self.createPhysicalVolume.setVisible(False)
self.createVolumeGroup = self.lvmDevices.addAction(_("Volume Group"))
self.createVolumeGroup.setWhatsThis(
_("Requires at least 1 free LVM formatted partition"))
self.createVolumeGroup.setVisible(False)
self.createLogicalVolume = self.lvmDevices.addAction(
_("Logical Volume"))
self.createLogicalVolume.setWhatsThis(
_("Create Logical Volume on selected Volume Group"))
self.createLogicalVolume.setVisible(False)
self.createRaidMember = self.raidDevices.addAction(_("Member"))
self.createRaidMember.setWhatsThis(
_("Create Raid formatted partition"))
self.createRaidMember.setVisible(False)
self.createRaidArray = self.raidDevices.addAction(_("Array"))
self.createRaidArray.setWhatsThis(
_("Requires at least 2 free Raid formatted partition"))
self.createRaidArray.setVisible(False)
self.ui.newButton.setMenu(self.menu)
def addDevice(self, device, item):
if device.format.hidden:
return
format = device.format
if not format.exists:
formatIcon = QIcon(":/gui/pics/tick.png")
else:
#formatIcon = QIcon(":/gui/pics/dialog-error.png")
formatIcon = QIcon("")
# mount point string
if format.type == "lvmpv":
vg = None
for _vg in self.storage.vgs:
if _vg.dependsOn(device):
vg = _vg
break
mountpoint = getattr(vg, "name", "")
elif format.type == "mdmember":
array = None
for _array in self.storage.raidArrays:
if _array.dependsOn(device):
array = _array
break
mountpoint = getattr(array, "name", "")
else:
mountpoint = getattr(format, "mountpoint", "")
if mountpoint is None:
mountpoint = ""
# device name
name = getattr(device, "lvname", device.name)
# label
label = getattr(format, "label", "")
if label is None:
label = ""
item.setDevice(device)
item.setName(name)
item.setMountpoint(mountpoint)
item.setLabel(label)
item.setType(format.name)
item.setSize("%Ld" % device.size)
item.setFormat(formatIcon)
item.setExpanded(True)
def populate(self):
# Clear device tree
self.ui.deviceTree.clear()
# first do LVM
vgs = self.storage.vgs
if vgs:
volumeGroupsItem = DeviceTreeItem(self.ui.deviceTree)
volumeGroupsItem.setName(_("Volume Groups"))
volumeGroupsItem.setExpanded(True)
for vg in vgs:
volumeGroupItem = DeviceTreeItem(volumeGroupsItem)
self.addDevice(vg, volumeGroupItem)
volumeGroupItem.setType("")
for lv in vg.lvs:
logicalVolumeItem = DeviceTreeItem(volumeGroupItem)
self.addDevice(lv, logicalVolumeItem)
# We add a row for the VG free space.
if vg.freeSpace > 0:
freeLogicalVolumeItem = DeviceTreeItem(volumeGroupItem)
freeLogicalVolumeItem.setName(_("Free"))
freeLogicalVolumeItem.setSize("%Ld" % vg.freeSpace)
freeLogicalVolumeItem.setDevice(None)
freeLogicalVolumeItem.setMountpoint("")
# handle RAID next
raidarrays = self.storage.raidArrays
if raidarrays:
raidArraysItem = DeviceTreeItem(self.ui.deviceTree)
raidArraysItem.setName(_("Raid Arrays"))
raidArraysItem.setExpanded(True)
for array in raidarrays:
raidArrayItem = DeviceTreeItem(raidArraysItem)
self.addDevice(array, raidArrayItem)
# now normal partitions
disks = self.storage.partitioned
# also include unpartitioned disks that aren't mpath or biosraid
whole = filter(lambda d: not d.partitioned and not d.format.hidden,
self.storage.disks)
disks.extend(whole)
disks.sort(key=lambda d: d.name)
# Disk&Partitions
drivesItem = DeviceTreeItem(self.ui.deviceTree)
drivesItem.setName(_("Hard Drives"))
drivesItem.setExpanded(True)
for disk in disks:
diskItem = DeviceTreeItem(drivesItem)
diskItem.setExpanded(True)
diskItem.setName("%s - %s" % (disk.model, disk.name))
#self.ui.deviceTree.expandItem(diskItem)
if disk.partitioned:
partition = disk.format.firstPartition
extendedItem = None
while partition:
if partition.type & parted.PARTITION_METADATA:
partition = partition.nextPartition()
continue
partName = devicePathToName(partition.getDeviceNodeName())
device = self.storage.devicetree.getDeviceByName(partName)
if not device and not partition.type & parted.PARTITION_FREESPACE:
ctx.logger.debug(
"can't find partition %s in device tree" %
partName)
# Force partitions tree item not to be less than 12 MB
if partition.getSize(unit="MB") <= 12.0:
if not partition.active or not partition.getFlag(
parted.PARTITION_BOOT):
partition = partition.nextPartition()
continue
if device and device.isExtended:
if extendedItem:
raise RuntimeError, _(
"Can't handle more than "
"one extended partition per disk")
extendedItem = partItem = DeviceTreeItem(diskItem)
partitionItem = extendedItem
elif device and device.isLogical:
if not extendedItem:
raise RuntimeError, _(
"Crossed logical partition before extended")
partitionItem = DeviceTreeItem(extendedItem)
else:
# Free space item
if partition.type & parted.PARTITION_LOGICAL:
partitionItem = DeviceTreeItem(extendedItem)
else:
partitionItem = DeviceTreeItem(diskItem)
if device and not device.isExtended:
self.addDevice(device, partitionItem)
else:
# either extended or freespace
if partition.type & parted.PARTITION_FREESPACE:
deviceName = _("Free")
device = partition
deviceType = ""
else:
deviceName = device.name
deviceType = _("Extended")
partitionItem.setName(deviceName)
partitionItem.setType(deviceType)
size = partition.getSize(unit="MB")
if size < 1.0:
size = "< 1"
else:
size = "%Ld" % (size)
partitionItem.setSize(size)
partitionItem.setDevice(device)
partition = partition.nextPartition()
else:
self.addDevice(disk, diskItem)
def refresh(self, justRedraw=None):
ctx.logger.debug("refresh: justRedraw=%s" % justRedraw)
self.ui.deviceTree.clear()
if justRedraw:
rc = 0
else:
try:
doPartitioning(self.storage)
rc = 0
except PartitioningError, msg:
self.intf.messageWindow(
_("Error Partitioning"),
_("Could not allocate requested partitions: %s.") % msg,
customIcon="error")
rc = -1
except PartitioningWarning, msg:
rc = self.intf.messageWindow(
_("Warning Partitioning"),
_("Warning: %s.") % msg,
customButtons=[_("Modify Partition"),
_("Continue")],
customIcon="warning")
if rc == 1:
rc = -1
else:
rc = 0
all_devices = self.storage.devicetree.devices
bootDevs = [d for d in all_devices if d.bootable]
