Python Window.show方法代码示例

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
#-*- coding:utf8 -*-

# =============================================================================
#      FileName: main.py
#          Desc: 程序主入口
#        Author: ysw(zjuysw)
#         Email: [email protected]
#      HomePage: http://my.oschina.net/zjuysw
#       Version: 0.0.1
#    LastChange: 2014-12-27 22:49:53
#       History:
# =============================================================================


import os
import sys

from PyQt4 import QtGui

from window import Window

if __name__ == "__main__":
    os.chdir(sys.path[0])

    app = QtGui.QApplication(sys.argv)
    w = Window()
    w.show()
    sys.exit(app.exec_())

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
class Application(Gtk.Application):
    simplename = "video-games"
    fullname = "Video Games"
    application_id = 'org.gnome.' + simplename
    
    def __init__(self):
        print (time.time()-start_time, "start init application")
        Gtk.Application.__init__(self, application_id = self.application_id, flags = Gio.ApplicationFlags.FLAGS_NONE)
        GLib.threads_init()
        Gdk.threads_init()
        
        self.datadir = os.path.dirname(os.path.dirname(os.path.realpath(sys.argv[0])))
        
        self.savedatadir = Environement.save_data_path()
        
        self.systems = Badnik.SystemCollection.full ()
        
        self.gamesdb = Badnik.Library(db_name = "games", db_dir = self.savedatadir, systems = self.systems)
        #self.gamesdb.app = self
        self.gamesdb.path = os.path.join(self.savedatadir, "games.db")
        
        self.focused_game = None
        
        self.connect("activate", self.on_activate)
        
        self.register(None)
        
        self.settings = Gio.Settings.new(self.application_id)
        
        self.builder = Gtk.Builder()
        self.builder.add_from_file(Environement.get_resource("AppMenu.ui"))
        self.builder.connect_signals(self)
        
        self.menumodel = self.builder.get_object("AppMenu")
        self.set_app_menu(self.menumodel)
        
        self._action_entries = [ { 'name': 'quit', 'callback': self.on_quit, 'accel': '<Primary>q' },
                                 { 'name': 'about', 'callback': self.on_about },
                                 { 'name': 'help', 'callback': self.on_help, 'accel': 'F1' },
                                 #{ 'name': 'fullscreen', 'callback': self.on_fullscreen, 'accel': 'F11' },
                                 #{ 'name': 'view-as', 'callback': self.on_view_as, 'create_hook': self._view_as_create_hook,
                                 #  'parameter_type': 's', 'state': self.settings.get_value('view-as') },
                                 { 'name': 'add-games', 'callback': self.on_add_games },
                                 #{ 'name': 'download-metadata', 'callback': self.on_download_metadata, 'accel': '<Primary>m' }
                               ]
        self._add_actions()
        
        settings = Gtk.Settings.get_default()
        settings.set_property("gtk-application-prefer-dark-theme", True)
        settings.set_property("gtk-shell-shows-app-menu", True)
        print (time.time()-start_time, "end init application")
        
        self.running_games = {}
        
        self.systems.connect("game_found", self.on_game_found)
        self.gamesdb.connect("game_added", self.on_game_added)
    
    def on_activate(self, data=None):
        #print (time.time()-start_time, "start activating application")
        #print("start window")
        self.window = Window(self)
        self.window.show ()
        self.window.connect('play_clicked', self.on_play_clicked)
        #print("stop  window")
        self.window.connect("destroy", self.on_quit, None)
        self.window.show()
        self.add_window(self.window)
        
        self.update_library_async()
        #print (time.time()-start_time, "end activating application")
    
    def on_play_clicked(self, window, game):
        self.play(game)
    
    def _add_actions(self):
        for action_entry in self._action_entries:
            state = action_entry['state'] if 'state' in action_entry else None
            parameterType = GLib.VariantType.new(action_entry['parameter_type']) if 'parameter_type' in action_entry else None
            
            action = None
            if (state):
                action = Gio.SimpleAction.new_stateful(action_entry['name'], parameterType, action_entry['state'])
            else:
                action = Gio.SimpleAction.new(action_entry['name'], None)
            
            if 'create_hook' in action_entry:
                action_entry['create_hook'](action)
            
            if 'callback' in action_entry:
                action.connect('activate', action_entry['callback'])
            
            if 'accel' in action_entry:
                self.add_accelerator(action_entry['accel'], 'app.' + action_entry['name'], None)
            
            self.add_action(action)
    
    def on_quit(self, action, data):
        print("Quitting Badnik")
        self.window.hide()
        self.systems.set_property("stop_searches", True)
