Merge branch 'V2' into feature/v2/googleDrive

devGuide/DeveloperGuide.md

@@ -8,15 +8,14 @@ Stirling-PDF is a robust, locally hosted, web-based PDF manipulation tool. This
 
 Stirling-PDF is built using:
 
-- Spring Boot (Backend API)
-- React + TypeScript + Vite (Frontend V2)
-- Mantine UI + TailwindCSS (UI Framework)
-- PDFBox (PDF manipulation)
-- LibreOffice (Document conversion)
-- qpdf (PDF processing)
-- PDF.js (Client-side PDF rendering)
-- Embedded-PDF (PDF viewer component)
+- Spring Boot + Thymeleaf
+- PDFBox
+- LibreOffice
+- qpdf
+- HTML, CSS, JavaScript
 - Docker
+- PDF.js
+- PDF-LIB.js
 - Lombok
 
 ## 3. Development Environment Setup
@@ -25,9 +24,8 @@ Stirling-PDF is built using:
 
 - Docker
 - Git
-- Java JDK 17 or later (JDK 21 recommended)
+- Java JDK 17 or later
 - Gradle 7.0 or later (Included within the repo)
-- Node.js 18+ and npm (for frontend development)
 
 ### Setup Steps
 
@@ -40,8 +38,8 @@ Stirling-PDF is built using:
 
 2. Install Docker and JDK17 if not already installed.
 
-3. Install a recommended IDE:
-   - **VSCode** (recommended for frontend)
+3. Install a recommended Java IDE such as Eclipse, IntelliJ, or VSCode
+   1. Only VSCode
       1. Open VS Code.
       2. When prompted, install the recommended extensions.
       3. Alternatively, open the command palette (`Ctrl + Shift + P` or `Cmd + Shift + P` on macOS) and run:
@@ -51,15 +49,13 @@ Stirling-PDF is built using:
         ```
 
       4. Install the required extensions from the list.
-   - **IntelliJ IDEA** (recommended for backend)
-   - **Eclipse** (alternative for backend)
 
 4. Lombok Setup
 Stirling-PDF uses Lombok to reduce boilerplate code. Some IDEs, like Eclipse, don't support Lombok out of the box. To set up Lombok in your development environment:
 Visit the [Lombok website](https://projectlombok.org/setup/) for installation instructions specific to your IDE.
 
 5. Add environment variable
-For local testing, you should generally be testing the full 'Security' version of Stirling PDF. To do this, you must add the environment flag DOCKER_ENABLE_SECURITY=true to your system and/or IDE build/run step.
+For local testing, you should generally be testing the full 'Security' version of Stirling PDF. To do this, you must add the environment flag DISABLE_ADDITIONAL_FEATURES=false to your system and/or IDE build/run step.
 
 ## 4. Project Structure
 
@@ -72,21 +68,10 @@ Stirling-PDF/
 ├── customFiles/           # Custom static files and templates (generated at runtime used to replace existing files)
 ├── docs/                  # Documentation files
 ├── exampleYmlFiles/       # Example YAML configuration files
-├── frontend/              # React frontend application (V2)
-│   ├── src/
-│   │   ├── components/    # React components
-│   │   ├── tools/         # PDF tool implementations
-│   │   ├── contexts/      # React contexts (FileContext, etc.)
-│   │   ├── hooks/         # Custom React hooks
-│   │   ├── services/      # API and processing services
-│   │   └── i18n.ts        # Internationalization config
-│   ├── public/
-│   │   └── locales/       # Translation JSON files
-│   └── package.json
 ├── images/                # Image assets
 ├── pipeline/              # Pipeline-related files (generated at runtime)
 ├── scripts/               # Utility scripts
-├── src/                   # Backend source code
+├── src/                   # Source code
 │   ├── main/
 │   │   ├── java/
 │   │   │   └── stirling/
@@ -94,14 +79,16 @@ Stirling-PDF/
 │   │   │           └── SPDF/
 │   │   │               ├── config/
 │   │   │               ├── controller/
-│   │   │               │   ├── api/    # REST API endpoints
-│   │   │               │   └── web/    # Web controllers
 │   │   │               ├── model/
 │   │   │               ├── repository/
 │   │   │               ├── service/
 │   │   │               └── utils/
 │   │   └── resources/
-│   │       └── static/    # Legacy static assets
+│   │       ├── static/
+│   │       │   ├── css/
+│   │       │   ├── js/
+│   │       │   └── pdfjs/
+│   │       └── templates/
 │   └── test/
 │       └── java/
 │           └── stirling/
@@ -154,7 +141,7 @@ services:
       - ./stirling/latest/config:/configs:rw
       - ./stirling/latest/logs:/logs:rw
     environment:
-      DOCKER_ENABLE_SECURITY: "true"
+      DISABLE_ADDITIONAL_FEATURES: "false"
       SECURITY_ENABLELOGIN: "true"
       PUID: 1002
       PGID: 1002
@@ -183,7 +170,7 @@ Stirling-PDF uses different Docker images for various configurations. The build
 1. Set the security environment variable:
 
    ```bash
-   export DOCKER_ENABLE_SECURITY=true  # or false to disable login and security features for builds
+   export DISABLE_ADDITIONAL_FEATURES=true  # or false for to enable login and security features for builds
    ```
 
 2. Build the project with Gradle:
@@ -209,7 +196,7 @@ Stirling-PDF uses different Docker images for various configurations. The build
    For the fat version (with login and security features enabled):
 
    ```bash
-   export DOCKER_ENABLE_SECURITY=true
+   export DISABLE_ADDITIONAL_FEATURES=false
    docker build --no-cache --pull --build-arg VERSION_TAG=alpha -t stirlingtools/stirling-pdf:latest-fat -f ./Dockerfile.fat .
    ```
 
@@ -237,50 +224,38 @@ Note: The `test.sh` script will run automatically when you raise a PR. However,
 
 ### Full Testing with Docker
 
-1. Build and run the Docker container per the above instructions
+1. Build and run the Docker container per the above instructions:
 
 2. Access the application at `http://localhost:8080` and manually test all features developed.
 
-### Local Testing (Frontend and Backend)
+### Local Testing (Java and UI Components)
 
-For quick iterations and development, you can run the frontend and backend separately:
+For quick iterations and development of Java backend, JavaScript, and UI components, you can run and test Stirling-PDF locally without Docker. This approach allows you to work on and verify changes to:
 
-#### Backend Development
+- Java backend logic
+- RESTful API endpoints
+- JavaScript functionality
+- User interface components and styling
+- Thymeleaf templates
 
-1. Run the backend:
+To run Stirling-PDF locally:
+
+1. Compile and run the project using built-in IDE methods or by running:
 
    ```bash
    ./gradlew bootRun
    ```
 
-2. The backend API will be available at `http://localhost:8080`
+2. Access the application at `http://localhost:8080` in your web browser.
 
-3. API documentation is available at `http://localhost:8080/swagger-ui/index.html`
+3. Manually test the features you're working on through the UI.
 
-#### Frontend Development
-
-1. Install dependencies (first time only):
-
-   ```bash
-   cd frontend
-   npm install
-   ```
-
-2. Start the development server:
-
-   ```bash
-   npm run dev
-   ```
-
-3. The frontend will be available at `http://localhost:5173`
-
-4. Vite automatically proxies API calls from `/api/*` to the backend at `localhost:8080`
+4. For API changes, use tools like Postman or curl to test endpoints directly.
 
 Important notes:
 
-- Frontend requires the backend to be running for full functionality
-- Hot module replacement (HMR) enables instant updates during development
 - Local testing doesn't include features that depend on external tools like qpdf, LibreOffice, or Python scripts.
+- There are currently no automated unit tests. All testing is done manually through the UI or API calls. (You are welcome to add JUnits!)
 - Always verify your changes in the full Docker environment before submitting pull requests, as some integrations and features will only work in the complete setup.
 
 ## 7. Contributing
@@ -332,170 +307,112 @@ docker run -p 8080:8080 -e APP_NAME="My PDF Tool" stirling-pdf:full
 
 Refer to the main README for a full list of customization options.
 
-## 10. Frontend Development (V2)
+## 10. Language Translations
 
-### Architecture Overview
+For managing language translations that affect multiple files, Stirling-PDF provides a helper script:
 
-The V2 frontend is designed for **stateful document processing**:
-- Users upload PDFs once, then chain tools (split → merge → compress → view)
-- File state and processing results persist across tool switches
-- No file reloading between tools - performance critical for large PDFs (up to 100GB+)
-
-### Key Components
-
-#### FileContext - Central State Management
-**Location**: `frontend/src/contexts/FileContext.tsx`
-- **Active files**: Currently loaded PDFs and their variants
-- **Tool navigation**: Current mode (viewer/pageEditor/fileEditor/toolName)
-- **Memory management**: PDF document cleanup, blob URL lifecycle, Web Worker management
-- **IndexedDB persistence**: File storage with thumbnail caching
-- **Preview system**: Tools can preview results without context pollution
-
-**Critical**: All file operations go through FileContext. Don't bypass with direct file handling.
-
-#### Processing Services
-- **enhancedPDFProcessingService**: Background PDF parsing and manipulation
-- **thumbnailGenerationService**: Web Worker-based with main-thread fallback
-- **fileStorage**: IndexedDB with LRU cache management
-
-### Tool Development
-
-**Architecture**: Modular hook-based system with clear separation of concerns:
-
-- **useToolOperation** (`frontend/src/hooks/tools/shared/useToolOperation.ts`): Main orchestrator hook
-  - Coordinates all tool operations with consistent interface
-  - Integrates with FileContext for operation tracking
-  - Handles validation, error handling, and UI state management
-
-- **Supporting Hooks**:
-  - **useToolState**: UI state management (loading, progress, error, files)
-  - **useToolApiCalls**: HTTP requests and file processing
-  - **useToolResources**: Blob URLs, thumbnails, ZIP downloads
-
-- **Utilities**:
-  - **toolErrorHandler**: Standardized error extraction and i18n support
-  - **toolResponseProcessor**: API response handling (single/zip/custom)
-  - **toolOperationTracker**: FileContext integration utilities
-
-**Three Tool Patterns**:
-
-**Pattern 1: Single-File Tools** (Individual processing)
-- Backend processes one file per API call
-- Set `multiFileEndpoint: false`
-- Examples: Compress, Rotate
-
-```typescript
-return useToolOperation({
-  operationType: 'compress',
-  endpoint: '/api/v1/misc/compress-pdf',
-  buildFormData: (params, file: File) => { /* single file */ },
-  multiFileEndpoint: false,
-});
+```bash
+/scripts/replace_translation_line.sh
 ```
 
-**Pattern 2: Multi-File Tools** (Batch processing)
-- Backend accepts `MultipartFile[]` arrays in single API call
-- Set `multiFileEndpoint: true`
-- Examples: Split, Merge, Overlay
+This script helps you make consistent replacements across language files.
 
-```typescript
-return useToolOperation({
-  operationType: 'split',
-  endpoint: '/api/v1/general/split-pages',
-  buildFormData: (params, files: File[]) => { /* all files */ },
-  multiFileEndpoint: true,
-  filePrefix: 'split_',
-});
+When contributing translations:
+
+1. Use the helper script for multi-file changes.
+2. Ensure all language files are updated consistently.
+3. The PR checks will verify consistency in language file updates.
+
+Remember to test your changes thoroughly to ensure they don't break any existing functionality.
+
+## Code examples
+
+### Overview of Thymeleaf
+
+Thymeleaf is a server-side Java HTML template engine. It is used in Stirling-PDF to render dynamic web pages. Thymeleaf integrates heavily with Spring Boot.
+
+### Thymeleaf overview
+
+In Stirling-PDF, Thymeleaf is used to create HTML templates that are rendered on the server side. These templates are located in the `app/core/src/main/resources/templates` directory. Thymeleaf templates use a combination of HTML and special Thymeleaf attributes to dynamically generate content.
+
+Some examples of this are:
+
+```html
+<th:block th:insert="~{fragments/navbar.html :: navbar}"></th:block>
+```
+or
+```html
+<th:block th:insert="~{fragments/footer.html :: footer}"></th:block>
 ```
 
