Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method executed on a computing device for transforming browser events into a semantic event comprehensible by an application executed by a remote server and hosted by a browser, the method comprising: receiving, from the browser, a browser event generated in response to a user input received via a user interface outputted on the browser that is executed on the computing device, the browser event representing an input configured to initiate a browser action to handle a selection with an operating system of the computing device, the browser action being browser or computing device dependent; upon receiving the browser event, determining, at the computing device, whether the received browser event matches a predetermined input event that corresponds to a semantic event of the application, the semantic event representing a command comprehensible by the application hosted by the browser and executed by the remote server; in response to determining that the received browser event matches the predetermined input event, transmitting, from the computing device and via a computer network, the semantic event comprehensible by the application to the application executed by the remote server; cancelling, in the browser, the received browser event on the computing device to prevent the browser action that is browser or computing device dependent from being performed on the computing device; receiving, via the computer network, an object generated by the application executed on the remote server in response to the command represented by the semantic event; and rendering, at the computing device and via the interface in the browser, the received object generated by the application in response to the user input in the browser on the computing device.
This invention relates to a system for transforming browser events into semantic events that can be processed by a remote application hosted in a browser. The technology addresses the challenge of handling user inputs in a way that is consistent across different browsers and computing devices, where native browser events are often browser or device-specific and may not be directly interpretable by remote applications. The method involves receiving a browser event generated by a user input, such as a selection action, which would typically trigger a browser or operating system-dependent action. Instead of allowing this default behavior, the system determines whether the browser event matches a predefined input event that corresponds to a semantic event understood by the remote application. If a match is found, the system transmits the semantic event to the remote application, cancels the original browser event to prevent the default action, and then receives and renders an object generated by the remote application in response to the semantic event. This approach ensures that user inputs are processed in a standardized way, improving compatibility and functionality across different browsers and devices. The system effectively bridges the gap between low-level browser events and high-level application commands, enabling more consistent and predictable behavior for web-based applications.
2. The method of claim 1 , wherein receiving the browser event generated in response to input received via the touch enabled device and determining whether the received browser event matches the predetermined input event comprises: receiving, at a register event handler of an event handler manager, the browser event; providing, through the register event handler, the browser event to at least one input manager associated with the browser event; processing, by the at least one associated input manager, the browser event and a document object model element of the browser event; and identifying, based on the processing, the semantic event associated with the browser event, wherein providing, to the application, the semantic event comprehensible by the application comprises providing the semantic event through the event handler manager.
This invention relates to processing touch-based input events in a web browser environment to generate semantic events that applications can understand. The problem addressed is the need to convert low-level touch events from a touch-enabled device into higher-level, application-specific events that abstract away device-specific details and provide meaningful context for web applications. The method involves receiving a browser event triggered by user input on a touch-enabled device. The event is first captured by a register event handler within an event handler manager. The register event handler then forwards the browser event to one or more input managers associated with the event. Each input manager processes the browser event along with the corresponding Document Object Model (DOM) element involved in the event. Through this processing, the input manager identifies a semantic event that represents the meaningful action or intent behind the raw touch input. This semantic event is then provided to the application through the event handler manager, ensuring the application receives a standardized, application-compatible event rather than raw touch data. The system abstracts device-specific details, allowing applications to handle touch interactions uniformly across different devices.
3. The method of claim 1 , wherein: the browser event comprises a series of browser events and the predetermined input event comprises a predetermined series of browser events, cancelling, in the browser, the browser event comprises cancelling, in the browser, the series of browser events to prevent corresponding browser actions in the browser.
This invention relates to browser event handling, specifically preventing unwanted browser actions triggered by sequences of browser events. The problem addressed is the occurrence of unintended browser actions when a user or automated process generates a series of browser events that inadvertently trigger a sequence of actions, such as form submissions, page reloads, or other disruptive behaviors. The solution involves detecting a series of browser events and comparing them to a predefined sequence of events. If a match is found, the system cancels the entire series of events before they can execute their corresponding browser actions, thereby preventing the unwanted behavior. The predefined sequence may include specific event types, timing patterns, or other distinguishing characteristics. This approach ensures that only intended actions are processed, improving user experience and system stability. The method applies to both user-initiated and automated event sequences, making it useful in web applications, testing environments, and security contexts where event-based actions must be controlled.
4. The method of claim 3 , wherein the semantic event comprises a stream of semantic events emulating the series of browser events.
A system and method for processing and analyzing browser events involves capturing and converting raw browser events into higher-level semantic events. The technology addresses the challenge of interpreting complex, low-level browser interactions by transforming them into meaningful, structured data that can be more easily analyzed or used for automation. The method includes capturing browser events such as clicks, key presses, and page navigation, then processing these events to derive semantic events that represent user actions or system behaviors in a more abstract and interpretable form. These semantic events can be further processed, stored, or used to emulate or reproduce the original browser interactions. The system may also include mechanisms for filtering, aggregating, or correlating semantic events to enhance their utility in applications such as user behavior analysis, automated testing, or web application debugging. By converting raw browser events into semantic representations, the technology enables more efficient and accurate analysis of web interactions, improving automation and monitoring capabilities.
5. The method of claim 4 , further comprising: ordering the series of browser events based at least in part on corresponding priority values.
A system and method for managing browser events in a web application involves capturing and processing a series of browser events generated by user interactions or system activities. The method includes detecting these events, such as clicks, key presses, or page loads, and assigning each event a priority value based on factors like event type, urgency, or system requirements. The events are then ordered according to these priority values to determine their execution sequence. Higher-priority events, such as critical system updates or security-related actions, are processed before lower-priority events, such as background analytics or non-essential UI updates. This prioritization ensures efficient resource allocation and improves application responsiveness by preventing lower-priority tasks from delaying critical operations. The method may also involve dynamically adjusting priority values based on real-time system conditions or user behavior to optimize performance. The solution addresses the challenge of managing event-driven workflows in web applications, where multiple events may compete for system resources, leading to delays or degraded user experience. By systematically prioritizing events, the system enhances efficiency and reliability in handling concurrent interactions.
6. The method of claim 5 , further comprising: for the browser events with an equal priority, providing the browser events of the series in a random order.
This invention relates to event handling in web browsers, specifically addressing the challenge of managing browser events with equal priority to prevent predictable processing sequences that could be exploited for security or performance issues. The method involves processing a series of browser events, where each event is assigned a priority level. When multiple events share the same priority, the system introduces randomness by reordering these events before execution. This randomization prevents attackers from predicting event handling sequences, which could be used to exploit timing-based vulnerabilities or performance bottlenecks. The method ensures that events with equal priority are not processed in a fixed order, thereby enhancing security and system stability. The randomization process may involve shuffling the events or applying a pseudo-random algorithm to determine their execution sequence. This approach is particularly useful in web applications where event-driven interactions are frequent, such as user input handling, network requests, or real-time updates. By breaking predictable patterns, the system mitigates risks associated with event-based attacks while maintaining responsiveness and efficiency. The invention is applicable to modern web browsers and frameworks that rely on event-driven architectures.
7. The method of claim 4 , further comprising: notifying the application about the stream of semantic events at an input manager associated with the stream; and notifying other input managers to stop listening for associated semantic events.
This invention relates to event handling in software applications, specifically managing semantic events within a system where multiple input managers may process similar events. The problem addressed is the inefficiency and potential conflicts that arise when multiple input managers listen for and process the same semantic events, leading to redundant processing or incorrect event handling. The method involves a system where an application generates a stream of semantic events, which are high-level representations of user actions or system occurrences. When such a stream is detected, the system notifies an input manager associated with that stream, enabling it to process the events. Simultaneously, the system notifies other input managers to stop listening for their associated semantic events, ensuring that only the relevant input manager handles the events. This prevents duplicate processing and ensures that events are routed to the correct handler. The input managers are specialized components that interpret and respond to specific types of semantic events. By dynamically enabling and disabling their event listening capabilities, the system optimizes performance and avoids conflicts. This approach is particularly useful in complex applications where multiple input managers may overlap in functionality, such as in user interface frameworks or event-driven systems. The method improves efficiency by reducing unnecessary event processing and ensures accurate event handling by preventing multiple managers from acting on the same events.
8. A computing system for transforming a browser event into a semantic event comprehensible by an application hosted by a browser and executed by a remote server, the computing system comprising: a memory storing computer-executable instructions of: receiving, from the browser, a browser event generated in response to a user input received via an interface of an application outputted by the browser, the browser event representing an input configured to initiate a browser action to handle a selection with an operating system of the computing device, wherein the browser action is browser or computing system dependent; upon receiving the browser event, determining, whether the received browser event matches a predetermined input event corresponds to a semantic event of the application, the semantic event representing a command comprehensible by the application executed by the remote server; providing, to the application executed on the remote server, the semantic event from the computing system and via a computer network; cancelling, in the browser, the browser event to prevent the browser action from being performed on the computing system; receiving, via the computer network, an object generated by the application executed on the remote server in response to the command represented by the semantic event; and rendering, via the interface of the application in the browser, the received object generated by the application executed on the remote server in response to the semantic event; and a processor for executing the computer-executable instructions stored in the memory.
The computing system transforms browser events into semantic events for applications hosted in a browser and executed by a remote server. The system addresses the challenge of handling user inputs in a way that is consistent across different browsers and computing systems, ensuring compatibility with applications that rely on semantic commands rather than browser-specific actions. When a user interacts with an application interface displayed in a browser, the system intercepts the browser event generated by the input. The system determines whether the browser event matches a predefined input event that corresponds to a semantic event understood by the remote application. If a match is found, the system sends the semantic event to the remote server via a network, cancels the original browser event to prevent default browser actions, and receives an object generated by the remote application in response. The system then renders this object in the application interface within the browser. This approach ensures that user inputs are processed consistently regardless of the browser or computing system, improving compatibility and functionality for web-based applications. The system includes a memory storing executable instructions for these operations and a processor to execute them.
9. The computing system of claim 8 , wherein the browser event comprises a series of browser events and the predetermined input event comprises a predetermined series of browser events, wherein cancelling, in the browser, the browser event comprises cancelling, in the browser, the series of browser events to prevent corresponding browser actions from being performed on the computing system.
This invention relates to computing systems that manage browser events to prevent unauthorized or unwanted actions. The system monitors browser events, such as user inputs or script-triggered actions, and compares them against predefined criteria. When a browser event matches a predetermined input event, the system cancels the event in the browser, preventing the corresponding action from executing. The invention specifically addresses scenarios where a browser event consists of a series of events, such as a sequence of keystrokes or script commands. In such cases, the system cancels the entire series of events to block the intended action, rather than individual events. This approach ensures that complex or multi-step actions, which could otherwise bypass simpler event-blocking mechanisms, are effectively neutralized. The system may be used to enhance security, prevent malicious scripts, or enforce policies by stopping unwanted interactions before they affect the computing system. The invention improves upon existing event-handling techniques by providing a more robust mechanism for intercepting and canceling event sequences, reducing the risk of unintended or harmful actions.
10. The computing system of claim 9 , wherein the semantic event comprises a stream of semantic events emulating the series of browser events.
A computing system processes semantic events derived from browser interactions to analyze user behavior. The system captures a stream of semantic events that emulate a series of browser events, such as clicks, scrolls, or form submissions, and converts them into higher-level semantic representations. These semantic events abstract raw browser actions into meaningful user intentions, such as "user searched for a product" or "user added an item to a cart." The system then processes these semantic events to generate insights, such as user engagement patterns, navigation flows, or conversion funnels. This approach improves upon traditional event tracking by reducing noise and providing a more structured, interpretable representation of user behavior. The system may also correlate semantic events with contextual data, such as page content or user demographics, to enhance analysis. By emulating browser events as semantic events, the system enables more accurate and actionable behavioral analytics for applications like web personalization, fraud detection, or user experience optimization. The technology addresses challenges in interpreting raw browser events by providing a standardized, semantic framework for event processing.
11. The computing system of claim 8 , wherein the semantic event associated with the browser event is determined based at least in part on a type of input associated with the browser event.
A computing system processes browser events to determine semantic events, enhancing user interaction analysis. The system captures browser events such as clicks, keystrokes, or scroll actions and analyzes their input types to infer higher-level semantic events. For example, a rapid sequence of keystrokes may indicate typing, while a mouse click on a button may signify a user action like form submission. The system uses this semantic context to improve event handling, such as triggering specific responses or logging meaningful user activities. This approach enables more accurate tracking of user behavior beyond raw input data, supporting applications like user experience analytics, accessibility features, or automated testing. The system may also integrate with other components to refine event interpretation, such as combining input type analysis with contextual data like page structure or user history. By mapping browser events to semantic events, the system provides a more nuanced understanding of user interactions, addressing limitations in traditional event logging that lacks contextual awareness.
12. The computing system of claim 11 , wherein the type of input comprises a gesture or touch.
A computing system is designed to enhance user interaction by recognizing and processing different types of input, including gestures or touch. The system includes a processor and a memory storing instructions that, when executed, enable the system to detect and interpret user inputs. These inputs can be gestures, such as swipes, pinches, or taps, or touch-based interactions, such as pressing or holding a touch-sensitive surface. The system processes these inputs to perform specific actions, such as navigating interfaces, selecting objects, or triggering commands. The recognition of gestures or touch allows for intuitive and efficient user interaction, particularly in environments where traditional input methods like keyboards or mice are impractical. The system may also include additional components, such as sensors or cameras, to capture and analyze the physical movements or touch patterns. By accurately interpreting these inputs, the system improves usability and responsiveness in applications like mobile devices, touchscreens, or virtual reality interfaces. The focus is on providing a seamless and natural interaction experience by leveraging gesture and touch recognition technologies.
13. The computing system of claim 11 , wherein the type of input comprises a stylus input.
A computing system is designed to enhance user interaction by processing and interpreting stylus inputs. The system includes a display device with a touch-sensitive surface capable of detecting stylus interactions, such as writing, drawing, or selecting objects. The system further comprises a processor configured to analyze the stylus input data, distinguishing it from other input types like finger touches or gestures. The processor applies specialized algorithms to interpret the stylus input, converting it into digital commands or data. For example, the system may recognize handwritten text, convert it to typed characters, or translate freehand drawings into digital vector graphics. The system may also support pressure sensitivity, allowing varying line thickness or opacity based on stylus pressure. Additionally, the system can integrate with software applications to enable stylus-specific functionalities, such as precision editing in graphic design tools or note-taking apps. The computing system ensures accurate and responsive stylus input processing, improving usability for tasks requiring fine motor control or artistic expression.
14. The computing system of claim 11 , wherein the type of input comprises a mouse click.
A computing system is disclosed that processes user inputs to determine the type of input and perform corresponding actions. The system includes an input detection module that identifies the type of input, such as a mouse click, keyboard input, or touch gesture. The system also includes an action execution module that executes predefined actions based on the detected input type. For example, when a mouse click is detected, the system may trigger a specific function, such as opening a file, selecting an object, or navigating a user interface. The system may also include a configuration module that allows users to customize the actions associated with different input types. Additionally, the system may include a feedback module that provides visual, auditory, or haptic feedback to confirm the execution of an action. The computing system is designed to improve user interaction efficiency by dynamically responding to different input types with appropriate actions, reducing the need for manual configuration or repetitive steps. This invention addresses the problem of inefficient input handling in computing systems, where users often have to perform multiple steps or manually configure actions for different input types. By automating the detection and execution of actions based on input type, the system enhances usability and productivity.
15. A method executed on a computing device for transforming browser events into a semantic event comprehensible by a web application executed by a remote server and hosted by a browser on the computing device, the method comprising: upon receiving, in response to a user input to a user interface of the application on the browser, a browser event representing an input configured to initiate a browser action that is browser dependent or computing device dependent, determining, at the computing device, whether the received browser event matches a predetermined input event corresponds to a semantic event of the application, the semantic event representing a command comprehensible by the application hosted by the browser and executed by the remote server; and in response to determining that the received browser event matches the predetermined input event, transmitting, from the computing device and via a computer network, the command represented by the semantic event to the remote server in lieu of performing the browser action on the computing device; receiving, via the computer network, an object generated by the application executed on the remote server in response to the command represented by the semantic event; and rendering, at the computing device and via the interface in the browser, the received object generated by the application in response to the user input in the browser on the computing device.
This invention relates to transforming browser events into semantic events for web applications. The problem addressed is the inconsistency in how different browsers and computing devices handle user inputs, which can lead to unpredictable behavior in web applications. The solution involves intercepting browser events triggered by user inputs, such as clicks or keystrokes, and determining whether they correspond to predefined semantic events that the web application can understand. If a match is found, the system transmits a command representing the semantic event to a remote server hosting the application, bypassing the default browser action. The server processes the command and returns an object, which is then rendered in the browser interface. This approach ensures consistent behavior across different browsers and devices by abstracting low-level input events into higher-level semantic commands. The method includes receiving user input, analyzing the corresponding browser event, mapping it to a semantic event, sending the command to the server, and displaying the server's response. This enables web applications to function predictably regardless of the underlying browser or device dependencies.
16. The method of claim 15 , further comprising providing an indication of the browser event and a type of input of the browser event to the application, wherein the type of input comprises a gesture, a touch, a stylus input, or a mouse click.
This invention relates to browser event handling in web applications, specifically improving how input events from various devices are processed and communicated to applications. The problem addressed is the lack of standardized or detailed event information, making it difficult for applications to accurately interpret and respond to different types of user inputs, such as gestures, touches, stylus inputs, or mouse clicks. The method involves capturing browser events triggered by user interactions with a web application. These events include inputs from touchscreens, stylus devices, mice, or other pointing devices. The method then processes these events to extract key details, such as the type of input (e.g., swipe, tap, click) and additional metadata like coordinates, pressure, or timing. This refined event data is then transmitted to the application, allowing it to distinguish between different input types and respond appropriately. For example, a swipe gesture may trigger a different action than a single tap, and a stylus input may include pressure sensitivity data that a mouse click lacks. By providing detailed event information, the method enables applications to support a wider range of input methods while maintaining precise control over user interactions. This enhances usability across devices and input modalities, ensuring consistent behavior regardless of the input source. The solution is particularly useful in modern web applications that need to support diverse input methods without requiring extensive custom coding for each device type.
17. The method of claim 15 , wherein the browser event comprises a series of browser events and the semantic event comprises a stream of semantic events emulating the series of browser events.
A system and method for translating browser events into semantic events to improve web application functionality and user experience. The technology addresses the challenge of interpreting raw browser events, such as clicks, scrolls, or key presses, into higher-level semantic actions that better represent user intent. This enables more intelligent processing, automation, and accessibility features in web applications. The method involves capturing a series of browser events generated by user interactions with a web application. These events are then processed to generate a stream of semantic events that emulate the original browser events but provide a more meaningful representation. For example, a sequence of mouse movements and clicks may be translated into a semantic event representing a "drag-and-drop" action. The semantic events can be used to enhance automation, assistive technologies, or analytics by providing a more structured and interpretable format. The system may include a browser extension or server-side component that monitors browser events, applies rules or machine learning models to derive semantic meaning, and outputs the corresponding semantic events. This approach allows for more sophisticated handling of user interactions, such as predicting user intent, optimizing performance, or adapting the interface dynamically. The method ensures compatibility with existing web applications while providing a more intelligent and responsive user experience.
18. The method of claim 15 , further comprising cancelling, in the browser, the browser event to prevent the corresponding browser action from being performed on the computing device in response to determining that the received browser event matches the predetermined input event.
A method for event handling in web browsers addresses the problem of unintended or malicious browser actions triggered by user input events. The method involves monitoring browser events generated by user interactions, such as clicks or keystrokes, and comparing them against a predefined set of input events. If a match is detected, the browser event is canceled to prevent the corresponding action from executing on the computing device. This approach enhances security and user control by blocking unwanted or harmful actions, such as form submissions, navigation, or script execution, without requiring modifications to the underlying web application. The method operates within the browser environment, ensuring compatibility with existing web technologies while providing a lightweight solution for event interception. By dynamically filtering events, it allows for real-time prevention of actions that may compromise user experience or system integrity. The technique is particularly useful in scenarios where input validation or action restrictions are necessary, such as in secure forms, interactive web applications, or environments with strict input constraints. The cancellation process is seamless, ensuring that the user interface remains responsive while preventing unauthorized or unintended actions from being processed.
19. The method of claim 15 , wherein: the browser event includes multiple browser sub-events; and determining whether the received browser event matches the predetermined input event includes determining whether the multiple browser sub-events represent a pattern that matches the predetermined input event.
This invention relates to event handling in web browsers, specifically improving the detection and processing of complex user interactions. The problem addressed is the difficulty in accurately identifying and responding to multi-step or patterned user inputs, such as gestures or sequences of actions, within a web application. Existing systems often struggle to distinguish between intentional user actions and accidental or unintended inputs, leading to poor user experience or security vulnerabilities. The invention provides a method for analyzing browser events to determine if they match a predefined input pattern. When a browser event is received, the system checks whether it contains multiple sub-events. If so, the method evaluates whether these sub-events form a recognizable pattern that corresponds to a predetermined input event. This allows the system to distinguish between simple, single-action inputs and more complex, multi-step interactions. For example, a sequence of mouse movements or keyboard inputs could be identified as a specific gesture or command, triggering a corresponding action in the web application. The method enhances user interaction by enabling more sophisticated input recognition, improving both usability and security. By analyzing sub-events within a broader event, the system can better filter out noise and unintended inputs, ensuring that only valid, patterned interactions are processed. This approach is particularly useful for applications requiring precise input handling, such as touch-based interfaces, authentication systems, or interactive web tools.
20. The method of claim 15 , wherein: the browser event includes multiple browser sub-events; determining whether the received browser event matches the predetermined input event includes determining whether the multiple browser sub-events represent a pattern that matches the predetermined input event; and in response to determining that the multiple browser sub-events represent a pattern that matches the predetermined input event, cancelling, in the browser, the multiple browser sub-events to prevent corresponding browser actions from being performed on the computing device.
This invention relates to browser event handling in computing systems, specifically addressing the problem of unintended or malicious browser actions triggered by sequences of browser sub-events. The method involves monitoring browser events to detect patterns of sub-events that match predetermined input events, which may indicate harmful or unwanted behavior. When such a pattern is identified, the system cancels the sub-events to prevent the corresponding browser actions from executing on the computing device. This approach enhances security and user control by intercepting and blocking sequences of sub-events that could otherwise lead to unauthorized actions, such as automated scripts or malicious inputs. The method ensures that only legitimate user interactions proceed while mitigating risks associated with event-based attacks or unintended automation. The solution is particularly useful in environments where browser security and user experience are critical, such as web applications handling sensitive data or interactive user interfaces.
Unknown
September 1, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.