Анимационный блесна с резьбой pygtk

Question 1

У меня была почти такая же ошибка:

Failed to open a session for the virtual machine Windows XP.
The virtual machine '**Windows XP**' has terminated unexpectedly during startup with exit code 1.

Затем появилось второе окно, в котором говорилось, что мне нужно было выполнить эту команду:

sudo /etc/init.d/vboxdrv setup

Когда я вынул эту команду, выполните следующую команду ошибка:

$ sudo /etc/init.d/vboxdrv setup
 * Stopping VirtualBox kernel modules                                                             [ OK ] 
 * Uninstalling old VirtualBox DKMS kernel modules                                                                   [ OK ] 
 * Trying to register the VirtualBox kernel modules using DKMS                                                              
Error! Your kernel headers for kernel 2.6.38-16-generic-pae cannot be found at
/lib/modules/2.6.38-16-generic-pae/build or /lib/modules/2.6.38-16-generic-pae/source.
Failed, trying without DKMS
Recompiling VirtualBox kernel modules                                                                                    Look at /var/log/vbox-install.log to find out what went wrong

Решение

Установите присвоенный linux-headers для вашей ОС версия. В моем случае было:

sudo apt-get install linux-headers-2.6.38-16-generic-pae

Убедитесь, что все окна VirtualBox закрыты.

Question 2

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 3

Question 4

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 5

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 6

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 7

Question 8

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 9

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 10

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

Question 11

Следите за двумя советами при использовании потоков и PyGTK:

Обязательно вызовите GObject.threads_init() как можно скорее в своей программе, чтобы включить потоки в вашем приложении PyGTK. Если вы выполняете какие-либо задачи графического интерфейса в своем потоке, всегда делайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, при необходимости адаптируйте свой код:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 12

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 13

Question 14

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 15

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 16

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 17

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 18

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Question 19

Question 20

При использовании потоков и PyGTK помните о следующих двух советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK. ]
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к своему коду при необходимости: / g3]

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

wolfv · Accepted Answer · 25 July 2018 в 18:12

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 2 August 2018 в 00:26

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 4 August 2018 в 15:54

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 6 August 2018 в 00:33

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 7 August 2018 в 17:58

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 10 August 2018 в 06:47

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

wolfv · Accepted Answer · 15 August 2018 в 18:42

Я тоже видел твой вопрос вчера на Reddit.

Когда я попытался использовать потоки в python и gtk, мне потребовалась одна ночь, чтобы понять это.

В конце это было так же просто, как

GObject.threads_init()
Gdk.threads_init()

в начале, а затем порождать потоки, как вы обычно делаете в python с чем-то вроде

watch_thread = Thread(target=self.function)
watch_thread.daemon = True
watch_thread.start()

[g4 Я понятия не имею, поможет ли это вам. Но я очень на это надеюсь. Я также посмотрю на ваш код и позже смогу отредактировать мой ответ:)

я объединяю ваш запрос извлечения, но я не работал ... я должен запустить обе функции с потоком? (один для запуска счетчика, а другой для выполнения команд) редактировать: это работает !!! Спасибо большое! — Clepto, 4 July 2012 в 20:04

Timo · Answer 8 · 25 May 2018 в 09:01

Следите за двумя советами при использовании потоков и PyGTK:

Обязательно вызовите GObject.threads_init() как можно скорее в своей программе, чтобы включить потоки в вашем приложении PyGTK. Если вы выполняете какие-либо задачи графического интерфейса в своем потоке, всегда делайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, при необходимости адаптируйте свой код:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 9 · 25 July 2018 в 18:12

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 10 · 2 August 2018 в 00:26

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 11 · 4 August 2018 в 15:54

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 12 · 6 August 2018 в 00:33

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 13 · 7 August 2018 в 17:58

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 14 · 10 August 2018 в 06:47

При использовании потоков и PyGTK помните о следующих 2 советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK.
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к вашему коду по мере необходимости:

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Timo · Answer 15 · 15 August 2018 в 18:42

При использовании потоков и PyGTK помните о следующих двух советах:

Убедитесь, что в вашей программе как можно скорее вызван GObject.threads_init(), чтобы включить многопоточность в приложении PyGTK. ]
Если вы выполняете какие-либо задачи с графическим интерфейсом в своем потоке, всегда оборачивайте его внутри GObject.idle_add(callable).

Вот полный рабочий пример, адаптируясь к своему коду при необходимости: / g3]

import time
import threading

from gi.repository import Gtk, GObject
GObject.threads_init() # Don' forget!


class WorkerThread(threading.Thread):
    def __init__(self, callback):
        threading.Thread.__init__(self)
        self.callback = callback

    def run(self):
        # Simulate a long process, do your actual work here
        time.sleep(4)

        # The callback runs a GUI task, so wrap it!
        GObject.idle_add(self.callback)


class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.resize(400, 400)

        vbox = Gtk.VBox()

        button = Gtk.Button("Let's spin!")
        button.connect('clicked', self.on_button_clicked)
        vbox.pack_start(button, False, False, 0)

        self.spinner = Gtk.Spinner()
        vbox.pack_start(self.spinner, True, True, 0)
        self.add(vbox)
        self.show_all()

    def on_button_clicked(self, widget):
        self.spinner.start()
        thread = WorkerThread(self.work_finished_cb)
        thread.start()

    def work_finished_cb(self):
        self.spinner.stop()

if __name__ == "__main__":
    app = MyWindow()
    Gtk.main()

Анимационный блесна с резьбой pygtk

15 ответов

Другие вопросы по тегам:

Похожие вопросы: