Abstract:
A method for optimizing pen-based annotations on a non-pen enabled window. The method includes starting a visible non-pen-enabled window further including position indicia and size indicia; starting a transparent pen-enabled window; and associating the visible non-pen-enabled window with the transparent pen-enabled window based on the position indicia and size indicia. The method further includes aligning the transparent pen-enabled window with the visible non-pen-enabled window, and accepting user input comprising a message. If the message further includes pen indicia, the method also includes forwarding the message to the transparent pen-enabled window. Else, the method includes forwarding the message to the first application.

Description:
BACKGROUND OF THE INVENTION 
     The present invention relates in general to interactive graphical computing environment. More particularly, the present invention relates to methods and apparatus for optimizing a transparent window. 
     Many early operating systems (i.e., MS DOS) could only run a single application. It was therefore possible, if not necessary, to allow the application to be directly coupled to the computer&#39;s hardware resources, such as the keyboard and video display. Primarily comprising a text-based interface, these applications received relatively little assistance from the operating system. For example, the application would directly poll the keyboard for any user keystrokes. 
     In contrast, most modern graphical operating systems (i.e. Microsoft Windows, Linux, MacOS, etc.) can simultaneously run multiple applications. Hence some sort of shared messaging system must be used to preclude resource sharing conflicts. User input is no longer polled by the application, but rather the application registers with the operating system, usually during installation, describing the forms of input that it would like to receive. The operating system, in turn, forwards messages to the application as appropriate. Likewise, any output to the display area or printer was also routed through the message system to the appropriate portion of the operating system (i.e., the typing of text, the scrolling of a mouse, or the resizing of the application window). 
     Display windows are common characteristic of most graphical operating systems. A window is a virtual entity, commonly referred to as a control, positioned on a computer display, for presenting the interaction between the user and the computer. The typical application has a single rectangular window displayed on the screen. However, some applications open multiple windows, and others permit arbitrarily shaped windows (not just rectangles) and windows of various styles and colors. 
     Computer platforms are also becoming smaller, faster, mobile, and more ubiquitous. Mobile, handheld computers; computing appliances; and smart telephones allow computer support to be built into task situations. Such situations include new physical environments, where computers have been impractical up to now, and also new social environments, where, previously, computers imposed a formidable barrier to social interaction. However, traditional user interface devices can be problematic. Keyboards are often awkward and bulky to carry, while the mouse (and other cursor-based input) is generally not optimized for entering text efficiently. 
     Pen-based computing developed as an alternative means of user input, comprising the functions of both the keyboard and the stylus. Most pen-based devices allow annotation directly on the screen display, much like the annotation of a physical sheet of paper with a marker. Furthermore, these platforms may also convert a user&#39;s handwritten notes into computer recognized text and commands. Many pen-based devices also run existing applications. For example, the Microsoft TabletPC, based on the XP platform, can run just about any XP application, 
     However, most applications must generally be specifically designed to take advantage of pen-based user input. Many previously written applications, such as an Internet browser, often do not allow direct annotation in the browser window. For instance, if two users are visually sharing a browser application, such as with Microsoft NetMeeting, it may be difficult, if not impossible, for a user to annotate directly on the browser display area. 
     In view of the foregoing, there is desired a method and apparatus for optimizing pen-based annotations on a window of a software application. 
     SUMMARY OF THE INVENTION 
     The invention relates, in one embodiment, to a method for optimizing pen-based annotations on a non-pen enabled window. The method includes starting a visible non-pen-enabled window further including position indicia and size indicia; starting a transparent pen-enabled window; and associating the visible non-pen-enabled window with the transparent pen-enabled window based on the position indicia and size indicia. The method further includes aligning the transparent pen-enabled window with the visible non-pen-enabled window, and accepting user input comprising a message. If the message further includes pen indicia, the method also includes forwarding the message to the transparent pen-enabled window. Else, the method includes forwarding the message to the first application. 
     In another embodiment, the invention relates to an apparatus for pen-based annotations on a non-pen enabled window. The apparatus includes a means of starting a visible non-pen-enabled window further including position indicia and size indicia; a means of starting a transparent pen-enabled window; and a means of associating the visible non-pen-enabled window with the transparent pen-enabled window based on the position indicia and size indicia. The apparatus further includes a means of aligning the transparent pen-enabled window with the visible non-pen-enabled window, and a means of accepting user input comprising a message. If the message further includes pen indicia, the apparatus also includes a means of forwarding the message to the transparent pen-enabled window. Else, the apparatus includes a means of forwarding the message to the first application. 
     These and other features of the present invention will be described in more detail below in the detailed description of the invention and in conjunction with the following figures. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which: 
         FIG. 1A  illustrates, in accordance with one embodiment of the present invention, a simplified diagram in which pen-based annotations are enabled on a previously non-pen enabled window; 
         FIG. 1B  illustrates, in accordance with one embodiment of the present invention, a simplified diagram in which pen-based annotations are enabled on a previously non-pen enabled window that cannot be automatically refreshed; 
         FIG. 2  illustrates, in accordance with one embodiment of the present invention, a graphical representation of the screen displays of  FIGS. 1A-1B ; 
         FIG. 3  illustrates, in accordance with one embodiment of the present invention, a simplified diagram in which pen-based annotations are enabled in an application that comprises both a pen-enabled window and a non-pen-enabled window; and, 
         FIG. 4  illustrates, in accordance with one embodiment of the present invention, a graphical representation of the screen display of  FIG. 3 . 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     The present invention will now be described in detail with reference to a few preferred embodiments thereof as illustrated in the accompanying drawings. In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without some or all of these specific details. In other instances, well known process steps and/or structures have not been described in detail in order to not unnecessarily obscure the present invention. The features and advantages of the present invention may be better understood with reference to the drawings and discussions that follow. 
     In accordance with one embodiment of the present invention, a transparent window is advantageously employed to optimize pen-based annotation on a window of a software application. 
     Many software applications, including the operating system itself, comprise a set of windows. The Microsoft Windows desktop, for instance, functions as a large window. Normally, the operating system maintains and provides spatial information for each window in its desktop area. As windows overlap each other (e.g. windows have a Z order relative to the user), each application responds by redrawing its own window (or portion thereof) when unobstructed. 
     Most modern operating systems, like Linux, are also event driven. Rather than being a based upon a constant course of action (i.e., MS DOS), various system events are handled by a set of operating system routines. For example, the movement of a mouse or the redrawing of a screen. At the core is a loop—a portion of code that gets executed time and again throughout the life of the program. The sole job of the main loop, often called a message pump, is to make sure that events get handled, such as being forwarded to the appropriate program. 
     Messages are used for most basic interactions between applications and the operating system. If a user wants a window or control (which is just a specialized window) to do something, a message is sent. If an event happens such as the user typing on the keyboard, moving the mouse, clicking a button, then messages are sent by the system to the windows affected. If the message is not recognized, it is often ignored. 
     For example, in Microsoft Windows, a simplified example of the message pump is: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 while(GetMessage(Message) 
               
               
                   
                 { 
               
               
                   
                   TranslateMessage (Message); 
               
               
                   
                   DispatchMessage (Message); 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
     The message loop calls GetMessage( ), which looks in a message queue. When an event occurs causing a message to be added to the queue (i.e., a mouse click). GetMessages( ) returns a positive value indicating there is a message to be processed, and places the appropriate information into the Message variable. It is then passed to TranslateMessage( ) for additional processing (i.e., translating virtual key messages into character messages). The message is then passed to DispatchMessage( ) which determines the window for which it is intended. It then forwards a message to the application associated with the window, sending the handle of the window, the original received message, and other parameters. A handle is a unique identifier or pointer that is used to access an object, similar to an index number. Whenever a program or resource needs to access another resource, its presents the handle to the appropriate application programming interface, or API. 
     In order to substantially mimic the behavior of a regular pen, pen-based computer input generally must account for additional attributes, such as the angle of the pen, pressure on the writing surface, pen speed, steadiness, in-air movements, and others. Traditional operating systems generally, however, do not generally expose or use these pen characteristics. For example, with Microsoft Windows XP Tablet PC Edition, the infrastructure that makes the pen work consists of a pen service that sends out system or pen events that correspond to pen actions. The service determines whether the destination is a pen-enabled application or a mouse-enabled application, or whether the destination is a control or a window within an application. The service then sends a mouse message to the mouse application or control or both mouse and pen messages to a pen-enabled application. 
     In a non-obvious manner, the current invention allows a transparent pen-enabled window to be superimposed upon a non-pen-enabled window. In a fashion similar to laying a sheet of transparency over a sheet of paper, the user can make annotations on the transparent pen-enabled window directly over displayed elements of the underlying window. For example, a user could directly annotate on an existing presentation application, such as on a Microsoft PowerPoint slide. In one embodiment, the non-pen-enabled window is included in a collaboration application, such as with Microsoft NetMeeting. In another embodiment, a single application comprises both the transparent pen-enabled window and a non-pen-enabled window, such as with Iteration Active Studio or Active Viewer. In yet another embodiment, a first application including a transparent pen-enabled window is coupled to a second application including a non-pen-enabled window. 
       FIG. 1A  depicts a simplified diagram according to one embodiment of the invention, in which pen-based annotations are enabled on a previously non-pen enabled window. In a non-obvious fashion, a transparent pen enabled window of a first application is coupled to a visible non-pen enabled window of a second application. 
     The first application may register itself with the operating system, requesting receipt of all pen messages generated by the user on the transparent window. These messages can describe pen angle, writing surface pressure, pen speed, etc. In one embodiment, the messages can be converted to a bitmap. In another embodiment, the messages are converted to a set of Bezier curves for efficient storage. In another embodiment, the messages are converted to a Microsoft Ink format. In another embodiment, the messages are converted to computer-readable characters through a handwriting recognition process. 
     Messages not relevant to the first application are ignored and subsequently received and processed by the second application in a normal fashion. For example, when a user selects a button control on the second application, a mouse click message is generated. The first application&#39;s transparent window, positioned before the second application&#39;s visible window, receives the mouse click message. Since it is not interested in mouse click messages, the message is instead is returned to the message pump. It is subsequently ignored by the first application, and received by the second application, wherein the mouse click message is associated with the button control. The screen is refreshed, and the user sees the appropriate button selection behavior (e.g. the mouse control being depressed and released). 
     In order to synchronize its movement to the underlying visible window, the first application requests the position and size of the visible window from the operating system. As the underlying visible window subsequently moves, or is resized, the pen-enabled transparent window moves or resizes as well. Furthermore, the first application can instruct the second application to redraw itself, through a refresh message, whenever a portion of the window becomes obstructed or unobstructed by another window, other than the transparent window, on the desktop. 
     Referring now to  FIG. 1A , a first application including a non-pen-enabled window is started at step  104 . Likewise, a second application including a pen-enabled window is started at step  106 . The non-pen-enabled window and the transparent pen-enabled window are then associated at step  108 . That this, the second application requests from the operating system information describing the position and size of the non-pen-enabled window. The transparent pen-enabled window is then instantiated and positioned over the non-pen-enabled window in the display area at step  110 . User input is then generated at step  114 . At step  118 , the message is analyzed to determine if it is relevant to the second application. If so, at step  116 , the message is forwarded to the second application, where it is processed. If not, at step  112 , the message is forwarded to the first application, where it is processed. In either case, the system is again ready for additional user input at step  114 . 
       FIG. 1B  depicts a simplified diagram according to one embodiment of the invention, in which pen-based annotations are enabled on a previously non-pen enabled window that cannot be automatically refreshed. Some applications, such as Microsoft Internet Explorer, will ignore refresh requests from other applications, in order to optimize performance. That is, the application, itself, will determine the situations in which it will refresh its own windows. However, appropriate control behavior, such as the depression of a button or the rendering of a data stream, usually requires periodic screen refreshments. If a first window is positioned above a second non-pen-enabled window, even if the first window is transparent, the underlying second window may choose not to refresh. This may freeze the display area, and effectively disable the user controls, such as buttons and scrollbars. 
     In a non obvious fashion, the first application captures an image of the visible non-pen enabled window, effectively making the previously transparent window opaque. The user can then annotate on this opaque window as before. In one embodiment, when the user desires to access controls on the visible non-pen enabled window, the opaque window becomes transparent and moves behind the visible non-pen enabled window. In another embodiment, when the user desires to access controls on the visible non-pen enabled window, the opaque window is moved off the visible desktop. 
     Referring now to  FIG. 1B , a first application including a non-pen-enabled window is started at step  144 . Likewise, a second application including a pen-enabled window is started at step  146 . The non-pen-enabled window and the transparent pen-enabled window are then associated at step  148 . That this, the second application requests from the operating system information describing the position and size of the non-pen-enabled window. A decision is made at step  150 , in which the user selects to enter pen annotations, or non-pen annotations (i.e., such as a mouse click). If yes, a transparent pen-enabled window is then instantiated and positioned over the non-pen-enabled window in the display area at step  152 . User input is then generated at step  156 . At step  160 , the messages are forwarded to the second application, where they are processed. At step  162 , the transparent window is removed, and the loop restarts at step  150 . If not, at step  150 , user input is then generated at step  154 . At step  158 , the messages are forwarded to the first application, where they are processed, and the loop restarts at step  150 . 
     Referring now to  FIG. 2 , a graphical representation of a screen display is shown of the simplified diagrams of  FIGS. 1A-B . The first application is shown as  202 , whereas the included non-pen-enabled visible window is shown as  204 . These, in turn, are coupled to a second application  206 , and the included transparent pen-enabled window is shown as  208 . Transparent pen-enabled window  208  is positioned over the visible non-pen-enabled window relative to the user&#39;s viewpoint  212 . That is, the transparent pen-enabled window has a higher Z order  210  in relationship to the visible non-pen-enabled window. 
       FIG. 3  depicts a simplified diagram according to one embodiment of the invention, in which pen-based annotations are enabled in an application that comprises both a pen-enabled window and a non-pen-enabled window. The application including is started at step  300 . The transparent pen-enabled window is then instantiated and may be automatically positioned over the non-pen-enabled window. For example, a Windows application that has and embedded Internet Explorer control (which is not commonly pen-enabled) and a transparent pen-enabled window control. There is no need to associate both windows, since both are within the same application. User input is then generated at step  304 . At step  308 , the message is analyzed to determine if it is a pen message. If yes, at step  306 , the message is forwarded to the pen message handler of the application, where it is processed. If not, at step  302 , the message is forwarded to the non-pen message handler of the application, where it too is processed. In either case, the system is again ready for additional user input at step  304 . 
     Referring now to  FIG. 4 , a graphical representation of a screen display is shown of the simplified diagram of  FIG. 3 . Unlike  FIG. 2 , there is only a single application  402  that includes a non-pen-enabled visible window  404 , and a transparent pen-enabled window  408 . Transparent pen-enabled window  408  is positioned over the visible non-pen-enabled window  404  relative to the user&#39;s viewpoint  412 . That is, the transparent pen-enabled window has a higher Z order  410  in relationship to the visible non-pen-enabled window. 
     While this invention has been described in terms of several preferred embodiments, there are alterations, permutations, and equivalents which fall within the scope of this invention. For example, although reference is given to the Microsoft TabletPC, it should be understood that the invention can also integrate with other computer platforms and operating systems. It should also be noted that there are many alternative ways of implementing the apparatuses of the present invention. It is therefore intended that the following appended claims be interpreted as including all such alterations, permutations, and equivalents as fall within the true spirit and scope of the present invention. 
     Advantages of the invention include optimizing pen-based annotations on a window of a software application. Additional advantages enhancing existing non-pen-based applications with pen annotation capability. 
     Having disclosed exemplary embodiments and the best mode, modifications and variations may be made to the disclosed embodiments while remaining within the subject and spirit of the invention as defined by the following claims.