示例#1
0
    def establecer_metodo(self, widget=None):
        m = self.cmb_metodo.get_model()
        a = self.cmb_metodo.get_active()

        if a < 0:
            return None

        self.metodo = [k for k, v in self.metodos.iteritems()
                       if v == m[a][0]][0]

        if self.metodo.split(':')[0] == 'TODO':
            msg = 'Si escoge esta opción tenga en cuenta que se borrarán todos \
los datos en el disco que ha seleccionado, Este borrado no se hará hasta que \
confirme que realmente quiere hacer los cambios.'

            self.ini = self.metodo.split(':')[2]
            self.fin = self.metodo.split(':')[3]
        elif self.metodo.split(':')[0] == 'LIBRE':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
            self.ini = self.metodo.split(':')[2]
            self.fin = self.metodo.split(':')[3]
        elif self.metodo.split(':')[0] == 'REDIM':
            msg = 'Si escoge esta opción se redimensionará la partición {0} \
para realizar la instalación.'.format(self.metodo)
        elif self.metodo == 'MANUAL':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
        elif self.metodo == 'NONE':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
        else:
            pass

        self.lbl4.set_text(msg)
示例#2
0
    def establecer_metodo(self, widget=None):
        m = self.cmb_metodo.get_model()
        a = self.cmb_metodo.get_active()

        if a < 0:
            return None

        self.metodo = [k for k, v in self.metodos.iteritems() if v == m[a][0]][0]

        if self.metodo.split(':')[0] == 'TODO':
            msg = 'Si escoge esta opción tenga en cuenta que se borrarán todos \
los datos en el disco que ha seleccionado, Este borrado no se hará hasta que \
confirme que realmente quiere hacer los cambios.'
            self.ini = self.metodo.split(':')[2]
            self.fin = self.metodo.split(':')[3]
        elif self.metodo.split(':')[0] == 'LIBRE':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
            self.ini = self.metodo.split(':')[2]
            self.fin = self.metodo.split(':')[3]
        elif self.metodo.split(':')[0] == 'REDIM':
            msg = 'Si escoge esta opción se redimensionará la partición {0} \
para realizar la instalación.'.format(self.metodo)
        elif self.metodo == 'MANUAL':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
        elif self.metodo == 'NONE':
            msg = 'Si escoge esta opción se instalará el sistema en la \
partición sin usar que mide {0}'.format(gen.hum(2))
        else:
            pass

        self.lbl4.set_text(msg)
示例#3
0
 def mostrar_info(self):
     #Tipo de Instalación
     msg = "Tipo de instalación: "
     if self.cfg['tipo'] == 'particion_1':
         msg = msg + "Realizar la instalación en una sola partición"
     elif self.cfg['tipo'] == 'particion_2':
         msg = msg + "Separar la partición /home"
     elif self.cfg['tipo'] == 'particion_3':
         msg = msg + "Separar las particiones /home, /usr y /boot"
     elif self.cfg['tipo'] == 'particion_3':
         msg = msg + "Particionado manual"
     self.lbltipo.set_text(msg)
     #Método
     if self.cfg['metodo'] == 'todo':
         msg = "Dispositivo a usar: {0}".format(self.cfg['disco'])
         self.lblmetodo.set_text(msg)
     elif self.cfg['metodo'] == 'vacio':
         pass
     else:
         #msg = "partición a usar: {0}".format(self.cfg['particion'])
         #self.lblmetodo.set_text(msg)
         msg = "Tamaño Anterior de la Partición: {0}".format(gen.hum(gen.h2kb(self.cfg['fin'])))
         self.lbltam.set_text(msg)
         msg = "Nuevo Tamaño de la Partición: {0}".format(gen.hum(gen.h2kb(self.cfg['nuevo_fin'])))
         self.lblnuevo.set_text(msg)
     #Nombre completo
     msg = "Nombre completo del usuario: {0}".format(self.cfg['nombre'])
     self.lblnombre.set_text(msg)
     #Nombre de usuario
     msg = "Nombre de usuario: {0}".format(self.cfg['usuario'])
     self.lblusuario.set_text(msg)
     #Máquina
     msg = "Nombre de la maquina: {0}".format(self.cfg['maquina'])
     self.lblmaquina.set_text(msg)
示例#4
0
    def lista_metodos(self):
        '''
            Crea una lista de los metodos de instalación disponibles para la
            partición
        '''
        i = 0
        self.metodos = {}
        self.cmb_metodo.get_model().clear()
        total = self.total
        minimo = self.minimo
        tini = self.particiones[0][1]
        tfin = self.particiones[0][2]

        for t in self.particiones:
            ini = t[1]
            fin = t[2]
            if tini > ini: tini = ini
            if tfin < fin: tfin = fin
            if t[5] == 'primary' and t[4] != 'free':
                i += 1

        if total > minimo:
            self.metodos[
                'MANUAL'] = 'Instalar editando particiones manualmente'

            if i < 4:
                for p in self.particiones:
                    tam = p[3]
                    libre = p[8]
                    ini = p[1]
                    fin = p[2]
                    part = p[0]
                    fs = p[5]

                    if fs != 'free' and libre >= minimo:
                        msg = 'Instalar redimensionando {0} para liberar espacio ({1} libres)'
                        met = 'REDIM:{0}:{1}:{2}'.format(part, ini, fin)
                        self.metodos[met] = msg.format(part, gen.hum(libre))

                    if fs == 'free' and tam >= minimo:
                        msg = 'Instalar usando espacio libre disponible ({0})'
                        met = 'LIBRE:{0}:{1}:{2}'.format(part, ini, fin)
                        self.metodos[met] = msg.format(gen.hum(tam))

            met = 'TODO:{0}:{1}:{2}'.format(self.disco, tini, tfin)
            msg = 'Instalar usando todo el disco ({0})'
            self.metodos[met] = msg.format(gen.hum(total))

        else:
            self.metodos['NONE'] = 'El tamaño del disco no es suficiente'

        for l1, l2 in self.metodos.items():
            self.cmb_metodo.append_text(l2)
        self.cmb_metodo.set_active(0)