#.........这里部分代码省略.........

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
def run():
    app = QtGui.QApplication(sys.argv)
    wds = Window()
    wds.show()
    sys.exit(app.exec_())
    del wds

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
class App(KApplication):
    def __init__(self):
        KApplication.__init__(self)
        self.setQuitOnLastWindowClosed(False)

        self.sni = KStatusNotifierItem()
        self.sni.setTitle(i18n("Deveba"))
        self.sni.setCategory(KStatusNotifierItem.SystemServices)
        self.sni.setStatus(KStatusNotifierItem.Active)

        self.sni.setIconByName("task-accepted")

        self.sni.setToolTipTitle(i18n("Deveba"))

        self.window = Window(self)
        self.window.hide()
        self.window.finished.connect(self.slotWindowClosed)
        self.sni.setAssociatedWidget(self.window)

        self.logMessages = []
        self.success = True
        self.workerThread = None

    @staticmethod
    def options():
        options = KCmdLineOptions()
        options.add("log <file>", ki18n("Write log to file"), "-")
        options.add("c").add("config <file>", ki18n("Config file to use"), core.CONFIG_FILE)
        options.add("+[group]", ki18n("Start backup of $group"))
        return options

    def exec_(self):
        args = KCmdLineArgs.parsedArgs()

        core.setup_logger(str(args.getOption("log")))

        config_file = args.getOption("config")
        config = core.load_config(config_file)

        if args.count() > 0:
            group_names = [str(args.arg(x)) for x in range(args.count())]
            groups = core.get_group_list(config, group_names)
            self.startSync(groups)
        else:
            self.window.show()

        return KApplication.exec_()

    def startSync(self, groups):
        self.success = True
        self.workerThread = WorkerThread(groups)
        self.workerThread.logCalled.connect(self.addLog, Qt.QueuedConnection)

        self.sni.setIconByName("task-ongoing")
        self.workerThread.start()
        self.workerThread.finished.connect(self.slotSyncFinished)

    def slotSyncFinished(self):
        if self.success:
            self.sni.setIconByName("task-accepted")
        self.workerThread = None
        QTimer.singleShot(2 * 60 * 1000, self.quitIfNoWindow)

    def slotWindowClosed(self):
        if self.workerThread is None:
            self.quit()

    def quitIfNoWindow(self):
        if not self.window.isVisible():
            self.quit()

    def addLog(self, level, msg):
        if level < UserInterface.LOG_INFO:
            return

        timestamp = time.localtime()
        message = LogMessage(timestamp, level, msg)
        self.logMessages.append(message)

        texts = [x.formatted() for x in self.logMessages[-MAX_TEXTS_LENGTH:]]
        html = "<ul>" + "".join(["<li>%s</li>" % x for x in texts]) + "</ul>"
        self.sni.setToolTipSubTitle(html)

        if level >= UserInterface.LOG_WARNING:
            self.success = False
            self.sni.setIconByName("dialog-error")

        self.window.addLog(message)

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
        windowView = Window(result or len(sys.argv) > 1)
        menu_controller = MenuController(windowView)
        database = Database()
        movie_info = MovieModule()
        app._extra_window = weakref.ref(windowView)

        qml_context = windowView.rootContext()
        qml_context.setContextProperty("config", config)
        qml_context.setContextProperty("_utils", utils)
        qml_context.setContextProperty("database", database)
        qml_context.setContextProperty("windowView", windowView)
        qml_context.setContextProperty("movieInfo", movie_info)
        qml_context.setContextProperty("_menu_controller", menu_controller)

        windowView.setSource(QUrl.fromLocalFile(MAIN_QML))
        windowView.initWindowSize()
        windowView.show()
        if len(parser.positionalArguments()) > 0:
            windowView.play(parser.positionalArguments()[0])

        windowView.windowStateChanged.connect(windowView.rootObject().monitorWindowState)
        app.lastWindowClosed.connect(windowView.rootObject().monitorWindowClose)
        app.focusWindowChanged.connect(windowView.focusWindowChangedSlot)

        signal.signal(signal.SIGINT, signal.SIG_DFL)
        sys.exit(app.exec_())
    finally:
        if movie_info is not None:
            movie_info.close()

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
#!/usr/bin/env python3
import genlist_api
import locale
import os
import sys 
from PyQt5.QtCore import Qt, QLocale, QTranslator
from PyQt5.QtWidgets import *
from window import Window

