path: root/iw/partition_gui.py

#
# partition_gui.py: allows the user to choose how to partition their disks
#
# Copyright (C) 2001, 2002  Red Hat, Inc.  All rights reserved.
#
# 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, see <http://www.gnu.org/licenses/>.
#
# Author(s): Matt Wilson <msw@redhat.com>
#            Michael Fulbright <msf@redhat.com>
#

import gobject
import gtk
import gtk.glade
try:
    import gnomecanvas
except ImportError:
    import gnome.canvas as gnomecanvas
import pango
import gui
import parted
import string
import types
import copy

import storage
from iw_gui import *
from flags import flags

import datacombo
import lvm_dialog_gui as l_d_g
import raid_dialog_gui as r_d_g
import partition_dialog_gui as p_d_g

from partIntfHelpers import *
from constants import *
from partition_ui_helpers_gui import *
from storage.partitioning import doPartitioning
from storage.partitioning import hasFreeDiskSpace
from storage.devicelibs import lvm
from storage.devices import devicePathToName, PartitionDevice

import gettext
_ = lambda x: gettext.ldgettext("anaconda", x)
P_ = lambda x, y, z: gettext.ldngettext("anaconda", x, y, z)

import logging
log = logging.getLogger("anaconda")

STRIPE_HEIGHT = 35.0
LOGICAL_INSET = 3.0
TREE_SPACING = 2

# XXX hack but will work for now
if gtk.gdk.screen_width() > 640:
    CANVAS_WIDTH = 490
else:
    CANVAS_WIDTH = 390
CANVAS_HEIGHT = 200

MODE_ADD = 1
MODE_EDIT = 2

class Slice:
    """Class representing a slice of a stripe.

    parent -- the stripe that the slice belongs too.
    text -- what will appear in the slice
    type -- either SLICE or SUBSLICE
    xoffset -- start percentage
    xlength -- a length percentage
    dcCB -- function that is called on a double click.
    cCB -- function that is called when one click (selected)
    sel_col -- color when selected
    unsel_col -- color when unselected
    obj -- some python object that is related to this slice.
    selected -- initial state of slice.
    """
    SLICE = 0
    SUBSLICE = 1
    CONTAINERSLICE = 2

    def __init__(self, parent, text, type, xoffset, xlength, dcCB=lambda: None,
            cCB=lambda x: None, sel_col="cornsilk1", unsel_col="white",
            obj = None, selected = False):
        self.text = text
        self.type = type
        self.xoffset = xoffset
        self.xlength = xlength
        self.parent = parent
        self.dcCB = dcCB
        self.cCB = cCB
        self.sel_col = sel_col
        self.unsel_col = unsel_col
        self.obj = obj
        self.selected = selected

    def eventHandler(self, widget, event):
        if event.type == gtk.gdk.BUTTON_PRESS:
            if event.button == 1:
                self.select()
                self.cCB(self.obj)
        elif event.type == gtk.gdk._2BUTTON_PRESS:
            #self.select()
            self.dcCB()

        return True

    def putOnCanvas(self):
        pgroup = self.parent.getGroup()
        self.group = pgroup.add(gnomecanvas.CanvasGroup)
        self.box = self.group.add(gnomecanvas.CanvasRect)
        self.group.connect("event", self.eventHandler)
        canvas_text = self.group.add(gnomecanvas.CanvasText,
                                    font="sans", size_points=8)

        xoffset = self.xoffset * CANVAS_WIDTH
        xlength = self.xlength * CANVAS_WIDTH

        if self.type == Slice.SUBSLICE:
            yoffset = 0.0 + LOGICAL_INSET
            yheight = STRIPE_HEIGHT - (LOGICAL_INSET * 2)
            texty = 0.0
        else:
            yoffset = 0.0
            yheight = STRIPE_HEIGHT
            texty = LOGICAL_INSET

        if self.selected:
            fill_color = self.sel_col
        else:
            fill_color = self.unsel_col

        self.group.set(x=xoffset, y=yoffset)
        self.box.set(x1=0.0, y1=0.0, x2=xlength,
                     y2=yheight, fill_color=fill_color,
                     outline_color='black', width_units=1.0)
        canvas_text.set(x=2.0, y=texty + 2.0, text=self.text,
                            fill_color='black',
                            anchor=gtk.ANCHOR_NW, clip=True,
                            clip_width=xlength-1, clip_height=yheight-1)

    def shutDown(self):
        self.parent = None
        if self.group:
            self.group.destroy()
            self.group = None

    def select(self):
        for slice in self.parent.slices:
            slice.deselect()
        self.selected = True

        if self.group and self.box:
            if self.type != Slice.CONTAINERSLICE:
                self.group.raise_to_top()
            self.box.set(outline_color="red")
            self.box.set(fill_color=self.sel_col)

    def deselect(self):
        self.selected = False
        if self.box:
            self.box.set(outline_color="black", fill_color=self.unsel_col)

class Stripe(object):
    """
    canvas -- the canvas where everything goes
    text -- the text that will appear on top of the stripe
    yoff -- its the position in the y axis where this stripe should be drawn
    dcCB -- function that should be called on a double click
    obj -- some python object that is related to this stripe

    """
    def __init__(self, canvas, text, dcCB, obj = None):
        self.canvas_text = None
        self.canvas = canvas
        self.text = text
        self.group = None
        self._slices = []
        self.dcCB = dcCB
        self.selected = None
        self.obj = obj

    def putOnCanvas(self, yoff):
        """
        returns the yposition after drawhing this stripe.

        """
        # We set the text for the stripe.
        self.canvas_text = self.canvas.root().add(gnomecanvas.CanvasText,
                x=0.0, y=yoff, font="sans", size_points=9)
        self.canvas_text.set(text=self.text, fill_color='black',
                anchor=gtk.ANCHOR_NW, weight=pango.WEIGHT_BOLD)

        (xxx1, yyy1, xxx2, yyy2) =  self.canvas_text.get_bounds()
        textheight = yyy2 - yyy1 + 2
        self.group = self.canvas.root().add(gnomecanvas.CanvasGroup,
                                       x=0, y=yoff+textheight)

        self.group.add(gnomecanvas.CanvasRect, x1=0.0, y1=0.0, x2=CANVAS_WIDTH,
                  y2=STRIPE_HEIGHT, fill_color='green',
                  outline_color='grey71', width_units=1.0)
        self.group.lower_to_bottom()

        # We paint all the container slices first.  So the contained slices
        # actually show up.
        for slice in [s for s in self.slices if s.type == Slice.CONTAINERSLICE]:
            slice.putOnCanvas()
        # After painting the containers we paint the rest.
        for slice in [s for s in self.slices if s.type != Slice.CONTAINERSLICE]:
            slice.putOnCanvas()

        # 10 is a separator space.
        return yoff + STRIPE_HEIGHT+textheight+10

    def shutDown(self):
        for slice in self.slices:
            slice.shutDown()
        self._slices = []

        if self.canvas_text:
            self.canvas_text.destroy()

        if self.group:
            self.group.destroy()
            self.group = None

    def getGroup(self):
        return self.group

    @property
    def slices(self):
        return self._slices

    def addSlice(self, new_slice):
        # check to see if they overlap.
        for slice in self.slices:
            # Container slices and subslices can overlap.
            if new_slice.type+slice.type == Slice.CONTAINERSLICE+Slice.SUBSLICE:
                continue

            if new_slice.xoffset > slice.xoffset \
                    and new_slice.xoffset < slice.xoffset + slice.xlength:
                # there is a colission, we cannot add.
                return

        self._slices.append(new_slice)

    def getSelectedSlice(self):
        for slice in self.slices:
            if slice.selected:
                return slice
        return None

