コード例 #1
0
ファイル: RTApplet.py プロジェクト: Steell/Ray-Tracer-Jython
    def init(self):
        w, h, aa, threads = (512, 512, 1, 2)
        canvas = RayTracePanel(w, h, aa, threads)
        self.getContentPane().add(JScrollPane(canvas))

        #Save FileChooser
        #fcS = JFileChooser()
        #fcS.addChoosableFileFilter(FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
        #fcS.addChoosableFileFilter(FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
        #fcS.addChoosableFileFilter(FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
        #def saveFile(event):
        #    '''Performed when the save button is pressed'''
        #    result = fcS.showSaveDialog(frame)
        #    if result == JFileChooser.APPROVE_OPTION:
        #        file = fcS.getSelectedFile()
        #        fname = file.getPath()
        #        ext = fcS.getFileFilter().getExtensions()[0]
        #        if not fname.endswith('.' + ext):
        #            file = File(fname + '.' + ext)
        #        canvas.saveToFile(file, ext)

        #Open FileChooser
        #fcO = JFileChooser()
        #fcO.addChoosableFileFilter(FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
        #def openFile(event):
        #    '''Performed when the open button is pressed'''
        #    result = fcO.showOpenDialog(frame)
        #    if result == JFileChooser.APPROVE_OPTION:
        #        fname = fcO.getSelectedFile().getPath()
        #        if fname.endswith('.rts'):
        #            f = open(fname, 'rb')
        #            newScene = SceneFactory().buildScene(f)
        #            f.close()
        #            Painter(canvas, newScene, openButton, saveButton, stopButton).start()

        def stop(event):
            '''Peformed when the stop button is pressed'''
            canvas.stopRendering()

        #Setup Menu
        menuBar = JMenuBar()
        menu = JMenu("File")
        menuBar.add(menu)
        #openButton = JMenuItem("Open...", actionPerformed=openFile)
        #openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
        #menu.add(openButton)
        #saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
        #saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
        #menu.add(saveButton)
        menu.addSeparator()
        stopButton = JMenuItem('Stop Render', actionPerformed=stop)
        stopButton.setAccelerator(KeyStroke.getKeyStroke(
            KeyEvent.VK_ESCAPE, 0))
        stopButton.setEnabled(False)
        menu.add(stopButton)
        menu.addSeparator()
        #closeButton = JMenuItem('Close', actionPerformed=exit)
        #closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
        #menu.add(closeButton)
        self.setJMenuBar(menuBar)
コード例 #2
0
def createAction(callback,
                 name,
                 description=None,
                 menu=None,
                 mnemonic=None,
                 accelerator=None,
                 toolBar=None,
                 menuItemType="standard"):
    action = CallbackAction(callback, name, description)
    if menu:
        if menuItemType == "standard":
            menuItem = JMenuItem(action)
        elif menuItemType == "checkbox":
            menuItem = JCheckBoxMenuItem(action)
        elif menuItemType == "radiobutton":
            menuItem = JRadioButtonMenuItem(action)
        else:
            internal_error("unsupported menu item type %s" % ` menuItemType `)
            menuItem = JMenuItem(action)
        if mnemonic:
            menuItem.setMnemonic(mnemonic)
        if accelerator:
            menuItem.setAccelerator(
                KeyStroke.getKeyStroke(ord(accelerator), Event.CTRL_MASK, 0))
        menu.add(menuItem)
        action.setMenuItem(menuItem)
    if toolBar:
        toolbarButton = JButton(action)
        toolBar.add(toolbarButton)
    return action
