Derivative works — US Patent 5742768

Defensive Disclosure Document

Reference: U.S. Patent 5,742,768, "System and method for providing and displaying a web page having an embedded menu."

Publication Date: April 26, 2026

Abstract: This document discloses a series of technical implementations, derivative applications, and combinations with existing technologies that build upon the foundational concepts described in U.S. Patent 5,742,768. The purpose of this disclosure is to place these concepts into the public domain, thereby establishing them as prior art for the purposes of patentability examination. The disclosures herein are intended to render obvious any subsequent patent applications that claim these specific improvements or variations of an applet-driven, embedded menu on a web page.

Derivatives of Core Claim 1/9/16: Embedded Menu Generation and Management

1. Material & Component Substitution

1.1. WebAssembly (WASM) Module for Menu Rendering
- Enabling Description: The executable applet described in the '768 patent, originally conceived as a Java applet, is replaced with a pre-compiled WebAssembly (WASM) module. The HTML page includes a <script> tag that fetches and instantiates the WASM module (menu_renderer.wasm). The module, written in a high-performance language like Rust or C++, exposes functions to the host JavaScript environment (e.g., renderMenu(menuData, parentElement)). Upon a "mouse-over" event on a designated hot-spot element, a JavaScript event listener invokes the WASM function, passing a JSON object defining the menu structure and the DOM element to which the menu should be appended. The WASM module performs the high-speed DOM manipulation to create and display the menu, offering superior performance over an interpreted Java applet for complex menus with thousands of items.
- ```
sequenceDiagram
    participant User
    participant Browser (JS)
    participant WASM Module
    participant Web Server
    User->>Browser (JS): Mouseover hot-spot
    Browser (JS)->>WASM Module: invoke renderMenu(jsonData, parentElement)
    WASM Module->>Browser (JS): Perform high-speed DOM manipulation
    Browser (JS)->>User: Display embedded menu
    Note right of User: Data for menu can be pre-fetched or fetched on demand.
    Browser (JS)->>Web Server: (Optional) GET /api/menu_data/b
    Web Server-->>Browser (JS): { "links": [...] }
```
1.2. JSON-LD for Semantic Menu Definition
- Enabling Description: Instead of a proprietary data format, the menu's structure, links, and metadata are defined within the HTML page using a <script type="application/ld+json"> block. This JSON-LD (JavaScript Object Notation for Linked Data) object conforms to a schema.org vocabulary (e.g., SiteNavigationElement). The applet (now a standard JavaScript module) parses this structured data upon page load. When a user hovers over a hot spot, the script uses the pre-parsed JSON-LD data to dynamically construct the menu's HTML. This method decouples the menu's data from the rendering logic and makes the navigation structure machine-readable for search engines and accessibility tools.
- ```
graph TD
    A[Web Page Load] --> B{Parse JSON-LD in <script> tag};
    B --> C[Store Menu Structure as JS Object];
    D[User mouseover hot-spot] --> E{Retrieve Menu Object for hot-spot};
    E --> F[Generate HTML from Object];
    F --> G[Inject Menu HTML into DOM];
```
1.3. SVG-based Animated Menu System
- Enabling Description: The embedded menu is not constructed from standard HTML DOM elements but is instead rendered as a Scalable Vector Graphics (SVG) object. An executable script (JavaScript) dynamically generates the <svg> markup. Menu items are represented as <g> (group) elements containing <rect> (background), <text>, and <foreignObject> tags for complex content. User interaction (hovering over a hot-spot) triggers SMIL (Synchronized Multimedia Integration Language) animations or CSS transitions defined within the SVG, causing the menu to appear with fluid effects like path-based motion or morphing shapes. Hyperlinks are implemented using <a> tags wrapping the SVG element groups.
- ```
classDiagram
    class SvgMenuApplet {
        +renderMenu(data, targetElement)
        -generateSvgMarkup(menuData)
        -applyAnimations(svgObject)
    }
    class MenuItem {
        -String text
        -String url
        -createSvgGroup()
    }
    SvgMenuApplet "1" *-- "many" MenuItem
```
1.4. WebSocket Push for Dynamic Menu Updates
- Enabling Description: The client-side applet establishes a persistent WebSocket connection to the web server upon page load. The server can push real-time updates to the menu structure. For example, if a menu displays stock prices or the status of a system, the server pushes a JSON payload through the WebSocket whenever the data changes. The client-side applet receives the payload and seamlessly updates the content of the embedded menu, even while it is displayed, without requiring a page refresh or a new HTTP request from the client.
- ```
sequenceDiagram
    participant Browser
    participant Server
    Browser->>Server: Upgrade: websocket
    Server-->>Browser: 101 Switching Protocols
    loop Real-time Updates
        Server->>Browser: PUSH menu_update.json
        Browser->>Browser: Update menu DOM
    end
```