示例#5
0
    def lista_metodos(self):
        '''
            Crea una lista de los metodos de instalación disponibles para la
            partición
        '''
        i = 0
        self.metodos = {}
        self.cmb_metodo.get_model().clear()
        total = self.total
        minimo = self.minimo
        tini = self.particiones[0][1]
        tfin = self.particiones[0][2]

        for t in self.particiones:
            ini = t[1]
            fin = t[2]
            if tini > ini: tini = ini
            if tfin < fin: tfin = fin
            if t[5] == 'primary' and t[4] != 'free':
                i += 1

        if total > minimo:
            self.metodos['MANUAL'] = 'Instalar editando particiones manualmente'

            if i < 4:
                for p in self.particiones:
                    tam = p[3]
                    libre = p[8]
                    ini = p[1]
                    fin = p[2]
                    part = p[0]
                    fs = p[5]

                    if fs != 'free' and libre >= minimo:
                        msg = 'Instalar redimensionando {0} para liberar espacio ({1} libres)'
                        met = 'REDIM:{0}:{1}:{2}'.format(part,ini,fin)
                        self.metodos[met] = msg.format(part, gen.hum(libre))

                    if fs == 'free' and tam >= minimo:
                        msg = 'Instalar usando espacio libre disponible ({0})'
                        met = 'LIBRE:{0}:{1}:{2}'.format(part,ini,fin)
                        self.metodos[met] = msg.format(gen.hum(tam))

            met = 'TODO:{0}:{1}:{2}'.format(self.disco,tini,tfin)
            msg = 'Instalar usando todo el disco ({0})'
            self.metodos[met] = msg.format(gen.hum(total))

        else:
            self.metodos['NONE'] = 'El tamaño del disco no es suficiente'

        for l1, l2 in self.metodos.items():
            self.cmb_metodo.append_text(l2)
        self.cmb_metodo.set_active(0)
    def iniciar(self, data):
        '''
        Inicia el llenado de la tabla
        '''

        self.data = data
        self.lista = []
        self.disco = data['disco'] if data['disco'] != '' \
                     else data['particion'][:-1]

        if data['metodo'] != 'todo' and data['metodo'] != 'vacio':
            self.ini = data['nuevo_fin']
        else:
            self.ini = 1049  # Inicio de la partición

        if str(data['fin'])[-2:] != 'kB':
            data['fin'] = str(data['fin']) + 'kB'

        self.fin = int(float(gen.kb(gen.hum(data['fin']))))

        #TODO: Revisar el por qué de esta sentencia, no asigna ni modifica nada
        float(gen.kb(gen.hum(data['fin']))),
        int(float(gen.kb(gen.hum(data['fin']))))

        if str(data['fin'])[-2:] != 'kB':
            data['fin'] = str(data['fin']) + 'kB'

        self.fin = data['fin']

        if self.tabla != None:

            l_part = particiones.Main().lista_particiones(self.disco)
            for particion in l_part:
                p_disp = particion[0]
                p_ini = particion[1]
                p_fin = particion[2]
                p_tam = particion[3]
                p_format = particion[4]
                p_tipo = particion[5]

                fila = [
                    p_disp,
                    p_tipo + '',
                    p_format + '',
                    '',  # Punto de montaje
                    gen.hum(gen.kb(p_tam)),
                    gen.kb(p_ini),
                    gen.kb(p_fin)
                ]
                self.lista.append(fila)

            self.llenar_tabla(self.lista)
    def iniciar(self, data):
        '''
        Inicia el llenado de la tabla
        '''

        self.data = data
        self.lista = []
        self.disco = data['disco'] if data['disco'] != '' \
                     else data['particion'][:-1]

        if data['metodo'] != 'todo' and data['metodo'] != 'vacio':
            self.ini = data['nuevo_fin']
        else:
            self.ini = 1049                            # Inicio de la partición

        if str(data['fin'])[-2:] != 'kB':
            data['fin'] = str(data['fin']) + 'kB'

        self.fin = int(float(gen.kb(gen.hum(data['fin']))))

        #TODO: Revisar el por qué de esta sentencia, no asigna ni modifica nada
        float(gen.kb(gen.hum(data['fin']))),
        int(float(gen.kb(gen.hum(data['fin']))))

        if str(data['fin'])[-2:] != 'kB':
            data['fin'] = str(data['fin']) + 'kB'

        self.fin = data['fin']

        if self.tabla != None:

            l_part = particiones.Main().lista_particiones(self.disco)
            for particion in l_part:
                p_disp = particion[0]
                p_ini = particion[1]
                p_fin = particion[2]
                p_tam = particion[3]
                p_format = particion[4]
                p_tipo = particion[5]

                fila = [
                       p_disp,
                       p_tipo + '',
                       p_format + '',
                       '', # Punto de montaje
                       gen.hum(gen.kb(p_tam)),
                       gen.kb(p_ini),
                       gen.kb(p_fin)
                   ]
                self.lista.append(fila)

            self.llenar_tabla(self.lista)
示例#8
0
 def __init__(self, cfg, parent):
     self.part_manual = particion_manual.Main(cfg, parent)
     self.particion = cfg['particion']
     self.disco = self.particion[:-1]
     self.num = self.particion[-1:]
     self.ini = cfg['inicio']
     self.fin = cfg['fin']
     self.nuevo_fin = cfg['nuevo_fin']
     self.total = int(gen.kb(self.fin)) - int(gen.kb(self.nuevo_fin))
     self.root_p2 = gen.hum(gen.part_root1(self.total))
     self.root_p3 = gen.hum(gen.part_root2(self.total))
     self.usr = gen.hum(gen.part_root1(self.total))
     self.swap = cfg['swap']
     self.fs = cfg['fs']
     self.par = parent
示例#9
0
 def __init__(self, cfg):
     super(Main, self).__init__()
     self.set_events(gtk.gdk.POINTER_MOTION_MASK
                     | gtk.gdk.POINTER_MOTION_HINT_MASK
                     | gtk.gdk.BUTTON_PRESS_MASK
                     | gtk.gdk.BUTTON_RELEASE_MASK)
     self.connect("expose-event", self.expose)
     self.disco = cfg[0]
     self.ini = int(float(cfg[1]))
     self.fin = int(float(cfg[2]))
     self.swap = int(float(cfg[3]))
     self.metodo = cfg[4]
     self.total = int(self.fin - self.ini)
     self.root1 = gen.hum(gen.part_root1(self.total))
     self.root2 = gen.hum(gen.part_root2(self.total))
     self.usr = gen.hum(gen.part_root1(self.total))
示例#10
0
 def __init__(self, cfg, parent, vacio=False):
     self.cfg = cfg
     self.disco = cfg['disco']
     self.par = parent
     self.lista = self.part.lista_particiones(self.disco)
     self.root_p2 = gen.hum(gen.part_root1(self.lista[0][9]))
     self.root_p3 = gen.hum(gen.part_root2(self.lista[0][9]))
     self.usr = gen.hum(gen.part_root1(self.lista[0][9]))
     self.vacio = vacio
     try:
         self.ini = cfg['inicio']
     except:
         self.ini = 0
     try:
         self.fin = cfg['fin']
     except:
         self.fin = 0
示例#11
0
 def __init__(self, cfg, parent, vacio=False):
     self.cfg = cfg
     self.disco = cfg['disco']
     self.par = parent
     self.lista = self.part.lista_particiones(self.disco)
     self.root_p2 = gen.hum(gen.part_root1(self.lista[0][9]))
     self.root_p3 = gen.hum(gen.part_root2(self.lista[0][9]))
     self.usr = gen.hum(gen.part_root1(self.lista[0][9]))
     self.vacio = vacio
     try:
         self.ini = cfg['inicio']
     except:
         self.ini = 0
     try:
         self.fin = cfg['fin']
     except:
         self.fin = 0
示例#12
0
 def __init__(self, cfg):
     super(Main, self).__init__()
     self.set_events(
         gtk.gdk.POINTER_MOTION_MASK
         | gtk.gdk.POINTER_MOTION_HINT_MASK
         | gtk.gdk.BUTTON_PRESS_MASK
         | gtk.gdk.BUTTON_RELEASE_MASK
     )
     self.connect("expose-event", self.expose)
     self.disco = cfg[0]
     self.ini = int(float(cfg[1]))
     self.fin = int(float(cfg[2]))
     self.swap = int(float(cfg[3]))
     self.metodo = cfg[4]
     self.total = int(self.fin - self.ini)
     self.root1 = gen.hum(gen.part_root1(self.total))
     self.root2 = gen.hum(gen.part_root2(self.total))
     self.usr = gen.hum(gen.part_root1(self.total))
示例#13
0
 def mostrar_info(self):
     #Tipo de Instalación
     msg = "Tipo de instalación: "
     if self.cfg['tipo'] == 'particion_1':
         msg = msg + "Realizar la instalación en una sola partición"
     elif self.cfg['tipo'] == 'particion_2':
         msg = msg + "Separar la partición /home"
     elif self.cfg['tipo'] == 'particion_3':
         msg = msg + "Separar las particiones /home, /usr y /boot"
     elif self.cfg['tipo'] == 'particion_3':
         msg = msg + "Particionado manual"
     self.lbltipo.set_text(msg)
     #Método
     if self.cfg['metodo'] == 'todo':
         msg = "Dispositivo a usar: {0}".format(self.cfg['disco'])
         self.lblmetodo.set_text(msg)
     elif self.cfg['metodo'] == 'vacio':
         pass
     else:
         #msg = "partición a usar: {0}".format(self.cfg['particion'])
         #self.lblmetodo.set_text(msg)
         msg = "Tamaño Anterior de la Partición: {0}".format(
             gen.hum(gen.h2kb(self.cfg['fin'])))
         self.lbltam.set_text(msg)
         msg = "Nuevo Tamaño de la Partición: {0}".format(
             gen.hum(gen.h2kb(self.cfg['nuevo_fin'])))
         self.lblnuevo.set_text(msg)
     #Nombre completo
     msg = "Nombre completo del usuario: {0}".format(self.cfg['nombre'])
     self.lblnombre.set_text(msg)
     #Nombre de usuario
     msg = "Nombre de usuario: {0}".format(self.cfg['usuario'])
     self.lblusuario.set_text(msg)
     #Máquina
     msg = "Nombre de la maquina: {0}".format(self.cfg['maquina'])
     self.lblmaquina.set_text(msg)