-**Pattern 3: Complex Tools** (Custom processing)
-- Tools with complex routing logic or non-standard processing
-- Provide `customProcessor` for full control
-- Examples: Convert, OCR
+Where it uses the `th:block`, `th:` indicating it's a special Thymeleaf element to be used server-side in generating the HTML, and block being the actual element type.
+In this case, we are inserting the `navbar` entry within the `fragments/navbar.html` fragment into the `th:block` element.
 
-```typescript
-return useToolOperation({
-  operationType: 'convert',
-  customProcessor: async (params, files) => { /* custom logic */ },
-});
+They can be more complex, such as:
+
+```html
+<th:block th:insert="~{fragments/common :: head(title=#{pageExtracter.title}, header=#{pageExtracter.header})}"></th:block>
 ```
 
-**Benefits**:
-- **No Timeouts**: Operations run until completion (supports 100GB+ files)
-- **Consistent**: All tools follow same pattern and interface
-- **Maintainable**: Single responsibility hooks, easy to test and modify
-- **i18n Ready**: Built-in internationalization support
-- **Type Safe**: Full TypeScript support with generic interfaces
-- **Memory Safe**: Automatic resource cleanup and blob URL management
+Which is the same as above but passes the parameters title and header into the fragment `common.html` to be used in its HTML generation.
 
-### Adding a New Tool
+Thymeleaf can also be used to loop through objects or pass things from the Java side into the HTML side.
 
-See [ADDING_TOOLS.md](../ADDING_TOOLS.md) for a complete guide to creating new PDF tools.
-
-### Internationalization
-
-Translations are stored in JSON files at `frontend/public/locales/{language-code}/translation.json`.
-
-To use translations in React components:
-
-```typescript
-import { useTranslation } from 'react-i18next';
-
-function MyComponent() {
-  const { t } = useTranslation();
-
-  return (
-    <div>
-      <h1>{t('myTool.title')}</h1>
-      <p>{t('myTool.description')}</p>
-    </div>
-  );
-}
+```java
+ @GetMapping
+       public String newFeaturePage(Model model) {
+           model.addAttribute("exampleData", exampleData);
+           return "new-feature";
+       }
 ```
 
-See [HowToAddNewLanguage.md](./HowToAddNewLanguage.md) for details on adding new languages.
+In the above example, if exampleData is a list of plain java objects of class Person and within it, you had id, name, age, etc. You can reference it like so
 
-## 11. Backend Development
+```html
+<tbody>
+   <!-- Use th:each to iterate over the list -->
+   <tr th:each="person : ${exampleData}">
+       <td th:text="${person.id}"></td>
+       <td th:text="${person.name}"></td>
+       <td th:text="${person.age}"></td>
+       <td th:text="${person.email}"></td>
+   </tr>
+</tbody>
+```
 
-### Adding a New API Endpoint
+This would generate n entries of tr for each person in exampleData
+
+### Adding a New Feature to the Backend (API)
 
 1. **Create a New Controller:**
-   - Create a new Java class in the `src/main/java/stirling/software/SPDF/controller/api` directory.
+   - Create a new Java class in the `app/core/src/main/java/stirling/software/SPDF/controller/api` directory.
    - Annotate the class with `@RestController` and `@RequestMapping` to define the API endpoint.
-   - Ensure to add API documentation annotations like `@Tag` and `@Operation`.
+   - Ensure to add API documentation annotations like `@Tag(name = "General", description = "General APIs")` and `@Operation(summary = "Crops a PDF document", description = "This operation takes an input PDF file and crops it according to the given coordinates. Input:PDF Output:PDF Type:SISO")`.
 
    ```java
    package stirling.software.SPDF.controller.api;
 
-   import org.springframework.web.bind.annotation.*;
-   import org.springframework.web.multipart.MultipartFile;
+   import org.springframework.web.bind.annotation.GetMapping;
+   import org.springframework.web.bind.annotation.RequestMapping;
+   import org.springframework.web.bind.annotation.RestController;
    import io.swagger.v3.oas.annotations.Operation;
    import io.swagger.v3.oas.annotations.tags.Tag;
 
    @RestController
-   @RequestMapping("/api/v1/pdf")
+   @RequestMapping("/api/v1/new-feature")
    @Tag(name = "General", description = "General APIs")
    public class NewFeatureController {
 
-       @PostMapping("/new-feature")
-       @Operation(summary = "New Feature", description = "This is a new feature endpoint. Input:PDF Output:PDF Type:SISO")
-       public ResponseEntity<byte[]> newFeature(
-           @RequestPart("fileInput") MultipartFile file,
-           @RequestParam("param1") String param1) {
-
-           // Process PDF
-           byte[] result = processFile(file, param1);
-
-           return ResponseEntity.ok()
-               .header("Content-Disposition", "attachment; filename=output.pdf")
-               .contentType(MediaType.APPLICATION_PDF)
-               .body(result);
+       @GetMapping
+       @Operation(summary = "New Feature", description = "This is a new feature endpoint.")
+       public String newFeature() {
+           return "NewFeatureResponse"; // This refers to the NewFeatureResponse.html template presenting the user with the generated html from that file when they navigate to /api/v1/new-feature
        }
    }
    ```
 
-2. **Define the Service Layer:** (Optional but recommended)
-   - Create a new service class in the `src/main/java/stirling/software/SPDF/service` directory.
+2. **Define the Service Layer:** (Not required but often useful)
+   - Create a new service class in the `app/core/src/main/java/stirling/software/SPDF/service` directory.
    - Implement the business logic for the new feature.
 
    ```java
@@ -506,76 +423,167 @@ See [HowToAddNewLanguage.md](./HowToAddNewLanguage.md) for details on adding new
    @Service
    public class NewFeatureService {
 
-       public byte[] processFile(MultipartFile file, String param1) {
+       public String getNewFeatureData() {
            // Implement business logic here
-           return processedBytes;
+           return "New Feature Data";
        }
    }
    ```
 
-3. **Integrate the Service with the Controller:**
+2b. **Integrate the Service with the Controller:**
+
+- Autowire the service class in the controller and use it to handle the API request.
+
+  ```java
+  package stirling.software.SPDF.controller.api;
+
+  import org.springframework.beans.factory.annotation.Autowired;
+  import org.springframework.web.bind.annotation.GetMapping;
+  import org.springframework.web.bind.annotation.RequestMapping;
+  import org.springframework.web.bind.annotation.RestController;
+  import stirling.software.SPDF.service.NewFeatureService;
+  import io.swagger.v3.oas.annotations.Operation;
+  import io.swagger.v3.oas.annotations.tags.Tag;
+
+  @RestController
+  @RequestMapping("/api/v1/new-feature")
+  @Tag(name = "General", description = "General APIs")
+  public class NewFeatureController {
+
+      @Autowired
+      private NewFeatureService newFeatureService;
+
+      @GetMapping
+      @Operation(summary = "New Feature", description = "This is a new feature endpoint.")
+      public String newFeature() {
+          return newFeatureService.getNewFeatureData();
+      }
+  }
+  ```
+
+### Adding a New Feature to the Frontend (UI)
+
+1. **Create a New Thymeleaf Template:**
+   - Create a new HTML file in the `app/core/src/main/resources/templates` directory.
+   - Use Thymeleaf attributes to dynamically generate content.
+   - Use `extract-page.html` as a base example for the HTML template, which is useful to ensure importing of the general layout, navbar, and footer.
+
+   ```html
+   <!DOCTYPE html>
+   <html th:lang="${#locale.language}" th:dir="#{language.direction}" th:data-language="${#locale.toString()}" xmlns:th="https://www.thymeleaf.org">
+     <head>
+     <th:block th:insert="~{fragments/common :: head(title=#{newFeature.title}, header=#{newFeature.header})}"></th:block>
+     </head>
+
+     <body>
+       <div id="page-container">
+         <div id="content-wrap">
+           <th:block th:insert="~{fragments/navbar.html :: navbar}"></th:block>
+           <br><br>
+           <div class="container">
+             <div class="row justify-content-center">
+               <div class="col-md-6 bg-card">
+                 <div class="tool-header">
+                   <span class="material-symbols-rounded tool-header-icon organize">upload</span>
+                   <span class="tool-header-text" th:text="#{newFeature.header}"></span>
+                 </div>
+                 <form th:action="@{'/api/v1/new-feature'}" method="post" enctype="multipart/form-data">
+                   <div th:replace="~{fragments/common :: fileSelector(name='fileInput', multipleInputsForSingleRequest=false, accept='application/pdf')}"></div>
+                   <input type="hidden" id="customMode" name="customMode" value="">
+                   <div class="mb-3">
+                     <label for="featureInput" th:text="#{newFeature.prompt}"></label>
+                     <input type="text" class="form-control" id="featureInput" name="featureInput" th:placeholder="#{newFeature.placeholder}" required>
+                   </div>
+
+                   <button type="submit" id="submitBtn" class="btn btn-primary" th:text="#{newFeature.submit}"></button>
+                 </form>
+               </div>
+             </div>
+           </div>
+         </div>
+         <th:block th:insert="~{fragments/footer.html :: footer}"></th:block>
+       </div>
+     </body>
+   </html>
+   ```
+
+2. **Create a New Controller for the UI:**
+   - Create a new Java class in the `app/core/src/main/java/stirling/software/SPDF/controller/ui` directory.
+   - Annotate the class with `@Controller` and `@RequestMapping` to define the UI endpoint.
 
    ```java
-   @RestController
-   @RequestMapping("/api/v1/pdf")
-   public class NewFeatureController {
+   package stirling.software.SPDF.controller.ui;
+
+   import org.springframework.beans.factory.annotation.Autowired;
+   import org.springframework.stereotype.Controller;
+   import org.springframework.ui.Model;
+   import org.springframework.web.bind.annotation.GetMapping;
+   import org.springframework.web.bind.annotation.RequestMapping;
+   import stirling.software.SPDF.service.NewFeatureService;
+
+   @Controller
+   @RequestMapping("/new-feature")
+   public class NewFeatureUIController {
 
        @Autowired
        private NewFeatureService newFeatureService;
 
-       @PostMapping("/new-feature")
-       public ResponseEntity<byte[]> newFeature(
-           @RequestPart("fileInput") MultipartFile file,
-           @RequestParam("param1") String param1) {
-
-           byte[] result = newFeatureService.processFile(file, param1);
-
-           return ResponseEntity.ok()
-               .header("Content-Disposition", "attachment; filename=output.pdf")
-               .contentType(MediaType.APPLICATION_PDF)
-               .body(result);
+       @GetMapping
+       public String newFeaturePage(Model model) {
+           model.addAttribute("newFeatureData", newFeatureService.getNewFeatureData());
+           return "new-feature";
        }
    }
    ```
 
-### Multi-File Endpoints
+3. **Update the Navigation Bar:**
+   - Add a link to the new feature page in the navigation bar.
+   - Update the `app/core/src/main/resources/templates/fragments/navbar.html` file.
 
-For tools that process multiple files in one request:
+   ```html
+   <li class="nav-item">
+       <a class="nav-link" th:href="@{'/new-feature'}">New Feature</a>
+   </li>
+   ```
 
-```java
-@PostMapping("/merge")
-public ResponseEntity<byte[]> mergePdfs(
-    @RequestPart("fileInput") MultipartFile[] files) {
+## Adding New Translations to Existing Language Files in Stirling-PDF
 
-    // Process all files together
-    byte[] merged = mergeService.mergeFiles(files);
+When adding a new feature or modifying existing ones in Stirling-PDF, you'll need to add new translation entries to the existing language files. Here's a step-by-step guide:
 
-    return ResponseEntity.ok()
-        .header("Content-Disposition", "attachment; filename=merged.pdf")
-        .contentType(MediaType.APPLICATION_PDF)
-        .body(merged);
-}
+### 1. Locate Existing Language Files
+
+Find the existing `messages.properties` files in the `app/core/src/main/resources` directory. You'll see files like:
+
+- `messages.properties` (default, usually English)
+- `messages_en_GB.properties`
+- `messages_fr_FR.properties`
+- `messages_de_DE.properties`
+- etc.
+
+### 2. Add New Translation Entries
+
+Open each of these files and add your new translation entries. For example, if you're adding a new feature called "PDF Splitter",
+Use descriptive, hierarchical keys (e.g., `feature.element.description`)
+you might add:
+
+```properties
+pdfSplitter.title=PDF Splitter
+pdfSplitter.description=Split your PDF into multiple documents
+pdfSplitter.button.split=Split PDF
+pdfSplitter.input.pages=Enter page numbers to split
 ```
 
-## 12. Best Practices
+Add these entries to the default GB language file and any others you wish, translating the values as appropriate for each language.
 
-### Frontend
-- Always use FileContext for file operations
-- Implement proper cleanup for PDF.js documents and blob URLs
-- Use the `useToolOperation` hook for consistent tool behavior
-- Follow TypeScript strict mode guidelines
-- Test with large files (100MB+) to ensure memory efficiency
+### 3. Use Translations in Thymeleaf Templates
 
-### Backend
-- Use PDFBox for PDF manipulation
-- Implement proper error handling and logging
-- Add Swagger documentation to all API endpoints
-- Use service layer for business logic
-- Follow Spring Boot best practices
+In your Thymeleaf templates, use the `#{key}` syntax to reference the new translations:
 
