Abstract:
A method and system are provided for detecting transparency simulation formulated by an application in a rendering device. The system includes a node structure construction component for saving each drawing function in a node with an associated node type and node state. The system further includes a node structure constructed from the saved nodes and traversal components for traversing the node structure. The traversal components include a type check mechanism for determining a saved type of each node in the structure and a state check mechanism for finding a saved state and detecting. The system detects the transparency simulation upon finding a predetermined node type and a predetermined node state.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS  
       [0001]     None.  
       STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT  
       [0002]     None.  
       TECHNICAL FIELD  
       [0003]     Embodiments of the present invention relate to providing a transparency effect for a user interface. More particularly, embodiments of the invention relate to the detection of a transparency simulation and conversion to a true transparency.  
       BACKGROUND OF THE INVENTION  
       [0004]     It is often desirable to provide a user with an image having portions that appear to be transparent. Microsoft Windows, a product of the Microsoft Corporation of Redmond, Wash., includes graphics device interface (GDI) application program interfaces (APIs) that lack some basic transparency supports. For example, the APIs offer no support for opacity in a brush, which is the graphics tool that applications use to paint the interiors of various shapes. In order to overcome this deficiency, applications such as Microsoft Office XP, Microsoft Office  2003 , and Microsoft GDI+ simulate the transparency effects by using a combination of read only printer codes (ROPs) when printing to a printer.  
         [0005]     While these simulations may appear to accurately portray a transparency effect in a single on-screen view, they often lose the desired appearance in zoomed views. Furthermore, the simulations are not device-independent and therefore often cannot be printed as rendered for viewing by a user.  
         [0006]     More efficient techniques have been formulated for creating transparency effects. However, these techniques are not currently universally implemented and many existing applications continue to use the transparency simulations described above that cannot be consistently accurately rendered. Accordingly, it is necessary to detect whether a transparency has been simulated in order to subsequently correct the simulation with a transparency effect that will be efficiently replicated in multiple views and by multiple printers or other output devices.  
         [0007]     Accordingly, a solution is needed for detecting simulation effects in a printer or display driver. The detection of the simulation effects will enable correction in order to prevent inaccurate rendering of transparency effects.  
       BRIEF SUMMARY OF THE INVENTION  
       [0008]     Embodiments of the present invention are directed to a method for system for detecting transparency simulation formulated by an application in a rendering device such as a printer driver or display. The system includes a node structure construction component for saving each drawing function in a node with an associated node type and node state. The system additionally includes a node structure constructed from the saved nodes and traversal components for traversing the node structure. The traversal components determine a saved type and state of each node in the structure and detect the transparency simulation upon finding a predetermined node type and predetermined node state.  
         [0009]     In another aspect of the invention, a method is provided for detecting a transparency simulation in a rendering device, such as a printer driver or display. The transparency simulated has been formulated by an application. The method includes saving each drawing function in a node with an associated node type and node state and constructing a node structure from the saved nodes. The method additionally includes traversing the node structure and determining the saved type of each node. The method additionally determines a saved state if a predetermined node type is found. The method further includes detecting the transparency simulation upon finding a predetermined node type and predetermined node state.  
         [0010]     Upon detecting nodes of a specified type and state and an ending marker, the system and method perform a conversion process for converting the simulated transparency to a true transparency. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0011]     The present invention is described in detail below with reference to the attached drawings figures, wherein:  
         [0012]      FIG. 1  is a block diagram illustrating a transparency simulation detection system in accordance with an embodiment of the invention;  
         [0013]      FIG. 2  is a block diagram illustrating a computerized environment in which the transparency simulation detection system may be implemented;  
         [0014]      FIG. 3  illustrates an example of a solid color transparency;  
         [0015]      FIG. 4  illustrates a potential appearance of a GDI simulation;  
         [0016]      FIG. 5  illustrates a zoomed view of the GDI simulation shown in  FIG. 4 ;  
         [0017]      FIG. 6  is a flow chart illustrating a simulation detection and conversion technique in accordance with an embodiment of the invention;  
         [0018]      FIG. 7  is a flowchart illustrating a conversion process in accordance with an embodiment of the invention;  
         [0019]      FIG. 8  is a flowchart illustrating further details of simulation detection in accordance with an embodiment of the invention;  
         [0020]      FIG. 9  is a flow chart illustrating additional details of simulation detection in accordance with an embodiment of the invention;  
         [0021]      FIG. 10  is a flowchart illustrating additional details of simulation detection in accordance with an embodiment of the invention; and  
         [0022]      FIG. 11  is a flowchart illustrating further details of a conversion process in accordance with an embodiment of the invention. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0000]     I. System Overview  
         [0023]     Embodiments of the invention include a method and system for detecting and converting a transparency simulation in a printer driver or other device driver.  FIG. 1  illustrates an embodiment of a system  10  for transparency simulation detection and conversion. The transparency simulation detection system  10  may include node structure construction components  20  and a resultant stored node structure  26 . The system  10  may additionally include node traversal components  30 . The traversal components  30  may include a type check mechanism  32  and a state check mechanism  34 . The system  10  may additionally include a conversion component  40  for converting a simulated transparent path fill operation into a true transparent path fill.  
         [0024]     In operation, in order to simulate transparency effects, independent applications route calls through the GDI. The GDI calls functions of the form “DrvXXX” that are implemented by display and/or printer drivers. In order to detect transparency simulations, the node structure construction components  20  save the states of the DrvXXX functions until the system  10  can determine whether a DrvXXX operation is part of a transparency simulation sequence. The node structure construction components  20  accordingly save the state of each DrvXXX operation in a node object and place each node object into a node structure  26  such as a queue, a list, or a tree structure.  
         [0025]     After the node structure  26  is constructed, traversal components  30  traverse the node structure  26  and use the type check mechanism  32  and the state check mechanism  34  to detect a simulated transparency sequence. The conversion component  40  converts the detected simulation sequence into a true transparency. The process will be further described below in conjunction with the additional drawings and flowcharts.  
         [0000]     II. Exemplary Operating Environment  
         [0026]      FIG. 2  illustrates an example of a suitable computing system environment  100  on which the transparency simulation detection system  10  may be implemented. The computing system environment  100  is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing environment  100  be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment  100 .  
         [0027]     The invention is described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the invention may be practiced with other computer system configurations, including hand-held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.  
         [0028]     With reference to  FIG. 2 , the exemplary system  100  for implementing the invention includes a general purpose-computing device in the form of a computer  110  including a processing unit  120 , a system memory  130 , and a system bus  121  that couples various system components including the system memory to the processing unit  120 .  
         [0029]     Computer  110  typically includes a variety of computer readable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. The system memory  130  includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM)  131  and random access memory (RAM)  132 . A basic input/output system  133  (BIOS), containing the basic routines that help to transfer information between elements within computer  110 , such as during start-up, is typically stored in ROM  131 . RAM  132  typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit  120 . By way of example, and not limitation,  FIG. 2  illustrates operating system  134 , application programs  135 , other program modules  136 , and program data  137 . The transparency simulation and detection system  10  may be stored in any of the aforementioned memory structures.  
         [0030]     The computer  110  may also include other removable/nonremovable, volatile/nonvolatile computer storage media. By way of example only,  FIG. 2  illustrates a hard disk drive  141  that reads from or writes to nonremovable, nonvolatile magnetic media, a magnetic disk drive  151  that reads from or writes to a removable, nonvolatile magnetic disk  152 , and an optical disk drive  155  that reads from or writes to a removable, nonvolatile optical disk  156  such as a CD ROM or other optical media. Other removable/nonremovable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive  141  is typically connected to the system bus  121  through an non-removable memory interface such as interface  140 , and magnetic disk drive  151  and optical disk drive  155  are typically connected to the system bus  121  by a removable memory interface, such as interface  150 .  
         [0031]     The drives and their associated computer storage media discussed above and illustrated in  FIG. 2 , provide storage of computer readable instructions, data structures, program modules and other data for the computer  110 . In  FIG. 2 , for example, hard disk drive  141  is illustrated as storing operating system  144 , application programs  145 , other program modules  146 , and program data  147 . Note that these components can either be the same as or different from operating system  134 , application programs  135 , other program modules  136 , and program data  137 . Operating system  144 , application programs  145 , other program modules  146 , and program data  147  are given different numbers here to illustrate that, at a minimum, they are different copies. A user may enter commands and information into the computer  110  through input devices such as a keyboard  162  and pointing device  161 , commonly referred to as a mouse, trackball or touch pad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit  120  through a user input interface  160  that is coupled to the system bus, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB). A monitor  191  or other type of display device is also connected to the system bus  121  via an interface, such as a video interface  190 . In addition to the monitor, computers may also include other peripheral output devices such as speakers  197  and printer  196 , which may be connected through an output peripheral interface  195 .  
         [0032]     The computer  110  in the present invention will operate in a networked environment using logical connections to one or more remote computers, such as a remote computer  180 . The remote computer  180  may be a personal computer, and typically includes many or all of the elements described above relative to the computer  110 , although only a memory storage device  181  has been illustrated in  FIG. 2 . The logical connections depicted in  FIG. 2  include a local area network (LAN)  171  and a wide area network (WAN)  173 , but may also include other networks.  
         [0033]     When used in a LAN networking environment, the computer  110  is connected to the LAN  171  through a network interface or adapter  170 . When used in a WAN networking environment, the computer  110  typically includes a modem  172  or other means for establishing communications over the WAN  173 , such as the Internet. The modem  172 , which may be internal or external, may be connected to the system bus  121  via the user input interface  160 , or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer  110 , or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,  FIG. 2  illustrates remote application programs  185  as residing on memory device  181 . It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.  
         [0034]     Although many other internal components of the computer  110  are not shown, those of ordinary skill in the art will appreciate that such components and the interconnection are well known. Accordingly, additional details concerning the internal construction of the computer  110  need not be disclosed in connection with the present invention.  
         [0000]     III. Transparency Simulation  
         [0035]     An understanding of the process of simulation detection depends upon an understanding of the transparency simulation processes implemented by various applications. A filled shape refers to a closed shape that is filled through the use of a brush object. The brush object may be used to paint the interior of graphics shapes, such as rectangles, ellipses, pies, polygons, and paths.  
         [0036]      FIG. 3  is an example of a transparency effect in Microsoft Word as it appears on a user display.  FIG. 3  shows rectangular portions  300  and  320 , oval portions  310  and  312 , and an irregularly shaped portion  314 . An opaque brush object can be used to paint the interior of any of the aforementioned graphic shapes. In  FIG. 3 , regions  310 ,  312 ,  320 , and  314  appear to be transparent. Non-overlapping portions of the rectangular portion  300  are opaque.  
         [0037]     However, as stated above, GDI, the native graphics API on the Windows operating system, does not support transparency in a brush natively. Because printing requires the use of GDI, this lack of support presents a major problem when applications need to print shapes having transparent portions.  
         [0038]     Thus, with GDI operations, applications exercise one of several alternatives. Many applications simulate their shape filled with transparency with a set of GDI operations. Alternatively, applications such as GDI+ and Microsoft Office will determine if a selected printer is a postscript printer. If the printer is a postscript printer, the applications will bypass GDI and emit a postscript representation that supports transparency. However, this alternative requires the application to work in a device dependent manner and add special codes for particular devices. Accordingly, in practice, applications only exercise this option for postscript printers. Another alternative allows applications to apply transparency themselves and convert everything into a large image and send the image into a printer driver. This approach creates an image that has a much larger size than desired and the image will show rough edges in a zoomed view  
         [0039]     Thus, for printing, because of the drawbacks of other techniques as set forth above, many applications simulate their shape filled with transparency with a set of GDI operations. Typically, the shapes are simulated by a sequence of GDI operations that involves ROPs. A resulting image is illustrated in  FIG. 4 .  
         [0040]      FIG. 4  includes the rectangular shapes  400  and  420 , irregular shape  414 , and oval shapes  410  and  412 . However, an attempt to simulate transparency results in a grid-like appearance of all portions except the non-overlapping portion of the rectangular shape  400 . This portion is the only opaque portion, whereas the other portions having the simulated transparency effect all appear undesirably grid-like.  FIG. 5  additionally illustrates a zoomed in or close-up view that illustrates the problem more clearly with rectangular portion  520 .  
         [0041]     The simulation that results in the above-identified effects involves a series of steps. In a first step, the applications create a desired brush in GDI and select it. Subsequent steps require knowledge of binary raster operation codes that define how GDI combines bits. Each raster operation code represents a Boolean operation in which values of pixels in the selected pen and destination bitmap are combined. The operations and operands in Table 1 may be used.  
                                               TABLE 1                                       Operand   Meaning                       P   Selected pen           D   Destination bitmap                        The Boolean operators used in these operations follow.                Operator   Meaning                       A   Bitwise AND           N   Bitwise NOT (inverse)           O   Bitwise OR           X   Bitwise exclusive OR (XOR)           .                      
 
         [0042]     Boolean operations are presented in reverse Polish notation. For example, the operation DPo is equivalent to “D OR P” and replaces the values of the pixels in the destination bitmap with a combination of the pixel values of the pen and the selected brush.  
         [0043]     Each raster-operation code is a 32-bit integer having a high-order word that is a Boolean operation index and a low-order word that is an operation code. The 16-bit operation index is a zero-extended 8-bit value that represents all possible outcomes resulting from the Boolean operation on two parameters (in this case, the pen and destination values).  
         [0044]     In a second step, the applications apply the “PatBlt” function of the brush to a bounding rectangle of the transparency area using ROP value DPx, which is the same is D XOR P. The Patblt function paints a given rectangle using a currently selected brush. In this case, the operation mixes a destination pixel value (or surface color) with a pixel value on the brush using an XOR operation. The PatBlt function affects the bounding rectangle, which may cover a wider area than the actual transparency area. For example, if the transparency is a filled circle, this operation will affect a larger area. This coverage is offset by the sixth step described below.  
         [0045]     In a third step, the application creates a binary mask brush with typical mask dimensions of 16×16 pixels or 8×8 pixels. The application divides the number of white pixels by the total number of pixels to obtain a transparency ratio and selects an appropriate mask.  
         [0046]     In a fourth step, the application fills the transparency area using the mask brush and ROP value DPa (D AND P). This operation mixes a destination pixel value with the pixel value on the brush with an AND operation. The fill operation depends on the shape of area. For a rectangle, the fill operation would be accomplished using the PatBIt function. For a circle, the fill operation would be accomplished using a “FillPath” operation. Several calls in sequence may be required.  
         [0047]     In a fifth step, the application selects the solid color brush of the first step again. Finally, in a sixth step, the application uses the PatBIt operation with the brush on the bounding rectangle of the transparency area using DPx (D XOR P). As a result of the above-mentioned six steps, the transparency simulation shown in above results.  
         [0048]     The six steps described above include a series of GDI calls that are translated to DrvXXX calls. In a display or printer driver, a number of DrvXXX functions are implemented by the driver in order to perform rendering operations. Some of the DrvXXX functions are displayed in Table 2 below.  
                       TABLE 2                               May be used               for path fill               with       Function   Purpose   transparency?                   DrvCopyBits   Translates between   Yes           device managed raster           surfaces and GDI           standard format bitmaps       DrvBitBlt   General bit block transfer   Yes       DrvStretchBlt   Provides stretching bit   Yes           block transfer capabilities           between any combination           of device managed and           GDI managed surfaces       DrvStrokePath   Outlines a path   Yes       DrvFillPath   Filling of closed paths   Yes       DrvStrokeAndFillPath   Outlines and fills path   Yes           concurrently       DrvTextOut   Entry point from GDI that   No           calls driver to render set           of glyphs       DrvStretchBltROP   Performs a stretch bit   No           block transfer using ROP       DrvPlgBlt   Provides rotate bit-block   No           transfer capabilities           between combinations of           device managed and GDI           managed surfaces       DrvGradientFill   Shades specified   No           primitives       DrvTransparentBlt   Provides bit block   No           transfer capabilities with           transparency       DrvAlphaBlend   Provides bit block   No           transfer capabilities with           alpha blending                  
 
         [0049]     GDI operations such as BitBIt and FillPath are handled by a graphics rendering engine (GRE) that calls DrvXXX operations implemented by graphics drivers.  
         [0000]     IV. Detection and Conversion Process  
         [0050]     A true (not simulated) transparent fill path has a number of properties. One of these properties is a path data property that describes the shape of the path. Another of these properties is a brush that describes the paint used to paint the interior of the shape. An additional property of a true fill path is an optional clip path that describes the clip region. Furthermore, a true fill path has an opacity value between 0.0 and 1.0. A value of 0.0 makes the brush completely invisible and everything under the shape is visible. A value of 1.0 makes the brush completely opaque.  
         [0051]     In order to detect and handle transparency simulations, the transparency simulation detection system  10  saves the states of DrvXXX operations until it can determine whether each DrvXXX operation is part of a transparency simulation sequence. The node structure construction component  20  can save the state of each DrvXXX operation in a node object and place it in the node structure  26 , which may be either a node queue, a list, or a tree structure. In a preferred embodiment of the invention, all DrvXXX operations for an entire page are inserted into nodes and placed into the list structure  26 . The traversal components  30  process the node structure  26  at the end of a page.  
         [0052]     In embodiments of the invention, a node structure named “PathFill” stores the state of DrvStrokePath, DrvFillPath, DrvStrokeAndFillPath. In addition, DrvBitBlt may also be represented as a “PathFill” when the parameters passed to DrvBitBlt meet certain conditions. In addition to general properties described above, this PathFill node contains a ROP property to store a raster operation value.  
         [0053]     The traversal components  30  traverse the node structure  26  after it is constructed. The traversal components  30  detect the simulated path fill sequence. The conversion component  40  converts the simulated path fill into a true path fill with transparency.  
         [0054]      FIG. 6  illustrates an embodiment of the traversal sequence. In step A 0 , traversal begins with a stored state equal to “none”. In step A 02 , the traversal components  30  determine if additional nodes are present in the node structure  26 . If no additional nodes are present in the structure in step A 02 , the process ends in step A 20 . If additional nodes exist in step A 02 , the traversal components get the next node in step A 04 . In step A 06 , the type check mechanism determines whether the node in question is of type Pathfill. If the node is not of type pathfill, the state is set equal to “none” in step A 16 . If the node in question is of type Pathfill, then the state checking mechanism checks the state value of the node in step A 08 .  
         [0055]     If the state value is “none” in step A 08 , the system checks to determine if the node is a beginning marker in step B 0 . If the state value is DPa, then the state check mechanism determines if the node is an end marker in step C 0 . If the state is Start_DPx, then the system determines whether the node has a state value of DPa in step D 0 .  
         [0056]     If the node does not have any of the state values of steps B 0 , C 0 , and D 0 , the state is set equal to “none”. If the state value is DPa (D AND P) in step A 10 , the process ends in step G 0 . If the node is an end marker in step C 0 , the end marker is set equal to node in step A 12  and the conversion mechanism performs a fill process at E 0 . The state is set equal to “none” in step A 16  and the process ends or the next node is traversed.  
         [0057]     If the node is a beginning marker in B 0 , the state is set equal to “Start_DPx” and the beginning marker is set equal to node. The next node is then traversed.  
         [0058]      FIG. 7  illustrates the conversion process shown in step E 0  of  FIG. 6  in accordance with an embodiment of the invention. In step E 02 , the conversion mechanism sets the brush equal to the brush of the beginning marker. In step E 04 , the conversion mechanism loops between all pathfill nodes between the beginning marker and the end marker. In step E 06 , the conversion mechanism determines if there is another node. If there is not another node, the system skips to step E 12 .  
         [0059]     If another node is present, in step E 08 , the conversion mechanism gets the next node. In process F 0 , the conversion mechanism calculates opacity. In step E 10 , the system sets the node opacity, brush and ROP. If no more nodes are present, the system removes the beginning marker node in step E 12  and removes the end marker node in step E 14 . The process ends in step E 16 .  
         [0060]      FIG. 8  illustrates an embodiment of the process for determining if the node is a beginning marker as performed in step B 0  of  FIG. 6 . In step B 02 , the state checking mechanism determines if the node has a brush. If the node does not have a brush, the system returns “false” in step B 10 . If the node does have a brush in step B 02 , the system determines if the ROP is PDx. If not, the system returns false in step B 10 . If the condition is true, the system determines if the node shape is a rectangle in step B 06 . If not, the system returns false. If the condition is true, the system returns “true” in step B 08 .  
         [0061]      FIG. 9  illustrates a process for determining if a node is an end marker in accordance with step C 0  of  FIG. 6 . In step C 02 , the system determines if the node&#39;s brush is that same as the brush of the begin marker. If not, the system returns false. If the condition is true, the system determines if ROP is equal to PDx in step C 04 . If the condition is false, the system returns false in step C 10 . If the condition is true in step C 04 , the system determines if the node shape is the same as that of the begin marker node. If not, the system returns false in step C 10 . If the condition is true, the system returns true in step C 08 .  
         [0062]      FIG. 10  illustrates a process for determining if a node has a state value of DPa as shown in step D 0  of  FIG. 6  in accordance with an embodiment of the invention. In step D 02 , the system determines if the node has an image pattern brush. If it does not, the system returns false in step D 16 . If the condition is true, the system determines if the ROP is DPa in step D 04 . If it is not, the system determines whether the node is DPna in step D 06 . If it is not, the system returns false in step D 16 . If the node has a value of either DPa or DPna, the system determines if the brush image has a one bit per pixel format. If it does not, the system returns false in step D 16 . If it does, the system determines in step D 10  whether the brush image has a specified dimension such as 16×16 pixels. If not, the system determines if the brush image has an 8×8 pixel dimension. If the brush image has neither a 16×16 pixel nor an 8×8 pixel brush dimension, the system returns false in step D 16 . If the brush image dimension is either 16×16 pixels or 8×8 pixels, the system returns true.  
         [0063]      FIG. 11  illustrates a process for calculating opacity for use by the conversion mechanism in accordance with an embodiment of the invention. In step F 02 , the system sets image equal to the brush for the node and sets the count equal to zero. In step F 04 , the system loops through every pixel in the image. In step F 06 , the system determines if more pixels exist. If another pixel is available in step F 06 , the system determines if the pixel is on in step F 08 . If not, the system looks for more pixels. If the pixel is on in step F 08 , the system increases the count by one in step F 10 .  
         [0064]     When no more pixels are available in step F 06 , the system sets the opacity equal to “Count/(image.width×image.height) in step F 12 . In step F 14 , the system determines if the ROP is equal to DPna. If the condition is true the system sets the opacity equal to (1.0—opacity) and returns the opacity. If the condition is false, the system returns opacity.  
         [0065]     Through the techniques of  FIGS. 6-11 , the system is able to detect a transparency simulation and convert a simulated transparency to a true transparency.  
         [0000]     V. Other Simulation Processes  
         [0066]     In addition to the transparency simulation process described above, other transparency simulations may be used to simulation transparency effects. One of them is the transparency mask effect. Some applications simulate the effect by breaking an image with a transparency mask into many single pixel images. Only opaque lines are drawn by calling DrvBitBlt or DrvStretchBltROP functions. The undesired effect is that the printer driver will get multiple single-line images for one such image. In an alternate detection process, the system of the invention can detect these adjacent single pixel height images and combine them back into a single image with an alpha channel, which is a transparency component of each pixel in an alpha bitmap.  
         [0000]     VI. Conclusion  
         [0067]     Thus, both printers and printer and display drivers can rely on the disclosed feature to properly convert documents containing transparency drawing objects into a corrected format such in a fixed XAML document. The technique can also be utilized by ordinary printers such ink jet printers.  
         [0068]     While particular embodiments of the invention have been illustrated and described in detail herein, it should be understood that various changes and modifications might be made to the invention without departing from the scope and intent of the invention. The embodiments described herein are intended in all respects to be illustrative rather than restrictive. Alternate embodiments will become apparent to those skilled in the art to which the present invention pertains without departing from its scope.  
         [0069]     From the foregoing it will be seen that this invention is one well adapted to attain all the ends and objects set forth above, together with other advantages, which are obvious and inherent to the system and method. It will be understood that certain features and sub-combinations are of utility and may be employed without reference to other features and sub-combinations. This is contemplated and within the scope of the appended claims.