示例#14
0
    def __init__(self, cfg):
        gtk.Fixed.__init__(self)
        self.cfg = cfg
        #print self.cfg

        altura = 260
        inc = 20

        msg = "Distribución del Teclado: {0}".format(self.cfg['teclado'])
        self.lbldist = gtk.Label(msg)
        self.lbldist.set_size_request(590, 30)
        self.put(self.lbldist, 0, altura)
        self.lbldist.set_alignment(0, 0)
        self.lbldist.show()
        altura = altura - inc

        msg = "Tipo de instalación: "
        if self.cfg['tipo'] == 'particion_1':
            msg = msg + "Realizar la instalación en una sola partición"
        elif self.cfg['tipo'] == 'particion_2':
            msg = msg + "Separar la partición /home"
        elif self.cfg['tipo'] == 'particion_3':
            msg = msg + "Separar las particiones /home, /usr y /boot"
        elif self.cfg['tipo'] == 'particion_3':
            msg = msg + "Particionado manual"
        self.lbltipo = gtk.Label(msg)
        self.lbltipo.set_size_request(590, 30)
        self.put(self.lbltipo, 0, altura)
        self.lbltipo.set_alignment(0, 0)
        self.lbltipo.show()
        altura = altura - inc

        if self.cfg['metodo'] == 'todo':
            msg = "Dispositivo a usar: {0}".format(self.cfg['disco'])
            self.lblmetodo = gtk.Label(msg)
            self.lblmetodo.set_size_request(590, 30)
            self.put(self.lblmetodo, 0, altura)
            self.lblmetodo.set_alignment(0, 0)
            self.lblmetodo.show()
            altura = altura - inc
        elif self.cfg['metodo'] == 'vacio':
            pass
        else:
            msg = "partición a usar: {0}".format(self.cfg['particion'])
            self.lblparticion = gtk.Label(msg)
            self.lblparticion.set_size_request(590, 30)
            self.put(self.lblparticion, 0, altura)
            self.lblparticion.set_alignment(0, 0)
            self.lblparticion.show()
            altura = altura - inc

            msg = "Tamaño Anterior de la Partición: {0}".format(
                gen.hum(gen.h2kb(self.cfg['fin'])))
            self.lbltam = gtk.Label(msg)
            self.lbltam.set_size_request(590, 30)
            self.put(self.lbltam, 0, altura)
            self.lbltam.set_alignment(0, 0)
            self.lbltam.show()
            altura = altura - inc

            msg = "Nuevo Tamaño de la Partición: {0}".format(
                gen.hum(gen.h2kb(self.cfg['nuevo_fin'])))
            self.lblnuevo = gtk.Label(msg)
            self.lblnuevo.set_size_request(590, 30)
            self.put(self.lblnuevo, 0, altura)
            self.lblnuevo.set_alignment(0, 0)
            self.lblnuevo.show()
            altura = altura - inc

        msg = "Nombre completo del usuario: {0}".format(self.cfg['nombre'])
        self.lblnombre = gtk.Label(msg)
        self.lblnombre.set_size_request(590, 30)
        self.put(self.lblnombre, 0, altura)
        self.lblnombre.set_alignment(0, 0)
        self.lblnombre.show()
        altura = altura - inc

        msg = "Nombre de usuario: {0}".format(self.cfg['usuario'])
        self.lblusuario = gtk.Label(msg)
        self.lblusuario.set_size_request(590, 30)
        self.put(self.lblusuario, 0, altura)
        self.lblusuario.set_alignment(0, 0)
        self.lblusuario.show()
        altura = altura - inc

        msg = "Nombre de la maquina: {0}".format(self.cfg['maquina'])
        self.lblmaquina = gtk.Label(msg)
        self.lblmaquina.set_size_request(590, 30)
        self.put(self.lblmaquina, 0, altura)
        self.lblmaquina.set_alignment(0, 0)
        self.lblmaquina.show()
        altura = altura - inc

        self.linea = gtk.HSeparator()
        self.linea.set_size_request(590, 10)
        self.put(self.linea, 0, altura)
        self.linea.show()
        altura = altura - inc

        msg = 'Confirme que todos los datos son correctos, al hacer click en '
        msg = msg + 'siguiente comenzará la\ninstalación y ya no podrá dar '
        msg = msg + 'marcha atrás.'
        self.lblmsg = gtk.Label(msg)
        self.lblmsg.set_size_request(590, (260 - altura))
        self.put(self.lblmsg, 0, 0)
        #self.lbl1.set_alignment(0, 0)
        self.lblmsg.show()
    def deshacer(self, widget=None):
        if self.lista[0][1] == 'Espacio Libre':
            return False
        if self.lista[-1][1] == 'Espacio Libre':
            self.lista.pop()
        if self.lista[-1][1] == 'Espacio Libre Extendida':
            self.lista.pop()
        if self.lista[-1][1] == 'Lógica':
            self.bext = True
        else:
            self.bext = False

        tipo = self.lista[-1][1]
        fin = self.lista[-1][6]

        self.lista.pop()

        if tipo == 'Extendida':
            inicio = self.ext_ini
            fin = self.ext_fin
        elif tipo == 'Lógica' and self.bext == True:
            if self.lista[-1][1] == 'Extendida':
                inicio = self.lista[-1][5]
            else:
                inicio = self.lista[-1][6]
            fin = self.ext_fin
        elif tipo == 'Primaria':
            try:
                inicio = self.lista[-1][6]
            except:
                inicio = gen.kb(self.ini)
            fin = gen.kb(self.fin)

        if self.bext == True:
            tamano = gen.hum(fin - inicio)
            particion = [self.disco, #Dispositivo
                         'Espacio Libre Extendida', #Formato
                         '', #Tipo
                         '', #Punto de montaje
                         tamano, #Tamaño
                         inicio, #inicio
                         fin]                       #fin
            self.lista.append(particion)


        if fin != self.fin:
            try:
                inicio = self.lista[-1][6]
            except:
                inicio = gen.kb(self.ini)
            fin = gen.kb(self.fin)
            tamano = gen.hum(fin - inicio)
            particion = [self.disco, #Dispositivo
                         'Espacio Libre', #Formato
                         '', #Tipo
                         '', #Punto de montaje
                         tamano, #Tamaño
                         inicio, #inicio
                         fin]               #fin
            self.lista.append(particion)

        self.llenar_tabla(self.lista)
 def on_changed(self, widget=None):
     self.lblsize.set_text(gen.hum(widget.get_value() - float(self.inicio)))
