def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application.
"""
setup_logging()
logging.info('Starting Mu {}'.format(__version__))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('icon'))
splash.show()
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.theme)
editor.restore_session()
# Connect the various buttons in the window to the editor.
button_bar = editor_window.button_bar
button_bar.connect("new", editor.new, "Ctrl+N")
button_bar.connect("load", editor.load, "Ctrl+O")
button_bar.connect("save", editor.save, "Ctrl+S")
button_bar.connect("flash", editor.flash)
button_bar.connect("repl", editor.toggle_repl)
button_bar.connect("zoom-in", editor.zoom_in)
button_bar.connect("zoom-out", editor.zoom_out)
button_bar.connect("theme", editor.toggle_theme)
button_bar.connect("quit", editor.quit)
# Finished starting up the application, so hide the splash icon.
splash.finish(editor_window)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application.
"""
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('icon'))
splash.show()
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.theme)
editor.restore_session()
# Connect the various buttons in the window to the editor.
button_bar = editor_window.button_bar
button_bar.connect("new", editor.new, "Ctrl+N")
button_bar.connect("load", editor.load, "Ctrl+O")
button_bar.connect("save", editor.save, "Ctrl+S")
button_bar.connect("flash", editor.flash)
button_bar.connect("repl", editor.toggle_repl)
button_bar.connect("zoom-in", editor.zoom_in)
button_bar.connect("zoom-out", editor.zoom_out)
button_bar.connect("theme", editor.toggle_theme)
button_bar.connect("quit", editor.quit)
# Finished starting up the application, so hide the splash icon.
splash.finish(editor_window)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_admin, 'Ctrl+Shift+D')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Finished starting up the application, so hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(5000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application.
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# capture the filename passed by the os, if there was one
passed_filename = sys.argv[1] if len(sys.argv) > 1 else None
editor.restore_session(passed_filename)
# Connect the various UI elements in the window to the editor.
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_logs, 'Ctrl+Shift+D')
status_bar.connect_mode(editor.select_mode, 'Ctrl+Shift+M')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Finished starting up the application, so hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(5000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application.
"""
setup_logging()
logging.info('Starting Mu {}'.format(__version__))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('icon'))
splash.show()
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.theme, MICROPYTHON_APIS)
# capture the filename passed by the os, if there was one
passed_filename = sys.argv[1] if len(sys.argv) > 1 else None
editor.restore_session(passed_filename)
# Connect the various buttons in the window to the editor.
button_bar = editor_window.button_bar
button_bar.connect("new", editor.new, "Ctrl+N")
button_bar.connect("load", editor.load, "Ctrl+O")
button_bar.connect("save", editor.save, "Ctrl+S")
button_bar.connect("flash", editor.flash)
button_bar.connect("files", editor.toggle_fs)
button_bar.connect("repl", editor.toggle_repl)
button_bar.connect("zoom-in", editor.zoom_in)
button_bar.connect("zoom-out", editor.zoom_out)
button_bar.connect("theme", editor.toggle_theme)
button_bar.connect("check", editor.check_code)
button_bar.connect("help", editor.show_help)
button_bar.connect("quit", editor.quit)
# Finished starting up the application, so hide the splash icon.
splash.finish(editor_window)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# By default PyQt uses the script name (run.py)
app.setApplicationName('mu')
# Set hint as to the .desktop files name
app.setDesktopFileName('mu.codewith.editor')
app.setApplicationVersion(__version__)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Images (such as toolbar icons) aren't scaled nicely on retina/4k displays
# unless this flag is set
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
# Create the "window" we'll be looking at.
editor_window = Window()
# Make sure all windows have the Mu icon as a fallback
app.setWindowIcon(load_icon(editor_window.icon))
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
editor_window.connect_find_replace(editor.find_replace, 'Ctrl+F')
editor_window.connect_find_replace(editor.toggle_comments, 'Ctrl+K')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_admin, 'Ctrl+Shift+D')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(2000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application.
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# capture the filename passed by the os, if there was one
passed_filename = sys.argv[1] if len(sys.argv) > 1 else None
editor.restore_session(passed_filename)
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_logs, 'Ctrl+Shift+D')
status_bar.connect_mode(editor.select_mode, 'Ctrl+Shift+M')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Finished starting up the application, so hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(5000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Create the "window" we'll be looking at.
editor_window = Window()
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_admin, 'Ctrl+Shift+D')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Finished starting up the application, so hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(5000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info("\n\n-----------------\n\nStarting Mu {}".format(__version__))
logging.info(platform.uname())
logging.info("Python path: {}".format(sys.path))
# logging.info("Language code: {}".format(language_code))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# By default PyQt uses the script name (run.py)
app.setApplicationName("mu")
# Set hint as to the .desktop files name
app.setDesktopFileName("mu.codewith.editor")
app.setApplicationVersion(__version__)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Images (such as toolbar icons) aren't scaled nicely on retina/4k displays
# unless this flag is set
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
# Create the "window" we'll be looking at.
editor_window = Window()
@editor_window.load_theme.connect
def load_theme(theme):
if theme == "contrast":
app.setStyleSheet(CONTRAST_STYLE)
elif theme == "night":
app.setStyleSheet(NIGHT_STYLE)
else:
app.setStyleSheet(DAY_STYLE)
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap("splash-screen"))
splash.show()
# Make sure the splash screen stays on top while
# the mode selection dialog might open
raise_splash = QTimer()
raise_splash.timeout.connect(lambda: splash.raise_())
raise_splash.start(10)
# Hide the splash icon.
def remove_splash():
splash.finish(editor_window)
raise_splash.stop()
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(remove_splash)
splash_be_gone.setSingleShot(True)
splash_be_gone.start(2000)
# Make sure all windows have the Mu icon as a fallback
app.setWindowIcon(load_icon(editor_window.icon))
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, "Ctrl+Shift+S")
editor_window.connect_find_replace(editor.find_replace, "Ctrl+F")
editor_window.connect_toggle_comments(editor.toggle_comments, "Ctrl+K")
editor.connect_to_status_bar(editor_window.status_bar)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting mPython2_{} ( base on Mu )'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
logging.info('Language code: {}'.format(language_code))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# By default PyQt uses the script name (run.py)
app.setApplicationName('mu')
# Set hint as to the .desktop files name
app.setDesktopFileName('mu.codewith.editor')
app.setApplicationVersion(__version__)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Images (such as toolbar icons) aren't scaled nicely on retina/4k displays
# unless this flag is set
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
# Create the "window" we'll be looking at.
editor_window = Window()
@editor_window.load_theme.connect
def load_theme(theme):
if theme == 'contrast':
app.setStyleSheet(CONTRAST_STYLE)
elif theme == 'night':
app.setStyleSheet(NIGHT_STYLE)
else:
app.setStyleSheet(DAY_STYLE)
# Make sure all windows have the Mu icon as a fallback
app.setWindowIcon(load_icon(editor_window.icon))
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
editor_window.connect_find_replace(editor.find_replace, 'Ctrl+F')
editor_window.connect_toggle_comments(editor.toggle_comments, 'Ctrl+K')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_admin, 'Ctrl+Shift+D')
# Display a friendly "splash" icon.
#splash = QSplashScreen(load_pixmap('splash-screen'))
#splash.show()
# Hide the splash icon.
#splash_be_gone = QTimer()
#splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
#splash_be_gone.setSingleShot(True)
#splash_be_gone.start(2000)
# Check software update.
key = get_platform()
url = "http://static.steamaker.cn/files/mPython2.json"
config_dir = os.path.join(editor.modes['mPython'].workspace_dir(), '__config__')
if not os.path.exists(config_dir):
os.makedirs(config_dir)
updater = Updater(key, url, config_dir)
updater.download_url.connect(editor_window.download_url)
updater.update_pylib.connect(editor_window.update_pylib)
updater.update_bin.connect(editor_window.update_bin)
updater.set_update_bin_status.connect(editor_window.set_update_bin_status)
updater.check_firmware.connect(editor.modes['mPython'].check_firmware)
updater.start()
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
def run():
"""
Creates all the top-level assets for the application, sets things up and
then runs the application. Specific tasks include:
- set up logging
- create an application object
- create an editor window and status bar
- display a splash screen while starting
- close the splash screen after startup timer ends
"""
setup_logging()
logging.info('\n\n-----------------\n\nStarting Mu {}'.format(__version__))
logging.info(platform.uname())
logging.info('Python path: {}'.format(sys.path))
logging.info('Language code: {}'.format(language_code))
# The app object is the application running on your computer.
app = QApplication(sys.argv)
# By default PyQt uses the script name (run.py)
app.setApplicationName('mu')
# Set hint as to the .desktop files name
app.setDesktopFileName('mu.codewith.editor')
app.setApplicationVersion(__version__)
app.setAttribute(Qt.AA_DontShowIconsInMenus)
# Images (such as toolbar icons) aren't scaled nicely on retina/4k displays
# unless this flag is set
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
# Create the "window" we'll be looking at.
editor_window = Window()
@editor_window.load_theme.connect
def load_theme(theme):
if theme == 'contrast':
app.setStyleSheet(CONTRAST_STYLE)
elif theme == 'night':
app.setStyleSheet(NIGHT_STYLE)
else:
app.setStyleSheet(DAY_STYLE)
# Make sure all windows have the Mu icon as a fallback
app.setWindowIcon(load_icon(editor_window.icon))
# Create the "editor" that'll control the "window".
editor = Editor(view=editor_window)
editor.setup(setup_modes(editor, editor_window))
# Setup the window.
editor_window.closeEvent = editor.quit
editor_window.setup(editor.debug_toggle_breakpoint, editor.theme)
# Restore the previous session along with files passed by the os
editor.restore_session(sys.argv[1:])
# Connect the various UI elements in the window to the editor.
editor_window.connect_tab_rename(editor.rename_tab, 'Ctrl+Shift+S')
editor_window.connect_find_replace(editor.find_replace, 'Ctrl+F')
editor_window.connect_toggle_comments(editor.toggle_comments, 'Ctrl+K')
status_bar = editor_window.status_bar
status_bar.connect_logs(editor.show_admin, 'Ctrl+Shift+D')
# Display a friendly "splash" icon.
splash = QSplashScreen(load_pixmap('splash-screen'))
splash.show()
# Hide the splash icon.
splash_be_gone = QTimer()
splash_be_gone.timeout.connect(lambda: splash.finish(editor_window))
splash_be_gone.setSingleShot(True)
splash_be_gone.start(2000)
# Stop the program after the application finishes executing.
sys.exit(app.exec_())
