Abstract:
Systems and method for dynamically loaded menus and objects are provided that can provide cross-platform capability and accessibility features. Objects in a page that are dynamic or are not human-readable (e.g., executable or images) can be identified and enhanced for compatibility with screen readers. HTML corresponding to the object can be generated and loaded in storage for use within the web page. The loaded HTML can be copied into the HTML of the web page. A blank placeholder may be displayed in the area in which the corresponding HTML is to be displayed and the corresponding HTML is displayed over the placeholder to provide a replacement object such as to display a list of URL menu items.

Description:
FIELD OF THE INVENTION  
       [0001]     The present inventions relates to systems and methods for dynamically generating objects.  
       BACKGROUND  
       [0002]     Applications written using HTML to display their user interface have had to contend with the limits imposed by a display technology designed for periodical-style layout and simple data entry forms. Chief among the problems has been the lack of a robust menu system mirroring menu systems commonly found in desktop applications. Java Applets and JavaScript have both been used to solve this problem, however they are known to have drawbacks, for example, because they are not, as yet, compatible with screen reading software and, for example, because they are not typically known to be capable of allowing users to navigate with only the keyboard. These drawbacks have placed web-based applications that use robust menu systems in conflict with Section 508 of the Rehabilitation Act which requires that Federal agencies&#39; electronic and information technology be accessible to people with disabilities. In certain cases, it may also conflict with portions of the Americans with Disabilities Act.  
         [0003]     One of the common uses for menus in an application (e.g., an application such as Livelink by Open Text, Corp.) is to present a list of actions available to perform on or in connection with a specific object. There are often many objects in a page that may each have its own menu containing the list of actions the user is able to perform on or in connection with that object. In a system with individually permissioned objects, to generate the list of usable actions, each possible action is checked to see if the user has the appropriate permissions to operate the action on that object. In such systems, for a page with many objects, this permission checking can take a significant amount of server processing time. Given that the user typically only views the menus of a few objects before choosing an action from a menu, the permission calculations for unviewed menus waste computing resources. Therefore, it is can be desirable to defer the permission checking until the user requests to see an object&#39;s list of actions. One known way to implement this permission checking by sending the user to a new page for each object picked. However, concern for usability precludes directing the user to a new page to see the list of available actions for a specific object. In systems that do not require permission checking for objects to be performed when the object are presented the user, other limitations such as the need for Section 508 compliance may also exist.  
         [0004]     Thus, it is desired to provide improved menu systems to address these drawbacks and other objects of the present invention.  
       SUMMARY OF THE INVENTION  
       [0005]     In accordance with the principles of the present invention, systems and methods for dynamically generating accessibility enhanced menus can be provided. In one embodiment of the present invention, the systems and method are configured to be implemented across different platforms (e.g., different browsers or different operating systems). For example, methods and systems for dynamically generating accessibility enhanced menus can be provided that can include displaying a web page (e.g., using conventional technology) and providing a user with an opportunity to request a menu identified in the web page. The web page object can for example identify or be linked to an executable application or module that is configured to dynamically generate a menu, which is not compatible with screen readers. The incompatibility can be because the generated menu is an executable or dynamic object. The systems and methods of the present invention can include generating a request for the menu (e.g., requesting information on the content of the menu, which may be include context-sensitive menu items) and generating HTML code defining the requested menu (e.g., HTML code that identifies each menu item and supporting links, which may if desired be context sensitive). Such systems and methods can further include copying the generated HTML code into the web page (e.g., based on the location of the menu in the original page) and displaying the HTML code to display the requested menu. For example, the menu can be displayed by refreshing the page to display the menu based on the HTML code (e.g., the HTML code is copied into the source for the web page and displayed when the web page is refreshed, in other words, rendered, reloaded, or otherwise updated automatically). If desired, the data transmitted in response to the request (e.g., the HTML code) can be in a form that is readable by accessibility applications for the visually impaired. The process may include positioning the HTML code to display the menu.  
         [0006]     In another aspect, methods and systems of the present invention can for example include displaying a context sensitive menu control (e.g., a link for activating the display of related menu items based on the current context such as the current user, application, access rights, document, menu item availability, etc.) in a web page (e.g., a web page that is compatible with different browsers such as Internet Explorer, Netscape Navigator, Mozilla, etc.). A user can be provided with an opportunity to select the menu control (e.g., by tabbing to the menu control) and in response to the user selecting the menu control, menu items for the menu control are generated that are readable (e.g., includes text context) by accessibility applications (e.g., JAWS) for visually impaired users. The generated menu items can subsequently be displayed in a floating menu in the web page in proximate location with the menu control. Thus providing a context sensitive dynamically generated menu that is compatible with accessibility applications and is displayed in a floating menu in appropriate context in the web page.  
         [0007]     In another aspect of the present invention, methods and systems for replacing web page objects with replacement objects that are compatible with screen readers can be provided. For example, a web page object (e.g., an executable menu that generates menu items when selected such as a JavaScript dynamic menu, or an object such as an image) can be identified in a web page for replacement. A request to have one more replacement objects generated can be sent (e.g., sent to a server, or some to other resource such as a local application) when a user selects the web page object (e.g., to generate menu items for the menu in a different format such as HTML). Such method and systems may further include loading the replacement objects in a separate location hidden from the user (e.g. load in a separate page or other storage). A blank frame (e.g., an IFRAME) can be displayed in the web page in close proximity to the web page object. The replacement objects can be copied to the web page. In addition, the replacement objects can be displayed over the blank frame.  
         [0008]     In another aspect of the present invention, methods and systems for complying with enhanced accessibility requirements can be provided. For example, a user may be provided with an opportunity to request a menu in a networked enterprise application. The menu can be generated and loaded as a complete HTML page into a hidden web page such as an IFRAME until it is completely received from a server (or other computer) on which the networked enterprise application has been implemented. This can involve generating a request for the HTML page for the menu using JavaScript and sending the request to the server (or other computer). HTML source code for the menu can be copied from the IFRAME into the original HTML page from which the user was provided with the opportunity to request the menu. In addition, menu size and position can be adjusted and a blank IFRAME can be positioned underneath the menu.  
         [0009]     In another aspect, systems and methods of the present invention can for example include the user requesting a menu, JavaScript sending a request to the server for the menu, the menu being generated as a complete HTML page into a hidden IFRAME until it is completely received from the server, the HTML for the menu being copied from the IFRAME into to the original HTML page, the size and positioning of the menu being tweaked and a blank IFRAME is positioned underneath the menu, and the menu is revealed to the user.  
         [0010]     Dynamic accessibility enhanced objects or menus of the present invention can be implemented in a number of ways. For example, Cascading Style Sheets (CSS), JavaScript and HTML techniques can be combined to provide such objects or menus.  
         [0011]     For example, HTML can be used to layout the menu and sub-menus. Using HTML to display the menu ensures that the panoply of HTML consumers will be able to interpret the menu. These HTML consumers include web browsers like Netscape, Mozilla, and Internet Explorer in addition to commonly used accessibility applications like JAWS. Accessibility applications read the text and links on a web page aloud and are commonly called screen readers. However, they are not able to read aloud text that is included in within executables, such as a Java applet, or in an image, such as a GIF or JPEG. The use of HTML, which the screen reader can turn into spoken words, can avoid obstacles to accessibility posed by executables or images that are part of web pages to which such techniques are applied.  
         [0012]     An application program interface such as JavaScript&#39;s Document Object Model (DOM) API can for example be used to transfer dynamically loaded content into an already loaded and rendered page. In this example, using the standard DOM model developed by the World Wide Web Consortium can provide that this JavaScript technique will be supported across browser implementations and versions. However, other techniques may also be used if desired.  
         [0013]     In order to position HTML so that it appears over the HTML page, an IFRAME or other tool can be used. It is commonly understood that HTML positioned above a standard SELECT drop-down menu (like that used to choose your state on a web form) or a Java applet will seem to disappear. This is known to be confirmed in a Microsoft technical note. Since the use of dynamic menus or objects could occur on pages that will contain any combination of HTML and Java applets, the disappearance of the HTML should likely be addressed. In one embodiment an IFRAME can be used and positioned underneath the HTML menu. As such, the menu would appear to float above all HTML elements, including SELECT menus and Java applets.  
         [0014]     For example, in some embodiments, the present invention can include methods for complying with enhanced accessibility requirements, such as by providing a user with an opportunity to request a menu in a networked enterprise application, generating a request for the menu using JavaScript, sending the request to a server on which the networked enterprise application has been implemented, generating and loading the menu as a complete HTML page into a hidden IFRAME until it is completely received from the server, copying HTML for the menu from the IFRAME into an original HTML page from which the user was provided with the opportunity to request the menu; and adjusting the menu size and position and positioning a blank IFRAME underneath the menu.  
         [0015]     Systems for implementing embodiments of the present invention may include client-server arrangements, enterprise applications, Internet applications, or other hardware, software, or combination thereof for providing the systems and method of the present invention. For example, dynamic menus may be generated from a response to a request sent to a server or from information obtained from other resources such as a local application. In another example, such dynamic menu techniques may be particularly suitable for enterprise solutions and in some cases may be applicable to applications having Internet accessibility. In another aspect, the present invention can be applicable to circumstances involving objects or menus displayed by conventional browsers (e.g., with the use of a plug-in module, through the detection of a browser mode at a remote location such as server that will implement relevant processes, etc.). Some embodiments of the present invention may be compatible across different platforms and applications while others may be configured for particular applications. Such techniques can provide among its advantages applications that can be compliant with Section 508 of U.S. laws regarding enhanced accessibility of software applications for the visually impaired (e.g., in combination with a screen reader). 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0016]     Further features of the invention, its nature, and various advantages will be more apparent from the following detailed description, taken in conjunction with the accompanying drawings in which like reference characters refer to like parts throughout, and in which:  
         [0017]      FIG. 1  is a diagram of a web page within a web page for displaying a menu in accordance with one embodiment of the present invention;  
         [0018]      FIG. 2  is an illustrative example of a menu generated in accordance with one embodiment of the present invention;  
         [0019]      FIG. 3  schematically illustrates an exemplary system for supporting a menu in accordance with one embodiment of the present invention; and  
         [0020]      FIG. 4  is a flowchart of exemplary processing for displaying a menu in accordance with one embodiment of the present invention. 
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0021]      FIG. 3  schematically illustrates an exemplary system for supporting a dynamic menu. As shown in  FIG. 3 , the exemplary system includes one or more client digital data processing devices  300  (“clients”), one or more application server digital data processing devices  330  (“servers”), and one or more database server digital data processing devices  340  (“databases”). A web browser application  302  (“browser”) residing on client  300  communicates with application server  330  using one or more data communications networks  310  (“networks”). The application server  330  and database server  340  operate together to process application data  350  that is sent to browser  302  in the form of a web page containing an element that allows the person operating client  300  to activate and display dynamic menu content  360  that is tailored based on user information  370  belonging to that person. Some embodiments may also include a screen reader application  301  (such as JAWS® from Freedom Scientific®) that interprets the contents of web pages displayed in browser  302  for the benefit of a visually impaired person using client  300 .  
         [0022]     Systems and method of embodiments of the present invention can be implemented in different ways. For example, a user can browse to a page that has a button or other mechanism (generically called a menu control) to open the menu. Each menu can be coded with a unique identifier assigned to the ID attribute on its HTML tag. This menu control can for example be an image. This mechanism can be surrounded by an anchor tag (e.g., the kind of tag that creates very common hyperlinks in a webpage).  FIG. 4  is a flowchart of exemplary processing for implementing the present invention. With reference now to  FIG. 4 , the anchor tag can specify that when a user clicks ( 400 ) on the menu control a specific JavaScript function should be executed. The call to the JavaScript function can pass along a unique identifier for the object whose menu control was activated ( 430 ).  
         [0023]     This JavaScript function can record some positioning information, and, if the object&#39;s menu has not already been loaded for this instance of the page ( 435 ), it instructs an IFRAME ( 440 ) to load a new webpage (URL) ( 445 ). An IFRAME is a piece of HTML that can contain another complete HTML page, just as though a separate window has been opened in a browser, but within the original HTML page (see for example  FIG. 1 ). However, this IFRAME  102  is set to be completely invisible so that the current user does not see this temporary holding place for the menu. The URL that the IFRAME loads can be coded so that it returns the menu for the correct object ( 450 ).  
         [0024]     The URL returns an HTML document that contains the menu items and sub-menus. The last item on the HTML page returned by the URL can be a JavaScript script. This script can be executed as it is loaded by the browser. This script calls a JavaScript function defined by the parent window using a predetermined name. The function may for example use the identification of the object for which the menu was generated and the DOM HTMLElement that is the root node (container) of the menu as parameters. The function then can use a property of the root menu node called inner HTML to insert the HTML for the menu into the parent window ( 455 ). This HTML code can be inserted into the original page just after the HTML code for the menu control whose unique identification matches that of the requested menu ( 460 ).  
         [0025]     Copying the menu HTML into the HTML of the rendered page allows the menu to be cached until the page is refreshed. The JavaScript can simply use the identification of the object to check for the presence of the menu element for that identification ( 435 ). This way if a user views a menu for an object and thereafter views a second object and returns to view the menu for the first object, a request will not be issued to the server to retrieve the list of actions, which may conserve computing resources.  
         [0026]     If desired the URL can return the data for the menu items and sub items in another format, for example SGML or XML, that can easily be converted to HTML prior to being inserted into the original web page.  
         [0027]     Once the HTML for the menu is inserted into the HTML for the original page, JavaScript (e.g., of the original page) can use cascading style sheet (CSS) technology to show, hide, and position the menu. First, the JavaScript can position the menu and insert a blank IFRAME underneath the menu ( 465 ), which causes the menu to float over all items on the webpage, including Java applets and drop-down menus (e.g., see  FIG. 2 ). Finally, the CSS style called ‘visibility,’ set to ‘hidden’ when the menu is generated, is set to ‘visible’ on both the menu and IFRAME underbelly ( 470 ).  
         [0028]     The contents of the menu can be composed entirely of standard DIV, IMG and anchor tags. This can allow screen readers to accurately recognize and read the links aloud. It also allows navigation through simple presses of the tab key to move between links and presses of the Enter key to open the menu and sub-menus or to execute a menu item. For the average user, CSS styles can be used to replicate the look of a more traditional menu system. Browsers also recognize hyperlinks as elements that can be tabbed to, making the menu system filly keyboard accessible, even to those users who do not have a screen reader.  
         [0029]     CSS styles can be used to show and hide the menus. The ‘visibility’ style is typically supported by both screen readers and browsers, which provides the ability to hide a menu while retaining its HTML within a page ( 405 ,  410 ,  415 ,  420 , and  425 ). Menus with the ‘visibility’ style set to ‘hidden’ are not read by the screen reader nor are they reachable using the keyboard. Activation of the menu control causes this style to be set to visible, which can thus, allow the screen reader and the browser to read and access the menu.  
         [0030]     Such solutions can provide menu systems that resemble those found in desktop applications, which can load its content dynamically, is usable by screen readers, and adheres to accessibility guidelines such as the guidelines in Section 508.  
         [0031]     The systems and methods of the present invention can be useful for example in any web-based application that wishes to defer the generation of a menu until the menu is requested by the user and to satisfy the accessibility requirements (e.g., Section 508).  
         [0032]     The system and method described herein provide examples of ways to implement such systems and method, which may be particularly suited for an enterprise applications such as Livelink by Open Text, Corp. (e.g. embedded in the core of the application) as for example described in the attached appendix entitled Technical Specification Document for: Livelink Menu Enhancements, but could also implemented in other ways (e.g., a ‘dropin’ solution) or in other applications.  
         [0033]     Although preferred embodiments of the invention have been illustrated in the accompanying drawings and described in the foregoing Detailed Description of the Preferred Embodiments, it will be understood that the invention is not limited to the embodiments disclosed but is capable of numerous rearrangements and modifications of parts and elements without departing from the spirit of the invention. It will be understood that the details of every design and embodiment may be slightly different or modified by one of ordinary skill in the art without departing from the systems, apparatus, and methods taught by the present invention.