class StripeGraph:
    """ This class will only handle one stripe."""

    __canvas = None
    def __init__(self):
        self.stripe = None
        self.next_ypos = 0.0

    def __del__(self):
        self.shutDown()

    def shutDown(self):
        if self.stripe:
            self.stripe.shutDown()
            self.stripe = None

        self.next_ypos = 0.0

    @classmethod
    def getCanvas(cls):
        if not StripeGraph.__canvas:
            StripeGraph.__canvas = gnomecanvas.Canvas()
        return StripeGraph.__canvas

    def setDisplayed(self, obj):
        # Check to see if we already have the correct obj displayed.
        if self.getDisplayed() and self.getDisplayed().obj == obj:
            return

        if self.stripe:
            self.stripe.shutDown()

        self.stripe = self._createStripe(obj)
        self.stripe.putOnCanvas(0)

        # Trying to center the picture.
        apply(self.getCanvas().set_scroll_region, self.getCanvas().root().get_bounds())

    def getDisplayed(self):
        return self.stripe

    def selectSliceFromObj(self, obj):
        """Search for obj in the slices """
        stripe = self.getDisplayed()
        if not stripe:
            return

        for slice in stripe.slices:
            # There is a part object in each slice.
            if not slice.obj:
                continue

            if obj == slice.obj and not slice.selected:
                slice.select()
                break

    def _createStripe(self, obj):
        #This method needs to be overridden
        pass

    def getSelectedSlice(self):
        return self.stripe.getSelectedSlice()


class DiskStripeGraph(StripeGraph):
    """Handles the creation of a bar view for the 'normal' devies.

    storage -- the storage object

    cCB -- call back function used when the user clicks on a slice. This function
           is passed a device object when its executed.
    dcCB -- call back function used when the user double clicks on a slice.
    drive -- drive to display
    """
    def __init__(self, storage, drive=None, cCB=lambda x:None, dcCB=lambda:None):
        StripeGraph.__init__(self)
        self.storage = storage
        self.cCB = cCB
        self.dcCB = dcCB
       # Define the default colors per partition type.
        self.part_type_colors = \
                {"sel_logical": "cornsilk1", "unsel_logical": "white",
                 "sel_extended": "cornsilk1", "unsel_extended": "white",
                 "sel_normal": "cornsilk1", "unsel_normal": "white",
                 "sel_freespace": "grey88", "unsel_freespace": "grey88"}
        if drive:
            self.setDisplayed(drive)

    def _createStripe(self, drive):
        # Create the stripe
        drivetext = _("Drive %(drive)s (%(size)-0.f MB) (Model: %(model)s)") \
                    % {'drive': drive.path,
                       'size': drive.size,
                       'model': drive.model}
        stripe = Stripe(self.getCanvas(), drivetext, self.dcCB, obj = drive)

        # Free Extended Calculation
        # Free slice/partition in the extended partition "free space".  If there
        # is space between the last logical partition and the ending of the
        # extended partition we create a "free space" in the extended part.
        # Create the slices.

        # These offsets are where the partition/slices end. 0<offset<1
        last_logical_offset = None
        last_extended_offset = None

        for part in drive.format.partedDisk.getFreeSpacePartitions() \
                + [d for d in drive.format.partitions]:
            if part.getSize(unit="MB") <= 1.0:
                continue

            # Create the start and length for the slice.
            xoffset = (float(part.geometry.start)
                        / float(drive.partedDevice.length))
            xlength = (float(part.geometry.length)
                        / float(drive.partedDevice.length))

            if part.type == parted.PARTITION_LOGICAL:
                partstr = "%s\n%.0f MB" % (part.path, float(part.getSize()))
                stype = Slice.SUBSLICE
                unsel_col = self.part_type_colors["unsel_logical"]
                sel_col = self.part_type_colors["sel_logical"]

                # Free Extended Calculation
                if last_logical_offset == None:
                    last_logical_offset = xoffset + xlength
                elif last_logical_offset < xoffset + xlength:
                    last_logical_offset = xoffset + xlength

            elif part.type == parted.PARTITION_FREESPACE:
                partstr = "%s\n%.0f MB" % (_("Free"), float(part.getSize()))
                stype = Slice.SLICE
                unsel_col = self.part_type_colors["unsel_freespace"]
                sel_col = self.part_type_colors["sel_freespace"]

            elif part.type == parted.PARTITION_EXTENDED:
                partstr = ""
                stype = Slice.CONTAINERSLICE
                unsel_col = self.part_type_colors["unsel_extended"]
                sel_col = self.part_type_colors["sel_extended"]

                # Free Extended Calculation
                last_extended_offset = xoffset + xlength

            elif part.type == parted.PARTITION_NORMAL:
                partstr = "%s\n%.0f MB" % (part.path, float(part.getSize()))
                stype = Slice.SLICE
                unsel_col = self.part_type_colors["unsel_normal"]
                sel_col = self.part_type_colors["sel_normal"]

            else:
                # We don't really want to draw anything in this case.
                continue

            # We need to use the self.storage objects not the partedDisk ones.
            # The free space has not storage object.
            if part.type != parted.PARTITION_FREESPACE:
                partName = devicePathToName(part.getDeviceNodeName())
                o_part = self.storage.devicetree.getDeviceByName(partName)
            else:
                o_part = None

            slice = Slice(stripe, partstr, stype, xoffset, xlength,
                    dcCB = self.dcCB, cCB = self.cCB, sel_col = sel_col,
                    unsel_col = unsel_col, obj = o_part)
            stripe.addSlice(slice)

        # Free Extended Calculation
        if (last_logical_offset != None and last_extended_offset != None) \
                and last_logical_offset < last_extended_offset:
            # We must create a "free extended" slice
            stype = Slice.SUBSLICE
            unsel_col = self.part_type_colors["unsel_freespace"]
            sel_col = self.part_type_colors["sel_freespace"]
            xoffset = last_logical_offset
            xlength = last_extended_offset - last_logical_offset
            slcstr = "%s\n%.0f MB" % (_("Free"), float(drive.size * xlength))

            slice = Slice(stripe, slcstr, stype, xoffset, xlength,
                    dcCB = self.dcCB, cCB = self.cCB, sel_col=sel_col,
                    unsel_col=unsel_col)
            stripe.addSlice(slice)

        return stripe

class LVMStripeGraph(StripeGraph):
    """
    storage -- the storage object

    cCB -- call back function used when the user clicks on a slice. This function
           is passed a device object when its executed.
    dcCB -- call back function used when the user double clicks on a slice.
    vg -- volume group to display
    """
    def __init__(self, storage, vg=None, cCB=lambda x:None, dcCB=lambda:None):
        StripeGraph.__init__(self)
        self.storage = storage
        self.cCB = cCB
        self.dcCB = dcCB
       # Define the default colors per partition type.
        self.part_type_colors = \
                {"sel_lv": "cornsilk1", "unsel_lv": "white",
                 "sel_freespace": "grey88", "unsel_freespace": "grey88"}
        if vg:
            self.setDisplayed(vg)

    def _createStripe(self, vg):
        # Create the stripe
        vgtext = _("LVM Volume Group %s (%-0.f MB)") % (vg.name, vg.size)
        stripe = Stripe(self.getCanvas(), vgtext, self.dcCB, obj = vg)

        # Create the slices.
        # Since se don't have a start and length like in the partitions, we
        # put all the LVs next to each other and put the free space at the end.
        curr_offset = float(0)
        for lv in vg.lvs:
            lvstr = "%s\n%.0f MB" % (lv.name, float(lv.size))
            stype = Slice.SLICE
            sel_col = self.part_type_colors["sel_lv"]
            unsel_col = self.part_type_colors["unsel_lv"]

            #xoffset = float(curr_offset) / float(vg.size)
            xoffset = curr_offset
            xlength = float(lv.size) / float(vg.size)

            slice = Slice(stripe, lvstr, stype, xoffset, xlength,
                    dcCB = self.dcCB, cCB = self.cCB, sel_col = sel_col,
                    unsel_col = unsel_col, obj = lv)
            stripe.addSlice(slice)

            curr_offset += xlength

        # We add the free space if there is any space left.
        if curr_offset < 1:
            #freestr = _("Free")
            stype = Slice.SLICE
            sel_col = self.part_type_colors["sel_freespace"]
            unsel_col = self.part_type_colors["unsel_freespace"]

            xoffset = curr_offset
            xlength = float(1 - curr_offset)

            # with the xlength we give an approximate size
            freestr = "%s\n%.0f MB" % (_("Free"), float(vg.size*xlength))

            # We append no object.
            slice = Slice(stripe, freestr, stype, xoffset, xlength,
                    dcCB = self.dcCB, cCB = self.cCB, sel_col = sel_col,
                    unsel_col = unsel_col)

            stripe.addSlice(slice)

        return stripe