-### General
-- Write clear commit messages
-- Update documentation for any API changes
-- Test in Docker before submitting PRs
-- Run `./gradlew spotlessApply` to format code
-- Ensure all tests pass with `./test.sh`
+```html
+<h1 th:text="#{pdfSplitter.title}">PDF Splitter</h1>
+<p th:text="#{pdfSplitter.description}">Split your PDF into multiple documents</p>
+<input type="text" th:placeholder="#{pdfSplitter.input.pages}">
+<button th:text="#{pdfSplitter.button.split}">Split PDF</button>
+```
+
+Remember, never hard-code text in your templates or Java code. Always use translation keys to ensure proper localization.

devGuide/HowToAddNewLanguage.md

@@ -8,66 +8,36 @@
 
 Fork Stirling-PDF and create a new branch out of `main`.
 
-## Add Language to i18n Configuration
+Then add a reference to the language in the navbar by adding a new language entry to the dropdown:
 
-Edit the file: [frontend/src/i18n.ts](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/frontend/src/i18n.ts)
+- Edit the file: [languages.html](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/app/core/src/main/resources/templates/fragments/languages.html)
 
-Add your language to the `supportedLanguages` object. For example, to add Polish:
 
-```typescript
-export const supportedLanguages = {
-  'en': 'English',
-  'en-GB': 'English (UK)',
-  // ... other languages ...
-  'pl-PL': 'Polski',  // Add your language here
-};
+For example, to add Polish, you would add:
+
+```html
+<div th:replace="~{fragments/languageEntry :: languageEntry ('pl_PL', 'Polski')}" ></div>
 ```
 
-If your language uses right-to-left (RTL) text direction, also add it to the `rtlLanguages` array:
+The `data-bs-language-code` is the code used to reference the file in the next step.
 
-```typescript
-export const rtlLanguages = ['ar-AR', 'fa-IR', 'pl-PL']; // Add if RTL
-```
+### Add Language Property File
 
-## Create Translation Directory
+Start by copying the existing English property file:
 
-Create a new directory for your language in `frontend/public/locales/`. For Polish, this would be:
+- [messages_en_GB.properties](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/app/core/src/main/resources/messages_en_GB.properties)
 
-```bash
-mkdir -p frontend/public/locales/pl-PL
-```
+Copy and rename it to `messages_{your data-bs-language-code here}.properties`. In the Polish example, you would set the name to `messages_pl_PL.properties`.
 
-## Add Translation File
+Then simply translate all property entries within that file and make a Pull Request (PR) into `main` for others to use!
 
-Start by copying the existing English (UK) translation file:
-
-- [frontend/public/locales/en-GB/translation.json](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/frontend/public/locales/en-GB/translation.json)
-
-Copy and rename it to `frontend/public/locales/{your-language-code}/translation.json`. In the Polish example:
-
-```bash
-cp frontend/public/locales/en-GB/translation.json frontend/public/locales/pl-PL/translation.json
-```
-
-Then translate all entries within that JSON file. The file uses nested JSON structure like:
-
-```json
-{
-  "addPageNumbers": {
-    "title": "Add Page Numbers",
-    "submit": "Add Page Numbers",
-    "error": {
-      "failed": "Add page numbers operation failed"
-    }
-  }
-}
-```
+If you do not have a Java IDE, I am happy to verify that the changes work once you raise the PR (but I won't be able to verify the translations themselves).
 
 ## Handling Untranslatable Strings
 
-Sometimes, certain strings may not require translation because they are the same in the target language or are universal (like names of protocols, certain terminologies, etc.). To ensure accurate statistics for language progress, these strings should be added to the `ignore_translation.toml` file located in the `scripts` directory. This will exclude them from the translation progress calculations.
+Sometimes, certain strings in the properties file may not require translation because they are the same in the target language or are universal (like names of protocols, certain terminologies, etc.). To ensure accurate statistics for language progress, these strings should be added to the `ignore_translation.toml` file located in the `scripts` directory. This will exclude them from the translation progress calculations.
 
-For example, if the English string for "error" does not need translation in Polish, add it to the `ignore_translation.toml` under the Polish section:
+For example, if the English string `error=Error` does not need translation in Polish, add it to the `ignore_translation.toml` under the Polish section:
 
 ```toml
 [pl_PL]
@@ -80,119 +50,27 @@ ignore = [
 ## Add New Translation Tags
 
 > [!IMPORTANT]
-> If you add any new translation tags, they must first be added to the `frontend/public/locales/en-GB/translation.json` file. This ensures consistency across all language files.
+> If you add any new translation tags, they must first be added to the `messages_en_GB.properties` file. This ensures consistency across all language files.
 
-- New translation tags **must be added** to the `en-GB` translation file to maintain a reference for other languages.
-- After adding the new tags to the en-GB file, add and translate them in the respective language file (e.g., `pl-PL/translation.json`).
+- New translation tags **must be added** to the `messages_en_GB.properties` file to maintain a reference for other languages.
+- After adding the new tags to `messages_en_GB.properties`, add and translate them in the respective language file (e.g., `messages_pl_PL.properties`).
 
 Make sure to place the entry under the correct language section. This helps maintain the accuracy of translation progress statistics and ensures that the translation tool or scripts do not misinterpret the completion rate.
 
-## Testing Your Translation
+### Use this code to perform a local check
 
-### Start the development server
+#### Windows command
 
-1. Start the frontend development server:
-   ```bash
-   cd frontend
-   npm run dev
-   ```
+```powershell
+python .github/scripts/check_language_properties.py --reference-file app\core\src\main\resources\messages_en_GB.properties --branch "" --files app\core\src\main\resources\messages_pl_PL.properties
 
-2. The language selector should now include your new language
+python .github/scripts/check_language_properties.py --reference-file app\core\src\main\resources\messages_en_GB.properties --branch "" --check-file app\core\src\main\resources\messages_pl_PL.properties
+```
 
-3. Select your language from the dropdown and verify all translations appear correctly
-
-## Summary Checklist
-
-When adding a new language, you need to update:
-
-- [ ] `frontend/src/i18n.ts` - Add to supportedLanguages (and rtlLanguages if needed)
-- [ ] `frontend/public/locales/{language-code}/translation.json` - Create and translate
-- [ ] `scripts/ignore_translation.toml` - Add untranslatable strings if needed
-
-Then make a Pull Request (PR) into `main` for others to use!
-
-If you do not have a Node.js environment, we are happy to verify that the changes work once you raise the PR (but we won't be able to verify the translations themselves).
-
-## Translation Guidelines
-
-- **Consistency**: Keep terminology consistent throughout the translation
-- **Context**: Consider the UI context when translating (e.g., button labels should be concise)
-- **Formatting**: Preserve placeholders like `{n}` or `{{count}}` in translations
-- **Testing**: Test your translations in the frontend interface
-- **RTL Languages**: If your language uses RTL, ensure you add it to the rtlLanguages array
-
-## Advanced: Translation Management Scripts
-
-For translators working on large translation files, Python scripts are available in `scripts/translations/` to help manage the workflow.
-
-### Finding Untranslated Strings
-
-To see which strings still need translation:
+#### Linux command
 
 ```bash
-# Check translation status for your language
-python scripts/translations/translation_analyzer.py --language pl-PL --summary
+python3 .github/scripts/check_language_properties.py --reference-file app/core/src/main/resources/messages_en_GB.properties --branch "" --files app/core/src/main/resources/messages_pl_PL.properties
 
-# See detailed list of missing translations
-python scripts/translations/translation_analyzer.py --language pl-PL --missing-only
+python3 .github/scripts/check_language_properties.py --reference-file app/core/src/main/resources/messages_en_GB.properties --branch "" --check-file app/core/src/main/resources/messages_pl_PL.properties
 ```
-
-### Extracting Untranslated Strings
-
-To extract only the strings that need translation into a separate file:
-
-```bash
-# Extract to a compact JSON file
-python scripts/translations/compact_translator.py pl-PL --output to_translate.json
-```
-
-This creates a file with just the untranslated entries:
-
-```json
-{
-  "addPageNumbers.title": "Add Page Numbers",
-  "compress.header": "Compress PDF",
-  "merge.submit": "Merge PDFs"
-}
-```
-
-### Translating the Extracted File
-
-Open `to_translate.json` and translate the values while keeping the keys unchanged:
-
-```json
-{
-  "addPageNumbers.title": "Dodaj numery stron",
-  "compress.header": "Kompresuj PDF",
-  "merge.submit": "Połącz pliki PDF"
-}
-```
-
-### Merging Translations Back
-
-After translating, merge your translations back into the main file:
-
-```bash
-# Apply your translations
-python scripts/translations/translation_merger.py pl-PL apply-translations --translations-file to_translate.json
-
-# Verify the result
-python scripts/translations/translation_analyzer.py --language pl-PL --summary
-```
-
-### Validating Your Work
-
-Before submitting, validate your translation file:
-
-```bash
-# Check for JSON syntax errors
-python scripts/translations/json_validator.py frontend/public/locales/pl-PL/translation.json
-
-# Check for missing placeholders
-python scripts/translations/validate_placeholders.py --language pl-PL
-
-# Check for structural issues
-python scripts/translations/validate_json_structure.py --language pl-PL
-```
-
-**Note**: These scripts require Python 3.7+ to be installed. See `scripts/translations/README.md` for detailed documentation.

frontend/package-lock.json

@@ -54,7 +54,6 @@
         "react-dom": "^19.1.1",
         "react-i18next": "^15.7.3",
         "react-router-dom": "^7.9.1",
-        "signature_pad": "^5.0.4",
         "tailwindcss": "^4.1.13",
         "web-vitals": "^5.1.0"
       },
@@ -9993,12 +9992,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/signature_pad": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/signature_pad/-/signature_pad-5.1.1.tgz",
-      "integrity": "sha512-BT5JJygS5BS0oV+tffPRorIud6q17bM7v/1LdQwd0o6mTqGoI25yY1NjSL99OqkekWltS4uon6p52Y8j1Zqu7g==",
-      "license": "MIT"
-    },
     "node_modules/slash": {
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",

frontend/package.json

@@ -50,7 +50,6 @@
     "react-dom": "^19.1.1",
     "react-i18next": "^15.7.3",
     "react-router-dom": "^7.9.1",
-    "signature_pad": "^5.0.4",
     "tailwindcss": "^4.1.13",
     "web-vitals": "^5.1.0"
   },

frontend/public/locales/en-GB/translation.json

@@ -1819,16 +1819,8 @@
       "placeholder": "Enter your full name"
     },
     "instructions": {
-      "title": "How to add signature",
-      "canvas": "After drawing your signature in the canvas, close the modal then click anywhere on the PDF to place it.",
-      "image": "After uploading your signature image above, click anywhere on the PDF to place it.",
-      "text": "After entering your name above, click anywhere on the PDF to place your signature."
+      "title": "How to add signature"
     },
