Ejemplo n.º 1
0
def nacti_cislo(otazka='Zadej číslo'):
    """Zeptá se uživatele na otázku a vrátí odpověď jako celé číslo."""
    root = Tk()
    root.title(otazka)

    entry = Spinbox(root, from_=0, to=100)
    entry.set('0')
    entry.pack(side=LEFT)

    # Předbíháme: vnořená funkce může přistupovat
    # k proměnným "entry" a "root", které jsou
    # lokální pro "vnější" funkci (nacti_cislo)

    def ok_pressed():
        text = entry.get()
        try:
            value = int(text)
        except ValueError:
            entry.set('sem zadej číslo!')
        else:
            root.quit()

    button = Button(root, text="OK", command=ok_pressed)
    button.pack(side=RIGHT)

    root.mainloop()

    value = int(entry.get())
    root.destroy()

    return value
Ejemplo n.º 2
0
class TimerUi:
    """View"""
    def __init__(self, app):
        self.time_label = Label(app.root,
                                textvariable=app.time,
                                anchor=CENTER,
                                foreground='black',
                                background='lightgray',
                                font=('Helvetica', 60))
        self.time_label.pack(fill=BOTH, expand=True)

        validate_command = (app.root.register(self.check), '%P')
        self.entry = Spinbox(app.root,
                             from_=1,
                             to=MAX_COUNT,
                             textvariable=app.count_start,
                             validate='all',
                             validatecommand=validate_command)
        self.entry.pack(fill=X)
        self.entry.focus()

        buttons_frame = Frame(app.root)
        buttons_frame.pack(fill=X)
        self.start_button = Button(buttons_frame,
                                   text='Start',
                                   command=app.start_timer)
        self.stop_button = Button(buttons_frame,
                                  text='Stop',
                                  state=DISABLED,
                                  command=app.stop_timer)
        self.start_button.pack(side=LEFT, fill=X, expand=True)
        self.stop_button.pack(side=RIGHT, fill=X, expand=True)

    def check(self, new_val):
        return new_val.isdigit() and 1 <= int(new_val) <= MAX_COUNT

    def state_started(self):
        self.stop_button.config(state=NORMAL)
        self.start_button.config(state=DISABLED)
        self.entry.config(state=DISABLED)
        self.time_label.config(foreground='white', background='red')

    def state_stopped(self):
        self.stop_button.config(state=DISABLED)
        self.start_button.config(state=NORMAL)
        self.entry.config(state=NORMAL)
        self.time_label.config(foreground='black', background='lightgray')
Ejemplo n.º 3
0
def startPassGen():
    global root
    root = Toplevel()
    root.attributes('-topmost', True)
    root.title("  Password Generator")
    root.geometry("350x380")
    # root.resizable(0,0)
    root.configure(bg="white")
    root.iconphoto(True, PhotoImage(file=assetpath + 'padlock.png'))
    root.tk.call('tk', 'scaling', 1.6)

    style = Style()
    style.configure("TLabel", background="white")
    style.configure('TCheckbutton', background='white')

    mainf = Frame(root, bg="white")
    mainf.pack(pady=20, padx=20, ipadx=10, ipady=10)

    f1 = Frame(mainf, bg="white")
    f1.pack()
    icon = ImageTk.PhotoImage(
        Image.open(assetpath + 'key.png').resize((45, 45)))
    Label(f1, image=icon, bg="white").grid(row=0,
                                           column=0,
                                           rowspan=2,
                                           padx=2,
                                           pady=5)
    Label(f1, text="Pass-Gen", font=('ARIAL', 15, 'bold'),
          bg="white").grid(row=0, column=2)
    Label(f1, text="Password Generator", bg="white").grid(row=1, column=2)

    f2 = Frame(mainf, bg="white")
    f2.pack(padx=10, pady=(30, 15))
    global passe
    passe = Entry(f2, width=30)
    passe.pack(side=LEFT)
    copyi = ImageTk.PhotoImage(
        Image.open(assetpath + 'copy.png').resize((25, 25)))
    copyb = Button(f2,
                   image=copyi,
                   bg="white",
                   bd=0,
                   activebackground="white",
                   command=lambda: copy2clip(passe.get()))
    copyb.pack(side=LEFT, padx=2)

    global length
    length = 8

    lenf = Frame(mainf)
    lenf.pack()
    Label(lenf, text="Length  ", bg="white").pack(side=LEFT)
    s = Spinbox(lenf,
                from_=4,
                to=25,
                width=5,
                command=lambda: setlength(s.get()))
    s.set(8)
    s.pack(side=LEFT)

    upper = BooleanVar()
    digit = BooleanVar()
    special = BooleanVar()
    upper.set(True)
    digit.set(True)
    special.set(True)
    f3 = Frame(mainf, bg="white")
    f3.pack(padx=10, pady=10)
    capb = Checkbutton(f3,
                       text="Include Capitals",
                       variable=upper,
                       offvalue=False,
                       onvalue=True)
    capb.pack(anchor=W, pady=5)
    digitb = Checkbutton(f3,
                         text="Include Digits",
                         variable=digit,
                         offvalue=False,
                         onvalue=True)
    digitb.pack(anchor=W, pady=5)
    specialb = Checkbutton(f3,
                           text="Include Special Symbols",
                           variable=special,
                           offvalue=False,
                           onvalue=True)
    specialb.pack(anchor=W, pady=5)

    genb = Button(mainf,
                  text="Generate",
                  command=lambda: passGen(length, upper.get(), digit.get(),
                                          special.get()),
                  bg="turquoise3",
                  activebackground="turquoise3",
                  bd=0)
    genb.pack(pady=10, ipadx=20, padx=(43, 10), side=LEFT)
    exitb = Button(mainf,
                   text="Exit",
                   command=exitPassGen,
                   bg="firebrick1",
                   activebackground="firebrick1",
                   bd=0,
                   width=37)
    exitb.pack(pady=10, ipadx=20, padx=(10, 30), side=LEFT)

    root.mainloop()