class MDRaidArrayStripeGraph(StripeGraph):
    """
    storage -- the storage object

    cCB -- call back function used when the user clicks on a slice. This function
           is passed a device object when its executed.
    dcCB -- call back function used when the user double clicks on a slice.
    md -- RAID device to display.
    """
    def __init__(self, storage, md=None, cCB=lambda x:None, dcCB=lambda:None):
        StripeGraph.__init__(self)
        self.storage = storage
        self.cCB = cCB
        self.dcCB = dcCB
        self.part_type_colors = \
                {"sel_md": "cornsilk1", "unsel_md": "white"}
        if md:
            self.setDisplayed(md)

    def _createStripe(self, md):
        mdtext = _("MD RAID ARRAY %s (%-0.f MB)") % (md.path, md.size)
        stripe = Stripe(self.getCanvas(), mdtext, self.dcCB, obj = md)

        # Since we can't really create subslices with md devices we will only
        # show the md device size in the bar.
        mdstr = "%s\n%.0f MB" % (md.path, float(md.size))
        stype = Slice.SLICE
        sel_col = self.part_type_colors["sel_md"]
        unsel_col = self.part_type_colors["unsel_md"]
        xoffset = 0
        xlength = 1

        slice = Slice(stripe, mdstr, stype, xoffset, xlength,
                dcCB = self.dcCB, cCB = self.cCB, sel_col = sel_col,
                unsel_col = unsel_col, obj = md)
        stripe.addSlice(slice)

        return stripe

class MessageGraph:
    def __init__(self, canvas, message):
        self.canvas = canvas
        self.message = message
        self.canvas_text = None

    def display(self):
        if self.canvas_text != None:
            # This means that its already displayed.
            return

        self.canvas_text = self.canvas.root().add(gnomecanvas.CanvasText,
                x=0.0, y=20, font="sans", size_points=16)
        self.canvas_text.set(text=self.message, fill_color='black',
                anchor=gtk.ANCHOR_CENTER, weight=pango.WEIGHT_BOLD)

        # Trying to center the picture.
        apply(self.canvas.set_scroll_region, self.canvas.root().get_bounds())

    def destroy(self):
        if self.canvas_text:
            self.canvas_text.destroy()
            self.canvas_text = None

class DiskTreeModelHelper:
    def __init__(self, model, columns, iter):
        self.model = model
        self.iter = iter
        self.columns = columns

    def __getitem__(self, key):
        if type(key) == types.StringType:
            key = self.columns[key]
        try:
            return self.model.get_value(self.iter, key)
        except:
            return None

    def __setitem__(self, key, value):
        if type(key) == types.StringType:
            key = self.columns[key]
        self.model.set_value(self.iter, key, value)

class DiskTreeModel(gtk.TreeStore):
    isLeaf = -3
    isFormattable = -2
    
    # format: column header, type, x alignment, hide?, visibleKey
    titles = ((N_("Device"), gobject.TYPE_STRING, 0.0, 0, 0),
              (N_("Label"), gobject.TYPE_STRING, 0.0, 1, 0),
              (N_("Size (MB)"), gobject.TYPE_STRING, 1.0, 0, 0),
              (N_("Mount Point"), gobject.TYPE_STRING, 0.0, 0, isLeaf),
              (N_("Type"), gobject.TYPE_STRING, 0.0, 0, 0),
              (N_("Format"), gobject.TYPE_OBJECT, 0.5, 0, isFormattable),
              ("", gobject.TYPE_STRING, 0.0, 0, 0),
              # the following must be the last two
              ("IsLeaf", gobject.TYPE_BOOLEAN, 0.0, 1, 0),
              ("IsFormattable", gobject.TYPE_BOOLEAN, 0.0, 1, 0),
              ("PyObject", gobject.TYPE_PYOBJECT, 0.0, 1, 0))
    
    def __init__(self):
	self.hiddenPartitions = []
        self.titleSlot = {}
        i = 0
        types = [self]
        self.columns = []
        for title, kind, alignment, hide, key in self.titles:
            self.titleSlot[title] = i
            types.append(kind)
            if hide:
                i += 1
                continue
            elif kind == gobject.TYPE_OBJECT:
                renderer = gtk.CellRendererPixbuf()
                propertyMapping = {'pixbuf': i}
            elif kind == gobject.TYPE_BOOLEAN:
                renderer = gtk.CellRendererToggle()
                propertyMapping = {'active': i}
            elif (kind == gobject.TYPE_STRING or
                  kind == gobject.TYPE_INT):
                renderer = gtk.CellRendererText()
                propertyMapping = {'markup': i}

            # wire in the cells that we want only visible on leaf nodes to
            # the special leaf node column.
            if key < 0:
                propertyMapping['visible'] = len(self.titles) + key
                
            renderer.set_property('xalign', alignment)
	    if title == "Mount Point":
		title = _("Mount Point/\nRAID/Volume")
	    elif title == "Size (MB)":
		title = _("Size\n(MB)")
            elif title != "":
                title = _(title)
            col = apply(gtk.TreeViewColumn, (title, renderer),
                        propertyMapping)
	    col.set_alignment(0.5)
	    if kind == gobject.TYPE_STRING or kind == gobject.TYPE_INT:
		col.set_property('sizing', gtk.TREE_VIEW_COLUMN_AUTOSIZE)
            self.columns.append(col)
            i += 1

        apply(gtk.TreeStore.__init__, types)

        self.view = gtk.TreeView(self)
        # append all of the columns
        map(self.view.append_column, self.columns)

    def getTreeView(self):
        return self.view

    def selectRowFromObj(self, obj, iter=None):
        """Find the row in the tree containing obj and select it.

        obj -- the object that we are searching
        iter -- an iter from the tree. If None, get the first one.

        Returns the iter where obj was found.  None otherwise.
        """
        retval = None
        r_obj = None
        #FIXME: watch out for hidden rows.

        if not iter:
            iter = self.get_iter_first()

        while iter:
            # r_obj -> (row object)
            r_obj = self[iter]["PyObject"]

            if obj and r_obj == obj:
                # We have fond our object, select this row and break.
                selection = self.view.get_selection()
                if selection is not None:
                    selection.unselect_all()
                    selection.select_iter(iter)

                # Make sure the tree view shows what we have selected.
                path = self.get_path(iter)
                col = self.view.get_column(0)
                self.view.set_cursor(path, col, False)
                self.view.scroll_to_cell(path, col, True, 0.5, 0.5)
                retval = iter
                break

            if self.iter_has_child(iter):
                # Call recursively if row has children.
                rv = self.selectRowFromObj(obj, iter=self.iter_children(iter))
                if rv != None:
                    retval = rv
                    break

            iter = self.iter_next(iter)

        return iter

    def getCurrentDevice(self):
        """ Return the device representing the current selection,
            None otherwise.
        """
        selection = self.view.get_selection()
        model, iter = selection.get_selected()
        if not iter:
            return None

        return model[iter]['PyObject']

    def getCurrentDeviceParent(self):
        """ Return the parent of the selected row.  Returns an iter.
            None if there is no parent.
        """
        selection = self.view.get_selection()
        model, iter = selection.get_selected()
        if not iter:
            return None

        return model.iter_parent(iter)

    def resetSelection(self):
        pass

    def clear(self):
        selection = self.view.get_selection()
        if selection is not None:
            selection.unselect_all()
        gtk.TreeStore.clear(self)

    def __getitem__(self, iter):
        if type(iter) == gtk.TreeIter:
            return DiskTreeModelHelper(self, self.titleSlot, iter)
        raise KeyError, iter