示例#17
0
    def expose(self, widget, event):
        cr = widget.window.cairo_create()
        cr.set_line_width(0.8)

        cr.select_font_face("Courier", cairo.FONT_SLANT_NORMAL,
                            cairo.FONT_WEIGHT_NORMAL)
        cr.set_font_size(11)

        #establece ancho y alto
        self.w = self.get_size_request()[0]
        self.h = self.get_size_request()[1]
        ancho = self.w
        alto = self.h

        w_usado = (int(self.usado) * ancho) / int(self.total)
        x_minimo = (
            (int(self.total) - int(self.minimo)) * ancho) / int(self.total)
        w_minimo = (int(self.minimo) * ancho) / int(self.total)
        x_particion = (self.cur * ancho) / int(self.total)
        w_particion = ancho - x_particion - w_minimo
        w_libre = x_particion - w_usado
        x1_barra = x_particion - 5
        y1_barra = 10
        x2_barra = x_particion + 5
        y2_barra = alto - 10
        w_barra = 10
        h_barra = alto - 20
        self.pos = [x1_barra, y1_barra, x2_barra, y2_barra]

        # Espacio usado
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0.3, 0.3, 0)
        linear.add_color_stop_rgb(0.3, 0.5, 0.5, 0.2)
        linear.add_color_stop_rgb(0.7, 0.8, 0.8, 0.4)
        cr.set_source(linear)
        cr.rectangle(0, 0, w_usado, alto)
        cr.fill()

        # Espacio libre
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0.5, 0.5, 0)
        linear.add_color_stop_rgb(0.3, 0.7, 0.7, 0.3)
        linear.add_color_stop_rgb(0.7, 1.0, 1.0, 0.7)
        cr.set_source(linear)
        cr.rectangle(w_usado, 0, w_libre, alto)
        cr.fill()

        # Espacio Mínimo
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0, 0.3, 0)
        linear.add_color_stop_rgb(0.3, 0.2, 0.4, 0.2)
        linear.add_color_stop_rgb(0.7, 0.4, 0.8, 0.4)
        cr.set_source(linear)
        cr.rectangle(x_minimo, 0, w_minimo, alto)
        cr.fill()

        #Espacio a particionar
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0, 0.5, 0)
        linear.add_color_stop_rgb(0.3, 0.3, 0.7, 0.3)
        linear.add_color_stop_rgb(0.7, 0.7, 1.0, 0.7)
        cr.set_source(linear)
        cr.rectangle(x_particion, 0, w_particion, alto)
        cr.fill()

        canaima = gen.hum(self.total - self.cur)
        otra = gen.hum(self.cur)
        msg = 'Espacio que se usará para instalar Canaima GNU/Linux'
        self.par.lbl_canaima.set_text('{1} ({0})'.format(canaima, msg))
        msg = 'Espacio que quedará despues de redimensionar la particion'
        self.par.lbl_otra.set_text('{2} {0} ({1})'.format(
            self.particion, otra, msg))

        cr.set_source_rgb(0, 0, 0)
        area = (x1_barra, x2_barra, y1_barra, y2_barra)
        self.draw_rounded(cr, area, 3)
        for i in range(y1_barra + 3, y2_barra - 2, 3):
            cr.move_to(x1_barra + 1, i)
            cr.rel_line_to(8, 0)
            cr.stroke()
    def deshacer(self, widget=None):
        if self.lista[0][1] == 'Espacio Libre':
            return False
        if self.lista[-1][1] == 'Espacio Libre':
            self.lista.pop()
        if self.lista[-1][1] == 'Espacio Libre Extendida':
            self.lista.pop()
        if self.lista[-1][1] == 'Lógica':
            self.bext = True
        else:
            self.bext = False

        tipo = self.lista[-1][1]
        fin = self.lista[-1][6]

        self.lista.pop()

        if tipo == 'Extendida':
            inicio = self.ext_ini
            fin = self.ext_fin
        elif tipo == 'Lógica' and self.bext == True:
            if self.lista[-1][1] == 'Extendida':
                inicio = self.lista[-1][5]
            else:
                inicio = self.lista[-1][6]
            fin = self.ext_fin
        elif tipo == 'Primaria':
            try:
                inicio = self.lista[-1][6]
            except:
                inicio = gen.kb(self.ini)
            fin = gen.kb(self.fin)

        if self.bext == True:
            tamano = gen.hum(fin - inicio)
            particion = [
                self.disco,  #Dispositivo
                'Espacio Libre Extendida',  #Formato
                '',  #Tipo
                '',  #Punto de montaje
                tamano,  #Tamaño
                inicio,  #inicio
                fin
            ]  #fin
            self.lista.append(particion)

        if fin != self.fin:
            try:
                inicio = self.lista[-1][6]
            except:
                inicio = gen.kb(self.ini)
            fin = gen.kb(self.fin)
            tamano = gen.hum(fin - inicio)
            particion = [
                self.disco,  #Dispositivo
                'Espacio Libre',  #Formato
                '',  #Tipo
                '',  #Punto de montaje
                tamano,  #Tamaño
                inicio,  #inicio
                fin
            ]  #fin
            self.lista.append(particion)

        self.llenar_tabla(self.lista)
示例#19
0
    def __init__(self, particion):
        gtk.Fixed.__init__(self)

        self.inicio(particion)
#        self.particion = particion
#        self.disco = particion[:-1]
#        self.num = particion[-1:]

#        self.cfg['particion'] = particion
#        self.cfg['disco'] = self.disco
#        self.cfg['num'] = self.num

#        p = self.part.lista_particiones(self.disco, self.particion)[0]
#        self.particiones = self.part.lista_particiones(self.disco)
#        self.ini = p[1]
#        self.fin = p[2]
#        self.fs = p[5]
#        self.cfg['ini'] = self.ini
#        self.cfg['fin'] = self.fin

        txt_info = "Seleccione el tamaño que desea usar para la instalación"
        self.lbl1 = gtk.Label(txt_info)
        self.lbl1.set_size_request(590, 20)
        self.lbl1.set_justify(gtk.JUSTIFY_CENTER)
        self.put(self.lbl1, 0, 0)
        self.lbl1.show()

        # Barra
        total = int(self.p[3][:-2])
        usado = gen.kb(self.p[7])
        minimo = gen.kb(self.minimo)
        libre = gen.kb(self.libre)
        self.swap = self.hay_swap()

        self.barra = widget.Barra(self, total, usado, libre, minimo, particion, self.cur_value)
        self.barra.set_size_request(590, 60)
        self.barra.show()
        self.put(self.barra, 0, 25)

        self.leyenda = leyenda.Main(self)
        self.leyenda.set_size_request(20, 100)
        self.put(self.leyenda, 0, 90)
        self.leyenda.show()

        # Etiqueta Información Espacio Usado
        msg = 'Espacio Usado en la partición'
        self.lbl_usado = gtk.Label('{0} ({1})'.format(msg, gen.hum(usado)))
        self.lbl_usado.set_size_request(590, 20)
        self.lbl_usado.set_alignment(0, 0)
        self.put(self.lbl_usado, 22, 90)
        self.lbl_usado.show()

        # Etiqueta Información Espacio Libre
        self.lbl_otra = gtk.Label('')
        self.lbl_otra.set_size_request(590, 20)
        self.lbl_otra.set_alignment(0, 0)
        self.put(self.lbl_otra, 22, 115)
        self.lbl_otra.show()

        # Etiqueta Información Instalación canaima
        self.lbl_canaima = gtk.Label('')
        self.lbl_canaima.set_size_request(590, 20)
        self.lbl_canaima.set_alignment(0, 0)
        self.put(self.lbl_canaima, 22, 140)
        self.lbl_canaima.show()

        # Etiqueta Información Espacio mínimo
        msg = 'Espacio mínimo requerido para instalar Canaima GNU/Linux'
        self.lbl_minimo = gtk.Label('{0} ({1})'.format(msg, gen.hum(self.minimo)))
        self.lbl_minimo.set_size_request(590, 20)
        self.lbl_minimo.set_alignment(0, 0)
        self.put(self.lbl_minimo, 22, 165)
        self.lbl_minimo.show()

        # Opciones
        button = gtk.RadioButton(None,
            "Realizar la instalación en una sola partición")
        button.connect("toggled", self.RadioButton_on_changed, "particion_1")
        button.set_size_request(590, 20)
        button.set_active(True)
        self.put(button, 0, 190)
        button.show()

        button = gtk.RadioButton(button,
            "Separar la partición /home (Recomendado)")
        button.connect("toggled", self.RadioButton_on_changed, "particion_2")
        button.set_size_request(590, 20)
        self.put(button, 0, 210)
        button.show()

        button = gtk.RadioButton(button,
            "Separar las particiones /home, /usr y /boot")
        button.connect("toggled", self.RadioButton_on_changed, "particion_3")
        button.set_size_request(590, 20)
        self.put(button, 0, 230)
        button.show()

        button = gtk.RadioButton(button,
            "Particionar Manualmente")
        button.connect("toggled", self.RadioButton_on_changed, "particion_4")
        button.set_size_request(590, 20)
        self.put(button, 0, 250)
        button.show()

        if self.swap != False:
            # Etiqueta Información Swap
            msg = 'Se usará la partición Swap Existente'
            self.lbl_usado = gtk.Label('{0}'.format(msg))
            self.lbl_usado.set_size_request(590, 20)
            self.lbl_usado.set_alignment(1, 0)
            self.put(self.lbl_usado, 0, 265)
            self.lbl_usado.show()