Ejemplo n.º 4
0
font_size = def_font.actual()['size'] + 2

def is_okay(text):
    """ validation function

    Parameters
    ----------
    text : str
        text if allowed

    Returns
    -------
    boolean
    """
    print(text)
    if text in ("", "-", ".", "-."):
        return True
    try:
        float(text)
    except ValueError:
        return False
    return True

vcmd = root.register(is_okay)

ent0 = Spinbox(root, validate="key", validatecommand=(vcmd, '%P'),
           font=(font_family, font_size, 'bold'))
ent0.pack(padx=10)

root.mainloop()
Ejemplo n.º 5
0
class Slider(Frame):
    MINIMO = 100
    MAXIMO = 2400
    
    def __init__(self, master, label, *args, **kwargs):
        '''
        parametros
        ----------
        master : tkinter.widget
        
        label : str
        
        '''
        super(Slider, self).__init__(master, *args, **kwargs)
        self._criar_estilo_label()
       
        self._criar_scale()
        self._criar_spinbox()
        self._criar_label(label)
        self.set_atual(self.MINIMO)

    def _criar_estilo_label(self):
        estilo = Style()
        estilo.configure('Slider.TLabel', font=('Arial', 14, 'normal'))
          
    def _criar_label(self, label):
        '''
        Criar label.
        '''
        frame = Frame(self, width=150, height=50)
        label = Label(frame, text=label, anchor='center', style='Slider.TLabel')
        
        label.bind('<Double-Button-1>', lambda e: self._spinbox.focus())

        label.pack(fill='both', expand=True, padx=5, pady=5)
        frame.pack(side='left')
        frame.pack_propagate(False)
                                       
    def _criar_spinbox(self):
        '''
        Criar Widget spinbox.
        '''
        self._spinbox = Spinbox(self, from_=self.MINIMO, 
                                         to=self.MAXIMO,
                            font=('Arial', 14, 'normal'),
                            width=10)
        
        self._spinbox['command'] = lambda: \
            self.set_atual(self._spinbox.get(), widget=self._spinbox)
        
        self._spinbox.bind('<Return>', lambda e: \
            self.set_atual(self._spinbox.get()))
        
        self._spinbox.pack(side='left', anchor='center')
    
    def _criar_scale(self):
        '''
        Criar widget Scale.
        '''
        self._scale = Scale(self, from_=self.MINIMO, 
                                    to=self.MAXIMO, 
                                orient='horizontal')
        
        self._scale['command'] = lambda e: \
            self.set_atual(self._scale.get(), widget=self._scale)  
                                        
        self._scale.pack(side='left', fill='x', anchor='center', expand=True, )
        
    def atual(self):
        '''
        Obter o valor atual
        
        retornos
        --------
        int
        '''
        return self._scale.get()
        
    def set_atual(self, atual, **kwargs):
        '''
        Define o valor atual.
        
        parametros
        ----------
        atual : int
        '''
        # caractere númerico é convertido em inteiro.
        if isinstance(atual, str) and atual.isdigit():
            atual = int(atual)
        
        # caractere não númerico convertido em inteiro.
        if not isinstance(atual, int):
            atual = self._scale.get()
        
        # atual fora do range.
        if atual not in range(self.MINIMO, self.MAXIMO):
            atual = self._scale.get()        
        
        widget = kwargs.get('widget')
        if widget:
            if isinstance(widget, Scale):
                self._spinbox.delete(0, 'end')
                self._spinbox.insert(0, str(atual))
            elif isinstance(widget, Spinbox):
                self._scale.set(atual)
        
        else:
            self._spinbox.delete(0, 'end')
            self._spinbox.insert(0, str(atual))
            self._scale.set(atual)