-    "mode": {
-      "move": "Move Signature",
-      "place": "Place Signature"
-    },
-    "updateAndPlace": "Update and Place",
     "activate": "Activate Signature Placement",
     "deactivate": "Stop Placing Signatures",
     "results": {

frontend/src/components/annotation/shared/DrawingCanvas.tsx

@@ -1,8 +1,7 @@
-import React, { useRef, useState } from 'react';
-import { Paper, Button, Modal, Stack, Text, Popover, ColorPicker as MantineColorPicker } from '@mantine/core';
+import React, { useRef, useState, useCallback } from 'react';
+import { Paper, Group, Button, Modal, Stack, Text } from '@mantine/core';
 import { ColorSwatchButton } from './ColorPicker';
 import PenSizeSelector from '../../tools/sign/PenSizeSelector';
-import SignaturePad from 'signature_pad';
 
 interface DrawingCanvasProps {
   selectedColor: string;
@@ -12,7 +11,6 @@ interface DrawingCanvasProps {
   onPenSizeChange: (size: number) => void;
   onPenSizeInputChange: (input: string) => void;
   onSignatureDataChange: (data: string | null) => void;
-  onDrawingComplete?: () => void;
   disabled?: boolean;
   width?: number;
   height?: number;
@@ -29,253 +27,411 @@ export const DrawingCanvas: React.FC<DrawingCanvasProps> = ({
   onPenSizeChange,
   onPenSizeInputChange,
   onSignatureDataChange,
-  onDrawingComplete,
   disabled = false,
   width = 400,
   height = 150,
+  modalWidth = 800,
+  modalHeight = 400,
+  additionalButtons
 }) => {
-  const previewCanvasRef = useRef<HTMLCanvasElement>(null);
+  const canvasRef = useRef<HTMLCanvasElement>(null);
   const modalCanvasRef = useRef<HTMLCanvasElement>(null);
-  const padRef = useRef<SignaturePad | null>(null);
-  const [modalOpen, setModalOpen] = useState(false);
-  const [colorPickerOpen, setColorPickerOpen] = useState(false);
+  const visibleModalCanvasRef = useRef<HTMLCanvasElement>(null);
 
-  const initPad = (canvas: HTMLCanvasElement) => {
-    if (!padRef.current) {
-      const rect = canvas.getBoundingClientRect();
-      canvas.width = rect.width;
-      canvas.height = rect.height;
+  const [isDrawing, setIsDrawing] = useState(false);
+  const [isModalDrawing, setIsModalDrawing] = useState(false);
+  const [isModalOpen, setIsModalOpen] = useState(false);
 
-      padRef.current = new SignaturePad(canvas, {
-        penColor: selectedColor,
-        minWidth: penSize * 0.5,
-        maxWidth: penSize * 2.5,
-        throttle: 10,
-        minDistance: 5,
-        velocityFilterWeight: 0.7,
-      });
+  // Drawing functions for main canvas
+  const startDrawing = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!canvasRef.current || disabled) return;
+
+    setIsDrawing(true);
+    const rect = canvasRef.current.getBoundingClientRect();
+    const scaleX = canvasRef.current.width / rect.width;
+    const scaleY = canvasRef.current.height / rect.height;
+    const x = (e.clientX - rect.left) * scaleX;
+    const y = (e.clientY - rect.top) * scaleY;
+
+    const ctx = canvasRef.current.getContext('2d');
+    if (ctx) {
+      ctx.strokeStyle = selectedColor;
+      ctx.lineWidth = penSize;
+      ctx.lineCap = 'round';
+      ctx.lineJoin = 'round';
+      ctx.beginPath();
+      ctx.moveTo(x, y);
     }
-  };
+  }, [disabled, selectedColor, penSize]);
 
-  const openModal = () => {
-    // Clear pad ref so it reinitializes
-    if (padRef.current) {
-      padRef.current.off();
-      padRef.current = null;
+  const draw = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!isDrawing || !canvasRef.current || disabled) return;
+
+    const rect = canvasRef.current.getBoundingClientRect();
+    const scaleX = canvasRef.current.width / rect.width;
+    const scaleY = canvasRef.current.height / rect.height;
+    const x = (e.clientX - rect.left) * scaleX;
+    const y = (e.clientY - rect.top) * scaleY;
+
+    const ctx = canvasRef.current.getContext('2d');
+    if (ctx) {
+      ctx.lineTo(x, y);
+      ctx.stroke();
     }
-    setModalOpen(true);
-  };
+  }, [isDrawing, disabled]);
 
-  const trimCanvas = (canvas: HTMLCanvasElement): string => {
-    const ctx = canvas.getContext('2d');
-    if (!ctx) return canvas.toDataURL('image/png');
+  const stopDrawing = useCallback(() => {
+    if (!isDrawing || disabled) return;
 
-    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
-    const pixels = imageData.data;
+    setIsDrawing(false);
 
-    let minX = canvas.width, minY = canvas.height, maxX = 0, maxY = 0;
+    // Save canvas as signature data
+    if (canvasRef.current) {
+      const dataURL = canvasRef.current.toDataURL('image/png');
+      onSignatureDataChange(dataURL);
+    }
+  }, [isDrawing, disabled, onSignatureDataChange]);
 
-    // Find bounds of non-transparent pixels
-    for (let y = 0; y < canvas.height; y++) {
-      for (let x = 0; x < canvas.width; x++) {
-        const alpha = pixels[(y * canvas.width + x) * 4 + 3];
-        if (alpha > 0) {
-          if (x < minX) minX = x;
-          if (x > maxX) maxX = x;
-          if (y < minY) minY = y;
-          if (y > maxY) maxY = y;
+  // Modal canvas drawing functions
+  const startModalDrawing = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!visibleModalCanvasRef.current || !modalCanvasRef.current) return;
+
+    setIsModalDrawing(true);
+    const rect = visibleModalCanvasRef.current.getBoundingClientRect();
+    const scaleX = visibleModalCanvasRef.current.width / rect.width;
+    const scaleY = visibleModalCanvasRef.current.height / rect.height;
+    const x = (e.clientX - rect.left) * scaleX;
+    const y = (e.clientY - rect.top) * scaleY;
+
+    // Draw on both the visible modal canvas and hidden canvas
+    const visibleCtx = visibleModalCanvasRef.current.getContext('2d');
+    const hiddenCtx = modalCanvasRef.current.getContext('2d');
+
+    [visibleCtx, hiddenCtx].forEach(ctx => {
+      if (ctx) {
+        ctx.strokeStyle = selectedColor;
+        ctx.lineWidth = penSize;
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+      }
+    });
+  }, [selectedColor, penSize]);
+
+  const drawModal = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
+    if (!isModalDrawing || !visibleModalCanvasRef.current || !modalCanvasRef.current) return;
+
+    const rect = visibleModalCanvasRef.current.getBoundingClientRect();
+    const scaleX = visibleModalCanvasRef.current.width / rect.width;
+    const scaleY = visibleModalCanvasRef.current.height / rect.height;
+    const x = (e.clientX - rect.left) * scaleX;
+    const y = (e.clientY - rect.top) * scaleY;
+
+    // Draw on both canvases
+    const visibleCtx = visibleModalCanvasRef.current.getContext('2d');
+    const hiddenCtx = modalCanvasRef.current.getContext('2d');
+
+    [visibleCtx, hiddenCtx].forEach(ctx => {
+      if (ctx) {
+        ctx.lineTo(x, y);
+        ctx.stroke();
+      }
+    });
+  }, [isModalDrawing]);
+
+  const stopModalDrawing = useCallback(() => {
+    if (!isModalDrawing) return;
+    setIsModalDrawing(false);
+
+    // Sync the canvases and update signature data (only when drawing stops)
+    if (modalCanvasRef.current) {
+      const dataURL = modalCanvasRef.current.toDataURL('image/png');
+      onSignatureDataChange(dataURL);
+
+      // Also update the small canvas display
+      if (canvasRef.current) {
+        const smallCtx = canvasRef.current.getContext('2d');
+        if (smallCtx) {
+          const img = new Image();
+          img.onload = () => {
+            smallCtx.clearRect(0, 0, canvasRef.current!.width, canvasRef.current!.height);
+            smallCtx.drawImage(img, 0, 0, canvasRef.current!.width, canvasRef.current!.height);
+          };
+          img.src = dataURL;
         }
       }
     }
+  }, [isModalDrawing]);
 
