Python Tkinter, envelopper les widgets dans l'image si ils arrivent à la fin de l'écran

Question

Est-il quelque chose comme une meute de nouvelle ligne pour les Savoirs traditionnels de la géométrie de manager?Je suis à l'aide du pack de mettre des widgets à l'intérieur d'un cadre.Sur un écran haute résolution, les widgets fit trouver de l'autre côté.Toutefois, si vous la mettez dans un écran plus petit, les widgets de chambre dans le cadre.

Fondamentalement, nous partons de l':

pour:

Vous pouvez voir comment il coupe de mes de Processeurs d'entrée de champ.Le code correspondant:

options_frame = ttk.LabelFrame(
        parent_frame, text="Blast Options")
options_frame.pack(side=TOP, fill=X, expand=1, padx=5, pady=5)
        self._set_up_blast_options(options_frame)

def _set_up_blast_options(self, options_frame):
    self.evalue = Tkinter.DoubleVar()
    self.evalue.set(1)
    self.word_size = Tkinter.IntVar()
    self.word_size.set(4)
    self.penalty_mismatch = Tkinter.DoubleVar()
    self.penalty_mismatch.set(-4)
    self.min_d_match = Tkinter.IntVar()
    self.min_d_match.set(5)
    self.proc_count = Tkinter.IntVar()
    self.proc_count.set(cpu_count())

    # evalue
    e_value_label = ttk.LabelFrame(
        options_frame, text="e-Value Threshold")
    e_value_entry = ttk.Entry(e_value_label)
    e_value_entry.insert(0, self.evalue.get())
    e_value_entry.bind('<Return>', self._validate_e_value)
    e_value_entry.bind('<FocusOut>', self._validate_e_value)
    e_value_label.pack(side=LEFT, expand=1, pady=5, padx=5, fill=X)
    e_value_entry.pack(side=TOP, expand=1, pady=5, padx=5, fill=X)

    # word size
    word_size_label = ttk.LabelFrame(
        options_frame, text="Word Size")
    word_size_entry = ttk.Entry(word_size_label)
    word_size_entry.insert(0, self.word_size.get())
    word_size_entry.bind('<Return>', self._validate_word_value)
    word_size_entry.bind('<FocusOut>', self._validate_word_value)
    word_size_label.pack(side=LEFT, expand=1, pady=5, padx=5, fill=X)
    word_size_entry.pack(side=TOP, expand=1, pady=5, padx=5, fill=X)

    penalty_mismatch_label = ttk.LabelFrame(
        options_frame, text="Penalty Mismatch")
    penalty_mismatch_entry = ttk.Entry(penalty_mismatch_label)
    penalty_mismatch_entry.insert(0, self.penalty_mismatch.get())
    penalty_mismatch_entry.bind(
        '<Return>', self._validate_penalty_mismatch_value)
    penalty_mismatch_entry.bind(
        '<FocusOut>', self._validate_penalty_mismatch_value)
    penalty_mismatch_label.pack(side=LEFT, expand=1, pady=5,
                                padx=5, fill=X)
    penalty_mismatch_entry.pack(side=TOP, expand=1, pady=5,
                                padx=5, fill=X)
    # Min D Nucleotides
    min_d_match_label = ttk.LabelFrame(
        options_frame, text="Minimal Number of D Nucleotides")
    min_d_match_entry = ttk.Entry(min_d_match_label)
    min_d_match_entry.insert(0, self.min_d_match.get())
    min_d_match_entry.bind(
        '<Return>', self._validate_min_match_value)
    min_d_match_entry.bind(
        '<FocusOut>', self._validate_min_match_value)
    min_d_match_label.pack(side=LEFT, expand=1, pady=5, padx=5, fill=X)
    min_d_match_entry.pack(side=TOP, expand=1, pady=5, padx=5, fill=X)

    # how many cpus to use
    proc_count_label = ttk.LabelFrame(
        options_frame, text="Processors")
    proc_count_entry = ttk.Entry(proc_count_label)
    proc_count_entry.insert(0, self.proc_count.get())
    proc_count_entry.bind(
        '<Return>', self._validate_proc_count_value)
    proc_count_entry.bind(
        '<FocusOut>', self._validate_proc_count_value)
    proc_count_label.pack(side=LEFT, expand=1, pady=5, padx=5, fill=X)
    proc_count_entry.pack(side=TOP, expand=1, pady=5, padx=5, fill=X)