2. Operational Parameter Expansion

2.1. Industrial-Scale Hierarchical Menus for Big Data Visualization
- Enabling Description: The embedded menu is designed to handle massive, deeply nested hierarchical data structures, such as a multi-terabyte file system or a complex organizational chart with over 1,000,000 nodes. The applet does not download the entire menu structure at once. Instead, hovering over a "hot spot" (e.g., a parent folder) triggers an asynchronous API call to fetch only the immediate children of that node. The menu employs a "virtual rendering" technique, where only the visible items in the menu's viewport are rendered as DOM elements, allowing the user to scroll through thousands of items at a single level without performance degradation.
- ```
stateDiagram-v2
    [*] --> Idle
    Idle --> Fetching: onMouseOverParentNode
    Fetching --> Rendering: onDataReceived
    Rendering --> Displayed: onDomUpdateComplete
    Displayed --> Fetching: onMouseOverChildWithChildren
    Displayed --> Idle: onMouseOut
```
2.2. Nanoscale Menu for Micro-display Interfaces
- Enabling Description: This variation targets micro-displays (e.g., < 100x100 pixels) on wearable devices or embedded systems. The "web page" is a minimal graphical interface rendered by a microcontroller. The "applet" is a lightweight C++ routine. The "hot spot" is a small, designated pixel area. When a user's gaze (tracked by a micro-camera) or a physical micro-joystick moves the cursor over the hot spot, the applet renders a compact, pixel-optimized menu. The menu may only consist of a few iconic symbols, and selection is made by dwelling on an icon for a set duration (e.g., 500ms). This provides multi-link navigation on extremely constrained displays.
- ```
graph TD
    A[Gaze detected on hot spot] --> B{Timer > 100ms?};
    B -- Yes --> C[Render 4-icon menu];
    C --> D{Gaze detected on icon};
    D --> E{Timer > 500ms?};
    E -- Yes --> F[Execute link action];
    B -- No --> A;
    E -- No --> D;
```

3. Cross-Domain Application

3.1. Aerospace: In-Cockpit Avionics Display
- Enabling Description: Within a glass cockpit's multifunction display (MFD), flight plan waypoints or system schematics are displayed. These waypoints and components act as "hot spots." When a pilot hovers the cursor over a waypoint using a trackball, an embedded menu appears, managed by the flight computer's display generation software (the "applet"). The menu provides links to execute pre-defined actions for that waypoint, such as "View Approach Plate," "Request Holding Pattern," or "Activate Missed Approach." This avoids deep menu diving through the main flight management system interface.
- ```
flowchart LR
    subgraph MFD Display
        A(Flight Plan View)
        B(Waypoint WPT01)
        C(Waypoint WPT02)
        A --- B & C
    end
    subgraph Embedded Menu for WPT02
        D[View STAR]
        E[View Approach]
        F[Enter Hold]
    end
    User(Pilot) -- hovers cursor --> C
    C -- triggers --> D & E & F
```
3.2. Agricultural Technology (AgTech): Precision Farming Dashboard
- Enabling Description: A web-based dashboard displays a satellite map of a farm, with different fields rendered as polygons. Each polygon is a "hot spot." When a farm manager hovers their mouse over a specific field, a JavaScript module (the "applet") fetches and displays an embedded context menu. The menu provides links to control or view data for that specific field, such as "Activate Irrigation Zone 3," "View Soil Moisture Data," or "Dispatch Drone for Scouting." The menu items are hyperlinks that trigger commands to IoT-enabled farm equipment.
- ```
erDiagram
    FARM ||--o{ FIELD : contains
    FIELD {
        string FieldID
        string PolygonCoordinates
    }
    FIELD ||--|{ MENU_ACTION : provides
    MENU_ACTION {
        string ActionID
        string DisplayText
        string TargetURL
    }
    FIELD "is hot spot for" MENU_ACTION
```
3.3. Automotive: Infotainment System Control
- Enabling Description: On a vehicle's central touchscreen, a map is displayed for navigation. Points of Interest (POIs) like charging stations or restaurants are displayed as icons ("hot spots"). When the user touches and holds a finger on a POI icon for > 300ms, the infotainment unit's UI software (the "applet") renders an embedded radial menu around the user's finger. The menu options ("links") allow for immediate actions like "Navigate Here," "Call Business," or "View Charging Status." This provides multi-function access without leaving the map view.
- ```
graph TD
    A(User Touch & Hold on POI) --> B{Display Radial Menu};
    B -- slides to 'Navigate' --> C(Set Destination);
    B -- slides to 'Call' --> D(Initiate Phone Call);
    B -- slides to 'Details' --> E(Show POI Info Panel);
```

4. Integration with Emerging Tech

