Beispiel #1
0
 def crearColor(self, X):
     r = self.R.get()
     g = self.V.get()
     b = self.A.get()
     if r != "" and g != "" and b != "":
         if r.isdigit() and g.isdigit() and b.isdigit():
             r = int(r)
             g = int(g)
             b = int(b)
             if valorEntre(r, 0, 255) and valorEntre(
                     g, 0, 255) and valorEntre(b, 0, 255):
                 hr = hex(r).replace("0x", "").zfill(2)
                 hg = hex(g).replace("0x", "").zfill(2)
                 hb = hex(b).replace("0x", "").zfill(2)
                 hexcolor = ("#" + hr + hg + hb).upper()
                 self.paleta.config(bg=hexcolor)
                 self.color.config(text=hexcolor)
                 self.value = hexcolor
                 self.enviarb.config(state=NORMAL)
             else:
                 self.enviarb.config(state=DISABLED)
                 self.color.config(text="ERROR, VALORES ENTRE [0,255]")
                 lib("sonido", "minimo")
         else:
             self.color.config(text="ERROR, VALORES DEBEN SER DIGITOS")
             lib("sonido", "minimo")
             self.enviarb.config(state=DISABLED)
     else:
         self.enviarb.config(state=DISABLED)
         self.color.config(text="Elija un color")
Beispiel #2
0
    def get_device_info(self, Param):
        local_lib = lib()
        local_device = device()
        local_device.init_device_info("");
        #print "get info " + Param
        i = 0
        for i in range(len(device.meminfo)):
            #print "look " + Param + " in meminfo " +  str(device.meminfo[i])
            if Param in str(device.meminfo[i]):
                number = int(local_lib.get_str_first_value(device.meminfo[i]))
                #print number
                #print Param + str(number) + " " + "in meminfo"
                return number
        i = 0
        for i in range(len(device.vmstat)):
            #print "look " + Param + " in  vmstat " +  str(device.vmstat[i])
            if Param in str(device.vmstat[i]):

                number = int(local_lib.get_str_first_value(device.vmstat[i]))
                #print number
                #print Param + str(number) + " " + "in vmstat"
                return number
Beispiel #3
0
    def get_device_info(self, Param):
        local_lib = lib()
        local_device = device()
        local_device.init_device_info("")
        #print "get info " + Param
        i = 0
        for i in range(len(device.meminfo)):
            #print "look " + Param + " in meminfo " +  str(device.meminfo[i])
            if Param in str(device.meminfo[i]):
                number = int(local_lib.get_str_first_value(device.meminfo[i]))
                #print number
                #print Param + str(number) + " " + "in meminfo"
                return number
        i = 0
        for i in range(len(device.vmstat)):
            #print "look " + Param + " in  vmstat " +  str(device.vmstat[i])
            if Param in str(device.vmstat[i]):

                number = int(local_lib.get_str_first_value(device.vmstat[i]))
                #print number
                #print Param + str(number) + " " + "in vmstat"
                return number