示例#20
0
    def __init__(self, cfg):
        gtk.Fixed.__init__(self)
        self.cfg = cfg
        #print self.cfg

        altura = 260
        inc = 20

        msg = "Distribución del Teclado: {0}".format(self.cfg['teclado'])
        self.lbldist = gtk.Label(msg)
        self.lbldist.set_size_request(590, 30)
        self.put(self.lbldist, 0, altura)
        self.lbldist.set_alignment(0, 0)
        self.lbldist.show()
        altura = altura - inc

        msg = "Tipo de instalación: "
        if self.cfg['tipo'] == 'particion_1':
            msg = msg + "Realizar la instalación en una sola partición"
        elif self.cfg['tipo'] == 'particion_2':
            msg = msg + "Separar la partición /home"
        elif self.cfg['tipo'] == 'particion_3':
            msg = msg + "Separar las particiones /home, /usr y /boot"
        elif self.cfg['tipo'] == 'particion_3':
            msg = msg + "Particionado manual"
        self.lbltipo = gtk.Label(msg)
        self.lbltipo.set_size_request(590, 30)
        self.put(self.lbltipo, 0, altura)
        self.lbltipo.set_alignment(0, 0)
        self.lbltipo.show()
        altura = altura - inc

        if self.cfg['metodo'] == 'todo':
            msg = "Dispositivo a usar: {0}".format(self.cfg['disco'])
            self.lblmetodo = gtk.Label(msg)
            self.lblmetodo.set_size_request(590, 30)
            self.put(self.lblmetodo, 0, altura)
            self.lblmetodo.set_alignment(0, 0)
            self.lblmetodo.show()
            altura = altura - inc
        elif self.cfg['metodo'] == 'vacio':
            pass
        else:
            msg = "partición a usar: {0}".format(self.cfg['particion'])
            self.lblparticion = gtk.Label(msg)
            self.lblparticion.set_size_request(590, 30)
            self.put(self.lblparticion, 0, altura)
            self.lblparticion.set_alignment(0, 0)
            self.lblparticion.show()
            altura = altura - inc

            msg = "Tamaño Anterior de la Partición: {0}".format(gen.hum(gen.h2kb(self.cfg['fin'])))
            self.lbltam = gtk.Label(msg)
            self.lbltam.set_size_request(590, 30)
            self.put(self.lbltam, 0, altura)
            self.lbltam.set_alignment(0, 0)
            self.lbltam.show()
            altura = altura - inc

            msg = "Nuevo Tamaño de la Partición: {0}".format(gen.hum(gen.h2kb(self.cfg['nuevo_fin'])))
            self.lblnuevo = gtk.Label(msg)
            self.lblnuevo.set_size_request(590, 30)
            self.put(self.lblnuevo, 0, altura)
            self.lblnuevo.set_alignment(0, 0)
            self.lblnuevo.show()
            altura = altura - inc

        msg = "Nombre completo del usuario: {0}".format(self.cfg['nombre'])
        self.lblnombre = gtk.Label(msg)
        self.lblnombre.set_size_request(590, 30)
        self.put(self.lblnombre, 0, altura)
        self.lblnombre.set_alignment(0, 0)
        self.lblnombre.show()
        altura = altura - inc

        msg = "Nombre de usuario: {0}".format(self.cfg['usuario'])
        self.lblusuario = gtk.Label(msg)
        self.lblusuario.set_size_request(590, 30)
        self.put(self.lblusuario, 0, altura)
        self.lblusuario.set_alignment(0, 0)
        self.lblusuario.show()
        altura = altura - inc

        msg = "Nombre de la maquina: {0}".format(self.cfg['maquina'])
        self.lblmaquina = gtk.Label(msg)
        self.lblmaquina.set_size_request(590, 30)
        self.put(self.lblmaquina, 0, altura)
        self.lblmaquina.set_alignment(0, 0)
        self.lblmaquina.show()
        altura = altura - inc

        self.linea = gtk.HSeparator()
        self.linea.set_size_request(590, 10);
        self.put(self.linea, 0, altura)
        self.linea.show()
        altura = altura - inc

        msg = 'Confirme que todos los datos son correctos, al hacer click en '
        msg = msg + 'siguiente comenzará la\ninstalación y ya no podrá dar '
        msg = msg + 'marcha atrás.'
        self.lblmsg = gtk.Label(msg)
        self.lblmsg.set_size_request(590, (260 - altura))
        self.put(self.lblmsg, 0, 0)
        #self.lbl1.set_alignment(0, 0)
        self.lblmsg.show()
    def __init__(self, padre):
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
        gtk.Window.set_position(self, gtk.WIN_POS_CENTER_ALWAYS)
        self.set_title("Nueva Partición")
        self.padre = padre
        self.set_size_request(400, 200)
        self.set_resizable(0)
        self.set_border_width(0)

        self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
        self.set_default_response(gtk.RESPONSE_CANCEL)

        if self.padre.bext == False:
            self.inicio = gen.kb(self.padre.lista[-1][5])
            self.fin = gen.kb(self.padre.fin)
        else:
            self.inicio = gen.kb(self.padre.ext_ini)
            self.fin = gen.kb(self.padre.ext_fin)

        # Contenedor General
        self.cont = gtk.Fixed()
        self.cont.show()
        self.vbox.pack_start(self.cont)

        #Tamaño de la partición
        self.lbl = gtk.Label('Tamaño')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.lbl.show()
        self.cont.put(self.lbl, 5, 5)
        adj = gtk.Adjustment(float(self.fin),
                             float(self.inicio),
                             float(self.fin),
                             1.0,
                             5.0,
                             0.0)
        self.escala = gtk.HScale()
        self.escala.set_draw_value(False)
        self.escala.set_adjustment(adj)
        self.escala.set_property('value-pos', gtk.POS_RIGHT)
        self.escala.set_size_request(250, 30)
        self.escala.connect("value-changed", self.on_changed)
        self.cont.put(self.escala, 60, 5)
        self.escala.show()
        self.lblsize = gtk.Label(gen.hum(self.escala.get_value() - \
                                 float(self.inicio)))
        self.lblsize.set_alignment(0, 0.5)
        self.lblsize.set_size_request(100, 30)
        self.lblsize.show()
        self.cont.put(self.lblsize, 320, 5)

        #Tipo de partición
        self.lbl = gtk.Label('Tipo de partición')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.cont.put(self.lbl, 5, 35)
        self.lbl.show()

        self.cmb_tipo = gtk.combo_box_new_text()
        self.cmb_tipo.set_size_request(100, 30)
        self.cont.put(self.cmb_tipo, 145, 35)
        if padre.bext == True:
            self.cmb_tipo.append_text('Lógica')
            self.cmb_tipo.set_sensitive(False)
        else:
            #if self.padre.primarias < 4:
            self.cmb_tipo.append_text('Primaria')
            self.cmb_tipo.append_text('Extendida')
        self.cmb_tipo.set_active(0)
        self.cmb_tipo.connect("changed", self.cmb_tipo_on_changed)
        self.cmb_tipo.show()

        #Sistema de Archivos
        self.lbl = gtk.Label('Sistema de Archivos')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.lbl.show()
        self.cont.put(self.lbl, 5, 65)
        self.cmb_fs = gtk.combo_box_new_text()
        self.cmb_fs.set_size_request(100, 30)
        self.cont.put(self.cmb_fs, 145, 65)
        self.cmb_fs.append_text('ext2')
        self.cmb_fs.append_text('ext3')
        self.cmb_fs.append_text('ext4')
        self.cmb_fs.append_text('linux-swap')
        self.cmb_fs.append_text('reiserfs')
        self.cmb_fs.append_text('fat16')
        self.cmb_fs.append_text('fat32')
        self.cmb_fs.set_active(2)
        self.cmb_fs.connect("changed", self.cmb_fs_on_changed)
        self.cmb_fs.show()

        # Punto de Montaje
        self.lbl = gtk.Label('Punto de Montaje')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.cont.put(self.lbl, 5, 95)
        self.lbl.show()

        self.cmb_montaje = gtk.combo_box_new_text()
        self.cmb_montaje.set_size_request(200, 30)
        self.cont.put(self.cmb_montaje, 145, 95)
        self.agregar('/')
        self.agregar('/boot')
        self.agregar('/home')
        self.agregar('/tmp')
        self.agregar('/usr')
        self.agregar('/var')
        self.agregar('/srv')
        self.agregar('/opt')
        self.agregar('/usr/local')
        self.cmb_montaje.append_text('Ninguno')
        self.cmb_montaje.append_text('Escoger manualmente')
        self.cmb_montaje.set_active(0)
        self.cmb_montaje.connect("changed", self.cmb_montaje_on_changed)
        self.cmb_montaje.show()

        self.entrada = gtk.Entry()
        self.entrada.set_text('/')
        self.entrada.set_size_request(200, 30)
        self.cont.put(self.entrada, 145, 125)
        self.entrada.connect("changed", self.validar_punto)

        response = self.run()

        if response == gtk.RESPONSE_OK:
            tipo = gen.get_active_text(self.cmb_tipo)
            formato = gen.get_active_text(self.cmb_fs)
            montaje = gen.get_active_text(self.cmb_montaje)
            if tipo == 'Extendida':
                formato = 'Ninguno'
                montaje = 'Ninguno'
            if formato == 'linux-swap':
                montaje = 'Ninguno'
            if montaje == 'Escoger manualmente':
                montaje = self.entrada.get_text().strip()

            if self.padre.lista[-1][1] == 'Espacio Libre':
                self.padre.lista.pop()
            if len(self.padre.lista) > 0:
                if self.padre.lista[-1][1] == 'Espacio Libre Extendida':
                    self.padre.lista.pop()

            # Si la partición nueva es Primaria
            if tipo == 'Primaria':
                # Calculo el tamaño
                inicio = int(self.inicio)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Elimina ultimo elemento de la lista
                #self.padre.lista.pop()
                # Se crea elemento particion primaria y se agrega a la lista
                particion = [self.padre.disco, #Dispositivo
                             tipo, #Tipo
                             formato, #Formato
                             montaje, #Punto de montaje
                             tamano, #Tamaño
                             inicio, #inicio
                             fin]               #fin
                self.padre.lista.append(particion)
            # Si la partición nueva es Extendida
            elif tipo == 'Extendida':
                # Calculo el tamaño
                inicio = int(self.inicio)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Cambia variable bext a True
                self.padre.bext = True
                # Establece las variables ext_ini y ext_fin
                self.padre.ext_ini = inicio
                self.padre.ext_fin = fin
                # Elimina ultimo elemento de la lista
                #self.padre.lista.pop()
                # Se crea elemento particion extendida y se agrega a la lista
                particion = [self.padre.disco, #Dispositivo
                             tipo, #Tipo
                             '', #formato,     #Formato
                             montaje, #Punto de montaje
                             tamano, #Tamaño
                             inicio, #inicio
                             fin]               #fin
                self.padre.lista.append(particion)
                # Se crea elemento espacio libre en partición extendida
                particion = ['', #self.padre.disco,                      #Dispositivo
                             'Espacio Libre Extendida', #Tipo
                             '', #self.get_active_text(self.cmb_fs),     #Formato
                             '', #self.get_active_text(self.cmb_montaje),#Punto de montaje
                             tamano, #Tamaño
                             inicio, #inicio
                             fin]                                   #fin
                self.padre.lista.append(particion)
            # Si la partición nueva es Lógica
            elif tipo == 'Lógica':
                # Calculo el tamaño
                inicio = int(self.padre.ext_ini)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Elimina los dos ultimos elementos de la lista
                #self.padre.lista.pop()
                #self.padre.lista.pop()
                # Se crea elemento particion lógica y se agrega a la lista
                particion = [self.padre.disco, #Dispositivo
                             tipo, #Tipo
                             formato, #Formato
                             montaje, #Punto de montaje
                             tamano, #Tamaño
                             inicio, #inicio
                             fin]               #fin
                self.padre.lista.append(particion)
                # Si self.padre.ext_fin != fin entonces
                if self.padre.ext_fin == fin:
                    # No se crea elemento espacio libre en partición extendida
                    # Cambia variable bext a False
                    self.padre.bext = False
                # Si no
                else:
                    # se calcula el tamaño de la partición libre
                    ext_ini = fin
                    ext_fin = self.padre.ext_fin
                    tamano = gen.hum(ext_fin - ext_ini)
                    self.padre.ext_ini = ext_ini
                    # Se crea elemento espacio libre en partición extendida
                    particion = ['', #self.padre.disco,                      #Dispositivo
                                 'Espacio Libre Extendida', #Tipo
                                 '', #self.get_active_text(self.cmb_fs),     #Formato
                                 '', #self.get_active_text(self.cmb_montaje),#Punto de montaje
                                 tamano, #Tamaño
                                 ext_ini, #inicio
                                 ext_fin]                                   #fin
                    self.padre.lista.append(particion)

            # Calculamos el tamaño de la partición libre
            # si bext == True entonces se usará ext_fin como fin
            if self.padre.bext == True:
                fin = self.padre.ext_fin
            #print 'Inicio:', inicio, 'fin:', fin, "self.fin", int(self.fin)
            # Si fin == self.fin entonces 
            if fin == int(gen.kb(self.padre.fin)):
                pass
                # No se crea elemento espacio libre
                #print "No crea la elemento espacio libre"
            # Si no
            else:
                #print "Crea elemento espacio libre"
                # se calcula el tamaño de la partición libre
                inicio = fin
                fin = int(gen.kb(self.padre.fin))
                tamano = gen.hum(fin - inicio)
                # Se crea elemento espacio libre
                libre = ['', #Dispositivo
                         'Espacio Libre', #Tipo
                         '', #Formato
                         '', #Punto de montaje
                         tamano, #Tamaño
                         inicio, #inicio
                         fin]               #fin
                self.padre.lista.append(libre)
            # Se actualiza la tabla
            self.padre.llenar_tabla(self.padre.lista)

        else:
            pass

        self.destroy()
        return None
 def on_changed(self, widget=None):
     self.lblsize.set_text(gen.hum(widget.get_value() - float(self.inicio)))