if __name__ == "__main__":
    app = QApplication(sys.argv)
    # for retina
    #app.setAttribute(Qt.AA_EnableHighDpiScaling, True)
    current_locale = QLocale()
    trans = QTranslator()
    g = genlist_api.Genlist()
    i18n_ui_window_trans = g.resource_path(os.path.join('i18n', 'ui_window_' + current_locale.name() + '.qm'))
    print(i18n_ui_window_trans)
    trans.load(i18n_ui_window_trans)
    app.installTranslator(trans)
    
    window = Window()
    window.show()
    sys.exit(app.exec_())

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
class Squiggly:
	def __init__(self, dim = QRectF(0,0,800,600)):
		self.app = QApplication(sys.argv)

		self.dim = dim

		self.win = Window()
		self.scene = QGraphicsScene(dim)
		self.win.view.setScene(self.scene)

		self.grid = Grid(size = 16, bounds = dim)

		self.scene.addItem(self.grid)

		mypoly = SubRegion(dim = QRectF(-200,-200,200,200))
		mypoly.setBrush(QBrush(QPixmap("asphalt256.png")))
		mypoly.translate(200,200)
		self.scene.addItem(mypoly)

		mypoly2 = SubRegion(dim = QRectF(-200,-200,200,200))
		mypoly2.setBrush(QBrush(QPixmap("asphalt256.png")))
		mypoly2.translate(600,400)
		self.scene.addItem(mypoly2)

		mypoly3 = SubRegion(dim = QRectF(-100,-100,100,100))
		mypoly3.setBrush(QBrush(QColor("green")))
		mypoly3.translate(350,400)
		self.scene.addItem(mypoly3)

		self.link(mypoly, mypoly3)
		self.link(mypoly3, mypoly2)
		#self.path = Path(mypoly.connectors[1] + mypoly.mapToScene(mypoly.pos()),
		#	mypoly2.connectors[0] + mypoly2.mapToScene(mypoly2.pos()))
		self.path = Path(mypoly2.connectors[1] + mypoly2.mapToScene(mypoly2.pos()),
			QPointF(800,300))
		self.path_out = Path(QPointF(0,300),
			mypoly.connectors[0] + mypoly.mapToScene(mypoly.pos()))

		self.scene.addItem(self.path)
		self.scene.addItem(self.path_out)

		self.win.smooth_slider.setValue(self.path.smooth)
		self.win.dampen_slider.setValue(self.path.dampen)
		self.win.steps_slider.setValue(self.path.steps)
		self.win.smooth_spin.setValue(self.path.smooth)
		self.win.dampen_spin.setValue(self.path.dampen)
		self.win.steps_spin.setValue(self.path.steps)

		self.win.steps_spin.valueChanged.connect(self.steps_slider_update)
		self.win.steps_slider.valueChanged.connect(self.steps_spin_update)
		self.win.smooth_spin.valueChanged.connect(self.smooth_slider_update)
		self.win.smooth_slider.valueChanged.connect(self.smooth_spin_update)
		self.win.dampen_spin.valueChanged.connect(self.dampen_slider_update)
		self.win.dampen_slider.valueChanged.connect(self.dampen_spin_update)

		self.win.update_button.clicked.connect(self.path.update_lines)

		self.win.show()

		sys.exit(self.app.exec_())

	def link(self, a, b):
		self.scene.addItem(Path(a.exit() + a.mapToScene(a.pos()),
			b.entrance() + b.mapToScene(b.pos())))

	def steps_slider_update(self, value):
		self.path.steps = value
		self.win.steps_slider.setValue(value)
		self.path_update()

	def steps_spin_update(self, value):
		self.path.steps = value
		self.win.steps_spin.setValue(value)
		self.path_update()

	def smooth_slider_update(self, value):
		self.path.smooth = value
		self.win.smooth_slider.setValue(value)
		self.path_update()

	def smooth_spin_update(self, value):
		self.path.smooth = value
		self.win.smooth_spin.setValue(value)
		self.path_update()

	def dampen_slider_update(self, value):
		self.path.dampen = value
		self.win.dampen_slider.setValue(value)
		self.path_update()

	def dampen_spin_update(self, value):
		self.path.dampen = value
		self.win.dampen_spin.setValue(value)
		self.path_update()

	def path_update(self):
		self.path.update_lines()

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
if __name__ == "__main__":
    movie_file = ""
    if len(sys.argv) >= 2:
        movie_file = sys.argv[1]
    movie_info = MovieInfo(movie_file)
    
    app = QApplication(sys.argv)
    database = Database()
    config = Config()
    
    view = Window()
    page_manager = PageManager(view)
    
    qml_context = view.rootContext()
    qml_context.setContextProperty("windowView", view)
    qml_context.setContextProperty("qApp", qApp)
    qml_context.setContextProperty("movieInfo", movie_info)
    qml_context.setContextProperty("database", database)
    qml_context.setContextProperty("config", config)
    qml_context.setContextProperty("pageManager", page_manager)
    
    view.setSource(QtCore.QUrl.fromLocalFile(os.path.join(os.path.dirname(__file__), 'Main.qml')))
    view.show()
    
    view.windowStateChanged.connect(view.rootObject().monitorWindowState)
    app.lastWindowClosed.connect(view.rootObject().monitorWindowClose)
    app.setQuitOnLastWindowClosed(True)    
    
    signal.signal(signal.SIGINT, signal.SIG_DFL)
    sys.exit(app.exec_())

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
def main():
	app = QApplication( sys.argv )
	window = Window()
	window.show()

	sys.exit(app.exec_())

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import show [as 别名]
class Beam_Splitter(BaseProcess_noPriorWindow):
    '''
Overlay two image stacks to correct for xy pixel shift.  The current frame of the green window (or the smaller image if red is smaller) \
will be displayed over the current frame of the red window. Then use the arrow keys to align the movies.
    '''
    def __init__(self):
        BaseProcess_noPriorWindow.__init__(self)
        self.current_red = None
        self.current_green = None

    def __call__(self, red_window, green_window, x_shift, y_shift):
        '''
        plots red_window over green_window, shifted by (x_shift, y_shift) pixels
        '''
        self.unlink_frames(self.current_red, self.current_green)
        self.window.close()
        del self.window
        g.m.statusBar().showMessage("Applying beam splitter shift ...")
        t = time()
        imR = red_window.imageview.image
        t, w, h = imR.shape
        if red_window != None and green_window != None:
            self.newname = "%s shifted (%d, %d)" % (green_window.name, x_shift, y_shift)
            imG = green_window.imageview.image
        else:
            return
        imG = self.pad_shift(imG, np.shape(imR), x_shift, y_shift)
        self.command = 'beam_splitter(%s, %s, %s, %s)' % (red_window, green_window, x_shift, y_shift)
        g.m.statusBar().showMessage("Successfully shifted (%s s)" % (time() - t))
        self.newtif = imG
        win = self.end()
        win.imageview.setLevels(self.minlevel, self.maxlevel)
        return win

    def pad_shift(self, imGreen, size, x_shift, y_shift):
        '''
        shift imGreen by (x_shift, y_shift) onto an empty array of size similar to imRed
        '''
        g_size = imGreen.shape
        imGreen_shifted = np.zeros(size)
        if imGreen.ndim == 2:
            imGreen_shifted[:g_size[0], :g_size[1]] = imGreen
            imGreen_shifted = shift(imGreen_shifted, (x_shift, y_shift))
        elif imGreen.ndim == 3:
            rt, rw, rh = size
            gt, gw, gh = g_size
            r_left = max(0, x_shift)
            r_top = max(0, y_shift)
            r_right = min(rw, gw + x_shift)
            r_bottom = min(rh, gh + y_shift)

            g_left = max(0, -x_shift)
            g_top = max(0, -y_shift)
            g_right = min(gw, rw - x_shift)
            g_bottom = min(gh, rh - y_shift)
            
            imGreen_shifted[:, r_left:r_right, r_top:r_bottom] = imGreen[:, g_left:g_right, g_top:g_bottom]        
        return imGreen_shifted

    def keyPressed(self, event):
        if event.key() == Qt.Key_Up:
            self.y_shift_spin.setValue(self.y_shift_spin.value() - 1)
        if event.key() == Qt.Key_Down:
            self.y_shift_spin.setValue(self.y_shift_spin.value() + 1)
        if event.key() == Qt.Key_Left:
            self.x_shift_spin.setValue(self.x_shift_spin.value() - 1)
        if event.key() == Qt.Key_Right:
            self.x_shift_spin.setValue(self.x_shift_spin.value() + 1)
        if event.key() == 16777220: # Enter
            self.ui.close()
            self.call_from_gui()
            
        event.accept()

    def closeEvent(self, event):
        self.unlink_frames(self.current_red, self.current_green)
        BaseProcess_noPriorWindow.closeEvent(self, event)

    def indexChanged(self, i):
        if self.ui.isVisible():
            self.preview()

    def unlink_frames(self, *windows):
        for window in windows:
            if window != None:
                try:
                    window.sigTimeChanged.disconnect(self.indexChanged)
                except:
                    pass

    def preview(self):
        winRed = self.getValue('red_window')
        winGreen = self.getValue('green_window')
        x_shift = self.getValue('x_shift')
        y_shift = self.getValue('y_shift')
        
        if not winRed or not winGreen:
            if hasattr(self, "window"):
                self.window.hide()
            return
#.........这里部分代码省略.........