Python和Gtk倒计时，超时问题

Question

我正在尝试制作一个训练应用程序，所以我必须计算每个俯卧撑的次数，或者显示侧板倒计时。为此，我尝试使用GObject.timeout_添加但它似乎并不像我想象的那样有效。
在目前的情况下，一节课的所有练习都是同时进行的，而不是一次一个，按适当的顺序进行。 我确实漏掉了一些东西，通过我的网络搜索，我仍然没有找到它。
这是我的代码：

#!/usr/bin/python
"""
Work out app to keep track of your progression through the session
"""

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk, GObject
from Programms import *
from time import sleep


def time_hours(t):
    return t // 3600


def time_minutes(t):
    return (t % 3600) // 60


def time_seconds(t):
    return int((t % 3600) % 60)


def time_format(t):
    hours = double_digit(time_hours(t))
    minutes = double_digit(time_minutes(t))
    seconds = double_digit(time_seconds(t))
    return "{}:{}:{}".format(hours, minutes, seconds)


def double_digit(t):
    if t == 0:
        return "00"
    elif t < 10:
        return "0{}".format(t)
    return t


class StartingLine:
    """
    Gtk
    """
    def __init__(self):
        # main window
        self.window = Gtk.Window()
        self.window.set_title("Work out !")
        self.window.set_size_request(200, 200)
        self.window.connect('destroy', lambda x: Gtk.main_quit())

        # start button
        self.button = Gtk.Button("Start")
        self.button.connect('clicked', self.start_work_out)

        self.window.add(self.button)

        self.window.show_all()

    def start_work_out(self, widget):
        self.window.hide()
        work = Two
        duration = work.duration
        for exo in work.exercises:
            Instructor(exo, duration)


class Instructor:
    """
    Gtk
    """
    def __init__(self, exo, duration):
        # main window
        self.window = Gtk.Window()
        self.window.set_title("Work out !")
        self.window.set_size_request(200, 200)
        self.window.connect("destroy", lambda x: Gtk.main_quit())

        # timer
        self.current_time = 0
        self.counter = 0
        self.timer_label = Gtk.Label(time_format(self.counter))

        # exercise
        self.current_exercise = Gtk.Label(exo.name)

        # overall progression
        self.bar = Gtk.ProgressBar.new()

        # hierarchy
        grid = Gtk.Grid()
        grid.attach(self.timer_label, 1, 0, 1, 1)
        grid.attach(self.current_exercise, 1, 1, 1, 1)
        grid.attach(self.bar, 1, 2, 1, 1)
        self.window.add(grid)

        # display
        self.window.show_all()

        if exo.type == ExoType.Reps:
            print('exercise : ', exo.name)
            self.counter = 0
            self.timer_label.set_label(str(self.counter))
            rep_id = GObject.timeout_add(1000*exo.in_between, self.display_rep, exo, duration)
            print("rep ID : ", rep_id)
        elif exo.type == ExoType.Timer:
            self.counter = exo.number
            self.timer_label.set_label(time_format(self.counter))
            time_id = GObject.timeout_add(1000*exo.in_between, self.display_timer, exo, duration)
            print("time ID : ", time_id)

    def display_rep(self, exo, duration):
        print("current time : ", self.current_time)
        print("current exercise : ", exo.name)
        print("rep : ", self.counter)
        self.counter += 1
        self.current_time += exo.in_between
        self.timer_label.set_label(str(self.counter))  # update counter
        self.current_exercise.set_label(exo.name)  # update exercise name
        self.bar.set_fraction(self.current_time/duration)  # update progression bar
        return self.counter < exo.number

    def display_timer(self, exo, duration):
        print("current time : ", self.current_time)
        print("current exercise : ", exo.name)
        print("timer : ", self.counter)
        self.counter -= 1
        self.current_time += exo.in_between
        self.timer_label.set_label(time_format(self.counter))  # update counter
        self.current_exercise.set_label(exo.name)  # update name
        self.bar.set_fraction(self.current_time/duration)  # update progression bar
        return self.counter > 0


if __name__ == "__main__":
    StartingLine()
    Gtk.main()

在本代码中，我使用了两种类型，它们是：

^{pr2}$

我第一次在这里问问题，请告诉我是不是做错了。在

Answer 1

rep_id = GObject.timeout_add(1000*exo.in_between, self.display_rep, exo, duration)

当您timeout_add时，您告诉Mainloop每隔n秒调用function。在

^{pr2}$

在这里，您将每个练习添加到mainloop，这将导致同时运行，因为您只创建了一次mainloop。在

有几种解决方案，在我看来，没有一种方案包括main_iteration_do。在

1. 重新组织事物，使1个练习运行它自己的主循环。在
2. 当一个练习完成并在它的处理程序中开始另一个练习时，发出一个信号。在