示例#23
0
    def __init__(self, particion):
        gtk.Fixed.__init__(self)

        self.inicio(particion)
        #        self.particion = particion
        #        self.disco = particion[:-1]
        #        self.num = particion[-1:]

        #        self.cfg['particion'] = particion
        #        self.cfg['disco'] = self.disco
        #        self.cfg['num'] = self.num

        #        p = self.part.lista_particiones(self.disco, self.particion)[0]
        #        self.particiones = self.part.lista_particiones(self.disco)
        #        self.ini = p[1]
        #        self.fin = p[2]
        #        self.fs = p[5]
        #        self.cfg['ini'] = self.ini
        #        self.cfg['fin'] = self.fin

        txt_info = "Seleccione el tamaño que desea usar para la instalación"
        self.lbl1 = gtk.Label(txt_info)
        self.lbl1.set_size_request(590, 20)
        self.lbl1.set_justify(gtk.JUSTIFY_CENTER)
        self.put(self.lbl1, 0, 0)
        self.lbl1.show()

        # Barra
        total = int(self.p[3][:-2])
        usado = gen.kb(self.p[7])
        minimo = gen.kb(self.minimo)
        libre = gen.kb(self.libre)
        self.swap = self.hay_swap()

        self.barra = widget.Barra(self, total, usado, libre, minimo, particion,
                                  self.cur_value)
        self.barra.set_size_request(590, 60)
        self.barra.show()
        self.put(self.barra, 0, 25)

        self.leyenda = leyenda.Main(self)
        self.leyenda.set_size_request(20, 100)
        self.put(self.leyenda, 0, 90)
        self.leyenda.show()

        # Etiqueta Información Espacio Usado
        msg = 'Espacio Usado en la partición'
        self.lbl_usado = gtk.Label('{0} ({1})'.format(msg, gen.hum(usado)))
        self.lbl_usado.set_size_request(590, 20)
        self.lbl_usado.set_alignment(0, 0)
        self.put(self.lbl_usado, 22, 90)
        self.lbl_usado.show()

        # Etiqueta Información Espacio Libre
        self.lbl_otra = gtk.Label('')
        self.lbl_otra.set_size_request(590, 20)
        self.lbl_otra.set_alignment(0, 0)
        self.put(self.lbl_otra, 22, 115)
        self.lbl_otra.show()

        # Etiqueta Información Instalación canaima
        self.lbl_canaima = gtk.Label('')
        self.lbl_canaima.set_size_request(590, 20)
        self.lbl_canaima.set_alignment(0, 0)
        self.put(self.lbl_canaima, 22, 140)
        self.lbl_canaima.show()

        # Etiqueta Información Espacio mínimo
        msg = 'Espacio mínimo requerido para instalar Canaima GNU/Linux'
        self.lbl_minimo = gtk.Label('{0} ({1})'.format(msg,
                                                       gen.hum(self.minimo)))
        self.lbl_minimo.set_size_request(590, 20)
        self.lbl_minimo.set_alignment(0, 0)
        self.put(self.lbl_minimo, 22, 165)
        self.lbl_minimo.show()

        # Opciones
        button = gtk.RadioButton(
            None, "Realizar la instalación en una sola partición")
        button.connect("toggled", self.RadioButton_on_changed, "particion_1")
        button.set_size_request(590, 20)
        button.set_active(True)
        self.put(button, 0, 190)
        button.show()

        button = gtk.RadioButton(button,
                                 "Separar la partición /home (Recomendado)")
        button.connect("toggled", self.RadioButton_on_changed, "particion_2")
        button.set_size_request(590, 20)
        self.put(button, 0, 210)
        button.show()

        button = gtk.RadioButton(
            button, "Separar las particiones /home, /usr y /boot")
        button.connect("toggled", self.RadioButton_on_changed, "particion_3")
        button.set_size_request(590, 20)
        self.put(button, 0, 230)
        button.show()

        button = gtk.RadioButton(button, "Particionar Manualmente")
        button.connect("toggled", self.RadioButton_on_changed, "particion_4")
        button.set_size_request(590, 20)
        self.put(button, 0, 250)
        button.show()

        if self.swap != False:
            # Etiqueta Información Swap
            msg = 'Se usará la partición Swap Existente'
            self.lbl_usado = gtk.Label('{0}'.format(msg))
            self.lbl_usado.set_size_request(590, 20)
            self.lbl_usado.set_alignment(1, 0)
            self.put(self.lbl_usado, 0, 265)
            self.lbl_usado.show()