コード例 #3
0
ファイル: RTApplet.py プロジェクト: Steell/Ray-Tracer-Jython
    def init(self):
        w, h, aa, threads = (512, 512, 1, 2)
        canvas = RayTracePanel(w, h, aa, threads)
        self.getContentPane().add(JScrollPane(canvas))

        # Save FileChooser
        # fcS = JFileChooser()
        # fcS.addChoosableFileFilter(FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
        # fcS.addChoosableFileFilter(FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
        # fcS.addChoosableFileFilter(FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
        # def saveFile(event):
        #    '''Performed when the save button is pressed'''
        #    result = fcS.showSaveDialog(frame)
        #    if result == JFileChooser.APPROVE_OPTION:
        #        file = fcS.getSelectedFile()
        #        fname = file.getPath()
        #        ext = fcS.getFileFilter().getExtensions()[0]
        #        if not fname.endswith('.' + ext):
        #            file = File(fname + '.' + ext)
        #        canvas.saveToFile(file, ext)

        # Open FileChooser
        # fcO = JFileChooser()
        # fcO.addChoosableFileFilter(FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
        # def openFile(event):
        #    '''Performed when the open button is pressed'''
        #    result = fcO.showOpenDialog(frame)
        #    if result == JFileChooser.APPROVE_OPTION:
        #        fname = fcO.getSelectedFile().getPath()
        #        if fname.endswith('.rts'):
        #            f = open(fname, 'rb')
        #            newScene = SceneFactory().buildScene(f)
        #            f.close()
        #            Painter(canvas, newScene, openButton, saveButton, stopButton).start()

        def stop(event):
            """Peformed when the stop button is pressed"""
            canvas.stopRendering()

        # Setup Menu
        menuBar = JMenuBar()
        menu = JMenu("File")
        menuBar.add(menu)
        openButton = JMenuItem("Open...", actionPerformed=openFile)
        openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
        menu.add(openButton)
        # saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
        # saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
        # menu.add(saveButton)
        menu.addSeparator()
        stopButton = JMenuItem("Stop Render", actionPerformed=stop)
        stopButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0))
        stopButton.setEnabled(False)
        menu.add(stopButton)
        menu.addSeparator()
        # closeButton = JMenuItem('Close', actionPerformed=exit)
        # closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
        # menu.add(closeButton)
        self.setJMenuBar(menuBar)
コード例 #4
0
def createAction(callback, name, description=None, menu=None, mnemonic=None, accelerator=None, toolBar=None, menuItemType="standard"):
    action = CallbackAction(callback, name, description)
    if menu:
        if menuItemType == "standard":
            menuItem = JMenuItem(action)
        elif menuItemType == "checkbox":
            menuItem = JCheckBoxMenuItem(action)
        elif menuItemType == "radiobutton":
            menuItem = JRadioButtonMenuItem(action)
        else:
            internal_error("unsupported menu item type %s" % `menuItemType`)
            menuItem = JMenuItem(action)
        if mnemonic:
            menuItem.setMnemonic(mnemonic)
        if accelerator:
            menuItem.setAccelerator(KeyStroke.getKeyStroke(ord(accelerator), Event.CTRL_MASK, 0))
        menu.add(menuItem)
        action.setMenuItem(menuItem)
    if toolBar:
        toolbarButton = JButton(action)
        toolBar.add(toolbarButton)
    return action
コード例 #5
0
ファイル: RTApplet.py プロジェクト: Steell/Ray-Tracer-Jython
def run(scene, w=512, h=512, aa=1, threads=1):
    """Create GUI and perform ray-tracing."""
    # Make Swing not look like garbage (so much)
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
    # Setup frame
    frame = JFrame("RayTracer", defaultCloseOperation=JFrame.EXIT_ON_CLOSE, size=(w, h))
    frame.setIconImage(ImageIcon("resources/icon.png").getImage())
    canvas = RayTracePanel(w, h, aa, threads)
    frame.getContentPane().add(JScrollPane(canvas))

    # Save FileChooser
    fcS = JFileChooser()
    fcS.addChoosableFileFilter(FileNameExtensionFilter("Windows Bitmap (*.bmp)", ["bmp"]))
    fcS.addChoosableFileFilter(FileNameExtensionFilter("JPEG / JFIF (*.jpg)", ["jpg"]))
    fcS.addChoosableFileFilter(FileNameExtensionFilter("Portable Network Graphics (*.png)", ["png"]))

    def saveFile(event):
        """Performed when the save button is pressed"""
        result = fcS.showSaveDialog(frame)
        if result == JFileChooser.APPROVE_OPTION:
            file = fcS.getSelectedFile()
            fname = file.getPath()
            ext = fcS.getFileFilter().getExtensions()[0]
            if not fname.endswith("." + ext):
                file = File(fname + "." + ext)
            canvas.saveToFile(file, ext)

    # Open FileChooser
    fcO = JFileChooser()
    fcO.addChoosableFileFilter(FileNameExtensionFilter("RayTrace Scene File (*.rts)", ["rts"]))

    def openFile(event):
        """Performed when the open button is pressed"""
        result = fcO.showOpenDialog(frame)
        if result == JFileChooser.APPROVE_OPTION:
            fname = fcO.getSelectedFile().getPath()
            if fname.endswith(".rts"):
                f = open(fname, "rb")
                newScene = SceneFactory().buildScene(f)
                f.close()
                Painter(canvas, newScene, openButton, saveButton, stopButton).start()

    def exit(event):
        """Performed when the exit button is pressed"""
        import sys

        sys.exit(0)

    def stop(event):
        """Peformed when the stop button is pressed"""
        canvas.stopRendering()

    # Setup Menu
    menuBar = JMenuBar()
    menu = JMenu("File")
    menuBar.add(menu)
    openButton = JMenuItem("Open...", actionPerformed=openFile)
    openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
    menu.add(openButton)
    saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
    saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
    menu.add(saveButton)
    menu.addSeparator()
    stopButton = JMenuItem("Stop Render", actionPerformed=stop)
    stopButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0))
    stopButton.setEnabled(False)
    menu.add(stopButton)
    menu.addSeparator()
    closeButton = JMenuItem("Close", actionPerformed=exit)
    closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
    menu.add(closeButton)
    frame.setJMenuBar(menuBar)

    # Finish initializing GUI
    self.pack()
