📝 Notepad Application

A lightweight Java-based desktop text editor with essential text editing, file management, search and replace, and custom encryption/decryption, all through a simple graphical interface.

📑 Table of Contents

Overview
Features
Technology Stack
Architecture
Project Structure
Class Descriptions
Encryption & Decryption Workflow
Supported File Types
Keyboard Shortcuts
Getting Started
Application Workflow
Project Objectives
Learning Outcomes
Feature Status
Known Limitations
Future Enhancements
Security Note
Screenshots
Contributing
License

📌 Overview

The Notepad Application is a desktop text editor built with Java AWT. It provides a simple, intuitive environment for creating, editing, opening, and saving text-based documents.

Beyond standard editing, it includes Find, Replace, Replace All, and a custom encryption/decryption feature. The project is split into multiple Java classes, with separate components for file operations, dialogs, encryption, decryption, and shared constants. Encrypted files are stored in a custom .mg format.

The project demonstrates practical use of:

Object-Oriented Programming
Java AWT GUI development
Event-driven programming
File handling and I/O
Text processing
Dialog-based user interaction
Keyboard event handling
Custom encryption and decryption logic
Modular application design

✨ Features

📝 Text Editing

A basic text editor built on Java's TextArea component. Users can enter, modify, and manage text directly in the window.

📂 File Management

Open and save files using Java's FileDialog. See Supported File Types for the full list.

➕ New Document

Create a new Notepad window with the New option.

💾 Save File

Save documents with the Save option. For new documents, a save dialog appears and .mg is used as the default extension.

✂️ Cut, Copy and Paste

Basic clipboard operations. The selected text is held temporarily inside the application.

🔎 Find

Search for specific text in the document. Matches are highlighted, and the search can continue from the previous position.

🔄 Replace

A dedicated Replace dialog with:

Control	Purpose
Find What	Text to search for
Replace With	Replacement text
Find Next	Jump to the next occurrence
Replace	Replace the current selection
Replace All	Replace every occurrence

🔐 Encryption

A custom mechanism implemented in the Encrypt class. A random key is generated for each encryption, and key information is embedded at the beginning of the text before the content is transformed.

🔓 Decryption

The Decrypt class reconstructs the key from the encrypted content and recovers the original text. Files in the .mg format are automatically decrypted when opened.

⚠️ Error Handling

Custom alert dialogs display messages for:

Empty Find field
Text not found
Unsupported file types
Other user interaction errors

🛠️ Technology Stack

Technology	Purpose
Java	Core programming language
Java AWT	Graphical user interface
Java I/O	File reading and writing
Java Event Handling	User interaction and application events
Object-Oriented Programming	Application structure and modular design

🏗️ Architecture

Each class is responsible for a specific part of the system.

                    ┌──────────────────────┐
                    │     Notepad.java     │
                    │   Main Application   │
                    └──────────┬───────────┘
                               │
             ┌─────────────────┼─────────────────┐
             │                 │                 │
             ▼                 ▼                 ▼
     ┌───────────────┐  ┌───────────────┐  ┌────────────────┐
     │ FileOperations│  │ FindDialogBox │  │ReplaceDialogBox│
     └───────┬───────┘  └───────────────┘  └────────────────┘
             │
        ┌────┴─────┐
        ▼          ▼
  ┌──────────┐ ┌──────────┐
  │ Encrypt  │ │ Decrypt  │
  └──────────┘ └──────────┘

              ┌──────────────────┐
              │  AlertDialogBox  │
              └──────────────────┘

              ┌──────────────────┐
              │    Constants     │
              └──────────────────┘

Core Modules

Module	Responsibility
`Notepad`	Main application and GUI
`FileOperations`	File reading and writing
`FindDialogBox`	Text searching
`ReplaceDialogBox`	Find and replace
`Encrypt`	Text encryption
`Decrypt`	Text decryption
`AlertDialogBox`	Error and alert messages
`Constants`	Shared encryption constants

📁 Project Structure