class PartitionWindow(InstallWindow):
    def __init__(self, ics):
	InstallWindow.__init__(self, ics)
        ics.setTitle(_("Partitioning"))
        ics.setNextEnabled(True)
        self.parent = ics.getICW().window

    def quit(self):
        pass

    def presentPartitioningComments(self,title, labelstr1, labelstr2, comments,
				    type="ok", custom_buttons=None):

        if flags.autostep:
            return 1

        win = gtk.Dialog(title)
        gui.addFrame(win)
        
        if type == "ok":
            win.add_button('gtk-ok', 1)
	    defaultchoice = 0
        elif type == "yesno":
            win.add_button('gtk-no', 2)
            win.add_button('gtk-yes', 1)
	    defaultchoice = 1
	elif type == "continue":
            win.add_button('gtk-cancel', 0)
            win.add_button(_("Continue"), 1)
	    defaultchoice = 1
	elif type == "custom":
	    rid=0

	    for button in custom_buttons:
		widget = win.add_button(button, rid)
		rid = rid + 1

            defaultchoice = rid - 1
	    
        image = gtk.Image()
        image.set_from_stock('gtk-dialog-warning', gtk.ICON_SIZE_DIALOG)
        hbox = gtk.HBox(False, 9)
	al=gtk.Alignment(0.0, 0.0)
	al.add(image)
        hbox.pack_start(al, False)

        buffer = gtk.TextBuffer(None)
        buffer.set_text(comments)
        text = gtk.TextView()
        text.set_buffer(buffer)
        text.set_property("editable", False)
        text.set_property("cursor_visible", False)
        text.set_wrap_mode(gtk.WRAP_WORD)
        
        sw = gtk.ScrolledWindow()
        sw.add(text)
	sw.set_size_request(400, 200)
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_IN)
        
        info1 = gtk.Label(labelstr1)
        info1.set_line_wrap(True)
        info1.set_size_request(400, -1)

        info2 = gtk.Label(labelstr2)
        info2.set_line_wrap(True)
        info2.set_size_request(400, -1)
        
        vbox = gtk.VBox(False, 9)

	al=gtk.Alignment(0.0, 0.0)
	al.add(info1)
        vbox.pack_start(al, False)
	
        vbox.pack_start(sw, True, True)

	al=gtk.Alignment(0.0, 0.0)
	al.add(info2)
        vbox.pack_start(al, True)
	
        hbox.pack_start(vbox, True, True)

        win.vbox.pack_start(hbox)
        win.set_position(gtk.WIN_POS_CENTER)
        win.set_default_response(defaultchoice)
        win.show_all()
        rc = win.run()
        win.destroy()
        return rc
        
    def getNext(self):
        (errors, warnings) = self.storage.sanityCheck()
        if errors:
            labelstr1 =  _("The partitioning scheme you requested "
                           "caused the following critical errors.")
            labelstr2 = _("You must correct these errors before "
                          "you continue your installation of "
                          "%s.") % (productName,)

            commentstr = string.join(errors, "\n\n")
            
            self.presentPartitioningComments(_("Partitioning Errors"),
                                             labelstr1, labelstr2,
                                             commentstr, type="ok")
            raise gui.StayOnScreen
        
        if warnings:
            # "storage configuration"
            labelstr1 = _("The partitioning scheme you requested "
                          "generated the following warnings.")
            labelstr2 = _("Would you like to continue with "
                         "your requested partitioning "
                         "scheme?")
            
            commentstr = string.join(warnings, "\n\n")
            rc = self.presentPartitioningComments(_("Partitioning Warnings"),
                                                  labelstr1, labelstr2,
                                                  commentstr,
						  type="yesno")
            if rc != 1:
                raise gui.StayOnScreen

        formatWarnings = getPreExistFormatWarnings(self.storage)
        if formatWarnings:
            labelstr1 = _("The following pre-existing devices have been "
                          "selected to be formatted, destroying all data.")

