Вопросы Теги

Как изменить курсор на песочные часы в приложении python gtk3

Для 12.04:

Единственная официальная поддержка RT3060 / 3062/3562/2592 в Linux является экспериментальной и может быть не полностью функциональной. Это обеспечивается драйвером rt2800pci из команды kernel.org/compat-wireless. Драйвер является независимым усилием и, похоже, не использует код Ralink

. Вариант 1. Попробуйте установить последнюю совместимую беспроводную backports package и посмотреть, работает ли это

. Единственная официальная поддержка RT3060 / 3062/3562/2592 в Linux - экспериментальная и может быть не полностью функциональной. Это обеспечивается драйвером rt2800pci из команды kernel.org/compat-wireless. Драйвер является независимым усилием и, похоже, не использует код Ralink . Альтернативно, откройте терминал с помощью Ctrl + Alt + T и вставьте : sudo apt-get install linux-backports-modules-cw-3.3-precise-generic После завершения установки перезагрузитесь и проверьте, работает ли ваша беспроводная карта лучше. Если нет, следуйте варианту 2.

Вариант 2. Создайте и установите собственные драйверы Ralink

Загрузите их с веб-сайта Ralink. Сохраните папку загрузки (по умолчанию): откройте терминал с помощью Ctrl + Alt + T и вставьте следующие строки: sudo apt-get install linux-headers-$(uname -r) build-essential dkms cd Downloads tar -xzf DPO_RT3562_3592_3062_LinuxSTA_V2.4.1.1_20101217.tgz cd DPO_RT3562_3592_3062_LinuxSTA_V2.4.1.1_20101217 WPA1=HAS_WPA_SUPPLICANT WPA2=HAS_NATIVE_WPA_SUPPLICANT sed -i -e "s/$WPA1=n/$WPA1=y/g" -e "s/$WPA2=n/$WPA2=y/g" os/linux/config.mk sudo make && sudo make install && sudo make clean cd .. Черный список встроенного драйвера и загрузите новый с помощью: echo "blacklist rt2800pci" | sudo tee /etc/modprobe.d/blacklist-rt2800pci.conf sudo modprobe -rfv rt2800pci sudo modprobe -v rt3562sta Ваш RT3060 теперь должны быть функциональными. Теперь вы можете открыть папку «Загрузка» в Диспетчере файлов и удалить загруженный файл / папку Ralink:
4
задан 17 May 2012 в 15:52

8 ответов

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
2
ответ дан 25 July 2018 в 18:53

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
2
ответ дан 31 July 2018 в 13:03

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
2
ответ дан 2 August 2018 в 01:01

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
2
ответ дан 4 August 2018 в 16:32

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
2
ответ дан 6 August 2018 в 01:12

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
3
ответ дан 7 August 2018 в 18:38

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
3
ответ дан 10 August 2018 в 07:17

Вот рабочий пример того, что вы хотите.

Вам нужно понять концепцию основного цикла GTK, чтобы понять, почему важно отделить код манипулирования графическим интерфейсом от длинного кода блокировки. Надеемся, что комментарии и отладочные заявления в моем примере помогут вам разобраться. Эта запись PyGTK FAQ полезна, и эта концепция применима к Python с интроспекцией GTK3 и GObject.

Пример кода:

Этот код создает окно с простой кнопкой с надписью «Click me». Как только вы нажмете на него, он изменится на «Работа», курсор станет песочным часом, а графический интерфейс останется отзывчивым. По прошествии десяти секунд метка кнопки изменится на «Готово», и курсор вернется в нормальное состояние. 

import time
import threading

from gi.repository import Gtk, Gdk, GObject

window = None

def main():
    GObject.threads_init()
    Gdk.threads_init()

    # Build GUI:
    global window
    window = Gtk.Window()
    button = Gtk.Button(label="Click me")
    window.add(button)
    window.set_default_size(200, 200)
    window.show_all()

    # Connect signals:
    window.connect("delete-event", Gtk.main_quit)
    button.connect("clicked", on_button_click)

    Gtk.main()

def on_button_click(button):
    print "Debug on_button_click: current_thread name:", threading.current_thread().name

    # This is a callback called by the main loop, so it's safe to
    # manipulate GTK objects:
    watch_cursor = Gdk.Cursor(Gdk.CursorType.WATCH)
    window.get_window().set_cursor(watch_cursor)
    button.set_label("Working...")
    button.set_sensitive(False)

    def lengthy_process():
        print "Debug lengthy_process: current_thread name:", threading.current_thread().name
        # We're in a new thread, so we can run lengthy processes without
        # freezing the GUI, but we can't manipulate GTK objects except
        # through GObject.idle_add
        time.sleep(10)
        def done():
            print "Debug done: current_thread name:", threading.current_thread().name
            window.get_window().set_cursor(None)
            button.set_label("Done!")
            return False
        GObject.idle_add(done)

    thread = threading.Thread(target=lengthy_process)
    thread.start()

if __name__ == "__main__":
    main()
3
ответ дан 15 August 2018 в 19:18

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

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