def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
tk.Tk.wm_title(self, "Materials Lab Simulation Tool")
container = tk.Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
# Initialize Mechanical workshop page
self.Page1 = MechanicalWorkshopController(container, self)
self.Page1.page1.grid(row=0, column=0, sticky="nsew")
self.Page1.page2.grid(row=0, column=0, sticky="nsew")
# Initialize thermocouple page
self.Page2 = ThermocoupleController(container, self)
self.Page2.page1.grid(row=0, column=0, sticky="nsew")
# Initialize main view
self.HomePage = MainView(container, self)
self.HomePage.grid(row=0, column=0, sticky="nsew")
# Bind buttons to show_frame
self.HomePage.pages[0].configure(command=lambda: self.show_frame(0))
self.HomePage.pages[1].configure(command=lambda: self.show_frame(1))
self.HomePage.tkraise()
class App(QtWidgets.QApplication):
def __init__(self, sys_argv):
super(App, self).__init__(sys_argv)
self.model = Model()
self.main_ctrl = MainController(self.model)
self.main_view = MainView(self.model, self.main_ctrl)
self.main_view.show()
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.geometry('768x612')
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
if language is not None:
set_translator_locale(language)
self.root = Tk()
StudentRunner.TK_ROOT = self.root
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.geometry('768x612')
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
# message box to accept tracing or not on first launch by this user
if tracing.user_first_session():
user_enabled_tracing = tkMessageBox.askyesno(
title="Suivi pédagogique",
message=
"Acceptez-vous que des traces de vos actions dans MrPython " +
"soient collectées par le LIP6 ?\n" +
"Ces traces seront anonymisées et uniquement utilisées dans un but d'amélioration pédagogique "
+ "de MrPython.",
default=tkMessageBox.YES,
parent=self.root)
else:
user_enabled_tracing = tracing.check_tracing_is_enabled()
tracing.initialize_tracing(user_enabled_tracing)
self.icon_widget.switch_icon_tracing(user_enabled_tracing)
self.root.after(1000, self.check_user_state)
self.root.after(5000, self.update_active_timestamp)
self.state = "idle" # 3 states: idle, interacting or typing
def __init__(self):
gtk.Window.__init__(self)
self.set_default_size(1024, 768)
self.connect('destroy', self.on_destroy)
self.set_title('TASE')
self.set_border_width(8)
self.db = MySQLdb.connect(host=dbconn.DB_HOST, user=dbconn.DB_USERNAME, passwd=dbconn.DB_PASSWORD, db=dbconn.DB_SCHEMA)
self.main_view = MainView(self.select_symbol)
self.add(self.main_view)
self.main_view.show()
class TaseBrowser(gtk.Window):
def __init__(self):
gtk.Window.__init__(self)
self.set_default_size(1024, 768)
self.connect('destroy', self.on_destroy)
self.set_title('TASE')
self.set_border_width(8)
self.db = MySQLdb.connect(host=dbconn.DB_HOST, user=dbconn.DB_USERNAME, passwd=dbconn.DB_PASSWORD, db=dbconn.DB_SCHEMA)
self.main_view = MainView(self.select_symbol)
self.add(self.main_view)
self.main_view.show()
def select_symbol(self, treeview):
self.main_view.clear()
path = treeview.get_cursor()
if path == None:
return
selection = treeview.get_selection()
(model, pathlist) = selection.get_selected_rows()
iters = [model.get_iter(path) for path in pathlist]
for treeiter in iters:
type = model.get_value(treeiter, CompanyView.col_type)
symbol = model.get_value(treeiter, CompanyView.col_sector)
date = model.get_value(treeiter, CompanyView.col_buy_date)
if type == "Portfolio":
self.main_view.load(symbol, date)
else:
self.main_view.load(symbol)
def on_destroy(self, widget):
gtk.main_quit()
def __init__(self):
supported_image_formats = ('.png', '.jpg', '.jpeg', '.bmp', '.gif')
start_scan_callback = lambda scan_directories: self._start_scan_click_callback(
scan_directories)
delete_image_callback = lambda path_to_delete: self._delete_file(
path_to_delete)
delete_all_duplicates = lambda duplicates: self._delete_all_duplicated_keep_newest(
duplicates)
self._main_view = MainView(start_scan_callback, delete_image_callback,
delete_all_duplicates)
self._imageManager = DuplicateImagesManager(supported_image_formats)
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
def setUp(self):
view = MainView('')
controller = ControllerMain(view)
self.args = {
'parameter': 'dlink_backup',
'ip_range': '172.1.2.80,172.1.2.82',
'ip_dst_for_backup': '10.6.224.3',
'path_work_directory': '/Users/toxa/PycharmProjects/dlink_utility/'
}
self.operations_with_ports = OperationsWithPorts(controller)
def __init__(self):
self.root=Tk()
self.root.title("MrPython")
self.main_view=MainView(self.root)
self.pyEditorList=self.main_view.pyEditorList
self.pyShell=self.main_view.pyShell
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW',self.close_all_event)
def test_backup(self, mock_write_to_log_file,
mock_controller_authorisation, mock_model_get_dlink_model,
mock_network_receive_data_until, mock_network_send_data):
argv = ('/Users/toxa/PycharmProjects/dlink_utility/', 'dlink_backup',
'172.1.2.80,172.1.2.81', '10.6.224.1')
mock_write_to_log_file.return_value = True
mock_controller_authorisation.return_value = True
mock_model_get_dlink_model.return_value = 'DGS-3200'
mock_network_receive_data_until.return_value = b'success'
mock_network_send_data.return_value = 'success'
view = MainView(argv)
self.assertTrue(view)
def __init__(self, settingsManager: ConfigurationManager,
zeroPointManager: ZeroPointManager):
self._settingsManager = settingsManager
self._zeroPointManager = zeroPointManager
self._stopTurnTableEvent = Event()
self._jobThreads = ControllerThreads()
self._position = Position()
def connectionFactory(port: int, name: str) -> LANConnection:
return LANConnection(self._settingsManager.turnTableIPAddress,
port,
name=name,
timeout=self._settingsManager.timeout)
callbacks = TCPCallbacks(
getAzimuth=self.getCurrentPosition,
getElevation=self.getCurrentPosition,
setAzimuth=self.createGotoPositionJob,
setElevation=self.createGotoPositionJob,
stop=self.stop,
)
self._tcpServer = TCPServer(callbacks=callbacks,
settingsManager=self._settingsManager)
self._shaftEncoder = ShaftEncoderModel(connectionFactory(
self._settingsManager.shaftEncoderPort,
"Shaft Encoder Connection"),
settingsManager=settingsManager)
self._motorController = MotorControllerModel(
watchdogConnection=connectionFactory(
self._settingsManager.watchdogPort, "Watchdog Connection"),
motorControllerConnection=connectionFactory(
self._settingsManager.motorControllerPort,
"Motor Controller Connection"),
settingsManager=settingsManager,
)
self._mainView = MainView()
self._settingsManagerView = SettingsView(self._settingsManager)
self.showMainView()
def test_mac_on_ports(self, mock_write_to_log_file,
mock_controller_authorisation,
mock_model_get_dlink_model,
mock_network_receive_data_until,
mock_network_send_data, mock_file_settings_exists):
argv = ('/Users/toxa/PycharmProjects/dlink_utility/', 'mac_on_port',
'172.1.2.80,172.1.2.81', '1-2')
mock_write_to_log_file.return_value = True
mock_controller_authorisation.return_value = True
mock_model_get_dlink_model.return_value = 'DGS-1210-10P/ME'
mock_network_receive_data_until.return_value = b'kjhkjhskdf00-C0-34-DA-00-00'
mock_network_send_data.return_value = 'success'
mock_file_settings_exists.return_value = True
# mock_get_mac_on_ports.return_value = {'192.168.1.2': {2:['00-11-22-df-ab-ac', '00-11-22-df-ab-ac'],
# 3: ['00-11-22-df-ab-ac']},
# '192.168.1.3': {4: ['00-11-22-df-ab-ac']}}
view = MainView(argv)
self.assertTrue(view)
class Application:
def __init__(self):
self.root=Tk()
self.root.title("MrPython")
self.main_view=MainView(self.root)
self.pyEditorList=self.main_view.pyEditorList
self.pyShell=self.main_view.pyShell
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW',self.close_all_event)
def run(self):
self.main_view.show()
def apply_bindings(self, keydefs=None):
#bindings event
#file
self.root.bind("<<open-new-window>>", self.newfile)
self.root.bind('<<open-window-from-file>>',self.open)
self.root.bind('<<save-window>>',self.pyEditorList.save)
self.root.bind('<<save-window-as-file>>',self.pyEditorList.save_as)
self.root.bind('<<save-copy-of-window-as-file>>',self.pyEditorList.save_as_copy)
self.root.bind('<<close-window>>',self.pyEditorList.close_current_editor)
self.root.bind('<<close-all-windows>>',self.close_all_event)
#edit
self.root.bind('<<undo>>',self.pyEditorList.undo_event)
self.root.bind('<<redo>>',self.pyEditorList.redo_event)
self.root.bind('<<cut>>',self.pyEditorList.cut_event)
self.root.bind('<<copy>>',self.pyEditorList.copy_event)
self.root.bind('<<paste>>',self.pyEditorList.paste_event)
self.root.bind('<<select-all>>',self.pyEditorList.select_all_event)
self.root.bind('<<find>>',self.pyEditorList.find_event)
self.root.bind('<<find-again>>',self.pyEditorList.find_again_event)
self.root.bind('<<find-selection>>',self.pyEditorList.find_selection_event)
self.root.bind('<<find-in-files>>',self.pyEditorList.find_in_files_event)
self.root.bind('<<replace>>',self.pyEditorList.replace_event)
self.root.bind('<<goto-line>>',self.pyEditorList.goto_line_event)
# #format
self.root.bind('<<indent-region>>',self.pyEditorList.indent_region_event)
self.root.bind('<<dedent-region>>',self.pyEditorList.dedent_region_event)
self.root.bind('<<comment-region>>',self.pyEditorList.comment_region_event)
self.root.bind('<<uncomment-region>>',self.pyEditorList.uncomment_region_event)
self.root.bind('<<tabify-region>>',self.pyEditorList.tabify_region_event)
self.root.bind('<<untabify-region>>',self.pyEditorList.untabify_region_event)
self.root.bind('<<toggle-tabs>>',self.pyEditorList.toggle_tabs_event)
# #run
self.root.bind('<<check-module>>',self.check_module)
self.root.bind('<<run-module>>',self.run_module)
self.root.bind('<Control-Key-Return>',self.run_source)
# #debug
self.root.bind('<<goto-file-line>>',self.pyEditorList.goto_line_event)
#bindings keys
if keydefs is None:
keydefs=Bindings.default_keydefs
for event, keylist in keydefs.items():
if keylist:
self.root.event_add(event, *keylist)
def newfile(self,event=None):
fileEditor=PyEditor(self.main_view.pyEditorList)
self.pyEditorList.add(fileEditor,text=fileEditor.get_file_name())
def open(self, event=None):
fileEditor=PyEditor(self.main_view.pyEditorList,open=True)
if(self.pyEditorList.focusOn(fileEditor.long_title())==False):
if(fileEditor.isOpen()):
self.pyEditorList.add(fileEditor,text=fileEditor.get_file_name())
def close_all_event(self,event=None):
while self.pyEditorList.get_size()>0 :
reply = self.pyEditorList.close_current_editor()
if reply == "cancel":
break;
if self.pyEditorList.get_size()==0:
sys.exit(0)
def run_module(self,event=None):
reply=self.pyEditorList.get_current_editor().maybesave_run()
if(reply!="cancel"):
filename=self.pyEditorList.get_current_editor().long_title()
self.pyShell.run(filename)
def check_module(self,event=None):
reply=self.pyEditorList.get_current_editor().maybesave_run()
if(reply!="cancel"):
self.pyShell.check(self.pyEditorList.get_current_editor())
def run_source(self,event=None):
filename=self.pyEditorList.get_current_editor().long_title()
self.pyShell.runit(filename)
from PyQt5.QtWidgets import QApplication
from OmxPlayer import OmxPlayer
import sys
from MainView import MainView
if __name__ == '__main__':
app = QApplication(sys.argv)
omx_player = OmxPlayer()
view = MainView(app)
omx_player.set_observer(view)
sys.exit(app.exec_())
class TurnTableController:
def __init__(self, settingsManager: ConfigurationManager,
zeroPointManager: ZeroPointManager):
self._settingsManager = settingsManager
self._zeroPointManager = zeroPointManager
self._stopTurnTableEvent = Event()
self._jobThreads = ControllerThreads()
self._position = Position()
def connectionFactory(port: int, name: str) -> LANConnection:
return LANConnection(self._settingsManager.turnTableIPAddress,
port,
name=name,
timeout=self._settingsManager.timeout)
callbacks = TCPCallbacks(
getAzimuth=self.getCurrentPosition,
getElevation=self.getCurrentPosition,
setAzimuth=self.createGotoPositionJob,
setElevation=self.createGotoPositionJob,
stop=self.stop,
)
self._tcpServer = TCPServer(callbacks=callbacks,
settingsManager=self._settingsManager)
self._shaftEncoder = ShaftEncoderModel(connectionFactory(
self._settingsManager.shaftEncoderPort,
"Shaft Encoder Connection"),
settingsManager=settingsManager)
self._motorController = MotorControllerModel(
watchdogConnection=connectionFactory(
self._settingsManager.watchdogPort, "Watchdog Connection"),
motorControllerConnection=connectionFactory(
self._settingsManager.motorControllerPort,
"Motor Controller Connection"),
settingsManager=settingsManager,
)
self._mainView = MainView()
self._settingsManagerView = SettingsView(self._settingsManager)
self.showMainView()
def showMainView(self):
self._mainView.stepSizeSpinBox.setRange(
self._settingsManager.minimumStepSize,
self._settingsManager.maximumStepSize)
self._mainView.gotoPositionSpinBox.setRange(
self._settingsManager.minimumGotoPosition,
self._settingsManager.maximumGotoPosition)
self._mainView.motorVoltageSliderValueSpinBox.setRange(
self._settingsManager.minimumVoltage,
self._settingsManager.maximumVoltage)
self._mainView.motorVoltageSlider.setRange(
self._settingsManager.minimumVoltage,
self._settingsManager.maximumVoltage)
self._mainView.applicationSettingsAction.triggered.connect(
self._settingsManagerView.show)
self._mainView.loadZeroPositionDataAction.triggered.connect(
self.loadZeroPosition)
self._mainView.saveZeroPositionDataAction.triggered.connect(
self.saveZeroPosition)
self._mainView.connectButton.clicked.connect(self.connect)
self._mainView.disconnectButton.clicked.connect(self.disconnect)
self._mainView.goPushButton.clicked.connect(self.createGotoPositionJob)
self._mainView.motorVoltageSlider.doubleValueChanged.connect(
self.setMotorVoltage)
self._mainView.resetVoltageButton.clicked.connect(
self.resetMotorVoltage)
self._mainView.stopPushButton.clicked.connect(self.stopMotion)
self._mainView.stepPushButton.clicked.connect(self.stepPosition)
self._mainView.resetZeroPositionButton.clicked.connect(
self.resetPositionOffest)
self._mainView.setCurrentPositionAsZeroButton.clicked.connect(
self.setPositionOffset)
self._mainView.applicationClosed.connect(self.stop)
self._mainView.motorVoltageSlider.setValue(0.000)
self._mainView.show()
#------------------------------------------------------------------------------
# Starting and Stopping Methods
#------------------------------------------------------------------------------
def start(self):
self._jobThreads.updateGUI = TimedJobThread(
self._settingsManager.GUIUpdatePeriod, self.updateGUI)
self._jobThreads.updateGUI.start()
def stop(self):
logging.debug("Stopping Turn Table Controller")
self.stopMotion()
self.disconnect()
logging.debug("Turn Table Controller Stopped...")
def stopMotion(self):
if self._jobThreads.gotoPosition is not None:
self._stopTurnTableEvent.set()
self._jobThreads.gotoPosition = None
if self._motorController.getCurrentVoltage() != 0.000:
self.resetMotorVoltage()
#------------------------------------------------------------------------------
# Connection Handling Methods
#------------------------------------------------------------------------------
def connect(self):
self._motorController.start()
self._shaftEncoder.start()
self._tcpServer.connect()
if self._motorController.isWatchdogConnected(
) and self._motorController.isMotorControllerConnected(
) and self._shaftEncoder.isConnected() and self._tcpServer.isConnected(
):
self._mainView.toggleControls()
def disconnect(self):
self._motorController.stop()
self._shaftEncoder.stop()
self._tcpServer.disconnect()
if self._motorController.isWatchdogConnected(
) and self._motorController.isMotorControllerConnected(
) and self._shaftEncoder.isConnected() and self._tcpServer.isConnected(
):
self._mainView.toggleControls()
#------------------------------------------------------------------------------
# Position Helper Methods
#------------------------------------------------------------------------------
def setPositionOffset(self):
self._position.offset = -self._shaftEncoder.currentPosition
def resetPositionOffest(self):
self._position.offset = 0.000
def getCurrentPosition(self) -> float:
self._position.current = self._shaftEncoder.currentPosition
return self._position.current
#------------------------------------------------------------------------------
# GUI Update Helper Methods
#------------------------------------------------------------------------------
def updateGUI(self):
shaftEncoderConnectionStatus = self._shaftEncoder.isConnected()
motorControllerConnectionStatus = self._motorController.isMotorControllerConnected(
)
watchdogConnectionStatus = self._motorController.isWatchdogConnected()
tcpServerConnectionStatus = self._tcpServer.isConnected()
self._mainView.updateConnectionStatusLineEdits(
shaftEncoderConnectionStatus, motorControllerConnectionStatus,
watchdogConnectionStatus, tcpServerConnectionStatus)
self._mainView.updatePositionLineEdits(self._position)
#------------------------------------------------------------------------------
# Motor Control Methods
#------------------------------------------------------------------------------
def setMotorVoltage(self, newVoltage: float):
if (not self._motorController.isEnabled()) and (newVoltage != 0.000):
self._motorController.toggleEnable()
self._motorController.setVoltage(newVoltage=newVoltage)
def resetMotorVoltage(self):
if self._motorController.isEnabled():
self._motorController.toggleEnable()
self._motorController.setVoltage(0.000)
def createGotoPositionJob(self, targetPosition: float):
self._jobThreads.gotoPosition = Thread(target=self.gotoPosition,
args=(targetPosition, ))
self._jobThreads.gotoPosition.start()
def stepPosition(self, step: float):
currentPosition = self.getCurrentPosition()
self.createGotoPositionJob(currentPosition + step)
def gotoPosition(self, targetPosition: float):
maxVoltage = self._settingsManager.maximumVoltage
updatePeriod = self._settingsManager.voltageUpdatePeriod
KP = self._settingsManager.controlProportionalGain
KI = self._settingsManager.controlIntegralGain
KD = self._settingsManager.controlDerivativeGain
minimumControlSignalValue = self._settingsManager.minimumControlSignalValue
maximumAllowedError = self._settingsManager.maximumAllowedError
self._position.target = targetPosition
if not self._motorController.isEnabled():
self._motorController.toggleEnable()
previousError = 0
if self._stopTurnTableEvent.is_set():
self._stopTurnTableEvent.clear()
while True:
error = self._position.error
if (abs(error) < maximumAllowedError) or (
self._stopTurnTableEvent.is_set()):
self._motorController.setVoltage(0.000)
self._motorController.toggleEnable()
break
errorDelta = error - previousError
previousError = error
voltageControlSignal = (KP * error + KI * error * updatePeriod +
KD * errorDelta / updatePeriod)
voltageControlSignal = sorted(
(-maxVoltage, voltageControlSignal, maxVoltage))[1]
voltageControlSignal = math.copysign(
max(abs(voltageControlSignal), minimumControlSignalValue),
voltageControlSignal)
self._motorController.setVoltage(voltageControlSignal)
time.sleep(updatePeriod)
def saveZeroPosition(self):
saveZeroPoint = SaveZeroPoint(self._position.offset,
self._zeroPointManager)
saveZeroPoint.exec_()
def loadZeroPosition(self):
loadZeroPoint = LoadZeroPointView(self._zeroPointManager)
loadZeroPoint.exec_()
self._position.offset = self._zeroPointManager.getOffset()
from MainView import MainView
if __name__ == "__main__":
app = MainView()
app.mainloop()
def __init__(self):
self.__master = MainView()
self.select['menu'].delete(0, 'end')
for port in self.ports:
self.select['menu'].add_command(label=port,
command=tk._setit(
self.selectedPort, port))
def connect(self):
self.connection.close()
if self.selectedPort.get() != 'No hay puertos':
self.connection.baudrate = BAUDRATE
self.connection.port = self.selectedPort.get()
self.connection.open()
self.onPortChanged(self.connection)
def disconnect(self):
self.connection.close()
if __name__ == '__main__':
window = tk.Tk()
window.wm_title('Control DataLogger')
window.configure(background='#E8E9E8')
selector = SerialSelector()
device = DevControl(selector.connection)
mainView = MainView(window, device)
selector.onPortChanged.append(device.setConnection)
device.daemon = True
device.start()
window.mainloop()
class Application:
"""
The main class of the application
- root is the starting point of the GUI application
- main_view defines the main window
- py_editor_list defines the editor interface (from the main_view)
- py_shell defines the shell interface (white and orange widgets)
"""
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.geometry('768x612')
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
if tracing.user_first_session():
user_enabled_tracing = tkMessageBox.askyesno(
title="Suivi pédagogique",
message=
"Acceptez-vous que des traces de vos actions dans MrPython " +
"soient collectées par le LIP6 ?\n" +
"Ces traces seront anonymisées et uniquement utilisées dans un but d'amélioration pédagogique "
+ "de MrPython.",
default=tkMessageBox.YES,
parent=self.root)
else:
user_enabled_tracing = tracing.check_tracing_is_enabled()
tracing.initialize_tracing(user_enabled_tracing)
self.icon_widget.switch_icon_tracing(user_enabled_tracing)
self.root.after(1000, self.check_user_state)
self.root.after(5000, self.update_active_timestamp)
self.state = "idle" # 3 states: idle, interacting or typing
def run(self):
""" Run the application """
self.main_view.show()
def apply_bindings(self, keydefs=None):
""" Bind the actions to the related event methods """
self.new_file_button = self.icon_widget.icons['new_file'].wdgt
self.run_button = self.icon_widget.icons['run'].wdgt
self.save_button = self.icon_widget.icons['save'].wdgt
self.open_button = self.icon_widget.icons['open'].wdgt
self.mode_button = self.icon_widget.icons['mode'].wdgt
self.tracing_button = self.icon_widget.icons['tracing'].wdgt
self.new_file_button.bind("<1>", self.new_file)
self.run_button.bind("<1>", self.run_module)
self.mode_button.bind("<1>", self.change_mode)
self.save_button.bind("<1>", self.save)
self.save_button.bind("<3>", self.editor_list.save_as)
self.open_button.bind("<1>", self.open)
self.tracing_button.bind("<1>", self.enable_disable_tracing)
# File
self.root.bind("<Control-n>", self.new_file)
self.root.bind('<Control-o>', self.open)
self.root.bind('<Control-s>', self.save)
self.root.bind('<Control-S>', self.editor_list.save_as)
self.root.bind("<Control-m>", self.change_mode)
self.root.bind('<<save-window-as-file>>', self.editor_list.save_as)
self.root.bind('<<save-copy-of-window-as-file>>',
self.editor_list.save_as_copy)
self.root.bind('<Control-w>', self.editor_list.close_current_editor)
self.root.bind('<<close-all-windows>>', self.close_all_event)
# Edit
self.root.bind('<<undo>>', self.editor_list.undo_event)
self.root.bind('<<redo>>', self.editor_list.redo_event)
self.root.bind('<<cut>>', self.editor_list.cut_event)
self.root.bind('<<copy>>', self.editor_list.copy_event)
self.root.bind('<<paste>>', self.editor_list.paste_event)
self.root.bind('<<select-all>>', self.editor_list.select_all_event)
self.root.bind('<<find>>', self.editor_list.find_event)
self.root.bind('<<find-again>>', self.editor_list.find_again_event)
self.root.bind('<<find-selection>>',
self.editor_list.find_selection_event)
self.root.bind('<<find-in-files>>',
self.editor_list.find_in_files_event)
self.root.bind('<<replace>>', self.editor_list.replace_event)
self.root.bind('<<goto-line>>', self.editor_list.goto_line_event)
# Format
self.root.bind('<Control-i>', self.editor_list.indent_region_event)
self.root.bind('<Control-d>', self.editor_list.dedent_region_event)
self.root.bind('<<comment-region>>',
self.editor_list.comment_region_event)
self.root.bind('<<uncomment-region>>',
self.editor_list.uncomment_region_event)
self.root.bind('<<tabify-region>>',
self.editor_list.tabify_region_event)
self.root.bind('<<untabify-region>>',
self.editor_list.untabify_region_event)
self.root.bind('<<toggle-tabs>>', self.editor_list.toggle_tabs_event)
self.root.bind('<Control-plus>',
self.editor_list.increase_font_size_event)
self.root.bind('<Control-minus>',
self.editor_list.decrease_font_size_event)
# Code execution
self.root.bind('<<check-module>>', self.check_module)
self.root.bind('<Control-r>', self.run_module)
self.root.bind('<Control-Key-Return>', self.run_source)
# File change in notebook
self.root.bind('<<NotebookTabChanged>>', self.update_title)
# Bind the keys
if keydefs is None:
keydefs = Bindings.default_keydefs
for event, keylist in keydefs.items():
if keylist:
self.root.event_add(event, *keylist)
def check_user_state(self):
"""
Send a statement of the state of the user. User has 3 state: idle, interacting or typing
"""
last_typing_time, last_interacting_time = tracing.get_action_timestamps(
)
elapsed_typing_time = time.time(
) - last_typing_time if last_typing_time else None
elapsed_interacting_time = time.time(
) - last_interacting_time if last_interacting_time else None
inactivity_threshhold = 30
new_state = ""
if elapsed_typing_time is not None and elapsed_interacting_time is not None:
if self.state == "idle":
if elapsed_typing_time < inactivity_threshhold:
new_state = "typing"
elif elapsed_interacting_time < inactivity_threshhold:
new_state = "interacting"
elif self.state == "interacting":
if elapsed_typing_time < inactivity_threshhold:
new_state = "typing"
elif elapsed_interacting_time > inactivity_threshhold:
new_state = "idle"
elif self.state == "typing" and elapsed_typing_time > inactivity_threshhold:
if elapsed_interacting_time < 30:
new_state = "interacting"
elif elapsed_typing_time is not None:
if self.state == "idle" and elapsed_typing_time < inactivity_threshhold:
new_state = "typing"
elif self.state == "typing" and elapsed_typing_time > inactivity_threshhold:
new_state = "idle"
elif elapsed_interacting_time is not None:
if self.state == "idle" and elapsed_interacting_time < inactivity_threshhold:
new_state = "interacting"
elif self.state == "interacting" and elapsed_interacting_time > inactivity_threshhold:
new_state = "idle"
if new_state:
tracing.send_statement("entered", new_state + "-state")
self.state = new_state
self.root.after(1000, self.check_user_state)
def update_active_timestamp(self):
tracing.update_active_timestamp()
self.root.after(5000, self.update_active_timestamp)
def update_title(self, event=None):
""" Give the title the current filename """
#print("editor list: ", self.editor_list.index("current"))
try:
new_title = self.editor_list.tab(self.editor_list.index("current"),
"text")
except:
new_title = "MrPython"
self.root.title(new_title)
return
directory = ""
if self.editor_list.get_current_editor().io.filename:
directory = self.editor_list.get_current_editor().io.filename
if directory != "":
new_title += " (" + directory + ")"
new_title += " - MrPython"
self.root.title(new_title)
#def maybe_save_run(self, event=None):
def save(self, event=None):
""" Save the current file (and display it in the status bar) """
filename = self.editor_list.save()
if filename:
self.status_bar.update_save_label(filename)
self.update_title()
def change_mode(self, event=None):
""" Swap the python mode : full python or student """
if self.mode == "student":
self.mode = "full"
else:
self.mode = "student"
self.icon_widget.switch_icon_mode(self.mode)
self.console.change_mode(tr(self.mode))
self.status_bar.change_mode(tr(self.mode))
if event:
tracing.user_is_interacting()
tracing.send_statement(
"switched", "mode", {
"https://www.lip6.fr/mocah/invalidURI/extensions/mode":
tr(self.mode)
})
def new_file(self, event=None):
""" Creates a new empty editor and put it into the pyEditorList """
tracing.user_is_interacting()
file_editor = PyEditorFrame(self.editor_list)
self.editor_list.add(file_editor,
self.main_view.editor_widget,
text=file_editor.get_file_name())
tracing.send_statement("created", "file")
def open(self, event=None):
""" Open a file in the text editor """
tracing.user_is_interacting()
file_editor = PyEditorFrame(self.editor_list, open=True)
if (self.editor_list.focusOn(file_editor.long_title()) == False):
if (file_editor.isOpen()):
self.editor_list.add(file_editor,
self.main_view.editor_widget,
text=file_editor.get_file_name())
extensions = {
"https://www.lip6.fr/mocah/invalidURI/extensions/filename":
file_editor.get_file_name()
}
with open(file_editor.long_title(), "r") as source:
text = source.read()
extensions[
"https://www.lip6.fr/mocah/invalidURI/extensions/text"] = text
extensions[
"https://www.lip6.fr/mocah/invalidURI/extensions/filelength"] = len(
text)
tracing.send_statement("opened", "file", extensions)
#not clean, io should be handled here and should not require creation of PyEditor widget
else:
file_editor.destroy()
def enable_disable_tracing(self, event=None):
""" Enable/Disable tracing"""
tracing.user_is_interacting()
tracing_enabled = tracing.switch_tracing_enabled_disabled()
if tracing_enabled:
msg = "Le suivi a été activé\n"
else:
msg = "Le suivi a été désactivé\n"
self.console.write(msg, tags=('error'))
self.icon_widget.switch_icon_tracing(tracing_enabled)
def close_all_event(self, event=None):
""" Quit all the PyEditor : called when exiting application """
print("MrPython says 'bye bye!' ...")
while self.editor_list.get_size() > 0:
reply = self.editor_list.close_current_editor()
if reply == "cancel":
break
if self.editor_list.get_size() == 0:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive(
):
self.running_interpreter_proxy.process.terminate()
self.running_interpreter_proxy.process.join()
tracing.send_statement_close_app()
sys.exit(0)
def run_module(self, event=None):
""" Run the code : give the file name and code will be run from the source file """
tracing.user_is_interacting()
# already running
if self.running_interpreter_callback:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive(
):
report = RunReport()
report.set_header("\n====== STOP ======\n")
report.add_execution_error('error',
tr('User interruption'),
class_name='UserTerminatedError')
report.set_footer("\n==================\n")
self.running_interpreter_callback(False, report)
self.running_interpreter_callback = None
return
# not (yet) running
if self.editor_list.get_size() == 0:
self.main_view.console.no_file_to_run_message()
return
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
self.editor_list.get_current_editor().send_update_changed_line(
force_sending=True)
tracing.send_statement(
"started", "execution", {
"https://www.lip6.fr/mocah/invalidURI/extensions/mode":
tr(self.mode)
})
tracing.save_execution_start()
file_name = self.editor_list.get_current_editor().long_title()
self.update_title()
self.status_bar.update_save_label(file_name)
self.console.run(file_name)
def goto_position(self, lineno, col_offset):
editor = self.editor_list.get_current_editor()
editor.mark_set("insert", "%d.%d" % (lineno, col_offset))
editor.see("insert")
editor.focus()
# TODO: Continue ?
def check_module(self, event=None):
""" Check syntax : compilation """
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
self.console.check_syntax(self.editor_list.get_current_editor())
# TODO: remove ?
def run_source(self, event=None):
file_name = self.editor_list.get_current_editor().long_title()
self.console.runit(file_name)
class Application:
"""
The main class of the application
- root is the starting point of the GUI application
- main_view defines the main window
- py_editor_list defines the editor interface (from the main_view)
- py_shell defines the shell interface (white and orange widgets)
"""
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
if language is not None:
set_translator_locale(language)
self.root = Tk()
StudentRunner.TK_ROOT = self.root
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
def run(self):
""" Run the application """
self.main_view.show()
def apply_bindings(self, keydefs=None):
""" Bind the actions to the related event methods """
self.new_file_button = self.icon_widget.icons['new_file'].wdgt
self.run_button = self.icon_widget.icons['run'].wdgt
self.save_button = self.icon_widget.icons['save'].wdgt
self.open_button = self.icon_widget.icons['open'].wdgt
self.mode_button = self.icon_widget.icons['mode'].wdgt
self.new_file_button.bind("<1>", self.new_file)
self.run_button.bind("<1>", self.run_module)
self.mode_button.bind("<1>", self.change_mode)
self.save_button.bind("<1>", self.save)
self.open_button.bind("<1>", self.open)
# File
self.root.bind("<Control-n>", self.new_file)
self.root.bind('<Control-o>', self.open)
self.root.bind('<Control-s>', self.save)
self.root.bind("<Control-m>", self.change_mode)
self.root.bind('<<save-window-as-file>>', self.editor_list.save_as)
self.root.bind('<<save-copy-of-window-as-file>>',
self.editor_list.save_as_copy)
self.root.bind('<Control-w>',
self.editor_list.close_current_editor)
self.root.bind('<<close-all-windows>>', self.close_all_event)
# Edit
self.root.bind('<<undo>>', self.editor_list.undo_event)
self.root.bind('<<redo>>', self.editor_list.redo_event)
self.root.bind('<<cut>>', self.editor_list.cut_event)
self.root.bind('<<copy>>', self.editor_list.copy_event)
self.root.bind('<<paste>>', self.editor_list.paste_event)
self.root.bind('<<select-all>>', self.editor_list.select_all_event)
self.root.bind('<<find>>', self.editor_list.find_event)
self.root.bind('<<find-again>>', self.editor_list.find_again_event)
self.root.bind('<<find-selection>>',
self.editor_list.find_selection_event)
self.root.bind('<<find-in-files>>',
self.editor_list.find_in_files_event)
self.root.bind('<<replace>>', self.editor_list.replace_event)
self.root.bind('<<goto-line>>', self.editor_list.goto_line_event)
# Format
self.root.bind('<Control-i>', self.editor_list.indent_region_event)
self.root.bind('<Control-d>', self.editor_list.dedent_region_event)
self.root.bind('<<comment-region>>', self.editor_list.comment_region_event)
self.root.bind('<<uncomment-region>>', self.editor_list.uncomment_region_event)
self.root.bind('<<tabify-region>>', self.editor_list.tabify_region_event)
self.root.bind('<<untabify-region>>', self.editor_list.untabify_region_event)
self.root.bind('<<toggle-tabs>>', self.editor_list.toggle_tabs_event)
# Code execution
self.root.bind('<<check-module>>', self.check_module)
self.root.bind('<Control-r>', self.run_module)
self.root.bind('<Control-Key-Return>', self.run_source)
# File change in notebook
self.root.bind('<<NotebookTabChanged>>', self.update_title)
# Bind the keys
if keydefs is None:
keydefs = Bindings.default_keydefs
for event, keylist in keydefs.items():
if keylist:
self.root.event_add(event, *keylist)
def update_title(self, event=None):
""" Give the title the current filename """
#print("editor list: ", self.editor_list.index("current"))
try:
new_title = self.editor_list.tab(self.editor_list.index("current"), "text")
except:
new_title = "MrPython"
self.root.title(new_title)
return
directory = ""
if self.editor_list.get_current_editor().io.filename:
directory = self.editor_list.get_current_editor().io.filename
if directory != "":
new_title += " (" + directory + ")"
new_title += " - MrPython"
self.root.title(new_title)
#def maybe_save_run(self, event=None):
def save(self, event=None):
""" Save the current file (and display it in the status bar) """
filename = self.editor_list.save()
if filename:
self.status_bar.update_save_label(filename)
self.update_title()
def change_mode(self, event=None):
""" Swap the python mode : full python or student """
if self.mode == "student":
self.mode = "full"
else:
self.mode = "student"
self.icon_widget.switch_icon_mode(self.mode)
self.console.change_mode(tr(self.mode))
self.status_bar.change_mode(tr(self.mode))
def new_file(self, event=None):
""" Creates a new empty editor and put it into the pyEditorList """
file_editor = PyEditor(self.editor_list)
self.editor_list.add(file_editor, text=file_editor.get_file_name())
def open(self, event=None):
""" Open a file in the text editor """
file_editor = PyEditor(self.editor_list, open=True)
if (self.editor_list.focusOn(file_editor.long_title()) == False):
if (file_editor.isOpen()):
self.editor_list.add(file_editor, text=file_editor.get_file_name())
def close_all_event(self, event=None):
""" Quit all the PyEditor : called when exiting application """
while self.editor_list.get_size() > 0:
reply = self.editor_list.close_current_editor()
if reply == "cancel":
break
if self.editor_list.get_size() == 0:
sys.exit(0)
def run_module(self, event=None):
""" Run the code : give the file name and code will be run from the source file """
if self.editor_list.get_size() == 0:
self.main_view.console.no_file_to_run_message()
return
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
file_name = self.editor_list.get_current_editor().long_title()
self.update_title()
self.status_bar.update_save_label(file_name)
self.console.run(file_name)
# TODO: Continue ?
def check_module(self, event=None):
""" Check syntax : compilation """
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
self.console.check_syntax(self.editor_list.get_current_editor())
# TODO: remove ?
def run_source(self,event=None):
file_name = self.editor_list.get_current_editor().long_title()
self.console.runit(file_name)
def main():
ct = Controller()
mv = MainView(ct)
mv.run()
class Application:
"""
The main class of the application
- root is the starting point of the GUI application
- main_view defines the main window
- py_editor_list defines the editor interface (from the main_view)
- py_shell defines the shell interface (white and orange widgets)
"""
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
def run(self):
""" Run the application """
self.main_view.show()
def apply_bindings(self, keydefs=None):
""" Bind the actions to the related event methods """
self.new_file_button = self.icon_widget.icons['new_file'].wdgt
self.run_button = self.icon_widget.icons['run'].wdgt
self.save_button = self.icon_widget.icons['save'].wdgt
self.open_button = self.icon_widget.icons['open'].wdgt
self.mode_button = self.icon_widget.icons['mode'].wdgt
self.new_file_button.bind("<1>", self.new_file)
self.run_button.bind("<1>", self.run_module)
self.mode_button.bind("<1>", self.change_mode)
self.save_button.bind("<1>", self.save)
self.save_button.bind("<3>", self.editor_list.save_as)
self.open_button.bind("<1>", self.open)
# File
self.root.bind("<Control-n>", self.new_file)
self.root.bind('<Control-o>', self.open)
self.root.bind('<Control-s>', self.save)
self.root.bind('<Control-S>', self.editor_list.save_as)
self.root.bind("<Control-m>", self.change_mode)
self.root.bind('<<save-window-as-file>>', self.editor_list.save_as)
self.root.bind('<<save-copy-of-window-as-file>>',
self.editor_list.save_as_copy)
self.root.bind('<Control-w>',
self.editor_list.close_current_editor)
self.root.bind('<<close-all-windows>>', self.close_all_event)
# Edit
self.root.bind('<<undo>>', self.editor_list.undo_event)
self.root.bind('<<redo>>', self.editor_list.redo_event)
self.root.bind('<<cut>>', self.editor_list.cut_event)
self.root.bind('<<copy>>', self.editor_list.copy_event)
self.root.bind('<<paste>>', self.editor_list.paste_event)
self.root.bind('<<select-all>>', self.editor_list.select_all_event)
self.root.bind('<<find>>', self.editor_list.find_event)
self.root.bind('<<find-again>>', self.editor_list.find_again_event)
self.root.bind('<<find-selection>>',
self.editor_list.find_selection_event)
self.root.bind('<<find-in-files>>',
self.editor_list.find_in_files_event)
self.root.bind('<<replace>>', self.editor_list.replace_event)
self.root.bind('<<goto-line>>', self.editor_list.goto_line_event)
# Format
self.root.bind('<Control-i>', self.editor_list.indent_region_event)
self.root.bind('<Control-d>', self.editor_list.dedent_region_event)
self.root.bind('<<comment-region>>', self.editor_list.comment_region_event)
self.root.bind('<<uncomment-region>>', self.editor_list.uncomment_region_event)
self.root.bind('<<tabify-region>>', self.editor_list.tabify_region_event)
self.root.bind('<<untabify-region>>', self.editor_list.untabify_region_event)
self.root.bind('<<toggle-tabs>>', self.editor_list.toggle_tabs_event)
self.root.bind('<Control-plus>', self.editor_list.increase_font_size_event)
self.root.bind('<Control-minus>', self.editor_list.decrease_font_size_event)
# Code execution
self.root.bind('<<check-module>>', self.check_module)
self.root.bind('<Control-r>', self.run_module)
self.root.bind('<Control-Key-Return>', self.run_source)
# File change in notebook
self.root.bind('<<NotebookTabChanged>>', self.update_title)
# Bind the keys
if keydefs is None:
keydefs = Bindings.default_keydefs
for event, keylist in keydefs.items():
if keylist:
self.root.event_add(event, *keylist)
def update_title(self, event=None):
""" Give the title the current filename """
#print("editor list: ", self.editor_list.index("current"))
try:
new_title = self.editor_list.tab(self.editor_list.index("current"), "text")
except:
new_title = "MrPython"
self.root.title(new_title)
return
directory = ""
if self.editor_list.get_current_editor().io.filename:
directory = self.editor_list.get_current_editor().io.filename
if directory != "":
new_title += " (" + directory + ")"
new_title += " - MrPython"
self.root.title(new_title)
#def maybe_save_run(self, event=None):
def save(self, event=None):
""" Save the current file (and display it in the status bar) """
filename = self.editor_list.save()
if filename:
self.status_bar.update_save_label(filename)
self.update_title()
def change_mode(self, event=None):
""" Swap the python mode : full python or student """
if self.mode == "student":
self.mode = "full"
else:
self.mode = "student"
self.icon_widget.switch_icon_mode(self.mode)
self.console.change_mode(tr(self.mode))
self.status_bar.change_mode(tr(self.mode))
def new_file(self, event=None):
""" Creates a new empty editor and put it into the pyEditorList """
file_editor = PyEditor(self.editor_list)
self.editor_list.add(file_editor, self.main_view.editor_widget, text=file_editor.get_file_name())
def open(self, event=None):
""" Open a file in the text editor """
file_editor = PyEditor(self.editor_list, open=True)
if (self.editor_list.focusOn(file_editor.long_title()) == False):
if (file_editor.isOpen()):
self.editor_list.add(file_editor, self.main_view.editor_widget, text=file_editor.get_file_name())
def close_all_event(self, event=None):
""" Quit all the PyEditor : called when exiting application """
print("MrPython says 'bye bye!' ...")
while self.editor_list.get_size() > 0:
reply = self.editor_list.close_current_editor()
if reply == "cancel":
break
if self.editor_list.get_size() == 0:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive():
self.running_interpreter_proxy.process.terminate()
self.running_interpreter_proxy.process.join()
sys.exit(0)
def run_module(self, event=None):
""" Run the code : give the file name and code will be run from the source file """
# already running
if self.running_interpreter_callback:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive():
report = RunReport()
report.set_header("\n====== STOP ======\n")
report.add_execution_error('error', tr('User interruption'))
report.set_footer("\n==================\n")
self.running_interpreter_callback(False, report)
self.running_interpreter_callback = None
return
# not (yet) running
if self.editor_list.get_size() == 0:
self.main_view.console.no_file_to_run_message()
return
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
file_name = self.editor_list.get_current_editor().long_title()
self.update_title()
self.status_bar.update_save_label(file_name)
self.console.run(file_name)
def goto_position(self, lineno, col_offset):
editor = self.editor_list.get_current_editor()
editor.mark_set("insert", "%d.%d" % (lineno, col_offset))
editor.see("insert")
editor.focus()
# TODO: Continue ?
def check_module(self, event=None):
""" Check syntax : compilation """
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
self.console.check_syntax(self.editor_list.get_current_editor())
# TODO: remove ?
def run_source(self,event=None):
file_name = self.editor_list.get_current_editor().long_title()
self.console.runit(file_name)
# This Python file uses the following encoding: utf-8
import sys
import shiboken2
from PySide2.QtWidgets import (QApplication)
from MainView import MainView
import logging
if __name__ == "__main__":
app = QApplication([])
logging.basicConfig(filename='../log/EaraQuake.log', level=logging.WARNING)
window = MainView(_app=app)
window.show()
sys.exit(app.exec_())
class DuplicateImagesController:
""" Controller for 'Duplicate image finder' application.
Implements the 'Controller' from MVC design pattern.
"""
def __init__(self):
supported_image_formats = ('.png', '.jpg', '.jpeg', '.bmp', '.gif')
start_scan_callback = lambda scan_directories: self._start_scan_click_callback(
scan_directories)
delete_image_callback = lambda path_to_delete: self._delete_file(
path_to_delete)
delete_all_duplicates = lambda duplicates: self._delete_all_duplicated_keep_newest(
duplicates)
self._main_view = MainView(start_scan_callback, delete_image_callback,
delete_all_duplicates)
self._imageManager = DuplicateImagesManager(supported_image_formats)
def Start(self) -> None:
self._main_view.Init()
def _start_scan_click_callback(self, scan_directories: [str]) -> None:
""" Handler method for click on 'start scan' button.
"""
core.log_debug(
'DuplicateImagesController - starting scan on dirs [%s]' %
(scan_directories))
self._main_view.ShowScanInProgressWindow()
scan_start_time = datetime.now()
self._imageManager.CleanResults()
self._imageManager.ScanDirectories(scan_directories)
duplicates = self._imageManager.GetDuplicates()
scan_end_time = datetime.now()
scan_duration_in_secs = (scan_end_time -
scan_start_time).total_seconds()
core.log_debug(
'DuplicateImagesController - Scan duration in secs is [%d]' %
scan_duration_in_secs)
self._main_view.ShowResultsWindows(duplicates)
def _delete_file(self, file_path):
try:
core.log_debug('DuplicateImagesController - deleting file [%s]' %
(file_path))
os.remove(file_path)
except Exception as e:
core.log_error(
'DuplicateImagesController - delete file [%s] failed with exception [%s]'
% (file_path, e))
def _delete_all_duplicated_keep_newest(
self, duplicates: FileMetaDataList) -> FileMetaDataList:
updated_duplicate_list = []
for duplicate_file_list in duplicates:
newest_file = self._get_newest_file(duplicate_file_list)
for file in duplicate_file_list:
if file.GetPath() == newest_file.GetPath():
continue
else:
self._delete_file(file.GetPath())
updated_duplicate_list.append([newest_file])
return updated_duplicate_list
def _get_newest_file(self, files: FileMetaDataList):
return max(files, key=lambda file: file.GetLastEditTime())
def main():
window = arcade.Window(SCREEN_WIDTH, SCREEN_HEIGHT, TITLE)
main_view = MainView()
window.show_view(main_view)
main_view.setup()
arcade.run()
def __init__(self, sys_argv):
super(App, self).__init__(sys_argv)
self.model = Model()
self.main_ctrl = MainController(self.model)
self.main_view = MainView(self.model, self.main_ctrl)
self.main_view.show()
''' Created on 2015-11-26 @author: Xuewei (Harvey) Wu ''' from MainView import MainView import sys from PyQt4.QtGui import * app = QApplication(sys.argv) mw = MainView() mw.show() sys.exit(app.exec_())
def mainView():
from MainView import MainView
return MainView()
class Application:
"""
The main class of the application
- root is the starting point of the GUI application
- main_view defines the main window
- py_editor_list defines the editor interface (from the main_view)
- py_shell defines the shell interface (white and orange widgets)
"""
def __init__(self):
""" Set up some information like, set up the interfaces """
import locale
language = None
try: # Work around a possible Python3.7 bug on MacOS
loc = locale.getdefaultlocale()
if loc:
for el in loc:
if str(el).upper().startswith("FR"):
language = "fr"
break
except ValueError:
pass # language is still None
if language is not None:
set_translator_locale(language)
self.root = Tk()
self.root.geometry('768x612')
self.root.title("MrPython")
self.mode = "full"
self.main_view = MainView(self)
self.editor_list = self.main_view.editor_widget.py_notebook
self.icon_widget = self.main_view.icon_widget
self.status_bar = self.main_view.status_bar
self.console = self.main_view.console
self.change_mode()
self.apply_bindings()
self.root.protocol('WM_DELETE_WINDOW', self.close_all_event)
self.running_interpreter_proxy = None
self.running_interpreter_callback = None
def run(self):
""" Run the application """
self.main_view.show()
def apply_bindings(self, keydefs=None):
""" Bind the actions to the related event methods """
self.new_file_button = self.icon_widget.icons['new_file'].wdgt
self.run_button = self.icon_widget.icons['run'].wdgt
self.save_button = self.icon_widget.icons['save'].wdgt
self.open_button = self.icon_widget.icons['open'].wdgt
self.mode_button = self.icon_widget.icons['mode'].wdgt
self.new_file_button.bind("<1>", self.new_file)
self.run_button.bind("<1>", self.run_module)
self.mode_button.bind("<1>", self.change_mode)
self.save_button.bind("<1>", self.save)
self.save_button.bind("<3>", self.editor_list.save_as)
self.open_button.bind("<1>", self.open)
# File
self.root.bind("<Control-n>", self.new_file)
self.root.bind('<Control-o>', self.open)
self.root.bind('<Control-s>', self.save)
self.root.bind('<Control-S>', self.editor_list.save_as)
self.root.bind("<Control-m>", self.change_mode)
self.root.bind('<<save-window-as-file>>', self.editor_list.save_as)
self.root.bind('<<save-copy-of-window-as-file>>',
self.editor_list.save_as_copy)
self.root.bind('<Control-w>', self.editor_list.close_current_editor)
self.root.bind('<<close-all-windows>>', self.close_all_event)
# Edit
self.root.bind('<<undo>>', self.editor_list.undo_event)
self.root.bind('<<redo>>', self.editor_list.redo_event)
self.root.bind('<<cut>>', self.editor_list.cut_event)
self.root.bind('<<copy>>', self.editor_list.copy_event)
self.root.bind('<<paste>>', self.editor_list.paste_event)
self.root.bind('<<select-all>>', self.editor_list.select_all_event)
self.root.bind('<<find>>', self.editor_list.find_event)
self.root.bind('<<find-again>>', self.editor_list.find_again_event)
self.root.bind('<<find-selection>>',
self.editor_list.find_selection_event)
self.root.bind('<<find-in-files>>',
self.editor_list.find_in_files_event)
self.root.bind('<<replace>>', self.editor_list.replace_event)
self.root.bind('<<goto-line>>', self.editor_list.goto_line_event)
# Format
self.root.bind('<Control-i>', self.editor_list.indent_region_event)
self.root.bind('<Control-d>', self.editor_list.dedent_region_event)
self.root.bind('<<comment-region>>',
self.editor_list.comment_region_event)
self.root.bind('<<uncomment-region>>',
self.editor_list.uncomment_region_event)
self.root.bind('<<tabify-region>>',
self.editor_list.tabify_region_event)
self.root.bind('<<untabify-region>>',
self.editor_list.untabify_region_event)
self.root.bind('<<toggle-tabs>>', self.editor_list.toggle_tabs_event)
self.root.bind('<Control-plus>',
self.editor_list.increase_font_size_event)
self.root.bind('<Control-minus>',
self.editor_list.decrease_font_size_event)
# Code execution
self.root.bind('<<check-module>>', self.check_module)
self.root.bind('<Control-r>', self.run_module)
self.root.bind('<Control-Key-Return>', self.run_source)
# File change in notebook
self.root.bind('<<NotebookTabChanged>>', self.update_title)
# Bind the keys
if keydefs is None:
keydefs = Bindings.default_keydefs
for event, keylist in keydefs.items():
if keylist:
self.root.event_add(event, *keylist)
def update_title(self, event=None):
""" Give the title the current filename """
#print("editor list: ", self.editor_list.index("current"))
try:
new_title = self.editor_list.tab(self.editor_list.index("current"),
"text")
except:
new_title = "MrPython"
self.root.title(new_title)
return
directory = ""
if self.editor_list.get_current_editor().io.filename:
directory = self.editor_list.get_current_editor().io.filename
if directory != "":
new_title += " (" + directory + ")"
new_title += " - MrPython"
self.root.title(new_title)
#def maybe_save_run(self, event=None):
def save(self, event=None):
""" Save the current file (and display it in the status bar) """
filename = self.editor_list.save()
if filename:
self.status_bar.update_save_label(filename)
self.update_title()
def change_mode(self, event=None):
""" Swap the python mode : full python or student """
if self.mode == "student":
self.mode = "full"
else:
self.mode = "student"
self.icon_widget.switch_icon_mode(self.mode)
self.console.change_mode(tr(self.mode))
self.status_bar.change_mode(tr(self.mode))
def new_file(self, event=None):
""" Creates a new empty editor and put it into the pyEditorList """
file_editor = PyEditorFrame(self.editor_list)
self.editor_list.add(file_editor,
self.main_view.editor_widget,
text=file_editor.get_file_name())
def open(self, event=None):
""" Open a file in the text editor """
file_editor = PyEditorFrame(self.editor_list, open=True)
if (self.editor_list.focusOn(file_editor.long_title()) == False):
if (file_editor.isOpen()):
self.editor_list.add(file_editor,
self.main_view.editor_widget,
text=file_editor.get_file_name())
#not clean, io should be handled here and should not require creation of PyEditor widget
else:
file_editor.destroy()
def close_all_event(self, event=None):
""" Quit all the PyEditor : called when exiting application """
print("MrPython says 'bye bye!' ...")
while self.editor_list.get_size() > 0:
reply = self.editor_list.close_current_editor()
if reply == "cancel":
break
if self.editor_list.get_size() == 0:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive(
):
self.running_interpreter_proxy.process.terminate()
self.running_interpreter_proxy.process.join()
sys.exit(0)
def run_module(self, event=None):
""" Run the code : give the file name and code will be run from the source file """
# already running
if self.running_interpreter_callback:
if self.running_interpreter_proxy and self.running_interpreter_proxy.process.is_alive(
):
report = RunReport()
report.set_header("\n====== STOP ======\n")
report.add_execution_error('error', tr('User interruption'))
report.set_footer("\n==================\n")
self.running_interpreter_callback(False, report)
self.running_interpreter_callback = None
return
# not (yet) running
if self.editor_list.get_size() == 0:
self.main_view.console.no_file_to_run_message()
return
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
file_name = self.editor_list.get_current_editor().long_title()
self.update_title()
self.status_bar.update_save_label(file_name)
self.console.run(file_name)
def goto_position(self, lineno, col_offset):
editor = self.editor_list.get_current_editor()
editor.mark_set("insert", "%d.%d" % (lineno, col_offset))
editor.see("insert")
editor.focus()
# TODO: Continue ?
def check_module(self, event=None):
""" Check syntax : compilation """
reply = self.editor_list.get_current_editor().maybesave_run()
if (reply != "cancel"):
self.console.check_syntax(self.editor_list.get_current_editor())
# TODO: remove ?
def run_source(self, event=None):
file_name = self.editor_list.get_current_editor().long_title()
self.console.runit(file_name)
'''
Created on 6 Nov 2015
@author: wnm24546
'''
import sys
from PyQt4.QtGui import (QHBoxLayout, QWidget, QPushButton, QApplication,
QDialog)
from MainView import MainView
if __name__ == "__main__":
app = QApplication(sys.argv)
w = MainView()
w.show()
sys.exit(app.exec_())
class MainApp():
def __init__(self):
self.__master = MainView()
def run(self):
self.__master.mainloop()
def __init__(self):
MainView.__init__(self, None)
self.SetTitle(u"淘宝放大图片下载工具")
self.current_dir = None
'''
Created on 6 Nov 2015
@author: wnm24546
'''
import sys
from PyQt4.QtGui import (QHBoxLayout, QWidget, QPushButton, QApplication, QDialog)
from MainView import MainView
if __name__ == "__main__":
app = QApplication(sys.argv)
w = MainView()
w.show()
sys.exit(app.exec_())
#!/usr/bin/python3.8
import tkinter as tk
from MainView import MainView
if __name__ == "__main__":
root = tk.Tk(className=" Mail User Agent")
main = MainView(root)
main.pack(side="top", fill="both", expand=True)
root.wm_geometry("800x600")
root.mainloop()