4.1. AI-Driven Predictive Menu Generation
- Enabling Description: The content of the embedded menu is not static. When the user hovers over a hot spot, a client-side JavaScript module sends contextual data (e.g., user ID, time of day, content of the current page) to a machine learning model endpoint. The AI model returns a personalized list of links predicted to be most relevant to that user in that specific context. The applet then renders this dynamic, AI-generated menu. For instance, hovering over a product image might show "View similar items" for one user but "Re-order now" for a user who has purchased it before.
- ```
sequenceDiagram
    participant User
    participant Browser
    participant AI Service
    User->>Browser: Hover on hot-spot
    Browser->>AI Service: POST /predict-menu (context)
    AI Service-->>Browser: return personalized_links.json
    Browser->>Browser: Render menu from JSON
    Browser-->>User: Display personalized menu
```
4.2. IoT-Integrated Status Menus
- Enabling Description: A web page displays a dashboard for a smart factory. Each machine on the factory floor is represented by an icon, which is a "hot spot." The applet, upon page load, subscribes to an MQTT message broker, with topics corresponding to each machine. When a machine's IoT sensors publish a status update (e.g., temperature, pressure), the message is received by the applet. When the user hovers over a machine's icon, the embedded menu displays these real-time IoT data points as non-clickable items alongside clickable links for control (e.g., "Initiate Shutdown Sequence").
- ```
graph LR
    IoT_Sensor -- publishes --> MQTT_Broker;
    Browser_Applet -- subscribes --> MQTT_Broker;
    MQTT_Broker -- pushes message --> Browser_Applet;
    User -- hovers --> Machine_Icon;
    Machine_Icon -- triggers --> Embedded_Menu[Display Real-time Status & Control Links];
    Browser_Applet -- updates --> Embedded_Menu;
```

5. The "Inverse" or Failure Mode

5.1. Graceful Degradation to Static HTML
- Enabling Description: The system is designed for resilience. The "hot spot" is an HTML anchor tag <a> with a href attribute pointing to a fallback, static HTML page that lists all possible links. The page also contains a JavaScript applet. If the user's browser executes JavaScript, the applet intercepts the mouseover event on the anchor tag, prevents the default browser behavior, and displays the dynamic, embedded menu. If JavaScript is disabled or the applet fails to load, the element remains a standard hyperlink. A user can still click it to navigate to the fallback page, ensuring functionality is preserved, albeit in a less efficient manner.
- ```
stateDiagram-v2
    state "JavaScript Enabled" as JS_On {
        [*] --> Active
        Active: onMouseOver -> showEmbeddedMenu()
        Active: onClick -> followMenuLink()
    }
    state "JavaScript Disabled" as JS_Off {
        [*] --> Fallback
        Fallback: onClick -> navigateToStaticPage()
    }
```

Combination Prior Art Scenarios

1. Combination with Apache HTTP Server (httpd) and Server Side Includes (SSI)
- Enabling Description: The core HTML document is served by an Apache httpd server with the mod_include module enabled. The data for the embedded menus is not hardcoded in the page or fetched via a separate API call. Instead, the menu structure is defined in separate text files on the server. The main HTML page uses Server Side Includes (SSI) directives (e.g., ) inside a <script> tag. When the browser requests the page, Apache preprocesses it, injecting the contents of the menu data files directly into the HTML response. The client-side JavaScript applet then parses this pre-injected data to build the menus. This leverages a standard, open-source server technology to manage menu content separately from page logic.
2. Combination with ECMAScript 2022 (ES13) and Top-Level await
- Enabling Description: The applet is implemented as a modern JavaScript module (<script type="module">). It uses the top-level await feature introduced in ECMAScript 2022. Instead of waiting for the page to load and then fetching menu data, the module itself can be written to fetch and process configuration data asynchronously at the module's root level. For example: const menuConfig = await fetch('/api/menus').then(res => res.json());. This ensures that all required menu data is fetched and parsed before any user interaction code is executed, simplifying the logic and preventing race conditions where a user might hover over a hot spot before its corresponding menu data has been loaded. This combines the patent's concept with a specific, modern, open web standard.
3. Combination with W3C Web Components Standard
- Enabling Description: The entire menu system is encapsulated as a custom HTML element (e.g., <embedded-menu>) defined using the W3C's Web Components standard. The developer defines a custom element class in JavaScript (class EmbeddedMenu extends HTMLElement). This class handles all the logic: creating a Shadow DOM for styling encapsulation, defining slots for the "hot spot" content, and managing the display of the pop-up menu. A user implements the menu by simply including the tag in their HTML: <embedded-menu menu-src="/data/products-menu.json">Our Products</embedded-menu>. The menu-src attribute points to the data, and the text "Our Products" becomes the hot spot. This combines the '768 patent's functionality with the open standard for creating reusable, encapsulated UI components.