有什么不同的方法可以让pythongtk自己结束吗？

我是PyGTK的新手，一直在尝试编写一个自动更新的图片幻灯片程序。到目前为止，它完全符合我的需要，但有一个问题。它通过在保存它的目录中拍摄图像，然后在计时器上运行来运行。当它到达最后一张图片时，它应该重置并再次运行，以便您可以随时添加新图片而无需停止。它会这样做，但会打开新窗口，而不是正确重置。因此，如果它运行三次，有三个窗口打开，它可以相当快地使计算机紧张。有人知道如何避开这个问题吗

代码相当长，但此处仅供参考：

import os

import pygtk
pygtk.require('2.0')
import gtk
import glib

def is_image(filename):
if not os.path.isfile(filename):
    return False
for suffix in ['.jpg', '.png', '.bmp', '.gif']:
    if filename.lower().endswith(suffix):
        return True
return False

def resizeToFit(image, frame, aspect=True, enlarge=False):
if aspect:
    return scaleToFit(image, frame, enlarge)
else:
    return stretchToFit(image, frame, enlarge)

def scaleToFit(image, frame, enlarge=False):
image_width, image_height = image
frame_width, frame_height = frame
image_aspect = float(image_width) / image_height
frame_aspect = float(frame_width) / frame_height
if not enlarge:
    max_width = min(frame_width, image_width)
    max_height = min(frame_height, image_height)
else:
    max_width = frame_width
    max_height = frame_height
if frame_aspect > image_aspect:
    height = max_height
    width = int(height * image_aspect)
else:
    width = max_width
    height = int(width / image_aspect)
return (width, height)

def stretchToFit(image, frame, enlarge=False):
image_width, image_height = image
frame_width, frame_height = frame
if not enlarge:
    width = min(frame_width, image_width)
    height = min(frame_height, image_height)
else:
    width = frame_width
    height = frame_height
return (width, height)


class ResizableImage(gtk.DrawingArea):

def __init__(self, aspect=True, enlarge=False,
        interp=gtk.gdk.INTERP_NEAREST, backcolor=None, max=(1600,1200)):
    super(ResizableImage, self).__init__()
    self.pixbuf = None
    self.aspect = aspect
    self.enlarge = enlarge
    self.interp = interp
    self.backcolor = backcolor
    self.max = max
    self.connect('expose_event', self.expose)
    self.connect('realize', self.on_realize)

def on_realize(self, widget):
    if self.backcolor is None:
        color = gtk.gdk.Color()
    else:
        color = gtk.gdk.Color(*self.backcolor)
    self.window.set_background(color)

def expose(self, widget, event):
    self.context = self.window.cairo_create()
    self.context.rectangle(
        event.area.x, event.area.y,
        event.area.width, event.area.height)
    self.context.clip()
    self.draw(self.context)
    return False

def draw(self, context):
    rect = self.get_allocation()
    x, y = rect.x, rect.y
    parent = self.get_parent()
    if parent:
        offset = parent.get_allocation()
        x -= offset.x
        y -= offset.y
    if self.backcolor:
        context.rectangle(x, y, rect.width, rect.height)
        context.set_source_rgb(*self.backcolor)
        context.fill_preserve()
    if not self.pixbuf:
        return
    width, height = resizeToFit(
        (self.pixbuf.get_width(), self.pixbuf.get_height()),
        (rect.width, rect.height),
        self.aspect,
        self.enlarge)
    x = x + (rect.width - width) / 2
    y = y + (rect.height - height) / 2
    context.set_source_pixbuf(
        self.pixbuf.scale_simple(width, height, self.interp), x, y)
    context.paint()

def set_from_pixbuf(self, pixbuf):
    width, height = pixbuf.get_width(), pixbuf.get_height()
    if not self.max or (width < self.max[0] and height < self.max[1]):
        self.pixbuf = pixbuf
    else:
        width, height = resizeToFit((width, height), self.max)
        self.pixbuf = pixbuf.scale_simple(
            width, height,
            gtk.gdk.INTERP_BILINEAR)
    self.invalidate()