Beaucoup de cas de liaison et de réglage des options peuvent ne pas être pertinentes, mais j'ai pensé que je devrais encore comprendre...juste au cas où.Serait la meilleure option pour passer à un gestionnaire de réseau?Le problème il y aurait ce cadre est emballé à l'intérieur d'un autre...et ainsi de suite.N'est-il pas que si vous commencez à utiliser le gestionnaire de réseau, vous devez l'utiliser pour tout, parce que vous ne pouvez pas combiner des paniers et le gestionnaire de réseau dans le même cadre?

Answer 1

AFAIK Il n'y a pas de moyen intégré de créer des interfaces dynamiques dans Tkinter.Votre meilleur pari est d'obtenir la résolution de l'écran, puis de la grille / pack de manière appropriée.

user32 = ctypes.windll.user32
get_screensize = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))

Alors, par exemple ...

widget1 = tkinter.Entry(root,width=20,etc)
widget2 = tkinter.Label(root,text='Hello',etc)
## Now perform update_idletasks() which will force
## Tkinter to calculate their size.
widget1.update_idletasks()
widget2.update_idletasks()
## Now calculate whether they'll fit.
if widget1.winfo_width() + widget2.winfo_width() > screensize[0]:## Not enough space
    widget1.grid(row=0)
    widget2.grid(row=1)
else:## Both will fit on one line.
    widget1.grid(row=0,column=0)
    widget2.grid(row=0,column=1)

Answer 2

En général, je suis d'accord avec I_do_python réponse, mais je voudrais faire une petite modification.Je mettrais tous les widgets dans une nouvelle Image, et je voudrais utiliser le Cadre de la même largeur que le test décisif quant à l'envelopper.Et vous pouvez lier un gestionnaire d'événements pour l' "<Configure>" événement qui vérifie ensuite si le Cadre de contenu ont besoin d'être emballé lorsque la fenêtre de l'application (et donc de l'Image) est redimensionnée.

J'avais écrit ci-dessous la fonction qui utilise la grille de la méthode intelligemment insérer des widgets dans un cadre.Il peut certainement être améliorée, mais cela fonctionne pour moi.Habituellement, si vous utilisez .grid() pour remplir un parent, vous pouvez obtenir gaspillage d'espace blanc lorsque le remplissage des widgets varier en largeur.Ci-dessous des adresses de fonction en divisant le parent dans la logique des colonnes (divisions dans le code) et laisser les widgets pour s'étendre sur plusieurs colonnes.Le résultat est une grille de mise en page avec beaucoup d'-réduction du gaspillage de l'espace blanc.Plus la valeur est élevée divisions, le meilleur est le résultat, mais la valeur par défaut devrait fonctionner pour la plupart des situations.

def smart_grid(parent, *args, **kwargs): # *args are the widgets!
    divisions   = kwargs.pop('divisions', 100)
    force_f     = kwargs.pop('force', False)
    if 'sticky' not in kwargs:
        kwargs.update(sticky='w')
    try:
        parent.win_width
    except:
        parent.win_width = -1
    winfo_width = parent.winfo_width()
    if 1 < winfo_width != parent.win_width or force_f:
        parent.win_width = winfo_width
        row = col = width = 0
        argc = len(args)
        for i in range(argc):
            widget_width = args[i].winfo_width()
            columns = max(1, int(widget_width * float(divisions) / winfo_width))
            width += widget_width
            if width > winfo_width:
                width = widget_width
                row += 1
                col = 0
            args[i].grid(row=row, column=col, columnspan=columns, **kwargs)
            col += columns
        parent.update_idletasks() # update() # 
        return row + 1

Finalement je vais prendre quelques minutes pour le réécrire avec w.winfo_reqwidth() et mettrai à jour mon post.