Beispiel #4
0
    def __init__(self, title, icon, tipo, tamano, properties=[0, 0, 0, 0, 0]):
        self.value = 0
        self.root = Tk()
        self.root.geometry('%dx%d+%d+%d' % (tamano[0], tamano[1], (self.root.winfo_screenwidth() - tamano[0])/2,\
                                             (self.root.winfo_screenheight() - tamano[1])/2))
        self.root.iconbitmap(bitmap=icon)
        self.root.title(title)
        self.root.minsize(width=tamano[0], height=tamano[1])
        self.root.resizable(width=False, height=False)

        #Cambiar un color
        if tipo == "cambiarcolor":
            Label(self.root,
                  text="Escoja un color",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#ff0000").pack(side=LEFT)
            Button(F1_A,
                   text="Rojo",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FF0000"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#0000FF").pack(side=LEFT)
            Button(F1_B,
                   text="Azul",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#0000FF"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#FFFF00").pack(side=LEFT)
            Button(F1_A,
                   text="Amarillo",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FFFF00"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#800080").pack(side=LEFT)
            Button(F1_B,
                   text="Morado",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#800080"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#FFC0CB").pack(side=LEFT)
            Button(F1_A,
                   text="Rosado",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FFC0CB"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#FFA500").pack(side=LEFT)
            Button(F1_B,
                   text="Naranjo",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FFA500"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#000080").pack(side=LEFT)
            Button(F1_A,
                   text="Azul marino",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#000080"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#ADFF2F").pack(side=LEFT)
            Button(F1_B,
                   text="Verde",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#ADFF2F"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#DDA0DD").pack(side=LEFT)
            Button(F1_A,
                   text="Ciruela",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#DDA0DD"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#FA8072").pack(side=LEFT)
            Button(F1_B,
                   text="Salmon",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FA8072"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#008000").pack(side=LEFT)
            Button(F1_A,
                   text="Verde Oscuro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#008000"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#00FF00").pack(side=LEFT)
            Button(F1_B,
                   text="Verde Lima",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#00FF00"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#008080").pack(side=LEFT)
            Button(F1_A,
                   text="Celeste Oscuro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#008080"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#00FFFF").pack(side=LEFT)
            Button(F1_B,
                   text="Cyan",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#00FFFF"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#808000").pack(side=LEFT)
            Button(F1_A,
                   text="Oliva",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#808000"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#800000").pack(side=LEFT)
            Button(F1_B,
                   text="Marron",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#800000"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#643200").pack(side=LEFT)
            Button(F1_A,
                   text="Marron Claro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#643200"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#C86400").pack(side=LEFT)
            Button(F1_B,
                   text="Marron Oscuro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#C86400"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#5E5E5E").pack(side=LEFT)
            Button(F1_A,
                   text="Gris Oscuro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#5E5E5E"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#D0D0D0").pack(side=LEFT)
            Button(F1_B,
                   text="Gris Claro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#D0D0D0"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            F1_A = Frame(F1, border=1)
            F1_A.pack(side=LEFT)
            Canvas(F1_A, width=30, height=23, bg="#000000").pack(side=LEFT)
            Button(F1_A,
                   text="Negro",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#000000"),
                   width=13).pack(side=LEFT)
            Label(
                F1_A,
                text="",
            ).pack()
            F1_B = Frame(F1, border=1)
            F1_B.pack()
            Canvas(F1_B, width=30, height=23, bg="#ffffff").pack(side=LEFT)
            Button(F1_B,
                   text="Blanco",
                   relief=GROOVE,
                   command=lambda: self.putcolor("#FFFFFF"),
                   width=13).pack()

            #Nueva linea de colores
            F1 = Frame(self.root)
            F1.pack()
            Button(F1,
                   text="Color Personalizado",
                   relief=GROOVE,
                   command=self.colorPersonalizado,
                   width=17).pack()

            Label(self.root, text="").pack()
            F1 = Frame(self.root, border=4)
            F1.pack()
            self.color = Label(F1, width=10, text="Elija un color")
            self.color.pack(side=LEFT)
            Label(F1, text="     ").pack(side=LEFT)
            enviar = Button(F1, text="Listo", command=self.root.destroy)
            enviar.pack()

        #Crear un color
        if tipo == "crearcolor":
            Label(self.root,
                  text="Crear un color (RGB)",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()

            #Nueva linea de colores
            FA = Frame(self.root)
            FA.pack()
            F = Frame(FA)
            F.pack(side=LEFT)
            F1 = Frame(F)
            F1.pack()
            Label(F1, text="Rojo [0-255]", width=15,
                  justify=RIGHT).pack(side=LEFT)
            self.R = Entry(F1, width=4)
            self.R.bind("<Key>", self.crearColor)
            self.R.pack()

            F2 = Frame(F)
            F2.pack()
            Label(F2, text="Verde [0-255]", width=15).pack(side=LEFT)
            self.V = Entry(F2, width=4)
            self.V.bind("<Key>", self.crearColor)
            self.V.pack()

            F3 = Frame(F)
            F3.pack()
            Label(F3, text="Azul [0-255]", width=15).pack(side=LEFT)
            self.A = Entry(F3, width=4)
            self.A.bind("<Key>", self.crearColor)
            self.A.pack()

            FB = Frame(FA, border=10)
            FB.pack()
            self.paleta = Canvas(FB,
                                 width=100,
                                 height=70,
                                 relief=GROOVE,
                                 border=1)
            self.paleta.pack()

            Label(self.root, text="").pack()
            FF = Frame(self.root, border=4)
            FF.pack()
            self.color = Label(FF, width=30, text="Elija un color")
            self.color.pack(side=LEFT)
            Label(FF, text="     ").pack(side=LEFT)
            self.enviarb = Button(FF,
                                  text="Crear",
                                  command=self.root.destroy,
                                  state=DISABLED)
            self.enviarb.pack()

        #Grosor de las herramientas
        if tipo == "grosor":
            Label(self.root, text="Grosor", font=DEFAULT_FONT_TITLE,
                  border=10).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=1)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 1",
                   relief=GROOVE,
                   command=lambda: self.grosor(1),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=2)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 2",
                   relief=GROOVE,
                   command=lambda: self.grosor(2),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=3)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 3",
                   relief=GROOVE,
                   command=lambda: self.grosor(3),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=4)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 4",
                   relief=GROOVE,
                   command=lambda: self.grosor(4),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=5)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 5",
                   relief=GROOVE,
                   command=lambda: self.grosor(5),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=6)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 6",
                   relief=GROOVE,
                   command=lambda: self.grosor(6),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=7)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 7",
                   relief=GROOVE,
                   command=lambda: self.grosor(7),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=8)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 8",
                   relief=GROOVE,
                   command=lambda: self.grosor(8),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=9)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 9",
                   relief=GROOVE,
                   command=lambda: self.grosor(9),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=10)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 10",
                   relief=GROOVE,
                   command=lambda: self.grosor(10),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=11)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 11",
                   relief=GROOVE,
                   command=lambda: self.grosor(11),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=12)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 12",
                   relief=GROOVE,
                   command=lambda: self.grosor(12),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=13)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 13",
                   relief=GROOVE,
                   command=lambda: self.grosor(13),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=14)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 14",
                   relief=GROOVE,
                   command=lambda: self.grosor(14),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=15)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 15",
                   relief=GROOVE,
                   command=lambda: self.grosor(15),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=16)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 16",
                   relief=GROOVE,
                   command=lambda: self.grosor(16),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=17)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 17",
                   relief=GROOVE,
                   command=lambda: self.grosor(17),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=18)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 18",
                   relief=GROOVE,
                   command=lambda: self.grosor(18),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=19)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 19",
                   relief=GROOVE,
                   command=lambda: self.grosor(19),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=20)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 20",
                   relief=GROOVE,
                   command=lambda: self.grosor(20),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=21)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 21",
                   relief=GROOVE,
                   command=lambda: self.grosor(21),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=22)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 22",
                   relief=GROOVE,
                   command=lambda: self.grosor(22),
                   width=7).pack()

            #Nueva linea de grosores
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=23)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 23",
                   relief=GROOVE,
                   command=lambda: self.grosor(23),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=24)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Grosor 24",
                   relief=GROOVE,
                   command=lambda: self.grosor(24),
                   width=7).pack()

        if tipo == "estilo":
            self.estiloValues = properties
            Label(self.root,
                  text="Estilo de la herramienta",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()

            #Nueva linea de colores
            F = Frame(self.root, border=4)
            F.pack()
            F1 = Frame(F)
            F1.pack(side=LEFT)
            Label(F1, text="X - [X>0]", width=9, justify=RIGHT).pack(side=LEFT)
            self.XPLUS = Entry(F1, width=4)
            self.XPLUS.insert(0, properties[0])
            self.XPLUS.pack()
            F2 = Frame(F)
            F2.pack()
            Label(F2, text="Y - [Y>0]", width=9, justify=RIGHT).pack(side=LEFT)
            self.YPLUS = Entry(F2, width=4)
            self.YPLUS.insert(0, properties[1])
            self.YPLUS.pack()
            F3 = Frame(self.root, border=4)
            F3.pack()
            Label(F3, text="DASH [N1,N2..]", width=15,
                  justify=RIGHT).pack(side=LEFT)
            self.DASH = Entry(F3, width=7)
            self.DASH.insert(
                0,
                str(properties[2]).replace("[",
                                           "").replace("]",
                                                       "").replace(" ", ""))
            self.DASH.pack()
            F4 = Frame(self.root, border=4)
            F4.pack()
            Label(F4, text="SMOOTH [0,1]", width=15,
                  justify=RIGHT).pack(side=LEFT)
            self.SMOOTH = Entry(F4, width=3)
            self.SMOOTH.insert(0, str(properties[3]))
            self.SMOOTH.pack()
            F5 = Frame(self.root, border=4)
            F5.pack()
            Label(F5,
                  text="JOINSTYLE (miter, bevel, round)",
                  width=25,
                  justify=RIGHT).pack(side=LEFT)
            self.JOIN = Entry(F5, width=6)
            self.JOIN.insert(0, str(properties[4]))
            self.JOIN.pack()

            #Boton
            Label(self.root, text="").pack()
            FB = Frame(self.root)
            FB.pack()
            Button(FB, text="Ok", command=self.enviarEstilo).pack(side=LEFT)
            Label(FB, text=" ").pack(side=LEFT)
            Button(FB, text="Restaurar",
                   command=self.restaurarEstilo).pack(side=LEFT)
            self.defaultProperties = [
                properties[5][0], properties[5][1], properties[5][2],
                properties[5][3], properties[5][4]
            ]

        #Menu insertar figura
        if tipo == "insertarfigura":
            Label(self.root,
                  text="Insertar una figura",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            Button(self.root,
                   text="Arco",
                   command=lambda: self.enviarFigura("arco"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Cuadrado",
                   command=lambda: self.enviarFigura("cuadrado"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Imagen",
                   command=lambda: self.enviarFigura("imagen"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Ovalo",
                   command=lambda: self.enviarFigura("ovalo"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Poligono",
                   command=lambda: self.enviarFigura("poligono"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Recta",
                   command=lambda: self.enviarFigura("recta"),
                   width=10,
                   relief=GROOVE).pack()
            Button(self.root,
                   text="Texto",
                   command=lambda: self.enviarFigura("texto"),
                   width=10,
                   relief=GROOVE).pack()

        #Menu insertar figura
        if tipo == "insertartexto":
            Label(self.root,
                  text="Ingresar un texto",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.texto = Entry(self.root)
            self.texto.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Escribir",
                   command=self.enviarTexto,
                   width=10,
                   relief=GROOVE).pack()
            self.texto.focus_force()

        #Menu insertar figura
        if tipo == "guardar":
            Label(self.root,
                  text="Escoja un nombre",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.texto = Entry(self.root)
            self.texto.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Guardar",
                   command=self.enviarTexto,
                   width=10,
                   relief=GROOVE).pack()
            self.texto.focus_force()

        #Menu numero de vertices
        if tipo == "vertices":
            Label(self.root,
                  text="Numero de vertices",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.numvertices = Entry(self.root)
            self.numvertices.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Continuar",
                   command=self.enviarVertices,
                   width=10,
                   relief=GROOVE).pack()
            self.numvertices.focus_force()

        #Menu numero de vertices
        if tipo == "arco":
            Label(self.root,
                  text="Longitud del arco",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.arc = Entry(self.root)
            self.arc.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Continuar",
                   command=self.enviarArco,
                   width=10,
                   relief=GROOVE).pack()
            self.arc.focus_force()

        #Menu numero de vertices
        if tipo == "deseaGuardar":
            lib("sonido", "alerta")
            Label(self.root,
                  text="Desea Guardar?",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            F = Frame(self.root)
            F.pack()
            Button(F,
                   text="Si",
                   command=lambda: self.response("si"),
                   width=5,
                   relief=GROOVE).pack(side=LEFT)
            Label(F, text=" ").pack(side=LEFT)
            Button(F,
                   text="No",
                   command=lambda: self.response("no"),
                   width=5,
                   relief=GROOVE).pack()

        #About
        if tipo == "about":
            Label(self.root,
                  text="Creador: " + properties[0],
                  font=DEFAULT_FONT_TITLE,
                  border=5).pack()
            Label(self.root,
                  text="Mail: " + properties[2],
                  font=DEFAULT_FONT_TITLE,
                  border=5).pack()
            Label(self.root,
                  text="Version: " + str(properties[1]),
                  font=DEFAULT_FONT_TITLE,
                  border=5).pack()
            Button(self.root, text="Cerrar", command=self.root.destroy).pack()

        #Licencia o gnu
        if tipo == "licence" or tipo == "changelog" or tipo == "ayuda":
            archivo = open(properties[1], "r")
            Yscroll = Scrollbar(self.root)
            Yscroll.pack(side=RIGHT, fill=Y)
            texto = Text(self.root, wrap=NONE, yscrollcommand=Yscroll.set)
            texto.focus_force()
            for i in archivo:
                texto.insert(INSERT, i)
            texto.pack()
            texto.configure(state="disabled")
            Yscroll.config(command=texto.yview)
            archivo.close()
            if isNumerable(c_after_command[0]): C_DATA[4][0] = int(c_after_command[0])
            if isNumerable(c_after_command[1]): C_DATA[4][1] = int(c_after_command[1])
            if isNumerable(c_after_command[2]): C_DATA[4][2][0] = int(c_after_command[2])
            if isNumerable(c_after_command[3]): C_DATA[4][2][1] = int(c_after_command[3])
            if isNumerable(c_after_command[4]): C_DATA[4][3] = int(c_after_command[4])
            if len(c_after_command[5])>0 and (c_after_command[5]=="miter" or c_after_command[5]=="bevel" or c_after_command[5]=="round"):
                C_DATA[4][4] = c_after_command[5].replace("\"","").lower()
        if c_command[0].strip()=="DEFAULT_TOOL_WEIGHT":
            if isNumerable(c_command[1]): C_DATA[5]=int(c_command[1])
        if c_command[0].strip()=="DEFAULT_TOOL":
            if isNumerable(c_command[1]): C_DATA[6]=int(c_command[1])
        if c_command[0].strip()=="DEFAULT_LANGUAGE":
            C_DATA[7]=str(c_command[1]).strip().upper()
    conf_file.close()
except:
    lib("error","kernel",[1])
    lib("sonido","fatal")
    try:
        lib("conf_file",False,[CONFIGURATION_FILE,C_DATA])
        print ("IO/MESSAGE: New configuration file generated")
    except:
        print ("ERROR - 0,1: Cannot create configuration file")

#Default constants
DEFAULT_TITLE = "MonumentAR"
DEFAULT_EXTENSION = ".eps"

#Variables Configuration
PROGRAM_SIZE = C_DATA[0]
DEFAULT_COLOR = C_DATA[1]
DEFAULT_ERASER = C_DATA[2]
Beispiel #6
0
    def __init__(self,
                 title,
                 icon,
                 type_win,
                 size,
                 properties=[0, 0, 0, 0, 0]):
        self.root = tkinter.Tk()
        #tkinter.Toplevel(self.root)
        self.value = 0

        self.root.geometry('%dx%d+%d+%d' % (size[0], size[1], (self.root.winfo_screenwidth() - size[0])/2,\
                                             (self.root.winfo_screenheight() - size[1])/2))
        self.root.iconbitmap(bitmap=icon)
        self.root.title(title)
        self.root.minsize(width=size[0], height=size[1])
        self.root.resizable(width=False, height=False)

        #Weight of Tools
        if type_win == "weight":
            Label(self.root, text="Weight", font=DEFAULT_FONT_TITLE,
                  border=10).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=1)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 1",
                   relief=GROOVE,
                   command=lambda: self.weight(1),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=2)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 2",
                   relief=GROOVE,
                   command=lambda: self.weight(2),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=3)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 3",
                   relief=GROOVE,
                   command=lambda: self.weight(3),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=4)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 4",
                   relief=GROOVE,
                   command=lambda: self.weight(4),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=5)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 5",
                   relief=GROOVE,
                   command=lambda: self.weight(5),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=6)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 6",
                   relief=GROOVE,
                   command=lambda: self.weight(6),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=7)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 7",
                   relief=GROOVE,
                   command=lambda: self.weight(7),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=8)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 8",
                   relief=GROOVE,
                   command=lambda: self.weight(8),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=9)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 9",
                   relief=GROOVE,
                   command=lambda: self.weight(9),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=10)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 10",
                   relief=GROOVE,
                   command=lambda: self.weight(10),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=11)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 11",
                   relief=GROOVE,
                   command=lambda: self.weight(11),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=12)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 12",
                   relief=GROOVE,
                   command=lambda: self.weight(12),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=13)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 13",
                   relief=GROOVE,
                   command=lambda: self.weight(13),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=14)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 14",
                   relief=GROOVE,
                   command=lambda: self.weight(14),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=15)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 15",
                   relief=GROOVE,
                   command=lambda: self.weight(15),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=16)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 16",
                   relief=GROOVE,
                   command=lambda: self.weight(16),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=17)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 17",
                   relief=GROOVE,
                   command=lambda: self.weight(17),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=18)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 18",
                   relief=GROOVE,
                   command=lambda: self.weight(18),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=19)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 19",
                   relief=GROOVE,
                   command=lambda: self.weight(19),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=20)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 20",
                   relief=GROOVE,
                   command=lambda: self.weight(20),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=21)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 21",
                   relief=GROOVE,
                   command=lambda: self.weight(21),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=22)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 22",
                   relief=GROOVE,
                   command=lambda: self.weight(22),
                   width=7).pack()

            #New thickness line
            F = Frame(self.root)
            F.pack()
            FA = Frame(F)
            FA.pack(side=LEFT)
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=23)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 23",
                   relief=GROOVE,
                   command=lambda: self.weight(23),
                   width=7).pack(side=LEFT)
            Label(FA, text=" ").pack(side=LEFT)
            FA = Frame(F)
            FA.pack()
            F_C = Canvas(FA,
                         width=DEFAULT_WIDTH_CANVASTREE[0],
                         height=DEFAULT_WIDTH_CANVASTREE[1],
                         bg="white")
            F_C.pack(side=LEFT)
            F_C.create_line(0,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 2,
                            DEFAULT_WIDTH_CANVASTREE[0] + 2,
                            DEFAULT_WIDTH_CANVASTREE[1] / 2 + 1,
                            width=24)
            Label(FA, text=" ").pack(side=LEFT)
            Button(FA,
                   text="Weight 24",
                   relief=GROOVE,
                   command=lambda: self.weight(24),
                   width=7).pack()

        #Menu insert text
        if type_win == "inserttext":
            Label(self.root,
                  text="Insert Text",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.texto = Entry(self.root)
            self.texto.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Write",
                   command=self.sendText,
                   width=10,
                   relief=GROOVE).pack()
            self.texto.focus_force()

        #Menu savefile
        if type_win == "savefile":
            Label(self.root,
                  text="Choose name",
                  font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            self.texto = Entry(self.root)
            self.texto.pack()
            Label(self.root, text=" ").pack()
            Button(self.root,
                   text="Save",
                   command=self.sendText,
                   width=10,
                   relief=GROOVE).pack()
            self.texto.focus_force()

        #Menu save
        if type_win == "save":
            lib("sonido", "alerta")
            Label(self.root, text="Save?", font=DEFAULT_FONT_TITLE,
                  border=10).pack()
            F = Frame(self.root)
            F.pack()
            Button(F,
                   text="Yes",
                   command=lambda: self.response("yes"),
                   width=5,
                   relief=GROOVE).pack(side=LEFT)
            Label(F, text=" ").pack(side=LEFT)
            Button(F,
                   text="No",
                   command=lambda: self.response("no"),
                   width=5,
                   relief=GROOVE).pack()

        #About
        if type_win == "about":
            Label(self.root,
                  text="Creators" + properties[0],
                  font=DEFAULT_FONT_TITLE,
                  border=5).pack()
            Label(self.root,
                  text="Version: " + str(properties[1]),
                  font=DEFAULT_FONT_TITLE,
                  border=5).pack()
            Button(self.root, text="Close", command=self.root.destroy).pack()

        #License
        if type_win == "license" or type_win == "changelog" or type_win == "help":
            archive = open(properties[1], "r")
            Yscroll = Scrollbar(self.root)
            Yscroll.pack(side=RIGHT, fill=Y)
            text = Text(self.root, wrap=NONE, yscrollcommand=Yscroll.set)
            text.focus_force()
            for i in archive:
                text.insert(INSERT, i)
            text.pack()
            text.configure(state="disabled")
            Yscroll.config(command=text.yview)
            archive.close()
Beispiel #7
0
    def __init__(self):

        try:
            #Variables de dibujo
            self.pos = [[0, 0], [0, 0]]
            self.activeFigura = 0
            self.vertices = 0
            self.pointable = []
            self.befpoint = [0, 0]
            self.title = DEFAULT_TITLE
            self.activeherramienta = DEFAULT_HERRAMIENTA
            self.activecolor = DEFAULT_COLOR
            self.backgroundcolor = DEFAULT_COLOR
            self.colorgoma = DEFAULT_GOMA
            self.grosorHerramienta = DEFAULT_GROSOR_HERRAMIENTA
            self.estiloHerramienta = [DEFAULT_ESTILO_HERRAMIENTA[0],DEFAULT_ESTILO_HERRAMIENTA[1],DEFAULT_ESTILO_HERRAMIENTA[2],\
                                      DEFAULT_ESTILO_HERRAMIENTA[3],DEFAULT_ESTILO_HERRAMIENTA[4]]
            self.dibujado = False
            self.mainArchive = ""

            #Creacion de ventana
            self.main = Tk()
            self.main.focus_force()
            self.main.geometry('%dx%d+%d+%d' % (PROGRAMSIZE[0], PROGRAMSIZE[1], (self.main.winfo_screenwidth() - PROGRAMSIZE[0])/2,\
                                                 (self.main.winfo_screenheight() - PROGRAMSIZE[1])/2))
            self.main.title(PROGRAMTITLE)
            self.main.iconbitmap(DATAICONS + "coloricon.ico")
            self.main.minsize(PROGRAMSIZE[0], PROGRAMSIZE[1])
            self.main.resizable(width=False, height=False)

            #Eventos de ventana
            self.main.bind("<Control-S>", self.salir)
            self.main.bind("<Control-s>", self.salir)
            self.main.bind("<Control-N>", self.nuevaImagen)
            self.main.bind("<Control-n>", self.nuevaImagen)
            self.main.bind("<Control-g>", self.guardarImagen)
            self.main.bind("<Control-G>", self.guardarImagen)
            self.main.bind("<Control-a>", self.ayuda)
            self.main.bind("<Control-A>", self.ayuda)
            self.main.bind("<Control-i>", self.menuInsertarFigura)
            self.main.bind("<Control-I>", self.menuInsertarFigura)

            #Menu
            menubar = Menu(self.main)
            self.main.config(menu=menubar)

            #Archivo
            archivomenu = Menu(menubar, tearoff=0)
            archivomenu.add_command(label="Nuevo    [Ctrl-N]",
                                    command=self.nuevaImagen)
            archivomenu.add_command(label="Guardar    [Ctrl-G]",
                                    command=self.guardarImagen)
            archivomenu.add_separator()
            archivomenu.add_command(label="Salir    [Ctrl-S]",
                                    command=self.salir)
            menubar.add_cascade(label="Archivo", menu=archivomenu)

            #Opciones
            opcionesmenu = Menu(menubar, tearoff=0)
            colormenu = Menu(opcionesmenu, tearoff=0)
            opcionesmenu.add_cascade(label="Cambiar color", menu=colormenu)
            colormenu.add_command(label="De fondo",
                                  command=lambda: self.cambiarColor("fondo"))
            colormenu.add_command(label="De la goma",
                                  command=lambda: self.cambiarColor("goma"))
            colormenu.add_command(label="Principal",
                                  command=lambda: self.cambiarColor("activo"))
            opcionesmenu.add_command(label="Estilo de la herramienta",
                                     command=self.cambiarEstiloHerramienta)
            opcionesmenu.add_command(label="Grosor de la Herramienta",
                                     command=self.cambiarGrosorHerramienta)
            menubar.add_cascade(label="Opciones", menu=opcionesmenu)

            #Insertar
            insertarmenu = Menu(menubar, tearoff=0)
            insertarmenu.add_command(label="Arco",
                                     command=lambda: self.crearFigura("arco"))
            insertarmenu.add_command(
                label="Cuadrado", command=lambda: self.crearFigura("cuadrado"))
            insertarmenu.add_command(
                label="Imagen", command=lambda: self.crearFigura("imagen"))
            insertarmenu.add_command(label="Ovalo",
                                     command=lambda: self.crearFigura("ovalo"))
            insertarmenu.add_command(
                label="Poligono", command=lambda: self.crearFigura("poligono"))
            insertarmenu.add_command(label="Recta",
                                     command=lambda: self.crearFigura("recta"))
            insertarmenu.add_command(label="Texto",
                                     command=lambda: self.crearFigura("texto"))
            menubar.add_cascade(label="Insertar", menu=insertarmenu)

            #Herramientas
            herrammenu = Menu(menubar, tearoff=0)
            hmenu = Menu(herrammenu, tearoff=0)
            hmenu.add_command(label="Goma de Borrar",
                              command=lambda: self.herramienta("goma"))
            hmenu.add_command(label="Lapiz",
                              command=lambda: self.herramienta("lapiz"))
            hmenu.add_command(label="Plumon Fino",
                              command=lambda: self.herramienta("plumonf"))
            hmenu.add_command(label="Plumon Grueso",
                              command=lambda: self.herramienta("plumong"))
            menubar.add_cascade(label="Herramientas", menu=hmenu)

            #Ayuda
            ayudamenu = Menu(menubar, tearoff=0)
            ayudamenu.add_command(label="Acerca de", command=self.acercade)
            ayudamenu.add_command(label="Ayuda    [Ctrl-A]",
                                  command=self.ayuda)
            ayudamenu.add_command(label="Changelog", command=self.changelog)
            ayudamenu.add_command(label="Licencia", command=self.licence)
            menubar.add_cascade(label="Ayuda", menu=ayudamenu)

            #Plano de dibujo
            ParentFrame = Frame(self.main)
            ParentFrame.pack()

            #Canvas de dibujo
            ventanaframe = Frame(ParentFrame)
            ventanaframe.pack(side=LEFT)
            self.pantalla = Canvas(ventanaframe,
                                   width=PROGRAMSIZE[0] * 0.8,
                                   height=PROGRAMSIZE[1],
                                   bg=DEFAULT_FONDO)
            self.pantalla.pack()

            #Botones
            Buttonframe = Frame(ParentFrame, border=5)
            Buttonframe.pack()
            Label(Buttonframe, text="Herramientas", border=10).pack()
            Button(Buttonframe,
                   text="Goma de Borrar",
                   relief=GROOVE,
                   width=20,
                   command=lambda: self.herramienta("goma")).pack()
            Button(Buttonframe,
                   text="Lapiz",
                   relief=GROOVE,
                   width=20,
                   command=lambda: self.herramienta("lapiz")).pack()
            Button(Buttonframe,
                   text="Plumon Fino",
                   relief=GROOVE,
                   width=20,
                   command=lambda: self.herramienta("plumonf")).pack()
            Button(Buttonframe,
                   text="Plumon Grueso",
                   relief=GROOVE,
                   width=20,
                   command=lambda: self.herramienta("plumong")).pack()
            Button(Buttonframe,
                   text="Insertar Objeto",
                   relief=GROOVE,
                   width=20,
                   command=self.menuInsertarFigura).pack()

            #Informacion de la herramientas
            Label(Buttonframe, text="Herramienta", border=10).pack()
            GrosorLapiz = Frame(Buttonframe)
            GrosorLapiz.pack()
            self.infogrosorlapiz = Label(GrosorLapiz,
                                         text=str(self.grosorHerramienta),
                                         border=3,
                                         font=10,
                                         width=2)
            self.infogrosorlapiz.pack(side=LEFT)
            Label(GrosorLapiz, text="  ").pack(side=LEFT)
            Button(GrosorLapiz,
                   text="Grosor",
                   relief=GROOVE,
                   command=self.cambiarGrosorHerramienta,
                   width=9).pack()
            EstiloLapiz = Frame(Buttonframe)
            EstiloLapiz.pack()
            Label(EstiloLapiz, text=" ", border=3, font=10,
                  width=2).pack(side=LEFT)
            Label(EstiloLapiz, text="  ").pack(side=LEFT)
            Button(EstiloLapiz,
                   text="Estilo",
                   relief=GROOVE,
                   command=self.cambiarEstiloHerramienta,
                   width=9).pack()

            #Informaciones color
            Label(Buttonframe, text="Colores", border=10).pack()
            ActiveColor = Frame(Buttonframe)
            ActiveColor.pack()
            self.infoactivedcolor = Canvas(ActiveColor,
                                           width=30,
                                           height=20,
                                           bg=self.activecolor)
            self.infoactivedcolor.pack(side=LEFT)
            Button(ActiveColor,
                   text="Color principal",
                   relief=FLAT,
                   command=lambda: self.cambiarColor("activo"),
                   width=10).pack()
            ActiveColor = Frame(Buttonframe)
            ActiveColor.pack()
            self.infoactivedbackgroundcolor = Canvas(ActiveColor,
                                                     width=30,
                                                     height=20,
                                                     bg=self.backgroundcolor)
            self.infoactivedbackgroundcolor.pack(side=LEFT)
            Button(ActiveColor,
                   text="Color de fondo",
                   relief=FLAT,
                   command=lambda: self.cambiarColor("fondo"),
                   width=10).pack()
            ActiveColor = Frame(Buttonframe)
            ActiveColor.pack()
            self.infoactivedcolorgoma = Canvas(ActiveColor,
                                               width=30,
                                               height=20,
                                               bg=self.colorgoma)
            self.infoactivedcolorgoma.pack(side=LEFT)
            Button(ActiveColor,
                   text="Color goma ",
                   relief=FLAT,
                   command=lambda: self.cambiarColor("goma"),
                   width=10).pack()

            #Informacion para el usuario
            Label(Buttonframe, height=1).pack()
            self.messageUser = Label(Buttonframe,
                                     text="",
                                     relief=GROOVE,
                                     width=30,
                                     height=10,
                                     justify=CENTER,
                                     wraplength=125)
            self.messageUser.pack()

            #Inicializacion de funciones indev
            self.herramienta(self.activeherramienta)
            self.pantalla.bind("<ButtonRelease-1>", self.posPuntero)

            #Se crea la ventana
            self.main.mainloop(0)

        except:
            lib("error", "kernel", [2])
            lib("error", "kernel", [3])