def set_from_file(self, filename):
    self.set_from_pixbuf(gtk.gdk.pixbuf_new_from_file(filename))

def invalidate(self):
    self.queue_draw()

class DemoGtk:

SECONDS_BETWEEN_PICTURES = 1
FULLSCREEN = True
WALK_INSTEAD_LISTDIR = True

def __init__(self):
    self.window = gtk.Window()
    self.window.connect('destroy', gtk.main_quit)
    self.window.set_title('Slideshow')
    self.image = ResizableImage( True, True, gtk.gdk.INTERP_BILINEAR)
    self.image.show()
    self.window.add(self.image)
    self.load_file_list()
    self.window.show_all()
    if self.FULLSCREEN:
        self.window.fullscreen()
    glib.timeout_add_seconds(self.SECONDS_BETWEEN_PICTURES, self.on_tick)
    self.display()

def load_file_list(self):
    self.files = []
    self.index = 0
    if self.WALK_INSTEAD_LISTDIR:
        for directory, sub_directories, files in os.walk('.'):
            for filename in files:
                if is_image(filename):
                    filepath = os.path.join(directory, filename)
                    self.files.append(filepath)
    else:
        for filename in os.listdir('.'):
            if is_image(filename):
                self.files.append(filename)
    print "Images:", self.files

def display(self):
    if 0 <= self.index < len(self.files):
        self.image.set_from_file(self.files[self.index])
        return True
    else:
        return False

def on_tick(self):
    self.index += 1
    if self.index >= len(self.files):
        self.index = 0
        gtk.main_quit()
    return self.display()


    return self.display()
if __name__ == "__main__":
gui = DemoGtk()
gtk.main()

while True:
execfile("slideshowtest.py")

