Simple Text Editor in Python with Tkinter

Basic Text Editor:

Create a text editor with features like opening, editing, and saving text files.

Input values:

User interacts with the text editor by opening, editing, and saving text files.

Output value:

Visual representation of the text editor with the contents of the text files, along with feedback on user actions (opening, editing, saving).

Example:

Input values:
1. Open an existing text file
- User selects the file: "test.txt"
Output value:
Text editor displays the contents of the file "test.txt" for editing.
Input values:
2. Edit the text content
- User modifies the text: "This is the edited content of the text file."
Output value:
Text editor updates to display modified text content.
Input values:
3. Save the changes
- User saves the changes made to the file.
Output value:
Text editor saves the changes to the file "example.txt" and provides feedback on successful saving.
Input values:
4. Create a new text file
- User selects to create a new file.
Output value:
Text editor opens up a blank document for writing text.
Input values:
5. Enter text into the new document
- User types: "This is a new document."
Output value:
Text editor displays the entered text in the new document.
Input values:
6. Save the new document
- User saves the new document as "new_test.txt".
Output value:
Text editor saves the new document as "new_test.txt" and provides feedback on successful saving. 

Solution 1: Basic Text Editor Using Tkinter

This solution uses the tkinter library to create a simple GUI-based text editor. It provides basic functionalities such as opening, editing, saving text files, and creating new files.

Code:

import tkinter as tk  # Import tkinter for GUI
from tkinter import filedialog  # Import filedialog to handle file operations

# Function to open an existing text file
def open_file():
    """Opens an existing text file."""
    # Ask user to select a file to open
    file_path = filedialog.askopenfilename(defaultextension=".txt", filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")])
    if file_path:
        try:
            # Open the file in read mode
            with open(file_path, "r") as file:
                text_area.delete(1.0, tk.END)  # Clear the current content of the text area
                text_area.insert(tk.END, file.read())  # Insert the file content into the text area
            window.title(f"Text Editor - {file_path}")  # Update the window title with the file name
        except Exception as e:
            print(f"Error opening file: {e}")  # Print an error message if file opening fails

# Function to save the current content to a text file
def save_file():
    """Saves the current content to a text file."""
    # Ask user to select a file to save
    file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")])
    if file_path:
        try:
            # Open the file in write mode
            with open(file_path, "w") as file:
                file.write(text_area.get(1.0, tk.END))  # Write the content of the text area to the file
            window.title(f"Text Editor - {file_path}")  # Update the window title with the file name
        except Exception as e:
            print(f"Error saving file: {e}")  # Print an error message if file saving fails

# Function to create a new text file
def new_file():
    """Creates a new text file."""
    text_area.delete(1.0, tk.END)  # Clear the text area
    window.title("Text Editor - New File")  # Update the window title

# Create the main window
window = tk.Tk()
window.title("Text Editor")  # Set window title
window.geometry("600x400")  # Set window size

# Create a text area widget
text_area = tk.Text(window, wrap='word')
text_area.pack(expand=1, fill='both')

# Create a menu bar
menu_bar = tk.Menu(window)
window.config(menu=menu_bar)

# Add file menu options
file_menu = tk.Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="New", command=new_file)  # New file option
file_menu.add_command(label="Open", command=open_file)  # Open file option
file_menu.add_command(label="Save", command=save_file)  # Save file option
file_menu.add_separator()
file_menu.add_command(label="Exit", command=window.quit)  # Exit option

# Run the application
window.mainloop()  

Output:

Explanation

• Imports tkinter library to create a GUI for the text editor.
• Functions:
• open_file(): Opens a file dialog to select a file, reads its content, and displays it in the text editor.
• save_file(): Opens a save dialog to save the current text content to a file.
• new_file(): Clears the text area for creating a new file.
• GUI Components:
• Creates the main window and a text area widget for editing.
• Adds a menu bar with options for creating a new file, opening an existing file, saving the current file, and exiting the editor.
• Run the Application: Starts the Tkinter main loop to display the GUI.