コード例 #6
0
ファイル: shaderUI.py プロジェクト: elfprince13/FreeBuild
def menu_with_accelerator(menuText, accelerator_pair):
    menu = JMenuItem(menuText)
    menu.setAccelerator(KeyStroke.getKeyStroke(*accelerator_pair))
    return menu
コード例 #7
0
def run(scene, w=512, h=512, aa=1, threads=1):
    '''Create GUI and perform ray-tracing.'''
    #Make Swing not look like garbage (so much)
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
    #Setup frame
    frame = JFrame("RayTracer",
                   defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
                   size=(w, h))
    frame.setIconImage(ImageIcon('resources/icon.png').getImage())
    canvas = RayTracePanel(w, h, aa, threads)
    frame.getContentPane().add(JScrollPane(canvas))

    #Save FileChooser
    fcS = JFileChooser()
    fcS.addChoosableFileFilter(
        FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
    fcS.addChoosableFileFilter(
        FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
    fcS.addChoosableFileFilter(
        FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))

    def saveFile(event):
        '''Performed when the save button is pressed'''
        result = fcS.showSaveDialog(frame)
        if result == JFileChooser.APPROVE_OPTION:
            file = fcS.getSelectedFile()
            fname = file.getPath()
            ext = fcS.getFileFilter().getExtensions()[0]
            if not fname.endswith('.' + ext):
                file = File(fname + '.' + ext)
            canvas.saveToFile(file, ext)

    #Open FileChooser
    fcO = JFileChooser()
    fcO.addChoosableFileFilter(
        FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))

    def openFile(event):
        '''Performed when the open button is pressed'''
        result = fcO.showOpenDialog(frame)
        if result == JFileChooser.APPROVE_OPTION:
            fname = fcO.getSelectedFile().getPath()
            if fname.endswith('.rts'):
                f = open(fname, 'rb')
                newScene = SceneFactory().buildScene(f)
                f.close()
                Painter(canvas, newScene, openButton, saveButton).start()

    def exit(event):
        '''Performed when the exit button is pressed'''
        import sys
        sys.exit(0)

    #Setup Menu
    menuBar = JMenuBar()
    menu = JMenu("File")
    menuBar.add(menu)
    openButton = JMenuItem("Open...", actionPerformed=openFile)
    openButton.setAccelerator(
        KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
    menu.add(openButton)
    saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
    saveButton.setAccelerator(
        KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
    menu.add(saveButton)
    menu.addSeparator()
    closeButton = JMenuItem('Close', actionPerformed=exit)
    closeButton.setAccelerator(
        KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
    menu.add(closeButton)
    frame.setJMenuBar(menuBar)

    #Finish initializing GUI
    frame.pack()
    #frame.setLocationRelativeTo(None)
    frame.setVisible(True)

    #Perform ray-tracing
    if scene is not None:
        Thread(Painter(canvas, scene, openButton, saveButton)).start()
コード例 #8
0
	def __init__(self, windowManager, commandConsoleFactory, subject, windowTitle):
		self._windowManager = windowManager





		self.onCloseRequestListener = None



		# EDIT MENU

		transferActionListener = _TransferActionListener()

		editMenu = JMenu( 'Edit' )

		if Platform.getPlatform() is Platform.MAC:
			command_key_mask = ActionEvent.META_MASK
		else:
			command_key_mask = ActionEvent.CTRL_MASK;

		self.__editUndoItem = JMenuItem( 'Undo' )
		undoAction = _action( 'undo', self.__onUndo )
		self.__editUndoItem.setActionCommand( undoAction.getValue( Action.NAME ) )
		self.__editUndoItem.addActionListener( undoAction )
		self.__editUndoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Z, command_key_mask ) )
		self.__editUndoItem.setMnemonic( KeyEvent.VK_U )
		editMenu.add( self.__editUndoItem )

		self.__editRedoItem = JMenuItem( 'Redo' )
		redoAction = _action( 'redo', self.__onRedo )
		self.__editRedoItem.setActionCommand( redoAction.getValue( Action.NAME ) )
		self.__editRedoItem.addActionListener( redoAction )
		self.__editRedoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Y, command_key_mask ) )
		self.__editRedoItem.setMnemonic( KeyEvent.VK_R )
		editMenu.add( self.__editRedoItem )

		editMenu.addSeparator()

		editCutItem = JMenuItem( 'Cut' )
		editCutItem.setActionCommand( TransferHandler.getCutAction().getValue( Action.NAME ) )
		editCutItem.addActionListener( transferActionListener )
		editCutItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_X, command_key_mask ) )
		editCutItem.setMnemonic( KeyEvent.VK_T )
		editMenu.add( editCutItem )

		editCopyItem = JMenuItem( 'Copy' )
		editCopyItem.setActionCommand( TransferHandler.getCopyAction().getValue( Action.NAME ) )
		editCopyItem.addActionListener( transferActionListener )
		editCopyItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_C, command_key_mask ) )
		editCopyItem.setMnemonic( KeyEvent.VK_C )
		editMenu.add( editCopyItem )

		editPasteItem = JMenuItem( 'Paste' )
		editPasteItem.setActionCommand( TransferHandler.getPasteAction().getValue( Action.NAME ) )
		editPasteItem.addActionListener( transferActionListener )
		editPasteItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_V, command_key_mask ) )
		editPasteItem.setMnemonic( KeyEvent.VK_P )
		editMenu.add( editPasteItem )

		editMenu.addSeparator()

		self.__showUndoHistoryItem = JMenuItem( 'Show undo history' )
		self.__showUndoHistoryItem.addActionListener( _action( 'Show undo history', self.__onShowUndoHistory ) )
		editMenu.add( self.__showUndoHistoryItem )




		# HELP MENU

		helpMenu = JMenu( 'Help' )

		helpToggleTooltipHighlightsItem = JMenuItem( 'Toggle tooltip highlights' )
		toggleTooltipHighlightsAction = _action( 'Toggle tooltip highlights', self.__onToggleTooltipHighlights )
		helpToggleTooltipHighlightsItem.setActionCommand( toggleTooltipHighlightsAction.getValue( Action.NAME ) )
		helpToggleTooltipHighlightsItem.addActionListener( toggleTooltipHighlightsAction )
		helpToggleTooltipHighlightsItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_F2, 0 ) )
		helpMenu.add( helpToggleTooltipHighlightsItem )

		helpMenu.add( _action( 'Show all tip boxes', self.__onShowAllTipBoxes ) )


		# MENU BAR

		menuBar = JMenuBar()
		menuBar.add( editMenu )
		menuBar.add( helpMenu )




		# BROWSER

		# Initialise here, as the browser listener may invoke methods upon the browser's creation
		class _BrowserListener (TabbedBrowser.TabbedBrowserListener):
			def createNewBrowserWindow(_self, subject):
				self._onOpenNewWindow( subject )

			def onTabbledBrowserChangePage(_self, browser):
				pass


		def inspectFragment(fragment, sourceElement, triggeringEvent):
			return self._windowManager.world.inspectFragment( fragment, sourceElement, triggeringEvent )



		def onChangeHistoryChanged(history):
			self.__refreshChangeHistoryControls( history )

		self._browser = TabbedBrowser( self._windowManager.world.rootSubject, subject, inspectFragment, _BrowserListener(), commandConsoleFactory )
		self._browser.getComponent().setPreferredSize( Dimension( 800, 600 ) )
		changeHistory = self._browser.getChangeHistory()
		self._browser.getChangeHistory().addChangeHistoryListener(onChangeHistoryChanged)





		# MAIN PANEL

		windowPanel = JPanel()
		windowPanel.setLayout( BoxLayout( windowPanel, BoxLayout.Y_AXIS ) )
		windowPanel.add( self._browser.getComponent() )




		# WINDOW

		class _WindowLister (WindowListener):
			def windowActivated(listenerSelf, event):
				pass

			def windowClosed(listenerSelf, event):
				pass

			def windowClosing(listenerSelf, event):
				if self.onCloseRequestListener is not None:
					self.onCloseRequestListener( self )

			def windowDeactivated(listenerSelf, event):
				pass

			def windowDeiconified(listenerSelf, event):
				pass

			def windowIconified(listenerSelf, event):
				pass

			def windowOpened(listenerSelf, event):
				pass


		self.__frame = JFrame( windowTitle )

		self.__frame.setJMenuBar( menuBar )

		self.__frame.add( windowPanel )
		self.__frame.addWindowListener( _WindowLister() )
		self.__frame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE )

		self.__frame.pack()


		# Cause command history controls to refresh
		self.__refreshChangeHistoryControls( None )