导入操作系统
进口pygtk
pygtk.require（'2.0'）
进口gtk
进口油嘴滑舌
def是_图像（文件名）：
如果不是os.path.isfile（文件名）：
返回错误
对于['.jpg'、'.png'、'.bmp'、'.gif']中的后缀：
如果filename.lower（）.endswith（后缀）：
返回真值
返回错误
def resizeToFit（图像、帧、纵横比=真、放大=假）：
如果方面：
返回比例调整（图像、边框、放大）
其他：
返回stretchToFit（图像、帧、放大）
def scaleToFit（图像、帧、放大=假）：
图像宽度，图像高度=图像
框架宽度，框架高度=框架
图像宽高比=浮动（图像宽）/图像高
帧宽=浮动（帧宽）/帧高
如果没有放大：
最大宽度=最小（帧宽度、图像宽度）
最大高度=最小（帧高度、图像高度）
其他：
最大宽度=帧宽度
最大高度=框架高度
如果帧\纵横比>图像\纵横比：
高度=最大高度
宽度=整数（高度*图像\纵横比）
其他：
宽度=最大宽度
高度=整数（宽度/图像\纵横比）
返回（宽度、高度）
def stretchToFit（图像、帧、放大=假）：
图像宽度，图像高度=图像
框架宽度，框架高度=框架
如果没有放大：
宽度=最小值（帧宽度、图像宽度）
高度=最小值（帧高度、图像高度）
其他：
宽度=框架宽度
高度=框架高度
返回（宽度、高度）
类大小调整图像（gtk.DrawingArea）：
定义初始化（self，aspect=True，放大=False，
interp=gtk.gdk.interp_最近，backcolor=None，max=（16001200））：
超级（调整大小的图像，自我）。\uuuu init\uuuuu（）
self.pixbuf=无
self.aspect=aspect
放大
self.interp=interp
self.backcolor=背景色
self.max=max
self.connect（'expose\u event'，self.expose）
self.connect（'realize'，self.on\u realize）
def on_realize（自我，小部件）：
如果self.backcolor为“无”：
color=gtk.gdk.color（）
其他：
颜色=gtk.gdk.color（*self.backcolor）
self.window.set_背景（颜色）
def暴露（自我、小部件、事件）：
self.context=self.window.cairo\u create（）
self.context.rectangle(
事件.区域.x，事件.区域.y，
event.area.width、event.area.height）
self.context.clip（）
self.draw（self.context）
返回错误
def绘图（自身、上下文）：
rect=self.get\u分配（）
x、 y=rect.x，rect.y
parent=self.get\u parent（）
如果是家长：
偏移量=父项。获取_分配（）
x-=偏移量.x
y-=偏移量
如果self.backcolor：
矩形（x，y，rect.width，rect.height）
context.set\u source\u rgb（*self.backcolor）
context.fill_preserve（）
如果不是self.pixbuf：
返回
宽度、高度=重新调整其大小(
（self.pixbuf.get_width（），self.pixbuf.get_height（）），
（矩形宽度、矩形高度），
自我方面，
自我放大）
x=x+（矩形宽度-宽度）/2
y=y+（垂直高度-高度）/2
context.set_source_pixbuf(
self.pixbuf.scale_simple（宽度、高度、self.interp）、x、y）
context.paint（）
def set_from_pixbuf（自我，pixbuf）：
width，height=pixbuf.get_width（），pixbuf.get_height（）
如果不是self.max或（宽度

出于您的目的，在勾选（self）方法中执行

self.load\u file\u list（）

而不是

gtk.main\u quit（）

就足够了

然而，我认为你的程序可以简化很多。这基本上是相同的，需要一半的代码行（这是用于PyGObject的，但可以更改为pygtk）：

from gi.repository import Gtk, GdkPixbuf, GLib, Gdk
import sys, os

class ImageWindow(Gtk.Window):

    def __init__(self, fullscreen=False, walk=True):
        Gtk.Window.__init__(self, title="image test")
        self.connect('delete-event', Gtk.main_quit)
        if fullscreen:
            self.fullscreen()
        else:
            self.set_default_size(500, 500)

        self.walk = walk
        self.files = []

        self.image = Gtk.Image()
        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.add(self.image)
        scrolled_window.override_background_color(
            Gtk.StateFlags.NORMAL,
            Gdk.RGBA(red=0, blue=0, green=0)
        )
        self.add(scrolled_window)

        self.load_image()
        self.connect('check-resize', self.on_resize)
        GLib.timeout_add_seconds(3, self.load_image)

    def on_resize(self, window):
        width, height = self.get_size()
        self.pixbuf = GdkPixbuf.Pixbuf.new_from_file(self.current_file)
        if float(width) / height > self.dimension:
            self.pixbuf = self.pixbuf.scale_simple(
                self.dimension * height,
                height,
                GdkPixbuf.InterpType.NEAREST
            )
        else:
            self.pixbuf = self.pixbuf.scale_simple(
                width,
                width / self.dimension,
                GdkPixbuf.InterpType.NEAREST
            )
        GLib.idle_add(self.image.set_from_pixbuf, self.pixbuf)

    def load_image(self):
        if len(self.files) == 0:
            self.get_images()
        self.current_file = self.files.pop()
        self.pixbuf = GdkPixbuf.Pixbuf.new_from_file(self.current_file)
        self.image.set_from_pixbuf(self.pixbuf)

        width = self.pixbuf.get_width()
        height = self.pixbuf.get_height()
        self.dimension = float(width) / height
        return True

    def get_images(self):
        if self.walk:
            for directory, sub_directories, files in os.walk('.'):
                for filename in files:
                    if self.is_image(filename):
                        filepath = os.path.join(directory, filename)
                        self.files.append(filepath)
        else:
            for filename in os.listdir('.'):
                if self.is_image(filename):
                    self.files.append(filename)
        print('Images: {}'.format(self.files))

    def is_image(self, filename):
        return filename.split('.')[-1].lower() in ['png', 'jpg', 'gif']


if __name__ == '__main__':
    win = ImageWindow()
    win.show_all()
    Gtk.main()