Solution 2: Basic Text Editor Using PyQt5

This solution uses the PyQt5 library to create a text editor with a GUI. It includes functionalities such as opening, editing, and saving text files and creating new files.

Code:

import sys  # Import sys for command-line arguments
from PyQt5.QtWidgets import QApplication, QMainWindow, QTextEdit, QAction, QFileDialog, QMessageBox  # Import PyQt5 modules

# Class to create the text editor window
class TextEditor(QMainWindow):
    def __init__(self):
        """Initializes the text editor."""
        super().__init__()
        self.initUI()  # Call method to initialize the user interface

    # Method to initialize the user interface
    def initUI(self):
        """Initializes the user interface components."""
        self.text_area = QTextEdit(self)  # Create a QTextEdit widget for text editing
        self.setCentralWidget(self.text_area)  # Set the text area as the central widget
        self.setWindowTitle("Text Editor")  # Set window title
        self.setGeometry(100, 100, 600, 400)  # Set window size and position

        # Create actions for the menu bar
        new_action = QAction('New', self)
        new_action.triggered.connect(self.new_file)
        open_action = QAction('Open', self)
        open_action.triggered.connect(self.open_file)
        save_action = QAction('Save', self)
        save_action.triggered.connect(self.save_file)
        exit_action = QAction('Exit', self)
        exit_action.triggered.connect(self.close)

        # Create a menu bar and add file menu
        menu_bar = self.menuBar()
        file_menu = menu_bar.addMenu('File')
        file_menu.addAction(new_action)
        file_menu.addAction(open_action)
        file_menu.addAction(save_action)
        file_menu.addAction(exit_action)

    # Method to create a new file
    def new_file(self):
        """Creates a new file."""
        self.text_area.clear()  # Clear the text area

    # Method to open an existing file
    def open_file(self):
        """Opens an existing text file."""
        file_path, _ = QFileDialog.getOpenFileName(self, 'Open File', '', 'Text Files (*.txt);;All Files (*)')
        if file_path:
            try:
                # Read the file and display its content
                with open(file_path, 'r') as file:
                    self.text_area.setText(file.read())
                self.setWindowTitle(f"Text Editor - {file_path}")  # Update the window title
            except Exception as e:
                QMessageBox.warning(self, 'Error', f"Failed to open file: {e}")

    # Method to save the current file
    def save_file(self):
        """Saves the current text content to a file."""
        file_path, _ = QFileDialog.getSaveFileName(self, 'Save File', '', 'Text Files (*.txt);;All Files (*)')
        if file_path:
            try:
                # Write the content of the text area to the file
                with open(file_path, 'w') as file:
                    file.write(self.text_area.toPlainText())
                self.setWindowTitle(f"Text Editor - {file_path}")  # Update the window title
            except Exception as e:
                QMessageBox.warning(self, 'Error', f"Failed to save file: {e}")

# Main function to run the application
def main():
    app = QApplication(sys.argv)  # Create the application
    editor = TextEditor()  # Create an instance of the TextEditor
    editor.show()  # Show the text editor window
    sys.exit(app.exec_())  # Run the application loop

# Run the application
if __name__ == '__main__':
    main()  

Output:

Explanation

• Imports PyQt5 modules for GUI development.
• Class TextEditor:
• Inherits from QMainWindow to create the main window of the text editor.
• __init__(): Initializes the text editor and calls initUI() to set up the GUI.
• initUI(): Sets up the text area and menu bar with actions (New, Open, Save, Exit).
• new_file(): Clears the text area to create a new file.
• open_file(): Opens a file dialog to select and display an existing file.
• save_file(): Opens a file dialog to save the current text content.
• Main Function main():
• Creates the application and the text editor instance.
• Displays the text editor window and starts the application loop.
• Summary:
• Solution 1 (Tkinter): Creates a basic text editor using tkinter, which is suitable for simple applications with a minimal learning curve.
• Solution 2 (PyQt5): Provides a more advanced GUI using PyQt5, which offers greater flexibility and more features for creating modern applications.