notepad/
│
├── Notepad.java
├── FileOperations.java
├── FindDialogBox.java
├── ReplaceDialogBox.java
├── Encrypt.java
├── Decrypt.java
├── AlertDialogBox.java
├── Constants.java
├── .gitignore
└── README.md

📄 Class Descriptions

`Notepad.java`

The main class of the application; it extends Java's Frame class. It is responsible for:

Creating the main window, text area, and menu bar
Handling menu actions
Opening and saving files
Creating new Notepad windows
Cut, copy, and paste operations
Invoking the Find and Replace dialogs
Handling keyboard shortcuts
Managing supported file extensions

The application starts from:

public static void main(String[] args) {
    new Notepad();
}

`FileOperations.java`

Handles file-related operations:

Opening files and reading their content
Saving documents
Processing encrypted .mg files
Calling the encryption and decryption classes

Uses Java I/O classes such as FileInputStream, FileOutputStream, BufferedReader, DataInputStream, and DataOutputStream.

`FindDialogBox.java`

Implements the Find dialog. It lets the user:

Enter search text
Find the next occurrence
See an error if the search field is empty
See an error if the text is not found

The dialog communicates with the main Notepad class to perform the search.

`ReplaceDialogBox.java`

Implements the Replace dialog with three operations:

Find Next: searches for the next occurrence of the specified text
Replace: replaces the currently selected occurrence
Replace All: replaces all matching occurrences in the document

`Encrypt.java`

Implements the custom encryption mechanism. When an Encrypt object is created, it:

Generates a random encryption key
Converts the key into binary representation
Embeds key information into the text
Transforms characters using the generated key
Produces the encrypted text, which is then stored in the file

`Decrypt.java`

Reverses the encryption process. It:

Extracts the embedded key information
Reconstructs the encryption key
Removes the embedded metadata
Applies the reverse transformation
Returns the decrypted text

Primarily used when opening .mg files.

`AlertDialogBox.java`

A reusable dialog for displaying messages and errors, such as empty search input, text not found, and unsupported files.

`Constants.java`

An interface holding the constants used by encryption and decryption. It defines the special characters used to embed and recover encryption information.

🔐 Encryption & Decryption Workflow

The application uses a custom character-based encryption mechanism.

Encryption Flow

User enters text
       ↓
Generate random encryption key
       ↓
Convert key to binary
       ↓
Embed key information into text
       ↓
Transform characters using key
       ↓
Generate encrypted content
       ↓
Save encrypted content

Decryption Flow

Open encrypted .mg file
       ↓
Read encrypted content
       ↓
Extract embedded key information
       ↓
Reconstruct encryption key
       ↓
Reverse character transformation
       ↓
Recover original text
       ↓
Display text in editor

Note: The encryption mechanism is a custom educational implementation and is not a replacement for modern, industry-standard cryptographic algorithms.

📂 Supported File Types

Extension	Description
`.txt`	Plain text
`.mg`	Encrypted file format used by this application
`.java`	Java source
`.c`	C source
`.cpp`	C++ source
`.py`	Python source
`.php`	PHP source
`.js`	JavaScript source
`.html`	HTML
`.css`	CSS
`.xml`	XML
`.log`	Log files

⌨️ Keyboard Shortcuts

Shortcut	Action
`Ctrl + N`	Create a new Notepad window
`Ctrl + O`	Open a file
`Ctrl + S`	Save the current file
`Ctrl + F`	Open the Find dialog
`Ctrl + H`	Open the Replace dialog
`Ctrl + W`	Exit the application

🚀 Getting Started

Prerequisites

Java Development Kit (JDK)
Java compiler (javac)
Java Runtime Environment
A Java-compatible IDE or terminal

Verify your installation:

java -version
javac -version

Installation

1. Clone the repository

git clone https://github.com/YOUR-USERNAME/notepad-project.git

Replace YOUR-USERNAME with your GitHub username.

2. Navigate to the project directory

cd notepad-project

3. Compile the source files

javac *.java

4. Run the application

java Notepad

The Notepad window should open.

Running Through an IDE

