Exemple #1
0
def f_installtype(anaconda):

    anaconda.sn = '999'
    '''
    f = open("/root/isotype")
    lines = f.readlines()
    f.close()
    for line in lines:
        isotype = string.strip(line)
        break
    '''
    import fvi
    isotype = fvi.get_iso_type()
    anaconda.isotype = isotype.split('.')[0]
    # raise TypeError,self.anaconda.isotype
    if True:
        anaconda.id.installationtype = True
        anaconda.dispatch.skipStep("filtertype", skip=1)
        anaconda.dispatch.skipStep("u_filtertype", skip=0)

        anaconda.dispatch.skipStep("network", skip=1)
        anaconda.dispatch.skipStep("u_network", skip=0)

        anaconda.dispatch.skipStep("parttype", skip=1)
        anaconda.dispatch.skipStep("u_parttype", skip=0)

        anaconda.dispatch.skipStep("tasksel", skip=1)
        anaconda.dispatch.skipStep("u_tasksel", skip=0)

        anaconda.dispatch.skipStep("complete", skip=1)
        anaconda.dispatch.skipStep("u_complete", skip=0)

    return None
    def getNext(self):
        
        self.anaconda.sn = self.sn_entry.get_text()
        if len(self.anaconda.sn)==0:
            self.intf.messageWindow(_("Error With Data"),
                                _(u"必须输入出厂编号才能进行下一步操作!"))
            raise gui.StayOnScreen
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
        for line in lines:
            isotype = string.strip(line)
            break
        '''
        import fvi
        isotype = fvi.get_iso_type()
                
        self.anaconda.isotype = isotype.split('.')[0]
        if self.buttonGroup_setCurrent == "fast":
            self.anaconda.id.installationtype = True
            self.anaconda.dispatch.skipStep("filtertype",skip=1)
            self.anaconda.dispatch.skipStep("u_filtertype",skip=0)

            self.anaconda.dispatch.skipStep("network",skip=1)
            self.anaconda.dispatch.skipStep("u_network",skip=0)
 
            self.anaconda.dispatch.skipStep("parttype",skip=1)
            self.anaconda.dispatch.skipStep("u_parttype",skip=0)

            self.anaconda.dispatch.skipStep("tasksel",skip=1)
            self.anaconda.dispatch.skipStep("u_tasksel",skip=0)

            self.anaconda.dispatch.skipStep("complete",skip=1)
            self.anaconda.dispatch.skipStep("u_complete",skip=0)
        else:
            self.anaconda.id.installationtype = False
            self.anaconda.dispatch.skipStep("u_filtertype",skip=1)
            self.anaconda.dispatch.skipStep("filtertype",skip=0)

            self.anaconda.dispatch.skipStep("network",skip=0)
            self.anaconda.dispatch.skipStep("u_network",skip=1)

            self.anaconda.dispatch.skipStep("parttype",skip=0)
            self.anaconda.dispatch.skipStep("u_parttype",skip=1)

            self.anaconda.dispatch.skipStep("tasksel",skip=0)
            self.anaconda.dispatch.skipStep("u_tasksel",skip=1)

            self.anaconda.dispatch.skipStep("complete",skip=0)
            self.anaconda.dispatch.skipStep("u_complete",skip=1)
        #import pdb
        #pdb.set_trace()
        return None
Exemple #3
0
        def is_vc_va():

            try:
                '''
                isotype_file = "/root/isotype"
                strs = file(isotype_file).read()
                '''
                import fvi
                x = fvi.get_iso_type()
        
                if "vCenter" in x or "vAccess" in x:
                    return True
            except:
                pass
            return False
Exemple #4
0
    def getScreen(self, anaconda):
        self.anaconda = anaconda
        self.storage = anaconda.id.storage
        self.intf = anaconda.intf
        self.dispatch = anaconda.dispatch

        if self.anaconda.dir == DISPATCH_FORWARD:
            # Save system's partition type setting and restore user's
            self.anaconda.clearPartTypeSystem = self.storage.clearPartType
            if self.anaconda.clearPartTypeSelection is not None:
                self.storage.clearPartType = self.anaconda.clearPartTypeSelection


        self.prevrev = None
        ##############################################
        
        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True

        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"
        
        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon8_harddisk_partition.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>分区类型:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        label2.set_markup("<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>选择一种分区方式</b></span>")
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()

        vbox = gtk.VBox(False,0) 
        vbox.pack_start(eboximage,expand=False,fill=False)
        
        fix = gtk.Fixed()
        label = gtk.Label()
        label.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>您的安装将使用哪种分区方式?</b></span>\
        ")
        fix.put(label,70,55)
    
        rvbox = gtk.VBox()
        rvbox.show()
        fix.put(rvbox,70,100)
        radio = gtk.RadioButton(None)
        radio.connect("toggled",self.radiocallback,"all")
        rlabel1 = gtk.Label()
        rlabel1.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>使用所有空间</b></span>")
        lstr = "<span font=' 8.5' foreground='#525252' size='large'><b>    删除所选设备中的所有分区,其中包括其他操作系统创建的分区。\
\n    提示:这个选项将删除所选设备的所有数据,确定您已经做了备份。</b></span>"
        radio.add(rlabel1)
        
        rvbox.pack_start(radio, False,False,0)
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,5)
        
        radio.set_active(True)
        radio.show()
    
        radiof = gtk.RadioButton(radio)
        radiof.connect("toggled",self.radiocallback,"custom")
        rlabel2 = gtk.Label()
        rlabel2.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>使用自定义布局</b></span>")
        lstr = "<span font=' 8.5' foreground='#525252' size='large'><b>    使用分区工具手动在所选设备中创建自定义布局。</b></span>"
        radiof.add(rlabel2)
    
        rvbox.pack_start(radiof, False, False,5)
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,0)
        
        radiof.show()
        vbox.pack_start(fix,True,True)
        self.reviewButton = gtk.CheckButton(u"检验和修改分区方案")
        
        tmphbox = gtk.HBox()
        #tmphbox.pack_start(self.reviewButton,False,False,0)
        vbox.pack_start(tmphbox,False,False,0)
        ##############################################
        self.reviewButton.set_active(False)
        self.reviewButton.set_sensitive(False)

        # if not set in ks, use UI default
        if self.storage.clearPartChoice:
            #self.buttonGroup.setCurrent(self.storage.clearPartChoice)
            self.buttonGroup_setCurrent = self.storage.clearPartChoice
        else:
            if self.storage.clearPartType is None or self.storage.clearPartType == CLEARPART_TYPE_LINUX:
                #self.buttonGroup.setCurrent("replace")
                self.buttonGroup_setCurrent = "repalce"
            elif self.storage.clearPartType == CLEARPART_TYPE_NONE:
                #self.buttonGroup.setCurrent("freespace")
                self.buttonGroup_setCurrent = "freespace"
            elif self.storage.clearPartType == CLEARPART_TYPE_ALL:
                #self.buttonGroup.setCurrent("all")
                self.buttonGroup_setCurrent = "all"

        #if self.buttonGroup.getCurrent() == "custom":
        if self.buttonGroup_setCurrent == "custom":
            # make sure reviewButton is active and not sensitive
            if self.prevrev == None:
                self.prevrev = self.reviewButton.get_active()

            self.reviewButton.set_active(True)
            self.reviewButton.set_sensitive(False)
            #self.encryptButton.set_sensitive(False)\
            
        self.buttonGroup_setCurrent = "all"
        radio.set_active(True)
        radiof.set_active(False)
        self.reviewButton.set_active(False)  
        self.storage.clearPartType = CLEARPART_TYPE_ALL  

        return vbox
Exemple #5
0
    def getScreen(self, anaconda):
        # We skip the filter UI in basic storage mode
        if anaconda.id.simpleFilter:
            anaconda.id.storage.exclusiveDisks = []
            return None

        (self.xml, self.vbox) = gui.getGladeWidget("filter.glade", "vbox")
        self.buttonBox = self.xml.get_widget("buttonBox")
        self.notebook = self.xml.get_widget("notebook")
        #self.addAdvanced = self.xml.get_widget("addAdvancedButton")
        self.options = self.xml.get_widget("optionsButton")
        # liuweifeng
        #self.addAdvanced.hide_all()
        ol = self.options.get_property("label")
        self.options.set_property("label",ol[1:])
        osl = self.xml.get_widget("sizeLabel")
        osl.set_property("label",'选择了 %s 个设备(%sM),共 %s 个设备(%sM)。')
        #bs = self.xml.get_widget("basicScroll")
        #bs.set_property("label",'')
        
        self.notebook.connect("switch-page", self._page_switched)
        #self.addAdvanced.connect("clicked", self._add_advanced_clicked)
        self.options.connect("clicked", self._options_clicked)

        self.pages = []

        self.anaconda = anaconda

        # One common store that all the views on all the notebook tabs share.
        # Yes, this means a whole lot of columns that are going to be empty or
        # unused much of the time.  Oh well.

        # Object,
        # visible, active (checked), immutable,
        # device, model, capacity, vendor, interconnect, serial number, wwid
        # paths, port, target, lun
        self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT, 
                                   gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_BOOLEAN,gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_LONG, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING)
        self.store.set_sort_column_id(MODEL_COL, gtk.SORT_ASCENDING)

        anaconda.id.storage.devicetree.teardownAll()
        # So that drives onlined by these show up in the filter UI
        storage.iscsi.iscsi().startup(anaconda.intf)
        storage.fcoe.fcoe().startup(anaconda.intf)
        storage.zfcp.ZFCP().startup(anaconda.intf)
        storage.dasd.DASD().startup(anaconda.intf,
                                    anaconda.id.storage.exclusiveDisks,
                                    anaconda.id.storage.zeroMbr)
        disks = filter(lambda d: udev_device_is_disk(d) and \
                                 not udev_device_is_dm(d) and \
                                 not udev_device_is_md(d) and \
                                 not udev_device_get_md_container(d),
                       udev_get_block_devices())

        mcw = MultipathConfigWriter()
        cfg = mcw.write(friendly_names=True)
        with open("/etc/multipath.conf", "w+") as mpath_cfg:
            mpath_cfg.write(cfg)

        # identifyMultipaths() uses 'multipath -d' and 'multipath -ll' to find
        # mpath devices. In case there are devices already set up they won't
        # show up (or show up with a wrong name). Flush those first.
        log.info("filter_gui: flushing all multipath devices.")
        flush_mpaths()

        (singlepaths, mpaths, partitions) = identifyMultipaths(disks)
        # The device list could be really long, so we really only want to
        # iterate over it the bare minimum of times.  Dividing this list up
        # now means fewer elements to iterate over later.
        singlepaths = filter(lambda info: self._device_size_is_nonzero(info), singlepaths)
        (raids, nonraids) = self.split_list(lambda d: isRAID(d) and not isCCISS(d),
                                            singlepaths)

        self.pages = [self._makeBasic(), self._makeRAID(),
                      self._makeMPath(), self._makeOther(),
                      self._makeSearch()]

        self.populate(nonraids, mpaths, raids)

        # If the "Add Advanced" button is ever clicked, we need to have a list
        # of what devices previously existed so we know what's new.  Then we
        # can just add the new devices to the UI.  This is going to be slow,
        # but the user has to click a button to get to the slow part.
        self._cachedDevices = NameCache(singlepaths)
        self._cachedRaidDevices = NameCache(raids)

        # Multipath is a little more complicated.  Since mpaths is a list of
        # lists, we can't directly store that into the cache.  Instead we want
        # to flatten it into a single list of all components of all multipaths
        # and store that.
        lst = list(itertools.chain(*mpaths))
        self._cachedMPaths = NameCache(lst)

        # Switch to the first notebook page that displays any devices.
        i = 0
        for pg in self.pages:
            if pg.getNVisible():
                self.notebook.set_current_page(i)
                break

            i += 1
        
        """return self.vbox"""
        #####################################################
        
        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"
        
        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon4_storage_select.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>存储设备:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        lstr = "<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>选择操作系统安装位置</b></span>"
        label2.set_markup(lstr)
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()
        
        vbox = gtk.VBox(False,0)
        vbox.pack_start(eboximage,False,False,0)
        #####################################################
        
        tmphbox = gtk.HBox(False,0)
        tmphbox.pack_start(self.vbox,True,True,0)
        
        fix = gtk.Fixed()
        fix.put(tmphbox,35,35)
        vbox.pack_start(fix,True,True,0)
        
        """vbox.pack_start(tmphbox,True,True,0)"""
        return vbox
    def getScreen(self, anaconda):
        self.dispatch = anaconda.dispatch
        self.bl = anaconda.id.bootloader
        self.intf = anaconda.intf

        self.driveorder = self.bl.drivelist
        if len(self.driveorder) == 0:
            partitioned = anaconda.id.storage.partitioned
            disks = anaconda.id.storage.disks
            self.driveorder = [d.name for d in disks if d in partitioned]

        if self.bl.getPassword():
            self.usePass = 1
            self.password = self.bl.getPassword()
        else:
            self.usePass = 0
            self.password = None

        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"
            
        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon11_boot.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>引导程序:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        label2.set_markup("<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>选择引导程序安装位置</b></span>")
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()

        thebox = gtk.VBox(False,0)
        thebox.pack_start(eboximage,False,False,0)
        
        ###########################################################
        
        # make sure we get a valid device to say we're installing to
        if self.bl.getDevice() is not None:
            self.bldev = self.bl.getDevice()
        else:
            # we don't know what it is yet... if mbr is possible, we want
            # it, else we want the boot dev
            choices = anaconda.platform.bootloaderChoices(self.bl)
            if choices.has_key('mbr'):
                self.bldev = choices['mbr'][0]
            else:
                self.bldev = choices['boot'][0]
        ###########################################################
        boxall = gtk.VBox(False,0)
        
        hb = gtk.HBox(False, 12)
        """self.grubCB = gtk.CheckButton(_("_Install boot loader on /dev/%s.") %
                                      (self.bldev,))"""
        self.grubCB = gtk.CheckButton((u"在/dev/%s 中安装引导装载程序") %
                                      (self.bldev,))
        l = self.grubCB.get_children()[0]
        lstr = "<span  foreground='#333333'><b>"+l.get_text()+"</b></span>"
        l.set_markup(lstr)
            
        self.grubCB.set_active(not self.dispatch.stepInSkipList("instbootloader"))
        self.grubCB.connect("toggled", self.bootloaderChanged)
        hb.pack_start(self.grubCB, False)

        # no "Change device" button on EFI systems, since there should only
        # be one EFI System Partition available/usable
        self.deviceButton = None
        if not iutil.isEfi():
            self.deviceButton = gtk.Button(_(u"更换设备"))
            
            l = self.deviceButton.get_children()[0]
            lstr = "<span  foreground='#333333'><b>"+l.get_text()+"</b></span>"
            l.set_markup(lstr)
            
            self.deviceButton.connect("clicked", self._deviceChange, anaconda)
            hb.pack_start(self.deviceButton, False,False,32)

        boxall.pack_start(hb,False,False,0)
        #################################################################
        
        # control whether or not there's a boot loader password and what it is
        self.blpass = BootloaderPasswordWidget(anaconda, self.parent)
        boxall.pack_start(self.blpass.getWidget(),False,False,5)
        
        ###################################################################
        # configure the systems available to boot from the boot loader
        self.oslist = OSBootWidget(anaconda, self.parent)
        boxall.pack_start(self.oslist.getWidget(),True,True,10)
        
        fix = gtk.Fixed()
        fix.put(boxall,35,35)
        thebox.pack_start(fix,True,True,20)
        ######################################################################
        
        self.bootloaderChanged()
        """return thebox"""
        ####################################################################
        ebox = gtk.EventBox()
        ebox.add(thebox)
        ebox.set_app_paintable(True)
        ebox.set_border_width(0)
        ebox.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#e6e6e6"))
        return ebox
Exemple #7
0
    def createScreen(self, defaultByLang=None, kbd=None):
        if kbd is None:
            kbd = keyboard.Keyboard()

        self.kbd = kbd

        self.vbox = gtk.VBox(False, 10)

        #iconBox = gtk.HBox(False, 5)
        #iconBox.pack_start(loadToImage(iconFile))
        
        #msgLabel = gtk.Label(_("Select the appropriate keyboard for the system."))
        #msgLabel.set_line_wrap (True)
        #msgLabel.set_size_request(250, -1)

        #iconBox.pack_start(msgLabel)
        #iconBox.set_border_width(5)

        #align = gtk.Alignment()
        #align.add(iconBox);

        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"

        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True)
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)

        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon3_keyboard.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>键盘选择:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        lstr = "<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>请为系统选择一种键盘类型.缺省为美式键盘</b></span>"
        label2.set_markup(lstr)
        fixed.put(label2,160,58)
        eboximage.add(fixed)
        eboximage.show_all()

        #self.vbox.pack_start(align, False)
        self.vbox.pack_start(eboximage,False)
        global kbd_type
        if kbd_type=="":
            default = self.kbd.get()
        else:
            default = kbd_type
        if not default:
            default = defaultByLang
        self.type = default

        self.modelStore = gtk.ListStore(gobject.TYPE_STRING,
                                        gobject.TYPE_STRING)
        self.modelStore.set_sort_column_id(1, gtk.SORT_ASCENDING)

        # Sort the UI by the descriptive names, not the keymap abbreviations.
        self.kbdDict = self.kbd.modelDict
        lst = self.kbdDict.items()
        lst.sort(lambda a, b: cmp(a[1][0], b[1][0]))

        for item in lst:
            iter = self.modelStore.append()
            self.modelStore.set_value(iter, 0, item[0])
            self.modelStore.set_value(iter, 1, item[1][0])

        self.modelView = gtk.TreeView(self.modelStore)
        #self.col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=1)
        cell=gtk.CellRendererText()
        font = pango.FontDescription("微软雅黑 12")
        
        cell.set_property('font-desc', font)
        cell.set_property('foreground-set' , True)
        cell.set_property('foreground','#333333')

        self.col=gtk.TreeViewColumn(None,cell,text=1)
        self.modelView.append_column(self.col)
        self.modelView.set_property("headers-visible", False)
        self.modelView.get_selection().set_mode(gtk.SELECTION_BROWSE)

        # Type ahead should search on the names, not the keymap abbreviations.
        self.modelView.set_enable_search(True)
        self.modelView.set_search_column(1)

        selection = self.modelView.get_selection()
        selection.connect("changed", self.select_row)

        iter = self.modelStore.get_iter_root()
        while iter is not None:
            if self.modelStore.get_value(iter, 0) == default:
                path = self.modelStore.get_path(iter)
                self.modelView.set_cursor(path, self.col, False)
                self.modelView.scroll_to_cell(path, self.col, True,
                                              0.5, 0.5)
                break
            iter = self.modelStore.iter_next(iter)

        self.modelViewSW = gtk.ScrolledWindow()
        self.modelViewSW.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.modelViewSW.set_shadow_type(gtk.SHADOW_IN)
        self.modelViewSW.add(self.modelView)
        self.modelViewSW.set_border_width(5)
       
        eboximage1 = gtk.EventBox()
        eboximage1.set_app_paintable(True)
        eboximage1.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#e6e6e6"))

        vbox1 = gtk.VBox()
        eboximage1.add(vbox1)

        vbox1.set_border_width(20)
        vbox1.pack_start(self.modelViewSW,True)

        self.vbox.pack_start(eboximage1, True)

	setupTreeViewFixupIdleHandler(self.modelView,
				      self.modelView.get_model())
    def getScreen(self, anaconda):
        self.anaconda = anaconda
        self.intf = anaconda.intf

        isBlack = False
        import fvi
        x = fvi.get_iso_type()
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                 
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"

        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon2_install_selection.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc='16' weight='bold' foreground='"+fontcolor+"'><b>安装方式:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        lstr = "<span font_desc='11.5' weight='bold' foreground='"+fontcolor+"'><b>选择一种安装方式</b></span>"
        label2.set_markup(lstr)
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()
        
        vbox = gtk.VBox(False,0) 
        vbox.pack_start(eboximage,expand=False,fill=False)

        #######################################################
        fix = gtk.Fixed()
        label = gtk.Label()
        label.set_markup("<span font='10.5' foreground='#333333' size='large'><b>您想要选择哪种系统安装方式?</b></span>\
        ")
        fix.put(label,70,55)
    
        rvbox = gtk.VBox()
        rvbox.show()
        fix.put(rvbox,70,100)
        radio = gtk.RadioButton(None)
        radio.connect("toggled",self.radiocallback,"ordinary")
        rlabel1 = gtk.Label()
        rlabel1.set_markup("<span font='10.5' foreground='#333333' size='large'><b>普通安装</b></span>")
        lstr = "<span font='8.5' weight='50' foreground='#333333' size='large'><b>    建议选择此方式安装,可对网络,硬盘等信息进行配置。</b></span>"
        radio.add(rlabel1)
        rvbox.pack_start(radio, False,False,0)
        
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,5)

        radio.set_active(True)
        radio.show()
    
        radiof = gtk.RadioButton(radio)
        radiof.connect("toggled",self.radiocallback,"fast")
        rlabel2 = gtk.Label()
        rlabel2.set_markup("<span font='10.5' foreground='#333333' size='large'><b>一键安装</b></span>")
        lstr = "<span font='8.5' weight='50' foreground='#333333' size='large'><b>    安装介质将选择第一顺位物理硬盘(并清空该硬盘所有数据),安装网络为dhcp方式。若\
需要使用固定网络,请于安装后\n    的第一时间在本地界面进行网络配置修改。需要与其他主机通信时请不要使用此方式安装,避免dhcp网络的不稳定带来的\n    主机间通讯异常。</b></span>"
        radiof.add(rlabel2)
        rvbox.pack_start(radiof, False, False,5)
        
        
        
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,0)
        
        self.sn_entry = gtk.Entry()
        self.sn_entry.connect('insert-text',self.hinsert_text)
        try:
            self.sn_entry.set_text(self.anaconda.sn)
        except:
            pass
        sn_label = gtk.Label()
        sn_label.set_markup("<span font='10' foreground='#333333' size='large'><b>请输入出厂编号:</b></span>")
        sn_hbox = gtk.HBox()
        sn_hbox.pack_start(sn_label, False, False,5)
        sn_hbox.pack_start(self.sn_entry, False, False,5)
        rvbox.pack_start(sn_hbox, False, False,20)
        
        radiof.show()
        vbox.pack_start(fix,True,True)
        
        """f = gtk.FontSelection()
        vbox.pack_start(f,False,False,0)"""


        if self.anaconda.id.installationtype == True:
            self.buttonGroup_setCurrent = "fast"
            radiof.set_active(True)
            radio.set_active(False)
        else:
            self.buttonGroup_setCurrent = "ordinary"
            radiof.set_active(False)
            radio.set_active(True)
            
        sn_vbox = gtk.VBox(False,0)
        sn_vbox.show()
        
        ebox = gtk.EventBox()
        ebox.add(vbox)
        ebox.set_app_paintable(True)
        ebox.set_border_width(0)
        ebox.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#e6e6e6"))
        
        return ebox
    def getScreen (self, anaconda):
        # We can't just use exclusiveDisks here because of kickstart.  First,
        # the kickstart file could have used ignoredisk --drives= in which case
        # exclusiveDisks would be empty.  Second, ignoredisk is entirely
        # optional in which case neither list would be populated.  Luckily,
        # storage.disks takes isIgnored into account and that handles both these
        # issues.
        disks = filter(lambda d: not d.format.hidden, anaconda.id.storage.disks)

        # Skip this screen as well if there's only one disk to use.
        if len(disks) == 1:
            anaconda.id.storage.clearPartDisks = [disks[0].name]
            anaconda.id.bootloader.drivelist = [disks[0].name]
            return None

        (xml, self.vbox) = gui.getGladeWidget("cleardisks.glade", "vbox")
        self.leftScroll = xml.get_widget("leftScroll")
        self.rightScroll = xml.get_widget("rightScroll")
        ############################
        
        self.leftScroll.set_size_request(500,300)
        self.rightScroll.set_size_request(300,300)
        ###########################
        self.addButton = xml.get_widget("addButton")
        self.removeButton = xml.get_widget("removeButton")
        self.installTargetImage = xml.get_widget("installTargetImage")
        self.installTargetTip = xml.get_widget("installTargetTip")

        self.anaconda = anaconda

        self.leftVisible = 1
        self.leftActive = 2
        self.rightVisible = 4
        self.rightActive = 5
        self.delete_col = 6
        
        # One store for both views.  First the obejct, then a visible/active for
        # the left hand side, then a visible/active for the right hand side, then
        # all the other stuff.
        #
        # NOTE: the third boolean is a placeholder.  DeviceSelector uses the third
        # slot in the store to determine whether the row is immutable or not.  We
        # just need to put False in there for everything.
        self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT,
                                   gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_BOOLEAN,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING)
        self.store.set_sort_column_id(7, gtk.SORT_ASCENDING)

        # The left view shows all the drives that will just be mounted, but
        # can still be moved to the right hand side.
        self.leftFilteredModel = self.store.filter_new()
        self.leftSortedModel = gtk.TreeModelSort(self.leftFilteredModel)
        self.leftTreeView = gtk.TreeView(self.leftSortedModel)

        self.leftFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.leftVisible), self.leftTreeView)

        self.leftScroll.add(self.leftTreeView)

        self.leftDS = DeviceSelector(self.store, self.leftSortedModel,
                                     self.leftTreeView, visible=self.leftVisible,
                                     active=self.leftActive,delete_col=self.delete_col)
        self.leftDS.createSelectionCol_2(title=_("格式化"), radioButton=True)
        self.leftDS.createMenu()
        xxx = 7
        self.leftDS.addColumn(_("Model"), xxx)
        self.leftDS.addColumn(_("Capacity"), xxx+1)
        self.leftDS.addColumn(_("Vendor"), xxx+2)
        self.leftDS.addColumn(_("Identifier"), xxx+3)
        self.leftDS.addColumn(_("Interconnect"), xxx+4, displayed=False)

        # The right view show all the drives that will be wiped during install.
        self.rightFilteredModel = self.store.filter_new()
        self.rightSortedModel = gtk.TreeModelSort(self.rightFilteredModel)
        self.rightTreeView = gtk.TreeView(self.rightSortedModel)

        self.rightFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.rightVisible), self.rightTreeView)

        self.rightScroll.add(self.rightTreeView)

        self.rightDS = DeviceSelector(self.store, self.rightSortedModel,
                                      self.rightTreeView, visible=self.rightVisible,
                                      active=self.rightActive)
        self.rightDS.createSelectionCol(title=_("Boot\nLoader"), radioButton=True)
        self.rightDS.createMenu()
        yyy = 7
        self.rightDS.addColumn(_("Model"), yyy)
        self.rightDS.addColumn(_("Capacity"), yyy+1)
        self.rightDS.addColumn(_("Identifier"), yyy+3)

        # Store the first disk (according to our detected BIOS order) for
        # auto boot device selection
        names = map(lambda d: d.name, disks)
        self.bootDisk = sorted(names, self.anaconda.id.storage.compareDisks)[0]

        # The device filtering UI set up exclusiveDisks as a list of the names
        # of all the disks we should use later on.  Now we need to go get those,
        # look up some more information in the devicetree, and set up the
        # selector.
        for d in disks:
            rightVisible = d.name in self.anaconda.id.storage.clearPartDisks
            rightActive = rightVisible and \
                          d.name in self.anaconda.id.bootloader.drivelist[:1]
            leftVisible = not rightVisible
            
            deletexxx = d.name in self.anaconda.id.storage.destroyDisks
            
            if hasattr(d, "wwid"):
                ident = d.wwid
            else:
                try:
                    ident = deviceNameToDiskByPath(d.name)
                    if ident.startswith("/dev/disk/by-path/"):
                        ident = ident.replace("/dev/disk/by-path/", "")
                except DeviceNotFoundError:
                    ident = d.name

            self.store.append(None, (d,
                                     leftVisible, True, False,
                                     rightVisible, rightActive,
                                     deletexxx,
                                     d.model,
                                     str(int(d.size)) + " MB",
                                     d.vendor, ident, d.bus))

        self.addButton.connect("clicked", self._add_clicked)
        self.removeButton.connect("clicked", self._remove_clicked)

        # Also allow moving devices back and forth with double click, enter, etc.
        self.leftTreeView.connect("row-activated", self._add_clicked)
        self.rightTreeView.connect("row-activated", self._remove_clicked)

        # And let the user select multiple devices at a time.
        self.leftTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
        self.rightTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)

        if self.anaconda.id.storage.clearPartType == CLEARPART_TYPE_LINUX:
            self.installTargetTip.set_markup(_("<b>Tip:</b> All Linux filesystems on install target devices will be reformatted and wiped of any data.  Make sure you have backups."))
        elif self.anaconda.id.storage.clearPartType == CLEARPART_TYPE_ALL:
            self.installTargetTip.set_markup(_("<b>Tip:</b> Install target devices will be reformatted and wiped of any data.  Make sure you have backups."))
        else:
            self.installTargetTip.set_markup(_("<b>Tip:</b> Your filesystems on install target devices will not be wiped unless you choose to do so during customization."))

        """return self.vbox"""
        #####################################################
        
        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi 
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"
        
        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon4_storage_select.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>存储设备:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        lstr = "<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>选择操作系统安装位置</b></span>"
        label2.set_markup(lstr)
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()
        
        vbox = gtk.VBox(False,0)
        vbox.pack_start(eboximage,False,False,0)
        #####################################################
        
        tmphbox = gtk.HBox(False,0)
        tmphbox.pack_start(self.vbox,True,True,0)
        
        fix = gtk.Fixed()
        fix.put(tmphbox,35,35)
        #fix.set_size_request(900,400)
        vbox.pack_start(fix,True,True,0)
        
        l = xml.get_widget("label1")
        text = "下面是您选择用于这个安装的存储设备。请使用下面的箭头指定您要用做数据驱动器的设备(这些设备不会被格式化,只被挂载)以及用做系统驱动器的设备(这些设备将被格式化)。还请指定在哪个系统驱动器中安装引导装载程序。"
        lstr = "<span foreground='#333333'><b>"+text+"</b></span>"
        l.set_markup(lstr)
        l = xml.get_widget("label4")
        lstr = "<span foreground='#333333'><b>"+l.get_text()+"</b></span>"
        l.set_markup(lstr)
        l = xml.get_widget("label5")
        lstr = "<span foreground='#333333'><b>"+l.get_text()+"</b></span>"
        l.set_markup(lstr)
        
        return vbox
Exemple #10
0
    def getScreen (self, anaconda):
        self.intf = anaconda.intf
        if anaconda.dir == DISPATCH_BACK:
            self.intf.icw.prevClicked()
            return

        self.pixmaps = self._getRnotes()

        # Create vbox to contain components of UI
        vbox = gtk.VBox (False, 12)

        # Create rnote area

        #######################################
        
        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
    
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"

        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon12_vserver_installation.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        label1.set_markup("<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>安装软件:</b></span>")
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        label2.set_markup("<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>正在安装软件包,请稍等...</b></span>")
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()

        vbox = gtk.VBox(False,0) 
        vbox.pack_start(eboximage,expand=False,fill=False)
        #####################################################
        fix = gtk.Fixed()
        self.progress = gtk.ProgressBar()
        
        eboxpro = gtk.EventBox()
        eboxpro.add(self.progress)
        
        eboxpro.set_size_request(800,25)
        fix.put(eboxpro,120,240)
        
        self.intf.setPackageProgressWindow(self)
        anaconda.id.setInstallProgressClass(self)

        vbox.pack_start(fix,True,True)
        return vbox
Exemple #11
0
    def getScreen(self, anaconda):
        self.anaconda = anaconda
        self.intf = anaconda.intf
        
        isBlack = False
        '''
        f = open("/root/isotype")
        lines = f.readlines()
        f.close()
        
        for x in lines:
            if x.find("vServer") != -1 or x.find("vCenter") != -1:
                isBlack = True
                break
        '''
        import fvi
        x = fvi.get_iso_type()
        if x.find("vServer") != -1 or x.find("vCenter") != -1:
            isBlack = True
                
        if isBlack:
            bgcolor = "#333333"
            fontcolor = "#e6e6e6"
        else:
            bgcolor = "#cccccc"
            fontcolor = "#333333"
        
        eboximage = gtk.EventBox()
        eboximage.set_app_paintable(True) 
        eboximage.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse(bgcolor))
        eboximage.set_size_request(1024,100)
        
        fixed = gtk.Fixed()
        i = gtk.Image()
        path = "/usr/share/anaconda/pixmaps/icon4_storage_select.png"
        i.set_from_file(path)
        i.show()
        fixed.put(i,45,15)
        label1 = gtk.Label()
        lstr = "<span font_desc=' 16' weight='bold' foreground='"+fontcolor+"'><b>存储设备:</b></span>"
        label1.set_markup(lstr)
        fixed.put(label1,160,23)
        label2 = gtk.Label()
        lstr = "<span font_desc=' 11.5' weight='bold' foreground='"+fontcolor+"'><b>选择一种存储设备</b></span>"
        label2.set_markup(lstr)
        fixed.put(label2,160,58)
        eboximage.add(fixed) 
        eboximage.show_all()

        vbox = gtk.VBox(False,0) 
        vbox.pack_start(eboximage,expand=False,fill=False)
        
        fix = gtk.Fixed()
        label = gtk.Label()
        label.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>您的安装将使用哪种设备?</b></span>\
        ")
        fix.put(label,70,55)
    
        rvbox = gtk.VBox()
        rvbox.show()
        fix.put(rvbox,70,100)
        self.radio = gtk.RadioButton(None)
        self.radio.connect("toggled",self.radiocallback,"simple")
        rlabel1 = gtk.Label()
        rlabel1.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>基本存储设备</b></span>")
        lstr = "<span font=' 8.5' foreground='#525252' size='large'><b>    安装或者升级到存储设备的典型类型。如果您不确定哪个选项适合您,您可能应该选择这个\
选项。</b></span>"
        self.radio.add(rlabel1)
        
        rvbox.pack_start(self.radio, False,False,0)
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,5)
        
        self.radio.set_active(True)
        self.radio.show()
    
        self.radiof = gtk.RadioButton(self.radio)
        self.radiof.connect("toggled",self.radiocallback,"complex")
        rlabel2 = gtk.Label()
        rlabel2.set_markup("<span font=' 10.5' foreground='#333333' size='large'><b>指定存储设备</b></span>")
        lstr = "<span font=' 8.5' foreground='#525252' size='large'><b>    安装或者升级到企业级设备,比如存储局域网(SAN)。这个选项可让您添加FCoE/iSCSI/zFCP磁盘并过滤\
\n    掉安装程序应该忽略的设备。</b></span>"
        self.radiof.add(rlabel2)
    
        rvbox.pack_start(self.radiof, False, False,5)
        l = gtk.Label()
        l.set_markup(lstr)
        l.set_alignment(0.0, 0.5)
        rvbox.pack_start(l,False,False,0)
        
        self.radiof.show()
        vbox.pack_start(fix,True,True)

        
        if self.anaconda.id.simpleFilter == True:
            #self.buttonGroup.setCurrent("simple")
            self.buttonGroup_setCurrent = "simple"
#            radiof.set_active(False)
#            radio.set_active(True)
        else:
            #self.buttonGroup.setCurrent("complex")
            self.buttonGroup_setCurrent = "complex"
#            radiof.set_active(True)
#            radio.set_active(False)
        
        # 默认选中基本存储设备
        self.radiof.set_active(False)
        self.radio.set_active(True)
        return vbox