Abstract:
Methods and systems that can be used to dynamically restructure user interfaces into a set of communicating processes. The methods and systems update new and wrapped legacy user interface components for repurposing of user interfaces. The methods and systems provide for changing one or more of at least an appearance, a behavior, and a state or condition of the user interfaces.

Description:
BACKGROUND OF THE INVENTION  
       [0001]     1. Field of Invention  
         [0002]     This invention generally relates to restructuring user interface components of computer applications.  
         [0003]     2. Description of Related Art  
         [0004]     Computer application user interface components, such as, for example, Web browsers, have become entrenched in computer use practices. For example, Web content designers will at times depend on the many features of existing browsers, such as for example, the content types supported by a browser, underlying data representations for specifying the display properties, e.g., the tags and parameters, and the like.  
         [0005]     With the acceleration of technological development, system software designers are reaching the point where system software and their user interfaces become to some degree outdated ‘legacy systems’ as soon as they are released.  
       SUMMARY OF THE INVENTION  
       [0006]     The dependence on the features of existing browsers becomes a problem if software designers want to create new applications that retain some or all of the representational abilities of the older software, but have new interaction requirements, such as, for example, defining new ways links get followed.  
         [0007]     Maintaining, extending, overriding, and/or adapting system software and their user interfaces while preserving the features that software developers depend on is advantageous.  
         [0008]     This invention provides methods and systems that dynamically restructure user interfaces into a set of communicating processes.  
         [0009]     This invention separably provides methods and systems that dynamically restructure and/or update new and wrapped legacy user interface components to allow for repurposing of user interfaces.  
         [0010]     This invention separably provides methods and systems that provide for changing the appearance, behavior, and state/condition of user interfaces.  
         [0011]     This invention separably provides methods and systems that connect or link a proposed state/condition change of the user interface to other processes to enable these processes to override their actions in updating themselves to the new proposed state/condition.  
         [0012]     In various exemplary embodiments, the systems and methods according to this invention restructure a computer application user interface component by dynamically injecting a functionality into a first layer in the user interface component, communicating an event to a controlling process used in at least the first layer, and performing an action in the first layer based on the event. In various exemplary embodiments, the controlling process restructures at least one of an appearance, a functionality and a condition of at least the first layer.  
         [0013]     In various exemplary embodiments, the systems and methods according to this invention further include indicating to a second layer, a change of the condition of the at least the first layer. In various exemplary embodiments, an action is performed in the second layer in response to the change of the condition of the at least the first layer. In various exemplary embodiments, the action performed in the second layer is the same as the action performed in the first layer. In various exemplary embodiments, the first layer is a content layer. In various exemplary embodiments, the second layer is a branding layer. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0014]     Various exemplary embodiments of the systems and methods of this invention will be described in detail below, with reference to the following figures, in which:  
         [0015]      FIG. 1  is a high-level schematic representation of one exemplary embodiment of a method and system for restructuring a user interface component of a computer application according to this invention;  
         [0016]      FIG. 2  is a flowchart outlining one exemplary embodiment of a method for restructuring a user interface component of a computer application according to this invention;  
         [0017]      FIGS. 3-7  are a high-level schematic representation of one exemplary embodiment of a method and system for restructuring a user interface component of a computer application according to this invention;  
         [0018]      FIG. 8  is a high-level schematic representation of an alternative exemplary embodiment of a method and system for restructuring a user interface component of a computer application according to this invention;  
         [0019]      FIG. 9  is a functional block diagram of one exemplary embodiment of a system for restructuring a user interface component of a computer application according to this invention. 
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0020]      FIG. 1  is a high-level schematic representation of one exemplary embodiment of the implementation of a method and system for restructuring a user interface component of a computer application according to this invention.  
         [0021]     In various exemplary embodiments of the systems and methods according to this invention, a system  10  uses at least a controller  20  to inject one or more additional programming logic/programming calls  25  into one or more computer applications  30 . In various exemplary embodiments, the one or more computer applications  30  include any known or future developed computer applications, such as, for example, internet web browsers, e-mail applications, document productivity applications, multi-media processing and/or presentation applications, information processing applications and the like.  
         [0022]     In various exemplary embodiments, programming logic/programming calls  25  allow the controller  20  to capture one or more events  35  from the one or more computer applications  30 . Further, in various exemplary embodiments, the captured events  35  inject additional programming logic/programming calls  25  or invoke other processing commands in the controller  20 , in the modified application  30 , in some other application (not shown) modified by the controller or a similar controller (not shown) as specified according to this invention, or in another unrelated application (not shown).  
         [0023]      FIG. 2  is a flowchart outlining one exemplary embodiment of a method for restructuring a user interface component of a computer application according to this invention. As shown in  FIG. 2 , the method starts in step S 200 , and continues to step S 210 , where one or more existing user interface components, such as, for example, a viewer, are expanded/augmented. In various exemplary embodiments, the one or more existing user interface components are expanded/augmented by adding, removing, and/or modifying the code of the user interface components. In various alternative exemplary embodiments, the one or more existing user interface components are expanded/augmented by adding, removing, and/or modifying components of the content displayed in the user interface, i.e., by instrumenting content in the user interface.  
         [0024]     Methods for code expansion/augmentation include but are not limited to manipulation within the interface of scripting languages, macros, parameters and configuration information, and invocation of application programming interfaces for code modification such as document object model manipulation. Operations by the expanded/augmented code include, but are not limited to, adding or modifying communication of events occurring within the first layer to the other layers, redefinition of existing data structures within the first layer, incorporation of new data structures within the first layer, removal of data structures within the first layer, redefinition of existing functionality within the first layer, incorporation of new functionality within the first layer, and removal of functionality within the first layer.  
         [0025]     In various exemplary embodiments, these expansions/augmentations thereby create a Multi-Directionally communicating processes between multiple existing user interface components (S 220 ).  
         [0026]     As discussed above, the one or more user interface components are expanded and/or augmented by instrumenting content in the user interface. Instrumenting content may include instrumenting at least a first layer, such as, for example, a content layer, using one or more instrumentation methods or techniques. Instrumentation methods or techniques are well known in the art.  
         [0027]     In various exemplary embodiments, instrumenting content is performed by accessing an underlying data model of the content being displayed. In various exemplary embodiments, the underlying data model of the content being displayed includes a Document Object Model.  
         [0028]     In various exemplary embodiments, instrumenting content is performed by embedding the user interface into an environment that provides a means to trap or lock in all input events. In various exemplary embodiments, embedding the user interface is performed using well known software code, such as, for example, including ActiveX controls in a Visual Basic form, including Web Services in a C# form, trapping X Window event streams and the like.  
         [0029]     As discussed above, in step S 220 , multi-directionally communicating processes are created by inserting or adding application level repurposing communication protocols into the existing user interface components. In various exemplary embodiments, the multi-directionally communicating processes, such as, for example, bi-directionally communicating processes, redefine the existing or original user interface. In various exemplary embodiments, the insertion/addition of application level communication protocols into a first layer, for example, a content layer, redefines at least one of a presentation appearance and a behavior of the content layer.  
         [0030]     In various exemplary embodiments, when the user interface is updated with content, software code that is appropriate to the user interface communication model is introduced into the user interface. In various exemplary embodiments, software code includes, for example, event stream data, HTTP/HTML for Web-based applications, and the like.  
         [0031]     In various exemplary embodiments, the software code re-specifies one or more user interface events in the user interface component with the following information. For example, in various exemplary embodiments, the command being invoked is specified at the application level, for example, application level ‘Pause’ vs. device level ‘Mouse Down’. In various further exemplary embodiments, the software code re-specifies one or more user interface events such as, for example, attributes related to that command, such as, for example, meta-data, parameters, qualifiers, properties specified by name-value pairs and the like. In additional exemplary embodiments, the software code re-specifies a callback method, such as, for example, code designation in the embedding context or in some other context accessible from the embedding context. In yet further, exemplary embodiments, the software code re-specifies one or more user interface events such as, for example, any combination or the omission of any of the above information.  
         [0032]     Other repurposing protocol approaches, such as form example, XML documents, are applicable with the methods and systems of this invention.  
         [0033]     Whenever user or system actions trigger the instrumented user interface elements, code in the embedding context applies processing rules that redefine a condition/state and or behavior of the event processing. In various exemplary embodiments, the redefined event processing includes various actions or commands, such as, for example, ignore actions, process actions with the original user interface, perform new actions in the embedding context, pass information to some other context for processing, and the like.  
         [0034]      FIGS. 3-7  are a high-level schematic representation of one exemplary embodiment of a method and system for restructuring a user interface component of a computer application according to this invention. As shown in  FIG. 3 , restructuring of the user interface components allows information to flow between components, which might not have previously been able to directly communicate with each other. In this way, actions may be delegated to components whose capabilities and configurations make them a necessary or more appropriate choice to process redefined display operations.  
         [0035]      FIG. 4  shows how in an exemplary embodiment, a Controller component is injecting new codes into a Content component that redefines how scrolling actions. In this example, input processing for events to displayed Web content is being overridden with new processing wherein instead of showing scrollbars on the Web page and manipulating those, scroll bars are removed and mouse events directly on the Web content trigger the scrolling action, except where such events trigger other actions such as following a hyperlink in the Web content. In this way, many other changes of appearance, behavior, and content may be made.  
         [0036]      FIG. 5 , shows how in an exemplary embodiment, a Content component has been augmented to communicate a state to a Controller component. In this example, Web content has been augmented in such a way that when a touch event occurs within the content such as through a mouse input event, a message is communicated to the controller using a protocol defined for the purposes of repurposing the user interface of the displayed content. In this example, the protocol consists of a keyword indicating a repurposing event to be communicated, namely that a ‘Touch’ has occurred. Information about the touch event is further specified in the message, namely the X and Y coordinates of the touch in the coordinate frame of the Content. Lastly, a callback procedure within another component, in this case the Branding component, is communicated to request a Pause action to occur in the processing of the Branding component. Also shown in  FIG. 5 , a second action update is illustrated where a repurposing event to be communicated, namely that a ‘PlasmaPoster’ event has occurred indicating that within a Web page, an application specific hyperlink event has occurred. The Web address to be linked to is given along with an email address of a person who has been associated with that Web address. In this way, many other specifications of processing may occur with respect to repurposing events accepted in one component and invoking new processing in one or more possibly different components, as shown in  FIG. 6 .  
         [0037]      FIG. 7  shows how in an exemplary embodiment on component calls code embedded or injected into another component. In this example, code for setting and retrieving state in the Branding component is accessed from the Controller component.  
         [0038]      FIG. 8  is a high-level schematic representation of an alternative exemplary embodiment of a method and system for restructuring a user interface component of a computer application according to this invention. In addition to the Content, Controller, and Branding components described here, other components may be restructured in this manner to facilitate user interface repurposing. These include, but are not limited to, approaches for supporting annotations over content, and applying techniques for analyzing content and making recommendations about alternative related content.  
         [0039]      FIG. 9  is a functional block diagram of one exemplary embodiment of a system  1000  for restructuring a user interface component of a computer application according to this invention. The system  1000  includes an exterior data connection  1070 . In various exemplary embodiments, data connection  1070  is any known or later developed device or system for connecting the system  1000  to the exterior, such as, for example, to a network (not shown), including a connection over public switched telephone network, a direct cable connection, a connection over a wide area network, a local area network or a storage area network, a connection over an intranet or an extranet, a connection over the Internet, or a connection over any other distributed processing network or system. In general, data connection  1070  is any known or later-developed connection system or structure usable to connect the system  1000  to the exterior, such as, for example, to a network.  
         [0040]     As shown in  FIG. 9 , the system  1000  includes one or more display devices  1040  usable to display information to a user, and one or more user input devices  1050  usable to allow the user or users to input data into the system  1000 . The one or more display devices  1040  and the one or more input devices  1050  are connected to the system  1000  through an input/output interface  1030  via one or more communication links  1041  and  1051 , respectively. The one or more communication links  1041  and  1051  are generally similar to the data connection  1070  above.  
         [0041]     In various exemplary embodiments, the system  1000  includes at least one or more of a controller  1020 , a memory  1010 , a user interface augmentation circuit or routine  1005 , a content instrumenting circuit or routine  1015 , and a content repurposing circuit or routine  1025 , all of which are interconnected over one or more data and/or control buses and/or application programming interfaces  1060 .  
         [0042]     In various exemplary embodiments, the controller  1020  controls the operation of the other components of the system  1000 . In various exemplary embodiments, the controller  1020  also controls the flow of data between various components of the system  1000  as needed. In various exemplary embodiments, the memory  1010  stores information coming into or going out of the system  1000 . In various exemplary embodiments, the memory  1010  stores any necessary programs and/or data implementing the functions of the system  1000 , and/or stores data, such as, for example, data, actions, events required for restructuring a user interface component of a computer application.  
         [0043]     In various exemplary embodiments, the memory  1010  is implemented using any appropriate combination of alterable, volatile or non-volatile memory or non-alterable, or fixed, memory. In various exemplary embodiments, the alterable memory, whether volatile or non-volatile, is implemented using any one or more of static or dynamic RAM, a floppy disk and disk drive, a writable or re-rewriteable optical disk and disk drive, a hard drive, flash memory or the like. Similarly, in various exemplary embodiments, the non-alterable or fixed memory is implemented using any one or more of ROM, PROM, EPROM, EEPROM, an optical ROM disk, such as a CD-ROM or DVD-ROM disk, and disk drive or the like.  
         [0044]     In various exemplary embodiments, the controller performs various functions, selected from a list including, but not limited to, augmenting one or more existing user interface components, instrumenting content viewed in one or more existing user interface components, creating one or more multi-directionally communicating processes between multiple existing user interface components, and other like functions. In creating multi-directionally communications between existing user interface components, the controller is able to define and redefine what behaviors, appearances, and content are being processed in and between any of the interface components of the system. This includes but is not limited to repurposing input event processing, showing different styles, modifying content, communicating state to other systems, and accepting state from other systems and distributing that to interface components with the repurposed system.  
         [0045]     This invention has been desribed in conjunction with the exemplary embodiments outlined above. Various alternatives, modifications, variations, and/or improvements are within the spirit and scope of the invention, whether known or presently unforeseen. Accordingly, the exemplary embodiments of the invention, as set forth above, are intended to be illustrative, not limiting. Various changes may be made without departing from the spirit and scope of the invention. Therefore, the invention is intended to embrace all known or later developed alternatives, modifications, variations and/or improvements.