コード例 #9
0
def run(scene, w=512, h=512, aa=1, threads=1):
        '''Create GUI and perform ray-tracing.'''
        #Make Swing not look like garbage (so much)
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
        #Setup frame
        frame = JFrame(
            "RayTracer",
            defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
            size=(w, h)
        )
        frame.setIconImage(ImageIcon('resources/icon.png').getImage())
        canvas = RayTracePanel(w, h, aa, threads)
        frame.getContentPane().add(JScrollPane(canvas))
        
        #Save FileChooser
        fcS = JFileChooser()
        fcS.addChoosableFileFilter(FileNameExtensionFilter('Windows Bitmap (*.bmp)', ['bmp']))
        fcS.addChoosableFileFilter(FileNameExtensionFilter('JPEG / JFIF (*.jpg)', ['jpg']))
        fcS.addChoosableFileFilter(FileNameExtensionFilter('Portable Network Graphics (*.png)', ['png']))
        def saveFile(event):
            '''Performed when the save button is pressed'''
            result = fcS.showSaveDialog(frame)
            if result == JFileChooser.APPROVE_OPTION:
                file = fcS.getSelectedFile()
                fname = file.getPath()
                ext = fcS.getFileFilter().getExtensions()[0]
                if not fname.endswith('.' + ext):
                    file = File(fname + '.' + ext)
                canvas.saveToFile(file, ext)
        
        #Open FileChooser
        fcO = JFileChooser()
        fcO.addChoosableFileFilter(FileNameExtensionFilter('RayTrace Scene File (*.rts)', ['rts']))
        def openFile(event):
            '''Performed when the open button is pressed'''
            result = fcO.showOpenDialog(frame)
            if result == JFileChooser.APPROVE_OPTION:
                fname = fcO.getSelectedFile().getPath()
                if fname.endswith('.rts'):
                    f = open(fname, 'rb')
                    newScene = SceneFactory().buildScene(f)
                    f.close()
                    Painter(canvas, newScene, openButton, saveButton).start()
                    
        def exit(event):
            '''Performed when the exit button is pressed'''
            import sys
            sys.exit(0)
        
        #Setup Menu
        menuBar = JMenuBar()
        menu = JMenu("File")
        menuBar.add(menu)
        openButton = JMenuItem("Open...", actionPerformed=openFile)
        openButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.CTRL_MASK))
        menu.add(openButton)
        saveButton = JMenuItem("Save as...", actionPerformed=saveFile)
        saveButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.CTRL_MASK))
        menu.add(saveButton)
        menu.addSeparator()
        closeButton = JMenuItem('Close', actionPerformed=exit)
        closeButton.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, ActionEvent.ALT_MASK))
        menu.add(closeButton)
        frame.setJMenuBar(menuBar)
        
        #Finish initializing GUI
        frame.pack()
        #frame.setLocationRelativeTo(None)
        frame.setVisible(True)
        
        #Perform ray-tracing
        if scene is not None:
            Thread(Painter(canvas, scene, openButton, saveButton)).start()