Open the project directory in any of the following and run Notepad.java using its main() method:

IntelliJ IDEA
Eclipse
NetBeans
Visual Studio Code with Java extensions

🧪 Application Workflow

Launch Application
       ↓
Create / Open Document
       ↓
Write or Edit Content
       ↓
Find / Replace Text (Optional)
       ↓
Save Document
       ↓
Encrypted Content Stored
       ↓
Reopen File
       ↓
Content Decrypted
       ↓
Continue Editing

🎯 Project Objectives

Develop a functional desktop text editor using Java
Understand Java AWT-based GUI development
Implement event-driven programming
Implement file handling using Java I/O
Provide text search and replacement functionality
Implement keyboard shortcuts for common operations
Understand modular software design
Implement a custom encryption and decryption mechanism
Provide a simple and interactive user interface
Gain practical experience building a complete Java desktop application

📚 Learning Outcomes

Building this project helps practically reinforce:

Java classes and objects
Inheritance
Interfaces
Event listeners
AWT components
Layout managers
Dialog boxes
File streams
Buffered file reading
Character manipulation
String processing
Keyboard event handling
Exception handling
Modular programming
Basic encryption concepts

📊 Feature Status

Feature	Status
Text Editing	✅ Implemented
New Document	✅ Implemented
Open File	✅ Implemented
Save File	✅ Implemented
Cut / Copy / Paste	✅ Implemented
Find	✅ Implemented
Replace / Replace All	✅ Implemented
Keyboard Shortcuts	✅ Implemented
Custom Encryption	✅ Implemented
Custom Decryption	✅ Implemented
Multiple Tabs	❌ Not implemented
Auto Save	❌ Not implemented
Undo / Redo	❌ Not implemented
Dark Mode	❌ Not implemented
Syntax Highlighting	❌ Not implemented

⚠️ Known Limitations

The UI is based on Java AWT and has a basic visual design.
No modern text formatting features.
Clipboard functionality is implemented internally rather than through the system clipboard.
The encryption mechanism is custom and intended for educational purposes only.
A machine-specific command path is used to launch a new window, which may need updating on another system.
Advanced document management (tabs, auto-save, undo/redo) is not included.

🔮 Future Enhancements

User Interface

Modern graphical interface, dark mode, and custom themes
Adjustable font size and font family
Text formatting options
Improved responsive layout

Editing

Undo and redo
Word count and character count
Line numbering
Auto-indentation
Select All
Improved (system) clipboard support

File Management

Recent files
Auto-save and file recovery
Multiple document tabs
Drag-and-drop file opening
Better file format detection

Security

Replace the custom scheme with established standards such as AES, RSA, and PBKDF2
Secure password-based key derivation

Additional Features

Print documents
Export to PDF
Syntax highlighting
Custom keyboard shortcuts
Preferences/settings panel
Search history

🛡️ Security Note

The encryption functionality in this project demonstrates a custom encryption concept for educational purposes only. It should not be used to protect sensitive or confidential information. For real-world applications, use well-established, thoroughly reviewed cryptographic algorithms and libraries.

📸 Screenshots

Add screenshots to a screenshots/ folder in the repository and reference them below.

Application Interface

Find and Replace

🤝 Contributing

Contributions and improvements are welcome.

Fork the repository.
Create a new branch:
```
git checkout -b feature/new-feature
```
Make your changes.
Commit your changes:
```
git commit -m "Add new feature"
```
Push the branch:
```
git push origin feature/new-feature
```
Open a Pull Request.

📄 License

This project is intended for educational and learning purposes.

Name		Name	Last commit message	Last commit date
.gitignore		.gitignore
AlertDialogBox.java		AlertDialogBox.java
Constants.java		Constants.java
Decrypt.java		Decrypt.java
Encrypt.java		Encrypt.java
FileOperations.java		FileOperations.java
FindDialogBox.java		FindDialogBox.java
Notepad.java		Notepad.java
README.md		README.md
ReplaceDialogBox.java		ReplaceDialogBox.java

Latest commit

History

Folders and files

Repository files navigation