Patent Publication Number: US-5841434-A

Title: System and method for multi-platform implementation of objects on windowing computer systems

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     The present invention appears to claim subject matter disclosed in co-pending application U.S. Ser. No. 08/665,175, filed Jun. 14, 1996, now U.S. Pat. No. 5,705,928 issued on Jan. 6, 1998, entitled &#34;SYSTEM AND METHOD FOR IMPLEMENTING CANVAS OBJECTS ON WINDOWING COMPUTER SYSTEMS&#34;. 
    
    
     CROSS REFERENCE TO RELATED APPLICATIONS 
     The present invention appears to claim subject matter disclosed in co-pending application U.S. Ser. No. 08/665,175, filed Jun. 14, 1996, now U.S. Pat. No. 5,705,928 issued on Jan. 6, 1998, entitled &#34;SYSTEM AND METHOD FOR IMPLEMENTING CANVAS OBJECTS ON WINDOWING COMPUTER SYSTEMS&#34;. 
     TECHNICAL FIELD 
     This invention relates to computer systems employing graphical user interfaces and, more particularly, to such systems including multiple windows and mechanisms for controlling screen draws in allocated areas. 
     BACKGROUND OF THE INVENTION 
     In the early development of computer systems, the conventional user interface comprised a command line interface. In such a system a user provided input by means of instructions typed on a keyboard which appeared on a line on the user&#39;s video monitor. This form of user interface served quite well in the initial stages of development of the computer industry. This was because, at the time, users typically were computer operators or individuals with at least some computer training or technological expertise. Such individuals felt comfortable with the sometimes arcane syntax and semantics required by the then-current command line driven computer operating systems and software applications. 
     However, as the popularity of computer systems increased and use migrated downward to increasing numbers of individuals with little or no such training who often were mere casual users, the inherent weaknesses of such a command-line user interface became readily apparent. 
     In response to this problem, solutions began to appear attempting to avoid this command-line based form of interfacing with computer systems. Several forms of graphical user interfaces (GUI) thus became available which presented various choices, menus, icons, and the like to the user. The user was then able to interface with them by means of convenient pointing devices such as mouses, touchscreens, cursor keys, trackballs, etc. The syntax and semantics still required by the operating systems and applications were essentially made transparent to the end user and placed under the covers, thereby obviating the need for the user to be familiar with them. 
     Representative and very commonplace examples of such GUIs abound, including the familiar Macintosh operating system marketed by the Apple Computer Corporation and subsequently the Windows and OS/2 interfaces popularized by the Microsoft Computer Corporation and the IBM Corporation, respectively. 
     These GUI based interfaces represented a significant advancement over prior command-line interfaces and have enjoyed wide popularity. However, as the sophistication and versatility of modern computing systems continued to advance, significant inherent weaknesses in these systems even began to appear. 
     As an example, whereas previously users were content with standalone applications such as word processors, spreadsheets, and databases and utilized these applications and their resulting data independently of one another, it became increasing apparent that significant benefits could be derived from interaction between various applications and interchange of their data. With the increased popularity of graphics images (resulting from emergence of graphics design packages, improved computer image displays and processing, video capture cards, standardization of image files, and the general increase in popularity of multimedia) it became very desirable to be able to imbed graphics or an image in a text document. As the industry developed, various mechanisms were provided to facilitate this. Unfortunately, however, these methods were extremely clumsy and cumbersome and very difficult for the average user to employ easily and conveniently. 
     Typically suites of application programs were therefore developed, such as word processors and graphics/image packages, which permitted savings of data in a pre-specified format from one application which could thereafter be exported to the other application. 
     As an example, it is now commonplace to employ a word processing machine which can import images from within the word processor in various industry standard image formats such as .PCX, .GIF, .BMP and the like. This capability to import data from a different application has even become available between applications which were not marketed as a suite from a single vendor. 
     Although the foregoing ability represented yet another advance, it nevertheless still was fraught with numerous drawbacks. What a user typically desired to be able to do was not only import data from another application, but to edit or modify this data from within the receiving application to which it was exported. However, current technology did not permit these differing applications to essentially be imbedded within the same environment and &#34;talk&#34; directly to each other. In other words, once a .GIF image for example was imported by a user into a word processor and perhaps text was then added around the imported image, the user frequently would desire to be able to edit the GIF image from within the word processing application it was imported to. The user desired the ability to perform such editing just as the image previously would have been edited by a standalone Paint application for example. The end user in fact frequently might not even care what imaging application was providing the functionality under the covers to permit processing of the differing data types. However, in accordance with current technology, in order to effect such modification of an image, for example, it was necessary to do so outside the application and then re-import the image. This became extremely cumbersome and unworkable as should be readily apparent. 
     The foregoing difficulties gave rise to yet another advance in the computer field with the heightened awareness and interest in what is currently referred to as &#34;document-centered computing&#34;. In this model, the notion of a compound document was developed and an associated framework or architecture for effecting this. Different software components providing the functionality of word processing, functions of a spreadsheet, image editing and display, etc. were made available which functionally could literally plug into one another in a modular fashion. In essence these differing predecessor standalone applications and their associated functionality were converted by this model into separate components which could be invoked by a single environment. The analogy has been made to the familiar modular stereo component systems, wherein the user may select speakers, amplifiers, tuners, turntables, CD players, etc. from differing manufacturers to essentially build a custom system. The user is nevertheless assured that the various components will operate together correctly because standardized interfaces between the components had been defined and implemented in the components by the various manufacturers. 
     The foregoing developments gave rise to one specific embodiment of this compound document framework known in the industry as &#34;OpenDoc&#34; (TM of Apple Computer, Inc). This OpenDoc standard resulted from a consortium including the IBM Corporation, the Apple Computer Corporation, the Novell Corporation and others, and the specification or standard is currently maintained by the Component Integration Labs, Inc. 
     Three terms well known in the document-centered computing field comprise a part of the aforementioned OpenDoc standard and will be utilized hereinafter in describing the invention. These terms are &#34;Facet&#34;, &#34;Canvas Object&#34;, and &#34;Part&#34; and may be described as follows: 
     Part: A piece of a document that, when executing, includes both the document data and the part-editor code that manipulates it. See OpenDoc Programmer&#39;s Guide, infra, Chapter 1, pages 492-493. 
     Canvas Object: A wrapper for a platform-specific or graphics-system-specific structure which represents a drawing environment and holds a reference to its graphics port or other system-specific structure which is not deleted when the canvas is released. See OpenDoc Programmer&#39;s Guide, infra, Chapter 4. 
     Facet: A construct for drawing, one or more such Facet of which corresponds to an equivalent visible frame but directly references embedded Facets, needed only for frames visible at any one moment, not stored when a document is saved, and created and deleted by its frame(s) containing parts. See OpenDoc Programmer&#39;s Guide, infra, Chapter 3. 
     These terms are described more fully in numerous publications in the aforementioned OpenDoc Programmer&#39;s Guide, Apple Computer Inc, Addison Wesley Publishing Company, copyright 1995, which is incorporated herein by reference. Part of the purpose of this technology was in fact to define such interfaces in order to facilitate the combination in one environment of the various desired aspects of document-centered computing. This thereby freed the end user from having to consider what program to use to edit pictures for example. In an OpenDoc environment, the user could simply invoke from within a document any number of graphics packages, edit an image within the document with the package, save it, and read it back into text as desired without being concerned about format abilities and the like. Thus, now regardless of which document architecture became prevalent, the end user could nevertheless invoke a pulldown menu within such an OpenDoc environment, select at will an image to imbed and edit, and whatever under-the-covers software component was employed to create and edit the image and pull it into the word processing document would be attached to this image for use within a single environment. The modularity offered by this technology was extremely attractive both to developers as well as end users, resulting in, for example, yet another form of such compound document architecture known as &#34;OLE&#34;. 
     It should be readily apparent that this current interest in document-centered computing has rendered obsolete the prior approach of providing standalone word processors for example which became bloated with code for accommodating various text formats, associated conversion routines, and the like. One important gain from moving away from this approach is that as these monolithic applications became so bloated, they typically also would become more bug prone, harder and costlier to maintain, package, and distribute. It should not be surprising then to see the move in the industry to break functions out into smaller software components. One additional significant benefit of this was that new data formats such as VRML, etc. could easily be accommodated as new software components inasmuch as the OpenDoc environment could simply handle them by imbedding the new component. The end user also benefited in that he or she was not faced with continually having to purchase to numerous standalone applications. 
     Although the OpenDoc system has become very useful, as evidenced by its implementation on numerous platforms such as the aforementioned Macintosh, Microsoft Windows, OS/2, and AIX operating systems (the latter two being marketed by the IBM Corporation), it too nevertheless became subject to several serious and inherent weaknesses which troubled the industry. 
     Implementations of the visual component of the OpenDoc system 40 of FIG. 2, have to date been for a screen 46 displaying a single top-level window 48 enclosing the OpenDoc environment. A highly significant characteristic (and drawback) of such OpenDoc implementations was that only a single OpenDoc &#34;Canvas Object&#34; was provided which all OpenDoc component objects or &#34;Parts&#34; would employ and draw onto. In order to better understand the subject invention it is perhaps helpful to understand some terms associated with OpenDoc. The term &#34;Canvas Object&#34; as utilized hereinafter is an important object which allows for cross-platform compatibility of the invention. An OpenDoc environment includes various libraries which wrap all of the differing system services. For example, there is a storage system object in the OpenDoc environment which permits Parts (to be hereinafter explained) to interact with the system in order to get data onto a disk. For portability and modularity it is important that these Parts not be concerned with the particular platform in which they are operating. Thus, an important function of the Canvas Object is to effectively provide a wrapper to wrap all these differing system services, e.g., to wrap whatever the particular system&#39;s representation of its rendering service, whether it be an XWindow, HDC (in the case of the Windows environment), or the like. It is thus essentially a level of indirection that encapsulates various functions. 
     Yet another term used herein is the aforementioned notion of an OpenDoc &#34;Part&#34; Object (also referred to herein as a component). These parts are essentially pieces of code which handle particular data formats and actually perform the various operations to generate and modify the specific information associated with areas or &#34;Facets&#34; of a screen and the related images. 
     In the prior art implementation of OpenDoc as shown in FIG. 2, one and only one OpenDoc Canvas Object, 52, was provided per each window 48 which typically represented a compound document. Each and every OpenDoc Part, such as parts 56, 60 in FIG. 2 invoked the same single OpenDoc Canvas Object 52, which the respective Parts drew onto. 
     A serious drawback of the thus-described OpenDoc design was that it was necessary for each individual Part 56 or 60 to apply its own transformations and clipping supplied by its parent. Otherwise, the particular OpenDoc Part could potentially draw into an area of the screen which was not allocated to it. Referring again to FIG. 2, a representative such area 50 of the screen may be seen which has been erroneously drawn onto by a corresponding Part due to an improper application of such transformations and clipping. 
     More particularly, as will be hereinafter described, each Part will have associated with it a corresponding Facet which defines an area of the screen 46 which the corresponding Part is to draw to. Thus, for example, referring in more detail to FIG. 2, an area &#34;A&#34; shown at reference numeral 42 is defined by the Facet A, 54, which, at least in theory, is the predefined area to which the Part A, 56, is to draw to. In like manner, a physical geographic area &#34;B&#34; shown at reference numeral 44 on window 48 is a predefined area on the window 48 defined by Facet B, 58, and is intended, in theory, as the only area of the window 48 in which the Part B, 60, will be permitted to draw to. 
     The problem with prior technology arises that if Part A, 56, issues a drawing command erroneously extending beyond its allocated screen space defined by the Facet A and the area A shown in the window 48, there is nothing to preclude the erroneous drawing outside the area A and into the crosshatched area 50. Thus, in the prior technology, each Part was depended upon to essentially have perfect rendering code with no bugs which might result in execution of a drawing command to the system to effect drawing outside of its corresponding boundary and into region 50. In essence, the problem was that each Part was not provided with any enforcement (notwithstanding that in fact pre-defined shapes or areas A, B were in fact defined by the corresponding Facets 54, 56. 
     In summary, unfortunately, because of the inadequacies of the prior OpenDoc design, there was simply no way programmatically to check for such incorrect drawing into unallocated screen areas. This has remained as a serious source of development problems until the advent of the subject invention for essentially all platforms which have implemented the OpenDoc solution to date, including those of the Macintosh, Microsoft Windows, OS/2, and AIX operating systems. Certainly Parts could have been laboriously hardcoded in a manner to provide such checking. However, there has heretofore been no practical and reliable way to provide checking for this inappropriate drawing in an efficient manner. 
     Yet another problem presented by prior systems relates to the borders for Parts required by OpenDoc systems. Such borders may be seen in FIG. 2 as the outer lines defining the rectangular regions A and B. They may take the form of &#34;active&#34; borders as well as &#34;selected&#34; borders having different appearances defined by the OpenDoc specification. Because of lack of enforcement and inability to invoke these borders at will by simple platform-specific calls, it was also necessary in prior technology to effect these borders with burdensome and error-prone calculations and drawing calls. 
     In accordance with prior implementations of OpenDoc, in order to provide the effect of user interface elements for effecting various screen elements (scroll bars, push buttons, arrows and other user interface screen objects), this also entailed laborious calculations and numerous low level drawings calls to ensure that these elements were appropriately bounded since the enforcement provided by the invention was not present. However, notwithstanding the increased performance of systems and associated processors and hardware, these numerous calculations and calls became unduly burdensome on graphical user interface-based systems, seriously impairing their performance and quality regarding OpenDoc Parts which are rendering and providing border displays. 
     Yet another problem was associated with prior OpenDoc and other compound document implementations. Various rendering toolkits have become available to provide a rich range of graphics functionality such as OpenGL, PEX, etc., which provide such function as 3D libraries and the like. Third party vendors have often solved difficult rendering problems which are then packaged and sold as these toolkits and which others may make calls to in order to solve various graphics rendering problems. However one problem associated with these toolkits is that in their operation it is assumed that they have access to an entire Canvas. As heretofore noted with reference to FIG. 2, the prior art had dedicated a single Canvas 52 to the entire window area 48. Accordingly, use of such toolkits would result in ill-behaved software component Parts, inasmuch as they would thereby have no notion of the limited screen space afforded by the present invention in dedicating separate Canvases to predefined sub-areas of the screen. Thus the user ran the risk of such toolkits writing into screen areas which were never intended. 
     Although the foregoing problems have been addressed or example in my co-ending application Ser. No. 08/665,175, filed Jun. 14, 1996, a serious problem nevertheless remained. These problems were being addressed with individualized, platform-specific solutions. This, in turn, necessitated inefficient duplication of effort and associated expenses in repeatedly implementing essentially customized solutions for each platform. What was sorely needed was a generalized, generic approach to the aforesaid problems so as to provide essentially platform-specific components which could be introduced essentially on a plug-in basis as required. 
     SUMMARY OF THE INVENTION 
     The hierarchical window structure and graphics engine clipping functionality of a platform-specific graphics engine is leveraged in a novel compound document implementation to avoid prior problems associated with previous OpenDoc Canvas Object implementations which heretofore gave rise to OpenDoc Parts drawing in screen areas not allocated to the corresponding Parts, and other related problems. The internals of the OpenDoc Canvas Object are restructured while maintaining the same interface definition for multiple platforms including Macintosh, Microsoft Windows, OS/2, and AIX, taking advantage of the object-oriented basis of the OpenDoc system being implemented on top of a system object model (SOM) in the C++ language. 
     In accordance with a representative preferred embodiments (the AIX, OS/2, and Windows operating system platforms) when an OpenDoc Part is allocated a Facet defining an area of a screen for drawing, the system of the invention creates a distinct Canvas Object uniquely for this identical screen area. The Canvas Object defines the same size, shape, and location area as the area of the screen allocated for the OpenDoc Part as defined by its Facet. Accordingly, when the Part retrieves a Canvas Object upon which to effect a screen draw, the Part receives a separate window for each location of the screen allocated to the Part. 
     Clipping is imposed at the level of the graphics engine system. Accordingly, each OpenDoc Part is precluded from drawing onto an area of the screen not allocated to the particular Part, thereby effecting enforcement of its boundary. Support is provided in the operating system of the preferred embodiment for platform-specific clipping APIs, whereby nonrectangularly-shaped areas are also correctly clipped. 
     A generic PlatformCanvas object is employed disposed between a respective canvas and platform-specific canvas, serving as a handle to platform-dependent data types which may be passed directly to native drawing routines. This PlatformCanvas class of objects thereby isolates platform dependencies through its derived classes. Part writers utilize such PlatformCanvas types directly in calls made to native drawing routines. The PlatformCanvas in a preferred embodiment is defined as an SOM interface, wherein platform-specific data is isolated by making the PlatformCanvas an abstract base class, utilized the derived classes to expose platform-dependent data. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a functional block diagram illustrating a representative computer system in which the invention may be advantageously employed. 
     FIG. 2 is an graphical illustration of a prior implementation of a compound document architecture and system wherein only a single Canvas Object is provided 10 for each compound document, further illustrating use of this single OpenDoc Canvas Object by multiple OpenDoc Part objects. 
     FIG. 3 is an illustration of an implementation of the compound document architecture and system of the invention providing multiple Canvas Objects for a compound document each associated with a respective Part. 
     FIG. 4 is a flow diagram of program code for the system of the invention intended for execution in the system of FIG. 1. 
     FIG. 5 is a block diagram illustrating PlatformCanvas objects of the invention. 
     FIG. 6 is a block diagram illustrating the employment of the PlatformCanvas of FIG. 5 in accordance with the invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     First a description of a representative computer system in which the invention may be advantageously employed will be provided with reference to FIG. 1. This will be followed by a general description of the invention and a more specific description with reference to FIG. 3 and the accompany flow diagram of FIG. 4. 
     The preferred embodiments may be practiced in any suitable hardware configuration that uses a touchscreen, such as computing system 100 illustrated in FIG. 1 or, alternatively, in a laptop or notepad computing system. Computing system 100 includes any suitable central processing unit 10, such as a standard microprocessor, and any number of other objects interconnected via system bus 12. For purposes of illustration, computing system 100 includes memory, such as read only memory (ROM) 16, random access memory (RAM) 14, and peripheral memory devices (e.g., disk or tape drives 20) connected to system bus 12 via I/O adapter 18. Computing system 100 further includes a touchscreen display adapter 36 for connecting system bus 12 to a conventional touchscreen display device 38. Also, user interface adapter 22 could connect system bus 12 to other user controls, such as keyboard 24, speaker 28, mouse 26, and a touchpad 32 (not shown). 
     A graphical user interface (GUI) and operating system (OS) of the preferred embodiment reside within a computer-readable media and contain a touchscreen device driver that allows one or more users a user to initiate the manipulation of displayed object icons and text on a touchscreen display device. Any suitable computer-readable media may retain the GUI and operating system, such as ROM 16, RAM 14, disk and/or tape drive 20 (e.g., magnetic diskette, magnetic tape, CD-ROM, optical disk, or other suitable storage media). 
     In the preferred embodiment, a desktop GUI interfaces the user to the operating system. The GUI may be viewed as being incorporated and embedded within the operating system. Alternatively, other suitable operating system or desktop environment could be utilized. Examples of other GUIs and/or operating systems include X11™ (X Windows) graphical user interface, Apple&#39;s Macintosh™ operating system, Microsoft&#39;s Windows 95™ operating system, and the OS/2™ Operating System of IBM. 
     Turning now to FIG. 3, in comparing this figure with that of the prior art of FIG. 2 it will be noted significantly that in FIG. 2 a single Canvas Object 52 is provided in comparison with multiple Canvas Objects 50, 56, 62 in FIG. 3. In the illustration of the invention in FIG. 3, it should be apparent that a Canvas Object of the invention is not intended to be a global object handling the entire screen 48 as in the case of FIG. 2, but rather a plurality of Canvases is employed. Thus, the invention may be seen to have instantiated a separate Canvas Object 50, 56, 62 for each corresponding Facet 52, 58, 64. The OpenDoc Canvas A 56 of the invention has associated with it an OpenDoc Facet A 58 defining the area &#34;A&#34;, reference numeral 42, and this &#34;stack&#34; of Canvas, Facet, and Part 56, 68, 60 is uniquely associated with the window 42, with Facet A, 58, uniquely defining this area. 
     In like manner, the OpenDoc Canvas B 62, Facet B, 64, and Part B, 66, are uniquely defined and associated with the area &#34;B&#34;, reference numeral 44 with the Facet B defining, in like manner, the size, shape, and location of this second window. 
     Finally, and similarly, the Canvas C, 50, Facet C, 52, and Part C, 54, stack is, in turn, uniquely associated with the area defined by the entire window 48. 
     By providing for such multiple Canvases with corresponding Facets and Parts, each uniquely associated with a particular portion of the screen 48, even if, for example, Part A, 60, has a bug in its rendering code which may otherwise absent the invention have resulted in a call to the system and drawing outside of the region A (as in fact happened in the illustration of FIG. 2), this eventuality is precluded with the architecture of the invention. In other words, such erroneous drawing is precluded from occurring on other locations on the window 48, and in particular, in the Part B container 44. The reason is that the bounds of the Canvas A object are clipped. Thus, even identical code which might have resulted in the drawing outside of the boundary A of FIG. 2 will be precluded with the invention from causing drawing in any screen area other than the specific screen area allocated for that software component Part. It will be seen that the invention has thus provided a mechanism for enforcing physical screen locations of software component Parts whereas heretofore no such enforcement was provided. 
     Turning now to FIG. 4, a flow diagram is provided therein of one implementation of code for the compound document architecture of the invention which will yield the benefits of the invention when executed on a system such as that depicted in FIG. 1. 
     First, it will be assumed that a user interacting with the system has provided some input by means of a pointing device or the like which indicates the need to create a new OpenDoc component Part. This action might include dragging a piece of data into a window and dropping it, pulling down a menu item and instructing the system to imbed a graphics image or the like. The result of this action is for the system to request a new Part, 72. 
     Next, in response to this, the shape of such new Part will be defined, 74, by containing the Part where it is to be imbedded. This step will then be followed by a step in which a containing Facet (such as Facet &#34;C&#34;, 52 of FIG. 3) creates a new Facet &#34;A&#34; 58, of FIG. 3, wherein this new Facet will have the same shape, size and location, (this step being shown at reference numeral 76 of FIG. 4). It will be noted from the dividing lines 68, 70 of FIG. 4 that these are intended to set off differing levels of detail of the steps described in FIG. 4. In other words, the operation of the invention at a high level may be understood with reference to the blocks above line 68, e.g., the flow from block 72-78. However, block 76 is thence described in greater detail in the blocks 80-82 between the dividing lines 68 and 70. Block 80 similarly is described in greater detail with reference to the more detailed description of its components in block 84. 
     In describing block 76 in more detail, as shown at block 80 a newly imbedded Canvas Object is created by employing the containing Facet Object &#34;C&#34; as the parent. This in turn causes the creation of the new Facet &#34;A&#34; which will now have associated with it the new Canvas &#34;A&#34;, 82. 
     Finally, the block 84 below line 70 is intended to provide further detail as to the meaning in block 80 of creating a new Canvas. Specifically, the system employs system calls to create a new platform-specific window and drawing context. In other words, internally this new Canvas A will interact with the system to interact with the system level structures allocated by the platform-specific graphics engine calls. These items may thus be seen to be new data contained by the new Canvas Object which were not held before. 
     In terms of the order of steps for creating a new stack, it will thereby be seen by reference to FIG. 4 that a new Canvas will be created followed by its corresponding Facet and Part. Cross referring from FIG. 4 to FIG. 3, the third step, 76, of creating a new Facet may be seen to essentially have been effected by the steps shown at 80, 82, 84. Whereas the prior technology provided for multiple Facet classes but only one Canvas class, the present invention has altered the object oriented connection between the Facet class and Canvas class hierarchy in order to allow for multiple stacks and their associated canvases. 
     From the foregoing it will be apparent that the OpenDoc Canvas internals have essentially been redesigned. Inspection of the interface definition for the new Canvas Objects of FIG. 3 would indicate that although both the Canvas Objects of FIGS. 2 and 3 would meet an identical Canvas Object specification (e.g., such as the Canvas specification for OpenDoc promulgated by the Object Management Group), the Canvas of FIG. 3 has essentially been extended by the invention to hold additional information. 
     It will be appreciated that each object in an object oriented architecture such as that of the instant invention has associated therewith a public interface such as an Interface Definition Language (IDL) in the case of the particular embodiment herein described. This IDL defines the permissible calls which may be made, the various services the objects provide, and the information they hold. Typically such an interface, as is the case with IDL, is programming-language neutral and will have a corresponding IDL defining the particular Canvas. 
     The IDL for the previous Canvases such as those of FIG. 2 might include three method calls or services exported as one piece of data D1, represented by the nomenclature M1, M2, M3, D1. Such an IDL for the novel Canvases of FIG. 3 in accordance with the invention would still comply completely with OMG or like standard for Canvases and thus would include the aforementioned M1, M2, M3, D1. However, because the Canvases of FIG. 3 are of novel form and are extensions, they may have additional method calls and data such as M4, M5, D2. As noted, such IDL will define what a particular Canvas object does and in the case of the Canvas objects of the present invention, the IDL may be defined as follows: 
     
                       TABLE A                                                     
______________________________________                                    
interface ODPlatformCanvas : ODObject (                                   
  ODPlatformCanvas                                                        
               CreateConcreteCanvas(in                                    
               ODGraphicsSystem a SystemType,                             
  ODGraphicsSystem                                                        
               Get SystemType( );                                         
  ODBoolean    HasWindow( );                                              
  ODWindow     GetWindow ( );                                             
  ODBoolean    IsInitialized();                                           
 #ifdef.sub.-- SOMIDL.sub.--                                              
  implementation                                                          
  (                                                                       
  majorversion = 1; minorversion = 0;                                     
  releaseorder:                                                           
   CreateConcreteCanvas,                                                  
   GetSystemType,                                                         
   HasWindow,                                                             
   GenWindow,                                                             
   IsInitialized;                                                         
  override                                                                
   somInit;                                                               
  functionprefix = ODPlatformCanvas                                       
  #ifdef.sub.-- PRIVATE.sub.--                                            
   ODBoolean fInitialized;                                                
  #endif                                                                  
  );                                                                      
 #endif                                                                   
 );                                                                       
______________________________________                                    
 
    
     In the above IDL for ODPlatformCanvas, a factory method is employed for creation of derived classes. This factory method, CreateConcreteCanvas, creates an instance of one of its derived classes based upon input parameters specifying the platform type and whether the associated canvas has its own window. Once created, the instance is initialized with the class-specific initialization method. On Windows platforms, for example, if hasWindow is kODTrue, an instance of the class ODWin32WindowCanvas is returned. It is then initialized with the actual window by calling InitPlatformWindowCanvas. An invalid aSystemType that does not match the platform will throw a kODErrorInvalidGraphicsSystemexception. An instance of one of the derived classes is not considered initialized until its class-specific initialization method is called. The method, IsInitialized, will return kODFalse until the class is initialized. The methods, HasWindow and GetWindow will throw a KODErrorObjectNotInitialized if called before the class is initialized. These methods are overridden in each of the derived classes GetSystemType returns the ODGraphicsSystemType for the derived class type. It is overridden in each of the derived classes. 
     In addition to the IDL, in order to define and understand the operation of a particular Canvas object in the case of the invention, it is further necessary to understand how the Facets employ these extensions of the new Canvas objects which allow the multiple stacks to be built. The flow diagram of FIG. 4 previously described in fact provides such necessary detail as to how the facets employ these extensions provided by the new Canvas objects. 
     Several benefits and added features of the system must be pointed out. It will be recalled that because, in prior technology, separate Canvas Objects were not provided for each screen draw area, in order to draw borders it was necessary to perform numerous complicated calculations and multiple function calls. These operations could become quite complex when it was necessary to draw dashed lines for example or, worse yet, to draw poly lines (necessary if the area to be drawn in was non-rectangular). 
     Additional aspects of the system must also be pointed out referenced to step 84. The graphics system permits several ways in which to place images on the screen area. One permissible method is to write low level graphics engine calls in order to perform desired graphics tasks with respect to desired pixels, such as providing cross hatching, etc. Clearly the present system contemplates employing this feature as desired inasmuch as a platform-specific window is created with respect to each Facet. 
     However, yet an additional method of effecting screen imagery is provided in the X system, namely the notion of high level composite image enhancements effected by widgets and, more particularly, a Motif or similar Toolkit (which include such things as screen elements including scroll bars, pushbuttons, arrows and other user interface screen objects all made into a composite). All one needs to do to effect one of these high level tools is to issue a single system call in order to have the particular effect rendered. 
     It is specifically contemplated by the system disclosed herein to permit use of these items when desired to avoid the necessity for effecting drawings by low level graphics engine calls as in the first-described manner. Thus, although use of low level &#34;raw&#34; graphics library calls is intended, it is further contemplated, as desired, that single function calls may be made to place a user interface element in as desired, for example, as a composite screen element. Numerous sources are available for these various toolkits such as the aforementioned OpenGL which is a set of library functions permitting the easy rendering of 3D images on XWindows. 
     It is an important function of the invention to permit use of the same libraries with the invention. Because the Canvas Objects of the invention each support a single window, this window may be employed with different rendering toolkit code. Whereas this may also be done in the prior implementations of OpenDoc and other compound document frameworks, there is an important aspect of the invention which renders use of these toolkits particularly beneficial in implementations of the invention. Such toolkits typically assume that their functions will have available to them the entirety of a Canvas area. It will therefore be readily appreciated that these functions will potentially be quite ill-behaved as software component Parts in prior implementations of compound document frameworks since they have no notion of limited screen space. 
     Thus, when such a function is called in the system of FIG. 2 for example, there is the potential that the resulting screen draws may extend in an undesired manner essentially anywhere on the screen. In contrast, and in keeping with the invention, these functions are boxed in to predefined areas defined by their corresponding Facets and associated Canvas Objects so as to preclude writing outside the desired component Part area. 
     The Canvas/PlatformCanvas design of the present invention will now be described in greater detail. Referring briefly to FIG. 4, it will be recalled that the ODPlatformCanvas 90 is a mechanism whereby a generic architecture is provided so as to facilitate a number of different platform-specific GUIs such as that of AIX, 84, OS/2, 85, Win32, 87, etc. as desired. It will be recalled that canvases within the context of the invention may be thought of simply as wrappers to the graphics environment. A &#34;Platform Canvas&#34;, on the other hand, represents a handle to platform-dependent data types which can be passed directly to native drawing routines. What follows hereinafter is a description of a preferred embodiment of a design of an ODPlatformCanvas class which isolates platform dependencies through its derived classes. In this implementation, design is, as a matter of choice, based largely on an OS/2 Platform Canvas implementation. 
     Canvas Overview 
     As noted, canvases are wrappers for platform-dependent drawing environments. The class for a canvas is ODCanvas. In one implementation there are basically four kinds of canvases which may be defined. An isDynamic flag indicates whether the canvas represents a dynamic environment, such as a display, or a static environment such as a printer. Part handlers display parts differently based upon this distinction. An isOffScreen flag indicates whether the canvas is the main canvas for a display, a print job, or for off-screen rendering. Off-screen canvases may be used by parts that want to double-buffering or image effects such as translucency. The canvas owner is responsible for moving the contents of the off-screen canvas to the parent canvas. A canvas is attached to a particular facet and has a back-pointer to that facet and also a reference to the part that created it. The following table summarizes the four types of canvases and their uses in the implementation under consideration. 
     
                       TABLE B                                                     
______________________________________                                    
OnScreen      Dynamic  Screen Drawing                                     
OnScreen      State    Printing                                           
Off Screen    Dynamic  Double-Buffering                                   
                       or screen                                          
                       effects                                            
Off Screen    Static   Print preview                                      
______________________________________                                    
 
    
     Platform Canvas Overview 
     As previously noted, each canvas preferably has a corresponding platform canvas, ODPlatformCanvas. In the implementation under consideration, ODPlatformCanvas is represented essentially as a handle to a QuickDraw environment (from the Apple Computer Corporation), a handle to a display context (from the Novell Corporation) a pointer to a structure containing four elements (in the AIX operating system), and an interface defined with the system object model (SOM) from OS/2. Part writers typically use an ODPlatformCanvas type directly and calls made to the native drawing routines. 
     In essence, it is this platform canvas which provides a generic entity for specifically handling multiple different architectures and platforms. Previously this was done on a case by case basis wherein, on an AIX platform, for example, rather than a generic platform canvas, a simple &#34;AIXCanvas&#34; was provided for. Now, however, the system interacts with this Platform Canvas generic canvas and code is provided for determining which actual platform the GUI is intended to be operating on, whether it be OS/2, AIX, Win32, etc. 
     Thus, it has been an object of the invention to provide a common design for all platforms which may be derived from the prior platform-specific implementations. Thus, the notion of Platform Canvases is fundamental to this generic approach in providing a generic representation of platform-specific sets of structures. Referring to FIG. 5, it will thereby be appreciated that now an additional layer, e.g., the ODPlatformCanvas object 90 is interjected between an ODObject CanvasObject 92, and the various platform-specific objects 94-98. This PlatformCanvas Object may be seen essentially to encapsulate all platform-specific data structures inside of it so that the OpenDoc system does not have to maintain knowledge of the particular platform it is executing upon. It is important to note that this ODPlatformCanvas Object is the same on all three (or more) systems and what becomes different is the particular code substituted for this ODPlatformCanvas dependent upon the particular platform on which the code is executing. 
     Thus this ODPlatformCanvas may be thought of as defining a skeleton structure which each system will complete. Such Canvas will know where to go to obtain a window but doesn&#39;t care about what the type of window is. It simply knows that a platform-specific window pointer is provided in the Platform Canvas, e.g., an offset to the platform-specific window code. Prior to the invention, a platform-specific system, for example in the case of AIX, would create an XWindow and XGC, but there was no definition of where to find the particular window object. Now, however, the PlatformCanvas provides the definition of where the details regarding the particular platform-specific window object may be located, e.g., platform-specifics and where to find the drawing context object for the particular platform. The PlatformCanvas thereby provides yet another level of indirection generically to handle multiple platforms. 
     A great deal of platform independence is gained in the implementation being described by utilizing the OS/2 approach wherein the ODPlatformCanvas, reference numeral 90 of FIG. 5, is defined as a SOM interface. The platform-specific data is further isolated by making the ODPlatformCanvas an abstract base class (in C++ terminology) and utilizing derived classes to expose the platform-dependent data. 
     Turning now to FIG. 5, the foregoing may be seen graphically depicted wherein an ODPlatformCanvas 90 is interposed between the ODObject Canvas Object 92 and the various platform-specific Canvas Objects 94-102. 
     It should be noted that on the OS/2 and Windows platforms, separate derived classes are provided for, depending upon whether the associated canvas is onscreen and dynamic. The OS/2 Facet and Canvas design, wherein each facet that is displayed in an on-screen, dynamic canvas is displayed in a separate Presentation Manager (PM) window is carried forward to the windows platforms. The advantage of this is that because each window has its own presentation space (or drawing context), parts can update their own canvas asynchronously. In accordance with FIG. 5, a Platform Canvas which has its own window will preferably have the string Window in the class name. In the case of AIX, a similar facet design was implemented. 
     Referring now to FIG. 6, the common design of FIG. 6 to generically handle multiple platform-specific graphics will maintain drawing context in the Canvas 106 by keeping window handles there as well. This adds a slight extension to the Canvas design in order to allow OS/2 and Windows to store window handles. As indicated, all of the ODxxxCanvas classes are derived from the ODPlatformCanvas 110, and the PlatformCanvases store the drawing contexts and the child window handles. 
     In operation, it will be assumed that a Part is ready to draw itself to a screen after the initial process has been completed of identifying a screen area and setup is complete. When the high level object, the Part is to be displayed, it first obtains a pointer from its Facet 104. The Facet contains a reference to the associated Canvas 106 (1 per Facet). The particular Part 108 then requests that the Facet 104 make a call to GetCanvas as follows: 
     
                       TABLE C                                                     
______________________________________                                    
ODCanvas pCanvas = pFacet -&gt;GetCanvas();                                  
if (pCanvas |= kODNULL)                                                   
 pCanvas -&gt;GetPlatformCanvas() -&gt;GetHWND();                               
______________________________________                                    
 
    
     Once the Part, 108, has a reference to its CanvasObject, 106, the CanvasObject is asked for a reference to the PlatformCanvas Object 110. The Part 108 will then have the reference to the PlatformCanvas 110 and would thereby be able to obtain from the Canvas 110 the necessary platform-specific window information. It will be noted in FIG. 6 that the triangle interposed between the PlatformCanvas 110 and the specific Canvases 112 is conventional OMT object-oriented notational shorthand for &#34;is composed of&#34;. Accordingly, the illustration of FIG. 6 graphically is intended to simply depict that the PlatformCanvas 110 is composed of one of the canvases ODWin32, ODOS/2, or OD/AIX. 
     While the invention has been shown and described with reference to particular embodiments thereof, it will be understood by those skilled in the art that the foregoing and other changes in form and detail may be made therein without departing from the spirit and scope of the invention.