示例#24
0
    def expose(self, widget, event):
        cr = widget.window.cairo_create()
        cr.set_line_width(0.8)

        cr.select_font_face("Courier", 
            cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
        cr.set_font_size(11)

        #establece ancho y alto
        self.w = self.get_size_request()[0]
        self.h = self.get_size_request()[1]
        ancho = self.w
        alto = self.h

        w_usado = (int(self.usado) * ancho) / int(self.total)
        x_minimo = ((int(self.total) - int(self.minimo)) * ancho) / int(self.total)
        w_minimo = (int(self.minimo) * ancho) / int(self.total)
        x_particion = (self.cur * ancho) / int(self.total)
        w_particion = ancho - x_particion - w_minimo
        w_libre = x_particion - w_usado 
        x1_barra = x_particion - 5
        y1_barra = 10
        x2_barra = x_particion + 5
        y2_barra = alto - 10
        w_barra = 10
        h_barra = alto - 20
        self.pos = [x1_barra, y1_barra, x2_barra, y2_barra]
        
        # Espacio usado
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0.3, 0.3, 0)
        linear.add_color_stop_rgb(0.3, 0.5, 0.5, 0.2)
        linear.add_color_stop_rgb(0.7, 0.8, 0.8, 0.4)
        cr.set_source(linear)
        cr.rectangle(0, 0, w_usado, alto)
        cr.fill()

        # Espacio libre
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0.5, 0.5, 0)
        linear.add_color_stop_rgb(0.3, 0.7, 0.7, 0.3)
        linear.add_color_stop_rgb(0.7, 1.0, 1.0, 0.7)
        cr.set_source(linear)
        cr.rectangle(w_usado, 0, w_libre, alto)
        cr.fill()

        # Espacio Mínimo
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0, 0.3, 0)
        linear.add_color_stop_rgb(0.3, 0.2, 0.4, 0.2)
        linear.add_color_stop_rgb(0.7, 0.4, 0.8, 0.4)
        cr.set_source(linear)
        cr.rectangle(x_minimo, 0, w_minimo, alto)
        cr.fill()

        #Espacio a particionar
        linear = cairo.LinearGradient(0, 0, 0, alto)
        linear.add_color_stop_rgb(0, 0, 0.5, 0)
        linear.add_color_stop_rgb(0.3, 0.3, 0.7, 0.3)
        linear.add_color_stop_rgb(0.7, 0.7, 1.0, 0.7)
        cr.set_source(linear)
        cr.rectangle(x_particion, 0, w_particion, alto)
        cr.fill()

        canaima = gen.hum(self.total - self.cur)
        otra = gen.hum(self.cur)
        msg = 'Espacio que se usará para instalar Canaima GNU/Linux'
        self.par.lbl_canaima.set_text('{1} ({0})'.format(canaima, msg))
        msg = 'Espacio que quedará despues de redimensionar la particion'
        self.par.lbl_otra.set_text('{2} {0} ({1})'.format(self.particion, otra, msg))

        cr.set_source_rgb(0, 0, 0)
        area = (x1_barra, x2_barra, y1_barra, y2_barra)
        self.draw_rounded(cr, area, 3)
        for i in range(y1_barra + 3, y2_barra - 2, 3):
            cr.move_to(x1_barra + 1, i)
            cr.rel_line_to(8, 0)
            cr.stroke()
    def __init__(self, padre):
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
        gtk.Window.set_position(self, gtk.WIN_POS_CENTER_ALWAYS)
        self.set_title("Nueva Partición")
        self.padre = padre
        self.set_size_request(400, 200)
        self.set_resizable(0)
        self.set_border_width(0)

        self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
        self.set_default_response(gtk.RESPONSE_CANCEL)

        if self.padre.bext == False:
            self.inicio = gen.kb(self.padre.lista[-1][5])
            self.fin = gen.kb(self.padre.fin)
        else:
            self.inicio = gen.kb(self.padre.ext_ini)
            self.fin = gen.kb(self.padre.ext_fin)

        # Contenedor General
        self.cont = gtk.Fixed()
        self.cont.show()
        self.vbox.pack_start(self.cont)

        #Tamaño de la partición
        self.lbl = gtk.Label('Tamaño')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.lbl.show()
        self.cont.put(self.lbl, 5, 5)
        adj = gtk.Adjustment(float(self.fin), float(self.inicio),
                             float(self.fin), 1.0, 5.0, 0.0)
        self.escala = gtk.HScale()
        self.escala.set_draw_value(False)
        self.escala.set_adjustment(adj)
        self.escala.set_property('value-pos', gtk.POS_RIGHT)
        self.escala.set_size_request(250, 30)
        self.escala.connect("value-changed", self.on_changed)
        self.cont.put(self.escala, 60, 5)
        self.escala.show()
        self.lblsize = gtk.Label(gen.hum(self.escala.get_value() - \
                                 float(self.inicio)))
        self.lblsize.set_alignment(0, 0.5)
        self.lblsize.set_size_request(100, 30)
        self.lblsize.show()
        self.cont.put(self.lblsize, 320, 5)

        #Tipo de partición
        self.lbl = gtk.Label('Tipo de partición')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.cont.put(self.lbl, 5, 35)
        self.lbl.show()

        self.cmb_tipo = gtk.combo_box_new_text()
        self.cmb_tipo.set_size_request(100, 30)
        self.cont.put(self.cmb_tipo, 145, 35)
        if padre.bext == True:
            self.cmb_tipo.append_text('Lógica')
            self.cmb_tipo.set_sensitive(False)
        else:
            #if self.padre.primarias < 4:
            self.cmb_tipo.append_text('Primaria')
            self.cmb_tipo.append_text('Extendida')
        self.cmb_tipo.set_active(0)
        self.cmb_tipo.connect("changed", self.cmb_tipo_on_changed)
        self.cmb_tipo.show()

        #Sistema de Archivos
        self.lbl = gtk.Label('Sistema de Archivos')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.lbl.show()
        self.cont.put(self.lbl, 5, 65)
        self.cmb_fs = gtk.combo_box_new_text()
        self.cmb_fs.set_size_request(100, 30)
        self.cont.put(self.cmb_fs, 145, 65)
        self.cmb_fs.append_text('ext2')
        self.cmb_fs.append_text('ext3')
        self.cmb_fs.append_text('ext4')
        self.cmb_fs.append_text('linux-swap')
        self.cmb_fs.append_text('reiserfs')
        self.cmb_fs.append_text('fat16')
        self.cmb_fs.append_text('fat32')
        self.cmb_fs.set_active(2)
        self.cmb_fs.connect("changed", self.cmb_fs_on_changed)
        self.cmb_fs.show()

        # Punto de Montaje
        self.lbl = gtk.Label('Punto de Montaje')
        self.lbl.set_alignment(0, 0.5)
        self.lbl.set_size_request(200, 30)
        self.cont.put(self.lbl, 5, 95)
        self.lbl.show()

        self.cmb_montaje = gtk.combo_box_new_text()
        self.cmb_montaje.set_size_request(200, 30)
        self.cont.put(self.cmb_montaje, 145, 95)
        self.agregar('/')
        self.agregar('/boot')
        self.agregar('/home')
        self.agregar('/tmp')
        self.agregar('/usr')
        self.agregar('/var')
        self.agregar('/srv')
        self.agregar('/opt')
        self.agregar('/usr/local')
        self.cmb_montaje.append_text('Ninguno')
        self.cmb_montaje.append_text('Escoger manualmente')
        self.cmb_montaje.set_active(0)
        self.cmb_montaje.connect("changed", self.cmb_montaje_on_changed)
        self.cmb_montaje.show()

        self.entrada = gtk.Entry()
        self.entrada.set_text('/')
        self.entrada.set_size_request(200, 30)
        self.cont.put(self.entrada, 145, 125)
        self.entrada.connect("changed", self.validar_punto)

        response = self.run()

        if response == gtk.RESPONSE_OK:
            tipo = gen.get_active_text(self.cmb_tipo)
            formato = gen.get_active_text(self.cmb_fs)
            montaje = gen.get_active_text(self.cmb_montaje)
            if tipo == 'Extendida':
                formato = 'Ninguno'
                montaje = 'Ninguno'
            if formato == 'linux-swap':
                montaje = 'Ninguno'
            if montaje == 'Escoger manualmente':
                montaje = self.entrada.get_text().strip()

            if self.padre.lista[-1][1] == 'Espacio Libre':
                self.padre.lista.pop()
            if len(self.padre.lista) > 0:
                if self.padre.lista[-1][1] == 'Espacio Libre Extendida':
                    self.padre.lista.pop()

            # Si la partición nueva es Primaria
            if tipo == 'Primaria':
                # Calculo el tamaño
                inicio = int(self.inicio)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Elimina ultimo elemento de la lista
                #self.padre.lista.pop()
                # Se crea elemento particion primaria y se agrega a la lista
                particion = [
                    self.padre.disco,  #Dispositivo
                    tipo,  #Tipo
                    formato,  #Formato
                    montaje,  #Punto de montaje
                    tamano,  #Tamaño
                    inicio,  #inicio
                    fin
                ]  #fin
                self.padre.lista.append(particion)
            # Si la partición nueva es Extendida
            elif tipo == 'Extendida':
                # Calculo el tamaño
                inicio = int(self.inicio)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Cambia variable bext a True
                self.padre.bext = True
                # Establece las variables ext_ini y ext_fin
                self.padre.ext_ini = inicio
                self.padre.ext_fin = fin
                # Elimina ultimo elemento de la lista
                #self.padre.lista.pop()
                # Se crea elemento particion extendida y se agrega a la lista
                particion = [
                    self.padre.disco,  #Dispositivo
                    tipo,  #Tipo
                    '',  #formato,     #Formato
                    montaje,  #Punto de montaje
                    tamano,  #Tamaño
                    inicio,  #inicio
                    fin
                ]  #fin
                self.padre.lista.append(particion)
                # Se crea elemento espacio libre en partición extendida
                particion = [
                    '',  #self.padre.disco,                      #Dispositivo
                    'Espacio Libre Extendida',  #Tipo
                    '',  #self.get_active_text(self.cmb_fs),     #Formato
                    '',  #self.get_active_text(self.cmb_montaje),#Punto de montaje
                    tamano,  #Tamaño
                    inicio,  #inicio
                    fin
                ]  #fin
                self.padre.lista.append(particion)
            # Si la partición nueva es Lógica
            elif tipo == 'Lógica':
                # Calculo el tamaño
                inicio = int(self.padre.ext_ini)
                fin = int(self.escala.get_value())
                tamano = gen.hum(fin - inicio)
                # Elimina los dos ultimos elementos de la lista
                #self.padre.lista.pop()
                #self.padre.lista.pop()
                # Se crea elemento particion lógica y se agrega a la lista
                particion = [
                    self.padre.disco,  #Dispositivo
                    tipo,  #Tipo
                    formato,  #Formato
                    montaje,  #Punto de montaje
                    tamano,  #Tamaño
                    inicio,  #inicio
                    fin
                ]  #fin
                self.padre.lista.append(particion)
                # Si self.padre.ext_fin != fin entonces
                if self.padre.ext_fin == fin:
                    # No se crea elemento espacio libre en partición extendida
                    # Cambia variable bext a False
                    self.padre.bext = False
                # Si no
                else:
                    # se calcula el tamaño de la partición libre
                    ext_ini = fin
                    ext_fin = self.padre.ext_fin
                    tamano = gen.hum(ext_fin - ext_ini)
                    self.padre.ext_ini = ext_ini
                    # Se crea elemento espacio libre en partición extendida
                    particion = [
                        '',  #self.padre.disco,                      #Dispositivo
                        'Espacio Libre Extendida',  #Tipo
                        '',  #self.get_active_text(self.cmb_fs),     #Formato
                        '',  #self.get_active_text(self.cmb_montaje),#Punto de montaje
                        tamano,  #Tamaño
                        ext_ini,  #inicio
                        ext_fin
                    ]  #fin
                    self.padre.lista.append(particion)

            # Calculamos el tamaño de la partición libre
            # si bext == True entonces se usará ext_fin como fin
            if self.padre.bext == True:
                fin = self.padre.ext_fin
            #print 'Inicio:', inicio, 'fin:', fin, "self.fin", int(self.fin)
            # Si fin == self.fin entonces
            if fin == int(gen.kb(self.padre.fin)):
                pass
                # No se crea elemento espacio libre
                #print "No crea la elemento espacio libre"
            # Si no
            else:
                #print "Crea elemento espacio libre"
                # se calcula el tamaño de la partición libre
                inicio = fin
                fin = int(gen.kb(self.padre.fin))
                tamano = gen.hum(fin - inicio)
                # Se crea elemento espacio libre
                libre = [
                    '',  #Dispositivo
                    'Espacio Libre',  #Tipo
                    '',  #Formato
                    '',  #Punto de montaje
                    tamano,  #Tamaño
                    inicio,  #inicio
                    fin
                ]  #fin
                self.padre.lista.append(libre)
            # Se actualiza la tabla
            self.padre.llenar_tabla(self.padre.lista)

        else:
            pass

        self.destroy()
        return None