#            labelstr2 = _("Select 'Yes' to continue and format these "
#                          "partitions, or 'No' to go back and change these "
#                          "settings.")
            labelstr2 = ""
            commentstr = ""
            for (dev, type, mntpt) in formatWarnings:
                commentstr = commentstr + \
                        "%s         %s         %s\n" % (dev,type,mntpt)

            rc = self.presentPartitioningComments(_("Format Warnings"),
                                                  labelstr1, labelstr2,
                                                  commentstr,
						  type="custom",
						  custom_buttons=["gtk-cancel",
								  _("_Format")])
            if rc != 1:
                raise gui.StayOnScreen

        self.stripeGraph.shutDown()
        self.tree.clear()
        del self.parent
        return None

    def getPrev(self):
        self.stripeGraph.shutDown()
        self.storage.clearPartType = None
        self.storage.reset()
        self.tree.clear()
        del self.parent
        return None

    def addDevice(self, device, treeiter):
        if device.format.hidden:
            return

        if device.format.type == "luks":
            # we'll want to grab format info from the mapped
            # device, not the encrypted one
            try:
                dm_dev = self.storage.devicetree.getChildren(device)[0]
            except IndexError:
                format = device.format
            else:
                format = dm_dev.format
        else:
            format = device.format

        # icon for the format column
        if device.format.type == "luks" and not device.format.exists:
            # we're creating the LUKS header
            format_icon = self.lock_pixbuf
        elif not format.exists:
            # we're creating a format on the device
            format_icon = self.checkmark_pixbuf
        else:
            format_icon = None

        # mount point string
        if format.type == "lvmpv":
            vg = None
            for _vg in self.storage.vgs:
                if _vg.dependsOn(device):
                    vg = _vg
                    break

            mnt_str = getattr(vg, "name", "")
        elif format.type == "mdmember":
            array = None
            for _array in self.storage.mdarrays:
                if _array.dependsOn(device):
                    array = _array
                    break

            mnt_str = getattr(array, "name", "")
        else:
            mnt_str = getattr(format, "mountpoint", "")
            if mnt_str is None:
                mnt_str = ""

        # device name
        name_str = getattr(device, "lvname", device.name)

        # label
        label_str = getattr(format, "label", "")
        if label_str is None:
            label_str = ""

        self.tree[treeiter]['Device'] = name_str
        self.tree[treeiter]['Size (MB)'] = "%Ld" % device.size
        self.tree[treeiter]['PyObject'] = device
        self.tree[treeiter]['IsFormattable'] = format.formattable
        self.tree[treeiter]['Format'] = format_icon
        self.tree[treeiter]['Mount Point'] = mnt_str
        self.tree[treeiter]['IsLeaf'] = True
        self.tree[treeiter]['Type'] = format.name
        self.tree[treeiter]['Label'] = label_str

    def populate(self, initial = 0):
        self.tree.resetSelection()

        # first do LVM
        vgs = self.storage.vgs
        if vgs:
	    lvmparent = self.tree.append(None)
	    self.tree[lvmparent]['Device'] = _("LVM Volume Groups")
            for vg in vgs:
                vgparent = self.tree.append(lvmparent)
                self.addDevice(vg, vgparent)
                self.tree[vgparent]['Type'] = ""
                for lv in vg.lvs:
                    iter = self.tree.append(vgparent)
                    self.addDevice(lv, iter)

                # We add a row for the VG free space.
                if vg.freeSpace > 0:
                    iter = self.tree.append(vgparent)
                    self.tree[iter]['Device'] = _("Free")
                    self.tree[iter]['Size (MB)'] = vg.freeSpace
                    self.tree[iter]['PyObject'] = None
                    self.tree[iter]['Mount Point'] = ""
                    self.tree[iter]['IsLeaf'] = True

        # handle RAID next
        mdarrays = self.storage.mdarrays
        if mdarrays:
	    raidparent = self.tree.append(None)
	    self.tree[raidparent]['Device'] = _("RAID Devices")
            for array in mdarrays:
                iter = self.tree.append(raidparent)
                self.addDevice(array, iter)
                name = "%s <span size=\"small\" color=\"gray\">(%s)</span>" % \
                            (array.name, array.path)
                self.tree[iter]['Device'] = name

        # now normal partitions
        disks = self.storage.partitioned
        drvparent = self.tree.append(None)
        self.tree[drvparent]['Device'] = _("Hard Drives")
        for disk in disks:
            # add a parent node to the tree
            parent = self.tree.append(drvparent)

            self.tree[parent]['PyObject'] = disk
            if disk.partitioned:
                part = disk.format.firstPartition
                extendedParent = None
                while part:
                    if part.type & parted.PARTITION_METADATA:
                        part = part.nextPartition()
                        continue

                    partName = devicePathToName(part.getDeviceNodeName())
                    device = self.storage.devicetree.getDeviceByName(partName)
                    if not device and not part.type & parted.PARTITION_FREESPACE:
                        log.debug("can't find partition %s in device"
                                           " tree" % partName)

                    # ignore the tiny < 1 MB free space partitions (#119479)
                    if part.getSize(unit="MB") <= 1.0 and \
                       part.type & parted.PARTITION_FREESPACE:
                        if not part.active or not device.bootable:
                            part = part.nextPartition()
                            continue

                    if device and device.isExtended:
                        if extendedParent:
                            raise RuntimeError, ("can't handle more than "
                                                 "one extended partition per disk")
                        extendedParent = self.tree.append(parent)
                        iter = extendedParent
                    elif device and device.isLogical:
                        if not extendedParent:
                            raise RuntimeError, ("crossed logical partition "
                                                 "before extended")
                        iter = self.tree.append(extendedParent)
                    else:
                        iter = self.tree.append(parent)

                    if device and not device.isExtended:
                        self.addDevice(device, iter)
                    else:
                        # either extended or freespace
                        if part.type & parted.PARTITION_FREESPACE:
                            devstring = _("Free")
                            ptype = ""
                        else:
                            devstring = device.name
                            ptype = _("Extended")

                        self.tree[iter]['Device'] = devstring
                        self.tree[iter]['Type'] = ptype
                        size = part.getSize(unit="MB")
                        if size < 1.0:
                            sizestr = "< 1"
                        else:
                            sizestr = "%Ld" % (size)
                        self.tree[iter]['Size (MB)'] = sizestr
                        self.tree[iter]['PyObject'] = device

                    part = part.nextPartition()
            else:
                # whole-disk formatting
                self.addDevice(disk, parent)

            # Insert a '\n' when device string is too long.  Usually when it
            # contains '/dev/mapper'.  First column should be around 20 chars.
            if len(disk.name) + len(disk.path) > 20:
                separator = "\n"
            else:
                separator= " "
            self.tree[parent]['Device'] = \
                    "%s%s<span size=\"small\" color=\"gray\">(%s)</span>" \
                    % (disk.name, separator, disk.path)

        self.treeView.expand_all()
        self.messageGraph.display()

    def barviewActivateCB(self):
        """ Should be called when we double click on a slice"""
        # This is a bit of a hack to make the double click on free space work.
        # This function is useful when the selected slice is a free space,
        # in any other case it calls self.treeActiveCB.

        # We first see if the double click was from a free space or from another
        # slice.
        sel_slice = self.stripeGraph.getSelectedSlice()

        if sel_slice == None:
            # This really should not happen. Do nothing.
            return

        # The selected slice is a free slice if the object contained in it is
        # None.
        if sel_slice.obj != None:
            # This is not a free slice, we should call treeActivateCB
            return self.treeActivateCB()
        else:
            # Display a create window according to the stripe object.
            # Get the device from the stripe.obj
            disp_stripe = self.stripeGraph.getDisplayed()
            if disp_stripe == None:
                # this should not happen
                return

            # Display a create dialog.
            stripe_dev = disp_stripe.obj
            if stripe_dev.partitioned:
                tempformat = self.storage.defaultFSType
                device = self.storage.newPartition(fmt_type=tempformat)
                self.editPartition(device, isNew = True)

            elif isinstance(stripe_dev, storage.LVMVolumeGroupDevice):
                self.editLVMLogicalVolume(vg = stripe_dev)
                return

    def treeActivateCB(self, *args):
        curr_dev = self.tree.getCurrentDevice()
        if isinstance(curr_dev, storage.PartitionDevice) \
                or isinstance(curr_dev, storage.LVMLogicalVolumeDevice) \
                or isinstance(curr_dev, storage.LVMVolumeGroupDevice) \
                or isinstance(curr_dev, storage.MDRaidArrayDevice):
            self.editCB()

        elif curr_dev == None:
            # Its probably a free space
            iparent = self.tree.getCurrentDeviceParent()
            if iparent == None:
                # it was not free space, it is a root row.
                return

            # We execute a create function given the type of parent that was
            # found.
            # FIXME: This code might repeat itself.  might be a good idea to
            # put it in a function.
            curr_parent = self.tree[iparent]["PyObject"]
            if curr_parent.partitioned:
                tempformat = self.storage.defaultFSType
                device = self.storage.newPartition(fmt_type=tempformat)
                self.editPartition(device, isNew = True)

            elif isinstance(curr_parent, storage.LVMVolumeGroupDevice):
                self.editLVMLogicalVolume(vg = curr_parent)
                return

    def treeSelectCB(self, selection, *args):
        # The edit and create buttons will be enabled if the user has chosen
        # something editable and/or deletable.
        self.deleteButton.set_sensitive(False)
        self.editButton.set_sensitive(False)

        # I have no idea why this iter might be None.  Its best to return
        # without any action.
        model, iter = selection.get_selected()
        if not iter:
            return

        # If we return because there is no parent, make sure we show the user
        # the infoGraph and no stripeGraph.  The 'create' and 'delete' buttons
        # will be deactivated.
        iparent = model.iter_parent(iter)
        if not iparent:
            self.stripeGraph.shutDown()
            self.messageGraph.display()
            return # This is a root row.

        # We destroy the message first.  We will make sure to repaint it later
        # if no stipe is displayed.  Can't destroy it at the end of this func
        # because it uncenters the created stripe, if any.
        self.messageGraph.destroy()

        device = model[iter]['PyObject']

        # See if we need to change what is in the canvas. In all possibilities
        # we must make sure we have the correct StripeGraph class.
        if not device:
            # This is free space.
            parent = self.tree[iparent]["PyObject"]
            if parent.partitioned:
                if not isinstance(self.stripeGraph, DiskStripeGraph):
                    self.stripeGraph.shutDown()
                    self.stripeGraph = DiskStripeGraph(self.storage,
                            drive = parent, cCB = self.tree.selectRowFromObj,
                            dcCB = self.barviewActivateCB)
                self.stripeGraph.setDisplayed(parent)

            elif isinstance(parent, storage.LVMVolumeGroupDevice):
                if not isinstance(self.stripeGraph, LVMStripeGraph):
                    self.stripeGraph.shutDown()
                    self.stripeGraph = LVMStripeGraph(self.storage,
                            vg = parent, cCB = self.tree.selectRowFromObj,
                            dcCB = self.barviewActivateCB)
                self.stripeGraph.setDisplayed(parent)

        elif device.partitioned:
            if not isinstance(self.stripeGraph, DiskStripeGraph):
                self.stripeGraph.shutDown()
                self.stripeGraph = DiskStripeGraph(self.storage,
                        drive = device,
                        cCB = self.tree.selectRowFromObj,
                        dcCB = self.barviewActivateCB)
            self.stripeGraph.setDisplayed(device)
            # this is deletable but not editable.
            self.deleteButton.set_sensitive(True)

        elif isinstance(device, storage.PartitionDevice):
            if not isinstance(self.stripeGraph, DiskStripeGraph):
                self.stripeGraph.shutDown()
                self.stripeGraph = DiskStripeGraph(self.storage,
                        drive = device.parents[0],
                        cCB = self.tree.selectRowFromObj,
                        dcCB = self.barviewActivateCB)
            self.stripeGraph.setDisplayed(device.parents[0])
            self.stripeGraph.selectSliceFromObj(device)
            self.deleteButton.set_sensitive(True)
            self.editButton.set_sensitive(True)

        elif isinstance(device, storage.LVMVolumeGroupDevice):
            if not isinstance(self.stripeGraph, LVMStripeGraph):
                self.stripeGraph.shutDown()
                self.stripeGraph = LVMStripeGraph(self.storage, vg = device,
                        cCB = self.tree.selectRowFromObj,
                        dcCB = self.barviewActivateCB)
            self.stripeGraph.setDisplayed(device)
            self.deleteButton.set_sensitive(True)
            self.editButton.set_sensitive(True)

        elif isinstance(device, storage.LVMLogicalVolumeDevice):
            if not isinstance(self.stripeGraph, LVMStripeGraph):
                self.stripeGraph.shutDown()
                self.stripeGraph = LVMStripeGraph(self.storage, vg = device.vg,
                        cCB = self.tree.selectRowFromObj,
                        dcCB = self.barviewActivateCB)
            self.stripeGraph.setDisplayed(device.vg)
            self.stripeGraph.selectSliceFromObj(device)
            self.deleteButton.set_sensitive(True)
            self.editButton.set_sensitive(True)

        elif isinstance(device, storage.MDRaidArrayDevice):
            if not isinstance(self.stripeGraph, MDRaidArrayStripeGraph):
                self.stripeGraph.shutDown()
                self.stripeGraph = MDRaidArrayStripeGraph(self.storage,
                        md = device,
                        cCB = self.tree.selectRowFromObj,
                        dcCB = self.barviewActivateCB)
            self.stripeGraph.setDisplayed(device)
            self.deleteButton.set_sensitive(True)
            self.editButton.set_sensitive(True)

        else:
            # This means that the user selected something that is not showable
            # in the bar view.  Just show the information message.
            self.stripeGraph.shutDown()
            self.messageGraph.display()
            self.deleteButton.set_sensitive(False)
            self.editButton.set_sensitive(False)

    def deleteCB(self, widget):
        """ Right now we can say that if the device is partitioned we
            want to delete all of the devices it contains. At some point
            we will want to support creation and removal of partitionable
            devices. This will need some work when that time comes.
        """
        device = self.tree.getCurrentDevice()
        if device.partitioned:
            if doClearPartitionedDevice(self.intf,
                                        self.storage,
                                        device):
                self.refresh()
        elif doDeleteDevice(self.intf,
                            self.storage,
                            device):
            if isinstance(device, storage.devices.PartitionDevice):
                justRedraw = False
            else:
                justRedraw = True
                if device.type == "lvmlv" and device in device.vg.lvs:
                    device.vg._removeLogVol(device)

            self.refresh(justRedraw=justRedraw)

    def createCB(self, *args):
        # First we must decide what parts of the create_storage_dialog
        # we will activate.

        # For the Partition checkboxes.
        # If we see that there is free space in the "Hard Drive" list, then we
        # must activate all the partition radio buttons (RAID partition,
        # LVM partition and Standard partition).  We will have only one var to
        # control all three activations (Since they all depend on the same
        # thing)
        activate_create_partition = False
        free_part_available = hasFreeDiskSpace(self.storage)
        if free_part_available:
            activate_create_partition = True

        # We activate the create Volume Group radio button if there is a free
        # partition with a Physical Volume format.
        activate_create_vg = False
        availpvs = len(self.storage.unusedPVs())
        if (lvm.has_lvm()
                and getFormat("lvmpv").supported
                and availpvs > 0):
            activate_create_vg = True

        # We activate the create RAID dev if there are partitions that have
        # raid format and are not related to any raid dev.
        activate_create_raid_dev = False
        availraidparts = len(self.storage.unusedMDMembers())
        availminors = self.storage.unusedMDMinors
        if (len(availminors) > 0
                and getFormat("software RAID").supported
                and availraidparts > 1):
            activate_create_raid_dev = True

        # FIXME: Why do I need availraidparts to clone?
        activate_create_raid_clone = False
        if (len(self.storage.partitioned) > 1
                and availraidparts > 0):
            activate_create_raid_clone = True

        # Must check if all the possibilities are False.  In this case tell the
        # user that he can't create anything and the reasons.
        if (not activate_create_partition
                and not activate_create_vg
                and not activate_create_raid_dev
                and not activate_create_raid_clone):
            self.intf.messageWindow(_("Cannot perform any creation action"),
                        _("Note that the creation action requires one of the "
                        "following:\n\n"
                        "* Free space in one of the Hard Drives.\n"
                        "* At least two free Software RAID partitions.\n"
                        "* At least one free physical volume (LVM) partition.\n"
                        "* At least one Volume Group with free space."),
                        custom_icon="warning")
            return

        # We will activate the create lv button when we have a VG to put the
        # LVs on.
        activate_create_lv = False
        vgs_with_free_space = []
        for vg in self.storage.vgs:
            if vg.freeSpace > 0:
                vgs_with_free_space.append(vg)
        if len(vgs_with_free_space) > 0:
            activate_create_lv = True

        # GTK crap starts here.
        create_storage_xml = gtk.glade.XML(
                gui.findGladeFile("create-storage.glade"), domain="anaconda")
        self.dialog = create_storage_xml.get_widget("create_storage_dialog")

        # Activate the partition radio buttons if needed.
        # sp_rb -> standard partition
        sp_rb = create_storage_xml.get_widget("create_storage_rb_standard_part")
        # lp_rb -> lvm partition (physical volume)
        lp_rb = create_storage_xml.get_widget("create_storage_rb_lvm_part")
        # rp_rb -> RAID partition
        rp_rb = create_storage_xml.get_widget("create_storage_rb_raid_part")
        if activate_create_partition:
            sp_rb.set_sensitive(True)
            lp_rb.set_sensitive(True)
            rp_rb.set_sensitive(True)

        # Activate the Volume Group radio buttons if needed.
        # vg_rb -> Volume Group
        vg_rb = create_storage_xml.get_widget("create_storage_rb_lvm_vg")
        if activate_create_vg:
            vg_rb.set_sensitive(True)

        # Activate the Logical Volume radio button if needed.
        # We must also take care to control the combo box.
        lv_rb = create_storage_xml.get_widget("create_storage_rb_lvm_lv")
        if activate_create_lv:
            # The combobox will be visible if the radio button is active.
            # The combobox will be sensitive when the radio button is active.
            def toggle_vg_cb_CB(button, vg_cb, selected_dev):
                if button.get_active():
                    vg_cb.set_sensitive(True)

                    # We set the VG to whatever the user has chosen in the tree
                    # view. We will fall back on the first item on the list if
                    # there is no chosen VG.
                    if selected_dev and selected_dev.name \
                            and vg_cb.set_active_text(selected_dev.name):
                        # if set_active is True, we don't need to do anything else
                        pass
                    else:
                        vg_cb.set_active_text(vgs_with_free_space[0].name)

                else:
                    vg_cb.set_sensitive(False)

            vg_cb_st = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
            vg_cb = datacombo.DataComboBox(store = vg_cb_st)
            vg_cb.set_sensitive(False)

            for vg in vgs_with_free_space:
                # FIXME: the name length might be a problem.
                vg_cb.append(vg.name, vg)
            lv_hb = create_storage_xml.get_widget("create_storage_hb_lvm_lv")
            lv_hb.pack_start(vg_cb)

            lv_rb.set_sensitive(True)
            selected_dev = self.tree.getCurrentDevice()
            lv_rb.connect("toggled", toggle_vg_cb_CB, vg_cb, selected_dev)

        # Activate the RAID dev if needed.
        # rd_rb -> RAID device
        rd_rb = create_storage_xml.get_widget("create_storage_rb_raid_dev")
        if activate_create_raid_dev:
            rd_rb.set_sensitive(True)

        # Activate RAID clone if needed.
        # rc_rb -> RAID clone
        rc_rb = create_storage_xml.get_widget("create_storage_rb_raid_clone")
        if activate_create_raid_clone:
            rc_rb.set_sensitive(True)

        # Before drawing lets select the first radio button that is sensitive:
        # How can I get sensitivity from gtk.radiobutton?
        if activate_create_partition:
            sp_rb.set_active(True)
        elif activate_create_vg:
            vg_rb.set_active(True)
        elif activate_create_raid_dev:
            rd_rb.set_active(True)
        elif activate_create_raid_clone:
            rc_rb.set_active(True)

        gui.addFrame(self.dialog)
        self.dialog.show_all()

        # Lets work the information messages with CB
        # The RAID info message
        rinfo_button = create_storage_xml.get_widget("create_storage_info_raid")
        whatis_r = _("Software RAID allows you to combine several disks into "
                    "a larger RAID device.  A RAID device can be configured "
                    "to provide additional speed and reliability compared "
                    "to using an individual drive.  For more information on "
                    "using RAID devices please consult the %s "
                    "documentation.\n") % (productName,)
        whatneed_r = _("To use RAID you must first create at least two "
                "partitions of type 'software RAID'.  Then you can create a "
                "RAID device that can be formatted and mounted.\n\n")
        whathave_r = P_(
                "You currently have %d software RAID partition free to use.",
                "You currently have %d software RAID partitions free to use.",
                availraidparts) % (availraidparts,)
        rinfo_message = "%s\n%s%s" % (whatis_r, whatneed_r, whathave_r)
        rinfo_cb = lambda x : self.intf.messageWindow(_("About RAID"),
                                rinfo_message, custom_icon="information")
        rinfo_button.connect("clicked", rinfo_cb)

        # The LVM info message
        lvminfo_button = create_storage_xml.get_widget("create_storage_info_lvm")
        whatis_lvm = _("Logical Volume Manager (LVM) is a 3 level construct. "
                "The first level is made up of disks or partitions formatted with "
                "LVM metadata called Physical Volumes (PV).  A Volume Group "
                "(VG) sits on top of one or more PVs. The VG, in turn, is the "
                "base to create one or more Logical Volumes (LV).  Note that a "
                "VG can be an aggregate of PVs from multiple physical disks.  For "
                "more information on using LVM please consult the %s "
                "documentation\n") % (productName, )
        whatneed_lvm = _("To create a PV you need a partition with "
                "free space.  To create a VG you need a PV that is not "
                "part of any existing VG.  To create an LV you need a VG with "
                "free space.\n\n")
        whathave_lvm = P_("You currently have %d available PV free to use.\n",
                            "You currently have %d available PVs free to use.\n",
                            availpvs) % (availpvs, )
        if free_part_available:
            whathave_lvm = whathave_lvm + _("You currently have free space to "
                    "create PVs.")
        lvminfo_message = "%s\n%s%s" % (whatis_lvm, whatneed_lvm, whathave_lvm)
        lvminfo_cb = lambda x : self.intf.messageWindow(_("About LVM"),
                                    lvminfo_message, custom_icon="information")
        lvminfo_button.connect("clicked", lvminfo_cb)

        dialog_rc = self.dialog.run()

        # If Cancel was pressed
        if dialog_rc == 0:
            self.dialog.destroy()
            return

        # If Create was pressed  Make sure we do a dialog.destroy before
        # calling any other screen.  We don't want the create dialog to show
        # in the back when we pop up other screens.
        if dialog_rc != 1:
            log.error("I received a dialog_rc != 1 (%d) witch should not "
                    "happen" % dialog_rc)
            self.dialog.destroy()
            return

        self.dialog.destroy()
        if rp_rb.get_active():
            member = self.storage.newPartition(fmt_type="mdmember")
            self.editPartition(member, isNew = True, restrictfs=["mdmember"])
            return

        elif rc_rb.get_active():
            # r_d_g -> raid_dialog_gui
            cloneDialog = r_d_g.RaidCloneDialog(self.storage, self.intf,
                    self.parent)
            if cloneDialog is None:
                self.intf.messageWindow(_("Couldn't Create Drive Clone Editor"),
                                        _("The drive clone editor could not "
                                          "be created for some reason."),
                                        custom_icon="error")
                return

            if cloneDialog.run():
                self.refresh()

            cloneDialog.destroy()
            return

        elif rd_rb.get_active():
            array = self.storage.newMDArray(fmt_type=self.storage.defaultFSType)
            self.editRaidArray(array, isNew = True)
            return

        elif lp_rb.get_active():
            member = self.storage.newPartition(fmt_type="lvmpv")
            self.editPartition(member, isNew = True, restrictfs=["lvmpv"])
            return

        elif vg_rb.get_active():
            tempvg = self.storage.newVG()
            self.editLVMVolumeGroup(tempvg, isNew = True)
            return

        elif lv_rb.get_active():
            selected_vg = vg_cb.get_active_value()
            self.editLVMLogicalVolume(vg = selected_vg)
            return

        elif sp_rb.get_active():
            tempformat = self.storage.defaultFSType
            device = self.storage.newPartition(fmt_type=tempformat)
            self.editPartition(device, isNew = True)
            return

    def resetCB(self, *args):
        if not confirmResetPartitionState(self.intf):
            return

        self.stripeGraph.shutDown()
        self.storage.reset()
        self.tree.clear()
        self.populate()

    def refresh(self, justRedraw=None):
        log.debug("refresh: justRedraw=%s" % justRedraw)
        self.stripeGraph.shutDown()
        self.tree.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),
                                        custom_icon="error")
                rc = -1
            except PartitioningWarning, msg:
                # XXX somebody other than me should make this look better
                # XXX this doesn't handle the 'delete /boot partition spec' case
                #     (it says 'add anyway')
                dialog = gtk.MessageDialog(self.parent, 0, gtk.MESSAGE_WARNING,
                                           gtk.BUTTONS_NONE,
                                           _("Warning: %s.") % (msg))
                gui.addFrame(dialog)
                button = gtk.Button(_("_Modify Partition"))
                dialog.add_action_widget(button, 1)
                button = gtk.Button(_("_Continue"))
                dialog.add_action_widget(button, 2)
                dialog.set_position(gtk.WIN_POS_CENTER)

                dialog.show_all()
                rc = dialog.run()
                dialog.destroy()
                
                if rc == 1:
                    rc = -1
                else:
                    rc = 0
                    all_devices = self.storage.devicetree.devices
                    bootDevs = [d for d in all_devices if d.bootable]
                    #if reqs:
                    #    for req in reqs:
                    #        req.ignoreBootConstraints = 1

	if not rc == -1:
	    self.populate()

        return rc

    def editCB(self, *args):
        device = self.tree.getCurrentDevice()
        reason = self.storage.deviceImmutable(device, ignoreProtected=True)
        if reason:
            self.intf.messageWindow(_("Unable To Edit"),
                                    _("You cannot edit this device:\n\n%s")
                                    % reason,
                                    custom_icon="error")
            return

        if device.type == "mdarray":
            self.editRaidArray(device)
        elif device.type == "lvmvg":
            self.editLVMVolumeGroup(device)
        elif device.type == "lvmlv":
            self.editLVMLogicalVolume(lv = device)
        elif isinstance(device, storage.devices.PartitionDevice):
            self.editPartition(device)

    # isNew implies that this request has never been successfully used before
    def editRaidArray(self, raiddev, isNew = False):
        # r_d_g -> raid_dialog_gui
        raideditor = r_d_g.RaidEditor(self.storage, self.intf, self.parent,
                raiddev, isNew)

        while True:
            actions = raideditor.run()

            for action in actions:
                # FIXME: this needs to handle exceptions
                self.storage.devicetree.registerAction(action)

	    if self.refresh(justRedraw=True):
                actions.reverse()
                for action in actions:
                    self.storage.devicetree.cancelAction(action)
                    if self.refresh():
                        raise RuntimeError, ("Returning partitions to state "
                                             "prior to RAID edit failed")
                continue
	    else:
		break

	raideditor.destroy()		


    def editPartition(self, device, isNew = False, restrictfs = None):
        # p_d_g -> partition_dialog_gui
        parteditor = p_d_g.PartitionEditor(self.anaconda, self.parent, device,
                isNew = isNew, restrictfs = restrictfs)

        while True:
            orig_device = copy.copy(device)
            actions = parteditor.run()

            for action in actions:
                # XXX we should handle exceptions here
                self.anaconda.storage.devicetree.registerAction(action)

            if self.refresh(justRedraw=not actions):
                # autopart failed -- cancel the actions and try to get
                # back to previous state
                actions.reverse()
                for action in actions:
                    self.anaconda.storage.devicetree.cancelAction(action)

                # FIXME: proper action/device management would be better
                if not isNew:
                    device.req_size = orig_device.req_size
                    device.req_base_size = orig_device.req_base_size
                    device.req_grow = orig_device.req_grow
                    device.req_max_size = orig_device.req_max_size
                    device.req_primary = orig_device.req_primary
                    device.req_disks = orig_device.req_disks

                if self.refresh():
                    # this worked before and doesn't now...
                    raise RuntimeError, ("Returning partitions to state "
                                         "prior to edit failed")
            else:
		break

	parteditor.destroy()
	return 1

    def editLVMVolumeGroup(self, device, isNew = False):
        # l_d_g -> lvm_dialog_gui
        vgeditor = l_d_g.VolumeGroupEditor(self.anaconda, self.intf, self.parent,
                device, isNew)

        while True:
            actions = vgeditor.run()

            for action in actions:
                # FIXME: handle exceptions
                self.storage.devicetree.registerAction(action)

	    if self.refresh(justRedraw=True):
                actions.reverse()
                for action in actions:
                    self.storage.devicetree.cancelAction(action)

                if self.refresh():
                    raise RuntimeError, ("Returning partitions to state "
                                         "prior to edit failed")
		continue
	    else:
		break

	vgeditor.destroy()

    def editLVMLogicalVolume (self, lv = None, vg = None):
        """Will be consistent with the state of things and use this funciton
        for creating and editing LVs.

        lv -- the logical volume to edit.  If this is set there is no need
              for the other two arguments.
        vg -- the volume group where the new lv is going to be created. This
              will only be relevant when we are createing an LV.
        """

        if lv != None:
            # l_d_g -> lvm_dialog_gui
            vgeditor = l_d_g.VolumeGroupEditor(self.anaconda, self.intf, self.parent,
                    lv.vg, isNew = False)
            lv = vgeditor.lvs[lv.lvname]
            isNew = False

        elif vg != None:
            # l_d_g -> lvm_dialog_gui
            vgeditor = l_d_g.VolumeGroupEditor(self.anaconda, self.intf, self.parent,
                    vg, isNew = False)
            tempvg = vgeditor.getTempVG()
            name = self.storage.createSuggestedLVName(tempvg)
            vgeditor.lvs[name] = {'name': name,
                              'size': vg.freeSpace,
                              'format': getFormat(self.storage.defaultFSType),
                              'stripes': 1,
                              'logSize': 0,
                              'snapshotSpace': 0,
                              'exists': False}
            lv = vgeditor.lvs[name]
            isNew = True

        else:
            # This is non-sense.
            return


        while True:
            vgeditor.editLogicalVolume(lv, isNew = isNew)
            actions = vgeditor.convertToActions()

            for action in actions:
                # FIXME: handle exceptions
                self.storage.devicetree.registerAction(action)

            if self.refresh(justRedraw=True):
                actions.reverse()
                for action in actions:
                    self.storage.devicetree.cancelAction(action)

                if self.refresh():
                    raise RuntimeError, ("Returning partitions to state "
                                         "prior to edit failed")
                continue
            else:
                break

        vgeditor.destroy()

    def getScreen(self, anaconda):
        self.anaconda = anaconda
        self.storage = anaconda.storage
        self.intf = anaconda.intf
        self.checkmark_pixbuf = gui.getPixbuf("checkMark.png")
        self.lock_pixbuf = gui.getPixbuf("gnome-lock.png")

        checkForSwapNoMatch(anaconda)

        # Beginning of the GTK stuff.
        # create the operational buttons
        buttonBox = gtk.HButtonBox()
        buttonBox.set_spacing(6)
        buttonBox.set_layout(gtk.BUTTONBOX_END)

        ops = ((_("_Create"), self.createCB),
               (_("_Edit"), self.editCB),
               (_("_Delete"), self.deleteCB),
               (_("Re_set"), self.resetCB))

        for label, cb in ops:
            button = gtk.Button(label)
            buttonBox.add (button)
            button.connect ("clicked", cb)

            # We need these to control their sensitivity.
            if label == _("_Edit"):
                self.editButton = button
                self.editButton.set_sensitive(False)
            elif label == _("_Delete"):
                self.deleteButton = button
                self.deleteButton.set_sensitive(False)

        # Create the disk tree (Fills the tree and the Bar View)
        self.tree = DiskTreeModel()
        self.treeView = self.tree.getTreeView()
        self.treeView.connect('row-activated', self.treeActivateCB)
        self.treeViewSelection = self.treeView.get_selection()
        self.treeViewSelection.connect("changed", self.treeSelectCB)
        self.stripeGraph = StripeGraph()
        self.messageGraph = MessageGraph(self.stripeGraph.getCanvas(),
                _("Please Select A Device"))
        self.populate(initial = 1)

        # Create the top scroll window
        # We don't actually need a *scroll* window but nuthing else worked.
        hadj = gtk.Adjustment(step_incr = 5.0)
        vadj = gtk.Adjustment(step_incr = 5.0)
        swt = gtk.ScrolledWindow(hadjustment = hadj, vadjustment = vadj)
        swt.add(self.stripeGraph.getCanvas())
        swt.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        swt.set_shadow_type(gtk.SHADOW_IN)

        # Create the bottom scroll window
        swb = gtk.ScrolledWindow()
        swb.add(self.treeView)
        swb.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        swb.set_shadow_type(gtk.SHADOW_IN)

        # Create main vertical box and add everything.
        MVbox = gtk.VBox(False, 5)
        MVbox.pack_start(swt, False, False)
        MVbox.pack_start(swb, True)
        MVbox.pack_start(buttonBox, False, False)
        MVbox.pack_start(gtk.HSeparator(), False)

        return MVbox