-    const trimWidth = maxX - minX + 1;
-    const trimHeight = maxY - minY + 1;
+  // Clear canvas functions
+  const clearCanvas = useCallback(() => {
+    if (!canvasRef.current || disabled) return;
 
-    // Create trimmed canvas
-    const trimmedCanvas = document.createElement('canvas');
-    trimmedCanvas.width = trimWidth;
-    trimmedCanvas.height = trimHeight;
-    const trimmedCtx = trimmedCanvas.getContext('2d');
-    if (trimmedCtx) {
-      trimmedCtx.drawImage(canvas, minX, minY, trimWidth, trimHeight, 0, 0, trimWidth, trimHeight);
+    const ctx = canvasRef.current.getContext('2d');
+    if (ctx) {
+      ctx.clearRect(0, 0, canvasRef.current.width, canvasRef.current.height);
+
+      // Also clear the modal canvas if it exists
+      if (modalCanvasRef.current) {
+        const modalCtx = modalCanvasRef.current.getContext('2d');
+        if (modalCtx) {
+          modalCtx.clearRect(0, 0, modalCanvasRef.current.width, modalCanvasRef.current.height);
+        }
+      }
+
+      onSignatureDataChange(null);
+    }
+  }, [disabled]);
+
+  const clearModalCanvas = useCallback(() => {
+    // Clear both modal canvases (visible and hidden)
+    if (modalCanvasRef.current) {
+      const hiddenCtx = modalCanvasRef.current.getContext('2d');
+      if (hiddenCtx) {
+        hiddenCtx.clearRect(0, 0, modalCanvasRef.current.width, modalCanvasRef.current.height);
+      }
     }
 
-    return trimmedCanvas.toDataURL('image/png');
-  };
+    if (visibleModalCanvasRef.current) {
+      const visibleCtx = visibleModalCanvasRef.current.getContext('2d');
+      if (visibleCtx) {
+        visibleCtx.clearRect(0, 0, visibleModalCanvasRef.current.width, visibleModalCanvasRef.current.height);
+      }
+    }
 
-  const closeModal = () => {
-    if (padRef.current && !padRef.current.isEmpty()) {
-      const canvas = modalCanvasRef.current;
-      if (canvas) {
-        const trimmedPng = trimCanvas(canvas);
-        onSignatureDataChange(trimmedPng);
+    // Also clear the main canvas and signature data
+    if (canvasRef.current) {
+      const mainCtx = canvasRef.current.getContext('2d');
+      if (mainCtx) {
+        mainCtx.clearRect(0, 0, canvasRef.current.width, canvasRef.current.height);
+      }
+    }
 
-        // Update preview canvas with proper aspect ratio
+    onSignatureDataChange(null);
+  }, []);
+
+  const saveModalSignature = useCallback(() => {
+    if (!modalCanvasRef.current) return;
+
+    const dataURL = modalCanvasRef.current.toDataURL('image/png');
+    onSignatureDataChange(dataURL);
+
+    // Copy to small canvas for display
+    if (canvasRef.current) {
+      const ctx = canvasRef.current.getContext('2d');
+      if (ctx) {
         const img = new Image();
         img.onload = () => {
-          if (previewCanvasRef.current) {
-            const ctx = previewCanvasRef.current.getContext('2d');
-            if (ctx) {
-              ctx.clearRect(0, 0, previewCanvasRef.current.width, previewCanvasRef.current.height);
-
-              // Calculate scaling to fit within preview canvas while maintaining aspect ratio
-              const scale = Math.min(
-                previewCanvasRef.current.width / img.width,
-                previewCanvasRef.current.height / img.height
-              );
-              const scaledWidth = img.width * scale;
-              const scaledHeight = img.height * scale;
-              const x = (previewCanvasRef.current.width - scaledWidth) / 2;
-              const y = (previewCanvasRef.current.height - scaledHeight) / 2;
-
-              ctx.drawImage(img, x, y, scaledWidth, scaledHeight);
-            }
-          }
+          ctx.clearRect(0, 0, canvasRef.current!.width, canvasRef.current!.height);
+          ctx.drawImage(img, 0, 0, canvasRef.current!.width, canvasRef.current!.height);
         };
-        img.src = trimmedPng;
+        img.src = dataURL;
+      }
+    }
 
-        if (onDrawingComplete) {
-          onDrawingComplete();
+    setIsModalOpen(false);
+  }, []);
+
+  const openModal = useCallback(() => {
+    setIsModalOpen(true);
+    // Copy content to modal canvas after a brief delay
+    setTimeout(() => {
+      if (visibleModalCanvasRef.current && modalCanvasRef.current) {
+        const visibleCtx = visibleModalCanvasRef.current.getContext('2d');
+        if (visibleCtx) {
+          visibleCtx.strokeStyle = selectedColor;
+          visibleCtx.lineWidth = penSize;
+          visibleCtx.lineCap = 'round';
+          visibleCtx.lineJoin = 'round';
+          visibleCtx.clearRect(0, 0, visibleModalCanvasRef.current.width, visibleModalCanvasRef.current.height);
+          visibleCtx.drawImage(modalCanvasRef.current, 0, 0, visibleModalCanvasRef.current.width, visibleModalCanvasRef.current.height);
         }
       }
-    }
-    if (padRef.current) {
-      padRef.current.off();
-      padRef.current = null;
-    }
-    setModalOpen(false);
-  };
+    }, 300);
+  }, [selectedColor, penSize]);
 
-  const clear = () => {
-    if (padRef.current) {
-      padRef.current.clear();
-    }
-    if (previewCanvasRef.current) {
-      const ctx = previewCanvasRef.current.getContext('2d');
+  // Initialize canvas settings whenever color or pen size changes
+  React.useEffect(() => {
+    const updateCanvas = (canvas: HTMLCanvasElement | null) => {
+      if (!canvas) return;
+      const ctx = canvas.getContext('2d');
       if (ctx) {
-        ctx.clearRect(0, 0, previewCanvasRef.current.width, previewCanvasRef.current.height);
+        ctx.strokeStyle = selectedColor;
+        ctx.lineWidth = penSize;
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
       }
-    }
-    onSignatureDataChange(null);
-  };
+    };
 
-  const updatePenColor = (color: string) => {
-    if (padRef.current) {
-      padRef.current.penColor = color;
-    }
-  };
-
-  const updatePenSize = (size: number) => {
-    if (padRef.current) {
-      padRef.current.minWidth = size * 0.8;
-      padRef.current.maxWidth = size * 1.2;
-    }
-  };
+    updateCanvas(canvasRef.current);
+    updateCanvas(modalCanvasRef.current);
+    updateCanvas(visibleModalCanvasRef.current);
+  }, [selectedColor, penSize]);
 
   return (
     <>
       <Paper withBorder p="md">
         <Stack gap="sm">
-          <Text fw={500}>Draw your signature</Text>
+          <Group justify="space-between">
+            <Text fw={500}>Draw your signature</Text>
+            <Group gap="lg">
+              <div>
+                <Text size="sm" fw={500} mb="xs" ta="center">Color</Text>
+                <Group justify="center">
+                  <ColorSwatchButton
+                    color={selectedColor}
+                    onClick={onColorSwatchClick}
+                  />
+                </Group>
+              </div>
+              <div>
+                <Text size="sm" fw={500} mb="xs">Pen Size</Text>
+                <PenSizeSelector
+                  value={penSize}
+                  inputValue={penSizeInput}
+                  onValueChange={onPenSizeChange}
+                  onInputChange={onPenSizeInputChange}
+                  disabled={disabled}
+                  placeholder="Size"
+                  size="compact-sm"
+                  style={{ width: '60px' }}
+                />
+              </div>
+              <div style={{ paddingTop: '24px' }}>
+                <Button
+                  variant="light"
+                  size="compact-sm"
+                  onClick={openModal}
+                  disabled={disabled}
+                >
+                  Expand
+                </Button>
+              </div>
+            </Group>
+          </Group>
           <canvas
-            ref={previewCanvasRef}
+            ref={canvasRef}
             width={width}
             height={height}
             style={{
               border: '1px solid #ccc',
               borderRadius: '4px',
-              cursor: disabled ? 'default' : 'pointer',
+              cursor: disabled ? 'default' : 'crosshair',
               backgroundColor: '#ffffff',
               width: '100%',
             }}
-            onClick={disabled ? undefined : openModal}
+            onMouseDown={startDrawing}
+            onMouseMove={draw}
+            onMouseUp={stopDrawing}
+            onMouseLeave={stopDrawing}
           />
-          <Text size="sm" c="dimmed" ta="center">
-            Click to open drawing canvas
-          </Text>
+          <Group justify="space-between">
+            <div>
+              {additionalButtons}
+            </div>
+            <Button
+              variant="subtle"
+              color="red"
+              size="compact-sm"
+              onClick={clearCanvas}
+              disabled={disabled}
+            >
+              Clear
+            </Button>
+          </Group>
         </Stack>
       </Paper>
 
-      <Modal opened={modalOpen} onClose={closeModal} title="Draw Your Signature" size="auto" centered>
+      {/* Hidden canvas for modal synchronization */}
+      <canvas
+        ref={modalCanvasRef}
+        width={modalWidth}
+        height={modalHeight}
+        style={{ display: 'none' }}
+      />
+
+      {/* Modal for larger signature canvas */}
+      <Modal
+        opened={isModalOpen}
+        onClose={() => setIsModalOpen(false)}
+        title="Draw Your Signature"
+        size="xl"
+        centered
+      >
         <Stack gap="md">
-          <div style={{ display: 'flex', gap: '20px', alignItems: 'flex-end' }}>
-            <div>
-              <Text size="sm" fw={500} mb="xs">Color</Text>
-              <Popover
-                opened={colorPickerOpen}
-                onChange={setColorPickerOpen}
-                position="bottom-start"
-                withArrow
-                withinPortal={false}
-              >
-                <Popover.Target>
-                  <div>
-                    <ColorSwatchButton
-                      color={selectedColor}
-                      onClick={() => setColorPickerOpen(!colorPickerOpen)}
-                    />
-                  </div>
-                </Popover.Target>
-                <Popover.Dropdown>
-                  <MantineColorPicker
-                    format="hex"
-                    value={selectedColor}
-                    onChange={(color) => {
-                      onColorSwatchClick();
-                      updatePenColor(color);
-                    }}
-                    swatches={['#000000', '#0066cc', '#cc0000', '#cc6600', '#009900', '#6600cc']}
-                  />
-                </Popover.Dropdown>
-              </Popover>
-            </div>
-            <div>
-              <Text size="sm" fw={500} mb="xs">Pen Size</Text>
-              <PenSizeSelector
-                value={penSize}
-                inputValue={penSizeInput}
-                onValueChange={(size) => {
-                  onPenSizeChange(size);
-                  updatePenSize(size);
-                }}
-                onInputChange={onPenSizeInputChange}
-                placeholder="Size"
-                size="compact-sm"
-                style={{ width: '60px' }}
-              />
-            </div>
-          </div>
+          {/* Color and Pen Size picker */}
+          <Paper withBorder p="sm">
+            <Group gap="lg" align="flex-end">
+              <div>
+                <Text size="sm" fw={500} mb="xs">Color</Text>
+                <ColorSwatchButton
+                  color={selectedColor}
+                  onClick={onColorSwatchClick}
+                />
+              </div>
+              <div>
+                <Text size="sm" fw={500} mb="xs">Pen Size</Text>
+                <PenSizeSelector
+                  value={penSize}
+                  inputValue={penSizeInput}
+                  onValueChange={onPenSizeChange}
+                  onInputChange={onPenSizeInputChange}
+                  placeholder="Size"
+                  size="compact-sm"
+                  style={{ width: '60px' }}
+                />
+              </div>
+            </Group>
+          </Paper>
 
-          <canvas
-            ref={(el) => {
-              modalCanvasRef.current = el;
-              if (el) initPad(el);
-            }}
-            style={{
-              border: '1px solid #ccc',
-              borderRadius: '4px',
-              display: 'block',
-              touchAction: 'none',
-              backgroundColor: 'white',
-              width: '100%',
-              maxWidth: '800px',
-              height: '400px',
-              cursor: 'crosshair',
-            }}
-          />
+          <Paper withBorder p="md">
+            <canvas
+              ref={visibleModalCanvasRef}
+              width={modalWidth}
+              height={modalHeight}
+              style={{
+                border: '1px solid #ccc',
+                borderRadius: '4px',
+                cursor: 'crosshair',
+                backgroundColor: '#ffffff',
+                width: '100%',
+                maxWidth: `${modalWidth}px`,
+                height: 'auto',
+              }}
+              onMouseDown={startModalDrawing}
+              onMouseMove={drawModal}
+              onMouseUp={stopModalDrawing}
+              onMouseLeave={stopModalDrawing}
+            />
+          </Paper>
 
-          <div style={{ display: 'flex', justifyContent: 'space-between' }}>
-            <Button variant="subtle" color="red" onClick={clear}>
+          <Group justify="space-between">
+            <Button
+              variant="subtle"
+              color="red"
+              onClick={clearModalCanvas}
+            >
               Clear Canvas
             </Button>
-            <Button onClick={closeModal}>
-              Done
-            </Button>
-          </div>
+            <Group gap="sm">
+              <Button
+                variant="subtle"
+                onClick={() => setIsModalOpen(false)}
+              >
+                Cancel
+              </Button>
+              <Button
+                onClick={saveModalSignature}
+              >
+                Save Signature
+              </Button>
+            </Group>
+          </Group>
         </Stack>
       </Modal>
     </>
   );
 };
 
-export default DrawingCanvas;
+export default DrawingCanvas;

frontend/src/components/annotation/shared/ImageUploader.tsx

@@ -48,7 +48,7 @@ export const ImageUploader: React.FC<ImageUploaderProps> = ({
         disabled={disabled}
       />
       <Text size="sm" c="dimmed">
-        {hint || t('sign.image.hint', 'Upload an image of your signature')}
+        {hint || t('sign.image.hint', 'Upload a PNG or JPG image of your signature')}
       </Text>
     </Stack>
   );

frontend/src/components/annotation/shared/TextInputWithFont.tsx

@@ -1,7 +1,6 @@
 import React, { useState, useEffect } from 'react';
-import { Stack, TextInput, Select, Combobox, useCombobox, Group, Box } from '@mantine/core';
+import { Stack, TextInput, Select, Combobox, useCombobox } from '@mantine/core';
 import { useTranslation } from 'react-i18next';
-import { ColorPicker } from './ColorPicker';
 
 interface TextInputWithFontProps {
   text: string;
@@ -10,8 +9,6 @@ interface TextInputWithFontProps {
   onFontSizeChange: (size: number) => void;
   fontFamily: string;
   onFontFamilyChange: (family: string) => void;
-  textColor?: string;
-  onTextColorChange?: (color: string) => void;
   disabled?: boolean;
   label?: string;
   placeholder?: string;
@@ -24,8 +21,6 @@ export const TextInputWithFont: React.FC<TextInputWithFontProps> = ({
   onFontSizeChange,
   fontFamily,
   onFontFamilyChange,
-  textColor = '#000000',
-  onTextColorChange,
   disabled = false,
   label,
   placeholder
@@ -33,7 +28,6 @@ export const TextInputWithFont: React.FC<TextInputWithFontProps> = ({
   const { t } = useTranslation();
   const [fontSizeInput, setFontSizeInput] = useState(fontSize.toString());
   const fontSizeCombobox = useCombobox();
-  const [isColorPickerOpen, setIsColorPickerOpen] = useState(false);
 
   // Sync font size input with prop changes
   useEffect(() => {
@@ -48,7 +42,7 @@ export const TextInputWithFont: React.FC<TextInputWithFontProps> = ({
     { value: 'Georgia', label: 'Georgia' },
   ];
 
-  const fontSizeOptions = ['8', '12', '16', '20', '24', '28', '32', '36', '40', '48', '56', '64', '72', '80', '96', '112', '128', '144', '160', '176', '192', '200'];
+  const fontSizeOptions = ['8', '12', '16', '20', '24', '28', '32', '36', '40', '48'];
 
   return (
     <Stack gap="sm">
@@ -72,101 +66,61 @@ export const TextInputWithFont: React.FC<TextInputWithFontProps> = ({
         allowDeselect={false}
       />
 
-      {/* Font Size and Color */}
-      <Group grow>
-        <Combobox
-          onOptionSubmit={(optionValue) => {
-            setFontSizeInput(optionValue);
-            const size = parseInt(optionValue);
-            if (!isNaN(size)) {
-              onFontSizeChange(size);
-            }
-            fontSizeCombobox.closeDropdown();
-          }}
-          store={fontSizeCombobox}
-          withinPortal={false}
-        >
-          <Combobox.Target>
-            <TextInput
-              label="Font Size"
-              placeholder="Type or select font size (8-200)"
-              value={fontSizeInput}
-              onChange={(event) => {
-                const value = event.currentTarget.value;
-                setFontSizeInput(value);
+      {/* Font Size */}
+      <Combobox
+        onOptionSubmit={(optionValue) => {
+          setFontSizeInput(optionValue);
+          const size = parseInt(optionValue);
+          if (!isNaN(size)) {
+            onFontSizeChange(size);
+          }
+          fontSizeCombobox.closeDropdown();
+        }}
+        store={fontSizeCombobox}
+        withinPortal={false}
+      >
+        <Combobox.Target>
+          <TextInput
+            label="Font Size"
+            placeholder="Type or select font size (8-72)"
+            value={fontSizeInput}
+            onChange={(event) => {
+              const value = event.currentTarget.value;
+              setFontSizeInput(value);
 
-                // Parse and validate the typed value in real-time
-                const size = parseInt(value);
-                if (!isNaN(size) && size >= 8 && size <= 200) {
-                  onFontSizeChange(size);
-                }
-
-                fontSizeCombobox.openDropdown();
-                fontSizeCombobox.updateSelectedOptionIndex();
-              }}
-              onClick={() => fontSizeCombobox.openDropdown()}
-              onFocus={() => fontSizeCombobox.openDropdown()}
-              onBlur={() => {
-                fontSizeCombobox.closeDropdown();
-                // Clean up invalid values on blur
-                const size = parseInt(fontSizeInput);
-                if (isNaN(size) || size < 8 || size > 200) {
-                  setFontSizeInput(fontSize.toString());
-                } else {
-                  onFontSizeChange(size);
-                }
-              }}
-              disabled={disabled}
-            />
-          </Combobox.Target>
-
-          <Combobox.Dropdown>
-            <Combobox.Options>
-              {fontSizeOptions.map((size) => (
-                <Combobox.Option value={size} key={size}>
-                  {size}px
-                </Combobox.Option>
-              ))}
-            </Combobox.Options>
-          </Combobox.Dropdown>
-        </Combobox>
-
-        {/* Text Color Picker */}
-        {onTextColorChange && (
-          <Box>
-            <TextInput
-              label="Text Color"
-              value={textColor}
-              readOnly
-              disabled={disabled}
-              onClick={() => !disabled && setIsColorPickerOpen(true)}
-              style={{ cursor: disabled ? 'default' : 'pointer' }}
-              rightSection={
-                <Box
-                  style={{
-                    width: 24,
-                    height: 24,
-                    backgroundColor: textColor,
-                    border: '1px solid #ccc',
-                    borderRadius: 4,
-                    cursor: disabled ? 'default' : 'pointer'
-                  }}
-                />
+              // Parse and validate the typed value in real-time
+              const size = parseInt(value);
+              if (!isNaN(size) && size >= 8 && size <= 72) {
+                onFontSizeChange(size);
               }
-            />
-          </Box>
-        )}
-      </Group>
 
-      {/* Color Picker Modal */}
-      {onTextColorChange && (
-        <ColorPicker
-          isOpen={isColorPickerOpen}
-          onClose={() => setIsColorPickerOpen(false)}
-          selectedColor={textColor}
-          onColorChange={onTextColorChange}
-        />
-      )}
+              fontSizeCombobox.openDropdown();
+              fontSizeCombobox.updateSelectedOptionIndex();
+            }}
+            onClick={() => fontSizeCombobox.openDropdown()}
+            onFocus={() => fontSizeCombobox.openDropdown()}
+            onBlur={() => {
+              fontSizeCombobox.closeDropdown();
+              // Clean up invalid values on blur
+              const size = parseInt(fontSizeInput);
+              if (isNaN(size) || size < 8 || size > 72) {
+                setFontSizeInput(fontSize.toString());
+              }
+            }}
+            disabled={disabled}
+          />
+        </Combobox.Target>
+
+        <Combobox.Dropdown>
+          <Combobox.Options>
+            {fontSizeOptions.map((size) => (
+              <Combobox.Option value={size} key={size}>
+                {size}px
+              </Combobox.Option>
+            ))}
+          </Combobox.Options>
+        </Combobox.Dropdown>
+      </Combobox>
     </Stack>
   );
 };

frontend/src/components/shared/rightRail/ViewerAnnotationControls.tsx

@@ -10,7 +10,6 @@ import { useFileState, useFileContext } from '../../../contexts/FileContext';
 import { generateThumbnailWithMetadata } from '../../../utils/thumbnailUtils';
 import { createProcessedFile } from '../../../contexts/file/fileActions';
 import { createStirlingFile, createNewStirlingFileStub } from '../../../types/fileContext';
-import { useNavigationState } from '../../../contexts/NavigationContext';
 
 interface ViewerAnnotationControlsProps {
   currentView: string;
@@ -26,17 +25,13 @@ export default function ViewerAnnotationControls({ currentView }: ViewerAnnotati
   const viewerContext = React.useContext(ViewerContext);
 
   // Signature context for accessing drawing API
-  const { signatureApiRef, isPlacementMode } = useSignature();
+  const { signatureApiRef } = useSignature();
 
   // File state for save functionality
   const { state, selectors } = useFileState();
   const { actions: fileActions } = useFileContext();
   const activeFiles = selectors.getFiles();
 
-  // Check if we're in sign mode
-  const { selectedTool } = useNavigationState();
-  const isSignMode = selectedTool === 'sign';
-
   // Turn off annotation mode when switching away from viewer
   useEffect(() => {
     if (currentView !== 'viewer' && viewerContext?.isAnnotationMode) {
@@ -44,11 +39,6 @@ export default function ViewerAnnotationControls({ currentView }: ViewerAnnotati
     }
   }, [currentView, viewerContext]);
 
-  // Don't show any annotation controls in sign mode
-  if (isSignMode) {
-    return null;
-  }
-
   return (
     <>
       {/* Annotation Visibility Toggle */}
@@ -60,7 +50,7 @@ export default function ViewerAnnotationControls({ currentView }: ViewerAnnotati
           onClick={() => {
             viewerContext?.toggleAnnotationsVisibility();
           }}
-          disabled={currentView !== 'viewer' || viewerContext?.isAnnotationMode || isPlacementMode}
+          disabled={currentView !== 'viewer' || viewerContext?.isAnnotationMode}
         >
           <LocalIcon
             icon={viewerContext?.isAnnotationsVisible ? "visibility" : "visibility-off-rounded"}

frontend/src/components/tools/sign/SignSettings.tsx

@@ -1,9 +1,8 @@
 import { useState, useEffect } from 'react';
 import { useTranslation } from "react-i18next";
-import { Stack, Button, Text, Alert, Tabs, SegmentedControl } from '@mantine/core';
+import { Stack, Button, Text, Alert, Tabs } from '@mantine/core';
 import { SignParameters } from "../../../hooks/tools/sign/useSignParameters";
 import { SuggestedToolsSection } from "../shared/SuggestedToolsSection";
-import { useSignature } from "../../../contexts/SignatureContext";
 
 // Import the new reusable components
 import { DrawingCanvas } from "../../annotation/shared/DrawingCanvas";
@@ -36,14 +35,12 @@ const SignSettings = ({
   onSave
 }: SignSettingsProps) => {
   const { t } = useTranslation();
-  const { isPlacementMode } = useSignature();
 
   // State for drawing
   const [selectedColor, setSelectedColor] = useState('#000000');
   const [penSize, setPenSize] = useState(2);
   const [penSizeInput, setPenSizeInput] = useState('2');
   const [isColorPickerOpen, setIsColorPickerOpen] = useState(false);
-  const [interactionMode, setInteractionMode] = useState<'move' | 'place'>('move');
 
   // State for different signature types
   const [canvasSignatureData, setCanvasSignatureData] = useState<string | null>(null);
@@ -99,29 +96,20 @@ const SignSettings = ({
     }
   }, [parameters.signatureType]);
 
-  // Handle text signature activation (including fontSize and fontFamily changes)
+  // Handle text signature activation
   useEffect(() => {
     if (parameters.signatureType === 'text' && parameters.signerName && parameters.signerName.trim() !== '') {
       if (onActivateSignaturePlacement) {
-        setInteractionMode('place');
         setTimeout(() => {
           onActivateSignaturePlacement();
         }, 100);
       }
     } else if (parameters.signatureType === 'text' && (!parameters.signerName || parameters.signerName.trim() === '')) {
       if (onDeactivateSignature) {
-        setInteractionMode('move');
         onDeactivateSignature();
       }
     }
-  }, [parameters.signatureType, parameters.signerName, parameters.fontSize, parameters.fontFamily, onActivateSignaturePlacement, onDeactivateSignature]);
-
-  // Reset to move mode when placement mode is deactivated
-  useEffect(() => {
-    if (!isPlacementMode && interactionMode === 'place') {
-      setInteractionMode('move');
-    }
-  }, [isPlacementMode, interactionMode]);
+  }, [parameters.signatureType, parameters.signerName, onActivateSignaturePlacement, onDeactivateSignature]);
 
   // Handle signature data updates
   useEffect(() => {
@@ -142,23 +130,12 @@ const SignSettings = ({
   // Handle image signature activation - activate when image data syncs with parameters
   useEffect(() => {
     if (parameters.signatureType === 'image' && imageSignatureData && parameters.signatureData === imageSignatureData && onActivateSignaturePlacement) {
-      setInteractionMode('place');
       setTimeout(() => {
         onActivateSignaturePlacement();
       }, 100);
     }
   }, [parameters.signatureType, parameters.signatureData, imageSignatureData]);
 
-  // Handle canvas signature activation - activate when canvas data syncs with parameters
-  useEffect(() => {
-    if (parameters.signatureType === 'canvas' && canvasSignatureData && parameters.signatureData === canvasSignatureData && onActivateSignaturePlacement) {
-      setInteractionMode('place');
-      setTimeout(() => {
-        onActivateSignaturePlacement();
-      }, 100);
-    }
-  }, [parameters.signatureType, parameters.signatureData, canvasSignatureData]);
-
   // Draw settings are no longer needed since draw mode is removed
 
   return (
@@ -193,7 +170,7 @@ const SignSettings = ({
         hasSignatureData={!!(canvasSignatureData || imageSignatureData || (parameters.signerName && parameters.signerName.trim() !== ''))}
         disabled={disabled}
         showPlaceButton={false}
-        placeButtonText={t('sign.updateAndPlace', 'Update and Place')}
+        placeButtonText="Update and Place"
       />
 
       {/* Signature Creation based on type */}
@@ -206,11 +183,6 @@ const SignSettings = ({
           onPenSizeChange={setPenSize}
           onPenSizeInputChange={setPenSizeInput}
           onSignatureDataChange={handleCanvasSignatureChange}
-          onDrawingComplete={() => {
-            if (onActivateSignaturePlacement) {
-              onActivateSignaturePlacement();
-            }
-          }}
           disabled={disabled}
           additionalButtons={
             <Button
@@ -223,7 +195,7 @@ const SignSettings = ({
               variant="filled"
               disabled={disabled || !canvasSignatureData}
             >
-              {t('sign.updateAndPlace', 'Update and Place')}
+              Update and Place
             </Button>
           }
         />
@@ -244,43 +216,17 @@ const SignSettings = ({
           onFontSizeChange={(size) => onParameterChange('fontSize', size)}
           fontFamily={parameters.fontFamily || 'Helvetica'}
           onFontFamilyChange={(family) => onParameterChange('fontFamily', family)}
-          textColor={parameters.textColor || '#000000'}
-          onTextColorChange={(color) => onParameterChange('textColor', color)}
           disabled={disabled}
         />
       )}
 
 
-      {/* Interaction Mode Toggle */}
-      {(canvasSignatureData || imageSignatureData || (parameters.signerName && parameters.signerName.trim() !== '')) && (
-        <SegmentedControl
-          value={interactionMode}
-          onChange={(value) => {
-            setInteractionMode(value as 'move' | 'place');
-            if (value === 'place') {
-              if (onActivateSignaturePlacement) {
-                onActivateSignaturePlacement();
-              }
-            } else {
-              if (onDeactivateSignature) {
-                onDeactivateSignature();
-              }
-            }
-          }}
-          data={[
-            { label: t('sign.mode.move', 'Move Signature'), value: 'move' },
-            { label: t('sign.mode.place', 'Place Signature'), value: 'place' }
-          ]}
-          fullWidth
-        />
-      )}
-
       {/* Instructions for placing signature */}
       <Alert color="blue" title={t('sign.instructions.title', 'How to add signature')}>
         <Text size="sm">
-          {parameters.signatureType === 'canvas' && t('sign.instructions.canvas', 'After drawing your signature in the canvas, close the modal then click anywhere on the PDF to place it.')}
-          {parameters.signatureType === 'image' && t('sign.instructions.image', 'After uploading your signature image above, click anywhere on the PDF to place it.')}
-          {parameters.signatureType === 'text' && t('sign.instructions.text', 'After entering your name above, click anywhere on the PDF to place your signature.')}
+          {parameters.signatureType === 'canvas' && 'After drawing your signature in the canvas above, click "Update and Place" then click anywhere on the PDF to place it.'}
+          {parameters.signatureType === 'image' && 'After uploading your signature image above, click anywhere on the PDF to place it.'}
+          {parameters.signatureType === 'text' && 'After entering your name above, click anywhere on the PDF to place your signature.'}
         </Text>
       </Alert>
 

frontend/src/components/viewer/EmbedPdfViewer.tsx

@@ -13,7 +13,6 @@ import { useNavigationGuard, useNavigationState } from '../../contexts/Navigatio
 import { useSignature } from '../../contexts/SignatureContext';
 import { createStirlingFilesAndStubs } from '../../services/fileStubHelpers';
 import NavigationWarningModal from '../shared/NavigationWarningModal';
-import { isStirlingFile } from '../../types/fileContext';
 
 export interface EmbedPdfViewerProps {
   sidebarsVisible: boolean;
@@ -264,7 +263,6 @@ const EmbedPdfViewerContent = ({
             transition: 'margin-right 0.3s ease'
           }}>
             <LocalEmbedPDF
-              key={currentFile && isStirlingFile(currentFile) ? currentFile.fileId : (effectiveFile.file instanceof File ? effectiveFile.file.name : effectiveFile.url)}
               file={effectiveFile.file}
               url={effectiveFile.url}
               enableAnnotations={shouldEnableAnnotations}

frontend/src/components/viewer/LocalEmbedPDF.tsx

@@ -314,7 +314,7 @@ export function LocalEmbedPDF({ file, url, enableAnnotations = false, onSignatur
                     <CustomSearchLayer pageIndex={pageIndex} scale={scale} />
 
                     {/* Selection layer for text interaction */}
-                    <SelectionLayer pageIndex={pageIndex} scale={scale} />
+                    <SelectionLayer  pageIndex={pageIndex} scale={scale} />
                     {/* Annotation layer for signatures (only when enabled) */}
                     {enableAnnotations && (
                       <AnnotationLayer

frontend/src/components/viewer/SignatureAPIBridge.tsx

@@ -1,30 +1,34 @@
 import { useImperativeHandle, forwardRef, useEffect } from 'react';
 import { useAnnotationCapability } from '@embedpdf/plugin-annotation/react';
-import { PdfAnnotationSubtype, uuidV4 } from '@embedpdf/models';
+import { PdfAnnotationSubtype, PdfStandardFont, PdfTextAlignment, PdfVerticalAlignment, uuidV4 } from '@embedpdf/models';
+import { SignParameters } from '../../hooks/tools/sign/useSignParameters';
 import { useSignature } from '../../contexts/SignatureContext';
+import { useViewer } from '../../contexts/ViewerContext';
 
 export interface SignatureAPI {
   addImageSignature: (signatureData: string, x: number, y: number, width: number, height: number, pageIndex: number) => void;
+  addTextSignature: (text: string, x: number, y: number, pageIndex: number) => void;
   activateDrawMode: () => void;
   activateSignaturePlacementMode: () => void;
   activateDeleteMode: () => void;
   deleteAnnotation: (annotationId: string, pageIndex: number) => void;
   updateDrawSettings: (color: string, size: number) => void;
   deactivateTools: () => void;
+  applySignatureFromParameters: (params: SignParameters) => void;
   getPageAnnotations: (pageIndex: number) => Promise<any[]>;
 }
 
 export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPIBridge(_, ref) {
   const { provides: annotationApi } = useAnnotationCapability();
   const { signatureConfig, storeImageData, isPlacementMode } = useSignature();
+  const { isAnnotationMode } = useViewer();
 
 
-  // Enable keyboard deletion of selected annotations
+  // Enable keyboard deletion of selected annotations - when in signature placement mode or viewer annotation mode
   useEffect(() => {
-    // Always enable delete key when we have annotation API and are in sign mode
-    if (!annotationApi || (isPlacementMode === undefined)) return;
+    if (!annotationApi || (!isPlacementMode && !isAnnotationMode)) return;
 
-    const handleKeyDown = (event: KeyboardEvent) => {
+  const handleKeyDown = (event: KeyboardEvent) => {
       if (event.key === 'Delete' || event.key === 'Backspace') {
         const selectedAnnotation = annotationApi.getSelectedAnnotation?.();
 
@@ -63,7 +67,7 @@ export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPI
 
     document.addEventListener('keydown', handleKeyDown);
     return () => document.removeEventListener('keydown', handleKeyDown);
-  }, [annotationApi, storeImageData, isPlacementMode]);
+  }, [annotationApi, storeImageData, isPlacementMode, isAnnotationMode]);
 
   useImperativeHandle(ref, () => ({
     addImageSignature: (signatureData: string, x: number, y: number, width: number, height: number, pageIndex: number) => {
@@ -96,6 +100,34 @@ export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPI
       });
     },
 
+    addTextSignature: (text: string, x: number, y: number, pageIndex: number) => {
+      if (!annotationApi) return;
+
+      // Create text annotation for signature
+      annotationApi.createAnnotation(pageIndex, {
+        type: PdfAnnotationSubtype.FREETEXT,
+        rect: {
+          origin: { x, y },
+          size: { width: 200, height: 50 }
+        },
+        contents: text,
+        author: 'Digital Signature',
+        fontSize: 16,
+        fontColor: '#000000',
+        fontFamily: PdfStandardFont.Helvetica,
+        textAlign: PdfTextAlignment.Left,
+        verticalAlign: PdfVerticalAlignment.Top,
+        opacity: 1,
+        pageIndex: pageIndex,
+        id: uuidV4(),
+        created: new Date(),
+        customData: {
+          signatureText: text,
+          signatureType: 'text'
+        }
+      });
+    },
+
     activateDrawMode: () => {
       if (!annotationApi) return;
 
@@ -120,31 +152,45 @@ export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPI
 
       try {
         if (signatureConfig.signatureType === 'text' && signatureConfig.signerName) {
-          // Skip native text tools - always use stamp for consistent sizing
-          const activatedTool = null;
+          // Try different tool names for text annotations
+          const textToolNames = ['freetext', 'text', 'textbox', 'annotation-text'];
+          let activatedTool = null;
+
+          for (const toolName of textToolNames) {
+            annotationApi.setActiveTool(toolName);
+            const tool = annotationApi.getActiveTool();
+
+            if (tool && tool.id === toolName) {
+              activatedTool = tool;
+              annotationApi.setToolDefaults(toolName, {
+                contents: signatureConfig.signerName,
+                fontSize: signatureConfig.fontSize || 16,
+                fontFamily: signatureConfig.fontFamily === 'Times-Roman' ? PdfStandardFont.Times_Roman :
+                          signatureConfig.fontFamily === 'Courier' ? PdfStandardFont.Courier :
+                          PdfStandardFont.Helvetica,
+                fontColor: '#000000',
+              });
+              break;
+            }
+          }
 
           if (!activatedTool) {
-            // Create text image as stamp with actual pixel size matching desired display size
+            // Fallback: create a simple text image as stamp
             const canvas = document.createElement('canvas');
             const ctx = canvas.getContext('2d');
             if (ctx) {
-              const baseFontSize = signatureConfig.fontSize || 16;
+              const fontSize = signatureConfig.fontSize || 16;
               const fontFamily = signatureConfig.fontFamily || 'Helvetica';
-              const textColor = signatureConfig.textColor || '#000000';
 
-              // Canvas pixel size = display size (EmbedPDF uses pixel dimensions directly)
-              canvas.width = Math.max(200, signatureConfig.signerName.length * baseFontSize * 0.6);
-              canvas.height = baseFontSize + 20;
-
-              ctx.fillStyle = textColor;
-              ctx.font = `${baseFontSize}px ${fontFamily}`;
+              canvas.width = Math.max(200, signatureConfig.signerName.length * fontSize * 0.6);
+              canvas.height = fontSize + 20;
+              ctx.fillStyle = '#000000';
+              ctx.font = `${fontSize}px ${fontFamily}`;
               ctx.textAlign = 'left';
               ctx.textBaseline = 'middle';
               ctx.fillText(signatureConfig.signerName, 10, canvas.height / 2);
               const dataURL = canvas.toDataURL();
 
-              // Deactivate and reactivate to force refresh
-              annotationApi.setActiveTool(null);
               annotationApi.setActiveTool('stamp');
               const stampTool = annotationApi.getActiveTool();
               if (stampTool && stampTool.id === 'stamp') {
@@ -159,7 +205,6 @@ export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPI
           // Use stamp tool for image/canvas signatures
           annotationApi.setActiveTool('stamp');
           const activeTool = annotationApi.getActiveTool();
-
           if (activeTool && activeTool.id === 'stamp') {
             annotationApi.setToolDefaults('stamp', {
               imageSrc: signatureConfig.signatureData,
@@ -222,6 +267,84 @@ export const SignatureAPIBridge = forwardRef<SignatureAPI>(function SignatureAPI
       annotationApi.setActiveTool(null);
     },
 
+    applySignatureFromParameters: (params: SignParameters) => {
+      if (!annotationApi || !params.signaturePosition) return;
+
+      const { x, y, width, height, page } = params.signaturePosition;
+
+      switch (params.signatureType) {
+        case 'image':
+          if (params.signatureData) {
+            const annotationId = uuidV4();
+
+            // Store image data in our persistent store
+            storeImageData(annotationId, params.signatureData);
+
+            annotationApi.createAnnotation(page, {
+              type: PdfAnnotationSubtype.STAMP,
+              rect: {
+                origin: { x, y },
+                size: { width, height }
+              },
+              author: 'Digital Signature',
+              subject: `Digital Signature - ${params.reason || 'Document signing'}`,
+              pageIndex: page,
+              id: annotationId,
+              created: new Date(),
+              // Store image data in multiple places to ensure history captures it
+              imageSrc: params.signatureData,
+              contents: params.signatureData, // Some annotation systems use contents
+              data: params.signatureData, // Try data field
+              imageData: params.signatureData, // Try imageData field
+              appearance: params.signatureData // Try appearance field
+            });
+
+            // Switch to select mode after placing signature so it can be easily deleted
+            setTimeout(() => {
+              annotationApi.setActiveTool('select');
+            }, 100);
+          }
+          break;
+
+        case 'text':
+          if (params.signerName) {
+            annotationApi.createAnnotation(page, {
+              type: PdfAnnotationSubtype.FREETEXT,
+              rect: {
+                origin: { x, y },
+                size: { width, height }
+              },
+              contents: params.signerName,
+              author: 'Digital Signature',
+              fontSize: 16,
+              fontColor: '#000000',
+              fontFamily: PdfStandardFont.Helvetica,
+              textAlign: PdfTextAlignment.Left,
+              verticalAlign: PdfVerticalAlignment.Top,
+              opacity: 1,
+              pageIndex: page,
+              id: uuidV4(),
+              created: new Date(),
+              customData: {
+                signatureText: params.signerName,
+                signatureType: 'text'
+              }
+            });
+
+            // Switch to select mode after placing signature so it can be easily deleted
+            setTimeout(() => {
+              annotationApi.setActiveTool('select');
+            }, 100);
+          }
+          break;
+
+        case 'draw':
+          // For draw mode, we activate the tool and let user draw
+          annotationApi.setActiveTool('ink');
+          break;
+      }
+    },
+
     getPageAnnotations: async (pageIndex: number): Promise<any[]> => {
       if (!annotationApi || !annotationApi.getPageAnnotations) {
         console.warn('getPageAnnotations not available');

frontend/src/contexts/file/FileReducer.ts

@@ -51,9 +51,8 @@ function processFileSwap(
     }
   });
 
-  // Clear selections that reference removed files and add new files to selection
+  // Clear selections that reference removed files
   const validSelectedFileIds = state.ui.selectedFileIds.filter(id => !unpinnedRemoveIds.includes(id));
-  const newSelectedFileIds = [...validSelectedFileIds, ...addedIds];
 
   return {
     ...state,
@@ -63,7 +62,7 @@ function processFileSwap(
     },
     ui: {
       ...state.ui,
-      selectedFileIds: newSelectedFileIds
+      selectedFileIds: validSelectedFileIds
     }
   };
 }

frontend/src/hooks/tools/sign/useSignParameters.ts

@@ -17,7 +17,6 @@ export interface SignParameters {
   signerName?: string;
   fontFamily?: string;
   fontSize?: number;
-  textColor?: string;
 }
 
 export const DEFAULT_PARAMETERS: SignParameters = {
@@ -27,7 +26,6 @@ export const DEFAULT_PARAMETERS: SignParameters = {
   signerName: '',
   fontFamily: 'Helvetica',
   fontSize: 16,
-  textColor: '#000000',
 };
 
 const validateSignParameters = (parameters: SignParameters): boolean => {

frontend/src/tools/Sign.tsx

@@ -18,7 +18,6 @@ const Sign = (props: BaseToolProps) => {
   const { setSignatureConfig, activateDrawMode, activateSignaturePlacementMode, deactivateDrawMode, updateDrawSettings, undo, redo, signatureApiRef, getImageData, setSignaturesApplied } = useSignature();
   const { consumeFiles, selectors } = useFileContext();
   const { exportActions, getScrollState } = useViewer();
-  const { setHasUnsavedChanges, unregisterUnsavedChangesChecker } = useNavigation();
 
   // Track which signature mode was active for reactivation after save
   const activeModeRef = useRef<'draw' | 'placement' | null>(null);
@@ -39,11 +38,6 @@ const Sign = (props: BaseToolProps) => {
     handleSignaturePlacement();
   }, [handleSignaturePlacement]);
 
-  const handleDeactivateSignature = useCallback(() => {
-    activeModeRef.current = null;
-    deactivateDrawMode();
-  }, [deactivateDrawMode]);
-
   const base = useBaseTool(
     'sign',
     useSignParameters,
@@ -51,18 +45,14 @@ const Sign = (props: BaseToolProps) => {
     props
   );
 
-  const hasOpenedViewer = useRef(false);
-
-  // Open viewer when files are selected (only once)
+  // Open viewer when files are selected
   useEffect(() => {
-    if (base.selectedFiles.length > 0 && !hasOpenedViewer.current) {
+    if (base.selectedFiles.length > 0) {
       setWorkbench('viewer');
-      hasOpenedViewer.current = true;
     }
   }, [base.selectedFiles.length, setWorkbench]);
 
 
-
   // Sync signature configuration with context
   useEffect(() => {
     setSignatureConfig(base.params.parameters);
@@ -71,10 +61,6 @@ const Sign = (props: BaseToolProps) => {
   // Save signed files to the system - apply signatures using EmbedPDF and replace original
   const handleSaveToSystem = useCallback(async () => {
     try {
-      // Unregister unsaved changes checker to prevent warning during apply
-      unregisterUnsavedChangesChecker();
-      setHasUnsavedChanges(false);
-
       // Get the original file
       let originalFile = null;
       if (base.selectedFiles.length > 0) {
@@ -95,63 +81,68 @@ const Sign = (props: BaseToolProps) => {
       }
 
       // Use the signature flattening utility
-      const flattenResult = await flattenSignatures({
+      const success = await flattenSignatures({
         signatureApiRef,
         getImageData,
         exportActions,
         selectors,
+        consumeFiles,
         originalFile,
         getScrollState
       });
 
-      if (flattenResult) {
-        // Now consume the files - this triggers the viewer reload
-        await consumeFiles(
-          flattenResult.inputFileIds,
-          [flattenResult.outputStirlingFile],
-          [flattenResult.outputStub]
-        );
+      if (success) {
+        console.log('✓ Signature flattening completed successfully');
 
         // Mark signatures as applied
         setSignaturesApplied(true);
 
-        // Deactivate signature placement mode after everything completes
-        handleDeactivateSignature();
+        // Force refresh the viewer to show the flattened PDF
+        setTimeout(() => {
+          // Navigate away from viewer and back to force reload
+          setWorkbench('fileEditor');
+          setTimeout(() => {
+            setWorkbench('viewer');
 
-        // File has been consumed - viewer should reload automatically via key prop
+            // Reactivate the signature mode that was active before save
+            if (activeModeRef.current === 'draw') {
+              activateDrawMode();
+            } else if (activeModeRef.current === 'placement') {
+              handleSignaturePlacement();
+            }
+          }, 100);
+        }, 200);
       } else {
         console.error('Signature flattening failed');
       }
     } catch (error) {
       console.error('Error saving signed document:', error);
     }
-  }, [exportActions, base.selectedFiles, selectors, consumeFiles, signatureApiRef, getImageData, setWorkbench, activateDrawMode, setSignaturesApplied, getScrollState, handleDeactivateSignature, setHasUnsavedChanges, unregisterUnsavedChangesChecker]);
+  }, [exportActions, base.selectedFiles, selectors, consumeFiles, signatureApiRef, getImageData, setWorkbench, activateDrawMode]);
 
   const getSteps = () => {
     const steps = [];
 
-    // Step 1: Signature Configuration - Only visible when file is loaded
-    if (base.selectedFiles.length > 0) {
-      steps.push({
-        title: t('sign.steps.configure', 'Configure Signature'),
-        isCollapsed: false,
-        onCollapsedClick: undefined,
-        content: (
-          <SignSettings
-            parameters={base.params.parameters}
-            onParameterChange={base.params.updateParameter}
-            disabled={base.endpointLoading}
-            onActivateDrawMode={handleActivateDrawMode}
-            onActivateSignaturePlacement={handleActivateSignaturePlacement}
-            onDeactivateSignature={handleDeactivateSignature}
-            onUpdateDrawSettings={updateDrawSettings}
-            onUndo={undo}
-            onRedo={redo}
-            onSave={handleSaveToSystem}
-          />
-        ),
-      });
-    }
+    // Step 1: Signature Configuration - Always visible
+    steps.push({
+      title: t('sign.steps.configure', 'Configure Signature'),
+      isCollapsed: false,
+      onCollapsedClick: undefined,
+      content: (
+        <SignSettings
+          parameters={base.params.parameters}
+          onParameterChange={base.params.updateParameter}
+          disabled={base.endpointLoading}
+          onActivateDrawMode={handleActivateDrawMode}
+          onActivateSignaturePlacement={handleActivateSignaturePlacement}
+          onDeactivateSignature={deactivateDrawMode}
+          onUpdateDrawSettings={updateDrawSettings}
+          onUndo={undo}
+          onRedo={redo}
+          onSave={handleSaveToSystem}
+        />
+      ),
+    });
 
     return steps;
   };

frontend/src/utils/signatureFlattening.ts

@@ -1,7 +1,7 @@
 import { PDFDocument, rgb } from 'pdf-lib';
 import { generateThumbnailWithMetadata } from './thumbnailUtils';
-import { createProcessedFile, createChildStub } from '../contexts/file/fileActions';
-import { createStirlingFile, StirlingFile, FileId, StirlingFileStub } from '../types/fileContext';
+import { createProcessedFile } from '../contexts/file/fileActions';
+import { createNewStirlingFileStub, createStirlingFile, StirlingFile, FileId, StirlingFileStub } from '../types/fileContext';
 import type { SignatureAPI } from '../components/viewer/SignatureAPIBridge';
 
 interface MinimalFileContextSelectors {
@@ -17,18 +17,13 @@ interface SignatureFlatteningOptions {
     saveAsCopy: () => Promise<ArrayBuffer | null>;
   };
   selectors: MinimalFileContextSelectors;
+  consumeFiles: (inputFileIds: FileId[], outputStirlingFiles: StirlingFile[], outputStirlingFileStubs: StirlingFileStub[]) => Promise<FileId[]>;
   originalFile?: StirlingFile;
   getScrollState: () => { currentPage: number; totalPages: number };
 }
 
-export interface SignatureFlatteningResult {
-  inputFileIds: FileId[];
-  outputStirlingFile: StirlingFile;
-  outputStub: StirlingFileStub;
-}
-
-export async function flattenSignatures(options: SignatureFlatteningOptions): Promise<SignatureFlatteningResult | null> {
-  const { signatureApiRef, getImageData, exportActions, selectors, originalFile, getScrollState } = options;
+export async function flattenSignatures(options: SignatureFlatteningOptions): Promise<boolean> {
+  const { signatureApiRef, getImageData, exportActions, selectors, consumeFiles, originalFile, getScrollState } = options;
 
   try {
     // Step 1: Extract all annotations from EmbedPDF before export
@@ -71,6 +66,8 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
       }
     }
 
+    console.log(`Total annotations found: ${allAnnotations.reduce((sum, page) => sum + page.annotations.length, 0)}`);
+
     // Step 2: Delete ONLY session annotations from EmbedPDF before export (they'll be rendered manually)
     // Leave old annotations alone - they will remain as annotations in the PDF
     if (allAnnotations.length > 0 && signatureApiRef?.current) {
@@ -88,7 +85,7 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
     // Step 3: Use EmbedPDF's saveAsCopy to get the base PDF (now without annotations)
     if (!exportActions) {
       console.error('No export actions available');
-      return null;
+      return false;
     }
     const pdfArrayBuffer = await exportActions.saveAsCopy();
 
@@ -114,7 +111,7 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
 
       if (!currentFile) {
         console.error('No file available to replace');
-        return null;
+        return false;
       }
 
       let signedFile = new File([blob], currentFile.name, { type: 'application/pdf' });
@@ -122,6 +119,7 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
       // Step 4: Manually render extracted annotations onto the PDF using PDF-lib
       if (allAnnotations.length > 0) {
         try {
+          console.log('Manually rendering annotations onto PDF...');
           const pdfArrayBufferForFlattening = await signedFile.arrayBuffer();
 
           // Try different loading options to handle problematic PDFs
@@ -152,6 +150,7 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
 
           const pages = pdfDoc.getPages();
 
+
           for (const pageData of allAnnotations) {
             const { pageIndex, annotations } = pageData;
 
@@ -190,7 +189,6 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
 
                     if (imageDataUrl && typeof imageDataUrl === 'string' && imageDataUrl.startsWith('data:image')) {
                       try {
-
                         // Convert data URL to bytes
                         const base64Data = imageDataUrl.split(',')[1];
                         const imageBytes = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0));
@@ -217,7 +215,6 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
                         console.error('Failed to render image annotation:', imageError);
                       }
                     } else if (annotation.content || annotation.text) {
-                      console.warn('Rendering text annotation instead');
                       // Handle text annotations
                       page.drawText(annotation.content || annotation.text, {
                         x: pdfX,
@@ -290,30 +287,23 @@ export async function flattenSignatures(options: SignatureFlatteningOptions): Pr
       const record = selectors.getStirlingFileStub(currentFile.fileId);
       if (!record) {
         console.error('No file record found for:', currentFile.fileId);
-        return null;
+        return false;
       }
 
-      // Create output stub and file as a child of the original (increments version)
-      const outputStub = createChildStub(
-        record,
-        { toolId: 'sign', timestamp: Date.now() },
-        signedFile,
-        thumbnailResult.thumbnail,
-        processedFileMetadata
-      );
+      // Create output stub and file
+      const outputStub = createNewStirlingFileStub(signedFile, undefined, thumbnailResult.thumbnail, processedFileMetadata);
       const outputStirlingFile = createStirlingFile(signedFile, outputStub.id);
 
-      // Return the flattened file data for consumption by caller
-      return {
-        inputFileIds,
-        outputStirlingFile,
-        outputStub
-      };
+      // Replace the original file with the signed version
+      await consumeFiles(inputFileIds, [outputStirlingFile], [outputStub]);
+
+      console.log('✓ Signature flattening completed successfully');
+      return true;
     }
 
-    return null;
+    return false;
   } catch (error) {
     console.error('Error flattening signatures:', error);
-    return null;
+    return false;
   }
 }

package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "Stirling-PDF",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}