def __init__(self, home, parent=None):
super(LocalFileTree, self).__init__(parent)
self.home = home
self.setStyleSheet("border:1px solid darkgray;")
self.setAcceptDrops(True)
self.setDragDropMode(QAbstractItemView.InternalMove)
self.header().setVisible(False)
self.__icon_firmware = load_icon("firmware.png")
self.__icon_folder = load_icon("folder.png")
def setup(self, breakpoint_toggle, theme):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
self.breakpoint_toggle = breakpoint_toggle
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.read_only_tabs = False
screen_width, screen_height = self.screen_size()
self.setMinimumSize(screen_width // 2, screen_height // 2)
self.setTabPosition(Qt.AllDockWidgetAreas, QTabWidget.North)
self.widget = QWidget()
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
self.tabs = FileTabs()
self.setCentralWidget(self.tabs)
self.status_bar = StatusBar(parent=self)
self.setStatusBar(self.status_bar)
self.addToolBar(self.button_bar)
self.show()
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowIcon(load_icon('icon'))
self.update_title()
# Ensure we have a sensible size for the application.
self.setMinimumSize(800, 600)
self.setup()
def setup(self, theme):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.setMinimumSize(800, 600)
self.widget = QWidget()
self.splitter = QSplitter(Qt.Vertical)
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
self.tabs = QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.tabs.removeTab)
widget_layout.addWidget(self.button_bar)
widget_layout.addWidget(self.splitter)
self.splitter.addWidget(self.tabs)
self.addWidget(self.widget)
self.setCurrentWidget(self.widget)
self.set_theme(theme)
self.show()
self.autosize_window()
def setup(self, breakpoint_toggle, theme):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
self.breakpoint_toggle = breakpoint_toggle
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.read_only_tabs = False
self.setMinimumSize(800, 400)
self.widget = QWidget()
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
self.tabs = FileTabs()
self.tabs.setMovable(True)
self.setCentralWidget(self.tabs)
self.status_bar = StatusBar(parent=self)
self.setStatusBar(self.status_bar)
self.addToolBar(self.button_bar)
self.show()
self.autosize_window()
def setup(self, theme, api=None):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
self.api = api if api else []
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.setMinimumSize(926, 600)
self.widget = QWidget()
self.splitter = QSplitter(Qt.Vertical)
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
widget_layout.addWidget(self.button_bar)
widget_layout.addWidget(self.splitter)
self.tabs = FileTabs()
self.splitter.addWidget(self.tabs)
self.addWidget(self.widget)
self.setCurrentWidget(self.widget)
self.set_theme(theme)
self.show()
self.autosize_window()
def setup(self, theme, api=None):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
self.api = api if api else []
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.setMinimumSize(926, 600)
self.widget = QWidget()
self.splitter = QSplitter(Qt.Vertical)
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
widget_layout.addWidget(self.button_bar)
widget_layout.addWidget(self.splitter)
self.tabs = FileTabs()
self.splitter.addWidget(self.tabs)
self.addWidget(self.widget)
self.setCurrentWidget(self.widget)
self.set_theme(theme)
self.show()
self.autosize_window()
def __init__(self, name, description, parent=None):
super().__init__(parent)
self.name = name
self.description = description
text = "{}\n{}".format(name, description)
self.setText(text)
self.setIcon(load_icon("python.png"))
def setup(self, theme):
"""
Sets up the window.
Defines the various attributes of the window and defines how the user
interface is laid out.
"""
self.theme = theme
# Give the window a default icon, title and minimum size.
self.setWindowIcon(load_icon(self.icon))
self.update_title()
self.setMinimumSize(800, 600)
self.widget = QWidget()
self.splitter = QSplitter(Qt.Vertical)
widget_layout = QVBoxLayout()
self.widget.setLayout(widget_layout)
self.button_bar = ButtonBar(self.widget)
self.tabs = QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.tabs.removeTab)
widget_layout.addWidget(self.button_bar)
widget_layout.addWidget(self.splitter)
self.splitter.addWidget(self.tabs)
self.addWidget(self.widget)
self.setCurrentWidget(self.widget)
self.set_theme(theme)
self.show()
self.autosize_window()
def addAction(self, name, tool_text):
action = QAction(load_icon(name),
name.capitalize(),
self,
statusTip=tool_text)
super().addAction(action)
self.slots[name] = action
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 __init__(self, name, description, icon, parent=None):
super().__init__(parent)
self.name = name
self.description = description
self.icon = icon
text = "{}\n{}".format(name, description)
self.setText(text)
self.setIcon(load_icon(self.icon))
def play_toggle(self, event):
"""
Handles the toggling of the play button to start/stop a script.
"""
if self.runner:
self.stop_game()
play_slot = self.view.button_bar.slots['play']
play_slot.setIcon(load_icon('play'))
play_slot.setText(_('Play'))
play_slot.setToolTip(_('Play your Pygame Zero game.'))
else:
self.run_game()
if self.runner:
play_slot = self.view.button_bar.slots['play']
play_slot.setIcon(load_icon('stop'))
play_slot.setText(_('Stop'))
play_slot.setToolTip(_('Stop your Pygame Zero game.'))
def setRunIcon(self, run=True):
keyword = "run" if run else "stop"
textHead = "Run" if run else "Stop"
tooltip = textHead + "your Python script."
run_slot = self.view.button_bar.slots["run"]
run_slot.setIcon(load_icon(keyword))
run_slot.setText(_(textHead))
run_slot.setToolTip(_(tooltip))
def addAction(self, name, tool_text):
"""
Creates an action associated with an icon and name and adds it to the
widget's slots.
"""
action = QAction(load_icon(name), name.capitalize(), self,
statusTip=tool_text)
super().addAction(action)
self.slots[name] = action
def addAction(self, name, display_name, tool_text):
"""
Creates an action associated with an icon and name and adds it to the
widget's slots.
"""
action = QAction(load_icon(name), display_name, self,
toolTip=tool_text)
super().addAction(action)
self.slots[name] = action
def run_toggle(self, event):
"""
Handles the toggling of the run button to start/stop a script.
"""
if self.runner:
self.stop_script()
run_slot = self.view.button_bar.slots['run']
run_slot.setIcon(load_icon('run'))
run_slot.setText(_('Run'))
run_slot.setToolTip(_('Run your Python script.'))
self.view.button_bar.slots['debug'].setEnabled(True)
else:
self.run_script()
run_slot = self.view.button_bar.slots['run']
run_slot.setIcon(load_icon('stop'))
run_slot.setText(_('Stop'))
run_slot.setToolTip(_('Stop your Python script.'))
self.view.button_bar.slots['debug'].setEnabled(False)
def play_toggle(self, event):
"""
Handles the toggling of the play button to start/stop a script.
"""
if self.runner:
self.stop_game()
play_slot = self.view.button_bar.slots["play"]
play_slot.setIcon(load_icon("play"))
play_slot.setText(_("Play"))
play_slot.setToolTip(_("Play your Pygame Zero game."))
self.set_buttons(modes=True)
else:
self.run_game()
if self.runner:
play_slot = self.view.button_bar.slots["play"]
play_slot.setIcon(load_icon("stop"))
play_slot.setText(_("Stop"))
play_slot.setToolTip(_("Stop your Pygame Zero game."))
self.set_buttons(modes=False)
def run_toggle(self, event):
"""
Handles the toggling of the run button to start/stop a script.
"""
run_slot = self.view.button_bar.slots['run']
if self.runner:
self.stop_script()
run_slot.setIcon(load_icon('run'))
run_slot.setText(_('Run'))
run_slot.setToolTip(_('Run your Python script.'))
self.set_buttons(debug=True, modes=True)
else:
self.run_script()
if self.runner:
# If the script started, toggle the button state. See #338.
run_slot.setIcon(load_icon('stop'))
run_slot.setText(_('Stop'))
run_slot.setToolTip(_('Stop your Python script.'))
self.set_buttons(debug=False, modes=False)
def run_toggle(self, event):
"""
Handles the toggling of the run button to start/stop a script.
"""
run_slot = self.view.button_bar.slots["run"]
if self.runner:
self.stop_script()
run_slot.setIcon(load_icon("run"))
run_slot.setText(_("Run"))
run_slot.setToolTip(_("Run your Python script."))
self.set_buttons(debug=True, modes=True)
else:
self.run_script()
if self.runner:
# If the script started, toggle the button state. See #338.
run_slot.setIcon(load_icon("stop"))
run_slot.setText(_("Stop"))
run_slot.setToolTip(_("Stop your Python script."))
self.set_buttons(debug=False, modes=False)
def run_toggle(self, event):
"""
Handles the toggling of the run button to start/stop the server.
"""
if self.runner:
self.stop_server()
run_slot = self.view.button_bar.slots["run"]
run_slot.setIcon(load_icon("run"))
run_slot.setText(_("Run"))
run_slot.setToolTip(_("Run the web server."))
self.set_buttons(modes=True)
else:
self.start_server()
if self.runner:
run_slot = self.view.button_bar.slots["run"]
run_slot.setIcon(load_icon("stop"))
run_slot.setText(_("Stop"))
run_slot.setToolTip(_("Stop the web server."))
self.set_buttons(modes=False)
def addTab(self, widget, title):
"""
Add a new tab to the switcher
"""
# Proxy up to the real addTab
tab_id = super(FileTabs, self).addTab(widget, title)
# A widget to put the indicator and close button in
container = QWidget()
box = QHBoxLayout(container)
# We don't want any margins on the layout, that would expand the tab
box.setContentsMargins(0, 0, 0, 0)
# Ensure some space between image and button
box.setSpacing(6)
# Counterintuitively QImage doesn't show an image, QLabel does
state_lbl = QLabel(container)
box.addWidget(state_lbl)
state_lbl.setPixmap(load_pixmap("document.svg"))
# Watch for status change to update the dirty indicator
# We watch here as it's far easier to keep track of state_lbl
# It does mean we assume all tabs are EditorPane
@widget.modificationChanged.connect
def on_modified():
if widget.isModified():
state_lbl.setPixmap(load_pixmap("document-dirty.svg"))
else:
# This icon is actually empty
state_lbl.setPixmap(load_pixmap("document.svg"))
# Setup our own close button since we are overriding the built in one
close_btn = QPushButton(container)
box.addWidget(close_btn)
close_btn.setToolTip(_("Close file"))
close_btn.setFlat(True)
# Bit of a weird size but we want to avoid giant tabs
close_btn.setIconSize(QSize(10, 10))
close_btn.setIcon(load_icon("close-tab.svg"))
close_btn.show()
# Handle 'clicked' events
@close_btn.clicked.connect
def close():
# The tab_id isn't constant and may have changed, lookup the
# current id of the EditorPane
tab_id = self.indexOf(widget)
# Close the tab
self.removeTab(tab_id)
container.setLayout(box)
# Add the box, clearly it isn't a button but QTabBar actually takes
# any QWidget not just buttons
self.tabBar().setTabButton(tab_id, QTabBar.RightSide, container)
# Return the index of the new page just like the reall addTab
return tab_id
def addAction(self, name, tool_text):
"""
Creates an action associated with an icon and name and adds it to the
widget's slots.
"""
action = QAction(load_icon(name),
name.capitalize(),
self,
statusTip=tool_text)
super().addAction(action)
self.slots[name] = action
def set_checker_icon(self, icon):
"""
Set the status icon to use on the check button
"""
self.button_bar.slots["check"].setIcon(load_icon(icon))
timer = QTimer()
@timer.timeout.connect
def reset():
self.button_bar.slots["check"].setIcon(load_icon("check.png"))
timer.stop()
timer.start(500)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.setStyleSheet(DAY_STYLE)
self.theme = theme
new_theme = DayTheme
new_icon = 'theme'
if theme == 'night':
new_theme = NightTheme
new_icon = 'theme_day'
self.setStyleSheet(NIGHT_STYLE)
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl.set_theme(theme)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.setStyleSheet(DAY_STYLE)
self.theme = theme
new_theme = DayTheme
new_icon = 'theme'
if theme == 'night':
new_theme = NightTheme
new_icon = 'theme_day'
self.setStyleSheet(NIGHT_STYLE)
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl.set_theme(theme)
def setup(self, log, settings, packages, mode, device_list):
self.setMinimumSize(600, 400)
self.setWindowTitle(_("Mu Administration"))
widget_layout = QVBoxLayout()
self.setLayout(widget_layout)
self.tabs = QTabWidget()
widget_layout.addWidget(self.tabs)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
widget_layout.addWidget(button_box)
# Tabs
self.log_widget = LogWidget(self)
self.log_widget.setup(log)
self.tabs.addTab(self.log_widget, _("Current Log"))
if mode.short_name in ["python", "web", "pygamezero"]:
self.envar_widget = EnvironmentVariablesWidget(self)
self.envar_widget.setup(settings.get("envars", ""))
self.tabs.addTab(self.envar_widget, _("Python3 Environment"))
if mode.short_name == "microbit":
self.microbit_widget = MicrobitSettingsWidget(self)
self.microbit_widget.setup(
settings.get("minify", False),
settings.get("microbit_runtime", ""),
)
self.tabs.addTab(self.microbit_widget, _("BBC micro:bit Settings"))
if mode.short_name in ["python", "web", "pygamezero"]:
self.package_widget = PackagesWidget(self)
self.package_widget.setup(packages)
self.tabs.addTab(self.package_widget, _("Third Party Packages"))
if mode.short_name == "esp":
self.esp_widget = ESPFirmwareFlasherWidget(self)
self.esp_widget.setup(mode, device_list)
self.tabs.addTab(self.esp_widget, _("ESP Firmware flasher"))
# Configure local.
self.locale_widget = LocaleWidget(self)
self.locale_widget.setup(settings.get("locale"))
self.tabs.addTab(self.locale_widget, load_icon("language.svg"),
_("Select Language"))
self.log_widget.log_text_area.setFocus()
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.theme = theme
if theme == 'contrast':
self.setStyleSheet(CONTRAST_STYLE)
new_theme = ContrastTheme
new_icon = 'theme_day'
elif theme == 'night':
new_theme = NightTheme
new_icon = 'theme_contrast'
self.setStyleSheet(NIGHT_STYLE)
else:
self.setStyleSheet(DAY_STYLE)
new_theme = DayTheme
new_icon = 'theme'
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl_pane.set_theme(theme)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.theme = theme
self.load_theme.emit(theme)
if theme == 'contrast':
new_theme = ContrastTheme
new_icon = 'theme_day'
elif theme == 'night':
new_theme = NightTheme
new_icon = 'theme_contrast'
else:
new_theme = DayTheme
new_icon = 'theme'
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl_pane.set_theme(theme)
if hasattr(self, 'plotter') and self.plotter:
self.plotter_pane.set_theme(theme)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.theme = theme
self.load_theme.emit(theme)
if theme == 'contrast':
new_theme = ContrastTheme
new_icon = 'theme_day'
elif theme == 'night':
new_theme = NightTheme
new_icon = 'theme_contrast'
else:
new_theme = DayTheme
new_icon = 'theme'
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl_pane.set_theme(theme)
if hasattr(self, 'plotter') and self.plotter:
self.plotter_pane.set_theme(theme)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.theme = theme
self.load_theme.emit(theme)
if theme == "contrast":
new_theme = ContrastTheme
new_icon = "theme_day"
elif theme == "night":
new_theme = NightTheme
new_icon = "theme_contrast"
else:
new_theme = DayTheme
new_icon = "theme"
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots["theme"].setIcon(load_icon(new_icon))
if hasattr(self, "repl") and self.repl:
self.repl_pane.set_theme(theme)
if hasattr(self, "plotter") and self.plotter:
self.plotter_pane.set_theme(theme)
def set_theme(self, theme):
"""
Sets the theme for the REPL and editor tabs.
"""
self.theme = theme
if theme == 'contrast':
self.setStyleSheet(CONTRAST_STYLE)
new_theme = ContrastTheme
new_icon = 'theme_day'
elif theme == 'night':
new_theme = NightTheme
new_icon = 'theme_contrast'
self.setStyleSheet(NIGHT_STYLE)
else:
self.setStyleSheet(DAY_STYLE)
new_theme = DayTheme
new_icon = 'theme'
for widget in self.widgets:
widget.set_theme(new_theme)
self.button_bar.slots['theme'].setIcon(load_icon(new_icon))
if hasattr(self, 'repl') and self.repl:
self.repl_pane.set_theme(theme)
if hasattr(self, 'plotter') and self.plotter:
self.plotter_pane.set_theme(theme)
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 configure(self):
"""Set up the buttons"""
self.setMovable(False)
self.setIconSize(QSize(64, 64))
self.setToolButtonStyle(3)
self.setContextMenuPolicy(Qt.PreventContextMenu)
self.setObjectName("StandardToolBar")
# Create actions to be added to the button bar.
self.new_script_act = QAction(
load_icon("new"),
"New", self,
statusTip="Create a new MicroPython script.",
triggered=self.editor.new)
self.load_python_file_act = QAction(
load_icon("load"),
"Load", self,
statusTip="Load a MicroPython script.",
triggered=self.editor.load)
self.save_python_file_act = QAction(
load_icon("save"),
"Save", self,
statusTip="Save the current MicroPython script.",
triggered=self.editor.save)
self.snippets_act = QAction(
load_icon("snippets"),
"Snippets", self,
statusTip="Use code snippets to help you program.",
triggered=self.editor.snippets)
self.flash_act = QAction(
load_icon("flash"),
"Flash", self,
statusTip="Flash your MicroPython script onto the micro:bit.",
triggered=self.editor.flash)
self.repl_act = QAction(
load_icon("repl"),
"REPL", self,
statusTip="Connect to the MicroPython REPL for live coding of the micro:bit.",
triggered=self.editor.repl)
self.zoom_in_act = QAction(
load_icon("zoom-in"),
"Zoom In", self,
statusTip="Zoom in (to make the text bigger).",
triggered=self.editor.zoom_in)
self.zoom_out_act = QAction(
load_icon("zoom-out"),
"Zoom Out", self,
statusTip="Zoom out (to make the text smaller).",
triggered=self.editor.zoom_out)
self.quit_act = QAction(
load_icon("quit"),
"Quit", self,
statusTip="Quit the application.",
triggered=self.editor.quit)
# Add the actions to the button bar.
self.addAction(self.new_script_act)
self.addAction(self.load_python_file_act)
self.addAction(self.save_python_file_act)
self.addSeparator()
self.addAction(self.snippets_act)
self.addAction(self.flash_act)
self.addAction(self.repl_act)
self.addSeparator()
self.addAction(self.zoom_in_act)
self.addAction(self.zoom_out_act)
self.addSeparator()
self.addAction(self.quit_act)
def reset():
self.button_bar.slots['check'].setIcon(load_icon('check.png'))
timer.stop()
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_())
def configure(self):
"""Set up the buttons"""
self.setMovable(False)
self.setIconSize(QSize(64, 64))
self.setToolButtonStyle(3)
self.setContextMenuPolicy(Qt.PreventContextMenu)
self.setObjectName("StandardToolBar")
# Create actions to be added to the button bar.
self.new_script_act = QAction(
load_icon("new"),
"New", self,
statusTip="Create a new MicroPython script.",
triggered=self.editor.new)
self.load_python_file_act = QAction(
load_icon("load"),
"Load", self,
statusTip="Load a MicroPython script.",
triggered=self.editor.load)
self.save_python_file_act = QAction(
load_icon("save"),
"Save", self,
statusTip="Save the current MicroPython script.",
triggered=self.editor.save)
self.snippets_act = QAction(
load_icon("snippets"),
"Snippets", self,
statusTip="Use code snippets to help you program.",
triggered=self.editor.snippets)
self.flash_act = QAction(
load_icon("flash"),
"Flash", self,
statusTip="Flash your MicroPython script onto the micro:bit.",
triggered=self.editor.flash)
self.repl_act = QAction(
load_icon("repl"),
"REPL", self,
statusTip="Connect to the MicroPython REPL for live coding of the micro:bit.",
triggered=self.editor.repl)
#self.run_python_file_act = QAction(
# load_icon("run"),
# "Run", self,
# statusTip="Run your Python file",
# triggered=self.editor.project.run)
# self.build_python_file_act = QAction(
# load_icon("build"),
# "Build", self,
# statusTip="Build Python into Hex file",
# triggered=self._build_python_file)
"""
self.zoom_in_act = QAction(
load_icon("zoom-in"),
"Zoom in", self,
statusTip="Make the text bigger",
triggered=self.editor.zoom_in)
self.zoom_out_act = QAction(
load_icon("zoom-out"),
"Zoom out", self,
statusTip="Make the text smaller",
triggered=self.editor.zoom_out)
"""
# Add the actions to the button bar.
self.addAction(self.new_script_act)
self.addAction(self.load_python_file_act)
self.addAction(self.save_python_file_act)
self.addAction(self.snippets_act)
self.addAction(self.flash_act)
self.addAction(self.repl_act)
#self.addAction(self.run_python_file_act)
# self.addAction(self.build_python_file_act)
"""
def reset():
self.button_bar.slots["check"].setIcon(load_icon("check.png"))
timer.stop()
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 addAction(self, name, tool_text):
action = QAction(load_icon(name), name.capitalize(), self,
statusTip=tool_text)
super().addAction(action)
self.slots[name] = action