Renderer.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media / Renderer.cs / 3 / Renderer.cs

                            //------------------------------------------------------------------------------ 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: 
//      Though called "Renderer", this is used only for the 'rendering 
//      to a BitmapImage' case, and not when rendering to an HwndTarget.
// 
//-----------------------------------------------------------------------------

using System;
using System.Windows; 
using System.Collections.Generic;
using System.Windows.Threading; 
 
using System.Diagnostics;
 
using MS.Internal;
using System.Windows.Media;
using System.Windows.Media.Composition;
 
using MS.Win32;
using System.Security; 
using System.Security.Permissions; 

namespace System.Windows.Media 
{
    static internal class Renderer
    {
 
        /// 
        /// Critical - unmanaged pointer arguments, access critical resources, calls unmanaged code 
        ///  
        [SecurityCritical]
        static public void Render( 
            IntPtr pRenderTarget,
            DUCE.Channel channel,
            Visual visual,
            int width, 
            int height,
            double dpiX, 
            double dpiY) 
        {
            Render(pRenderTarget, channel, visual, width, height, dpiX, dpiY, Matrix.Identity, Rect.Empty, false); 
        }

        /// 
        /// If fRenderForBitmapEffect is true, the method calls special methods on visual 
        /// to render it specifically for an effect to be applied to it. It excludes
        /// properties such as transform, clip, offset and guidelines. 
        ///  
        /// 
        /// Critical - unmanaged pointer arguments, access critical resources, calls unmanaged code 
        /// 
        [SecurityCritical]
        static internal void Render(
            IntPtr pRenderTarget, 
            DUCE.Channel channel,
            Visual visual, 
            int width, 
            int height,
            double dpiX, 
            double dpiY,
            Matrix worldTransform,
            Rect windowClip,
            bool fRenderForBitmapEffect 
            )
        { 
            DUCE.Resource target = 
                new DUCE.Resource();
            DUCE.Resource root = 
                new DUCE.Resource();

            DUCE.ResourceHandle targetHandle = DUCE.ResourceHandle.Null;
            DUCE.ResourceHandle rootHandle = DUCE.ResourceHandle.Null; 

            Matrix deviceTransform = new Matrix( 
                dpiX * (1.0 / 96.0),    0, 
                0,                      dpiY * (1.0 / 96.0),
                0,                      0); 

            deviceTransform = worldTransform * deviceTransform;
            MatrixTransform mtDeviceTransform = new MatrixTransform(deviceTransform);
 
            DUCE.ResourceHandle deviceTransformHandle =
                ((DUCE.IResource)mtDeviceTransform).AddRefOnChannel(channel); 
 

            try 
            {
                // -----------------------------------------------------------
                //   Create the composition target and root visual resources.
 
                target.CreateOrAddRefOnChannel(channel, DUCE.ResourceType.TYPE_GENERICRENDERTARGET);
                targetHandle = target.Handle; 
 
                DUCE.CompositionTarget.PrintInitialize(
                    targetHandle, 
                    pRenderTarget,
                    width,
                    height,
                    channel); 

                root.CreateOrAddRefOnChannel(channel, DUCE.ResourceType.TYPE_VISUAL); 
                rootHandle = root.Handle; 

                DUCE.CompositionNode.SetTransform( 
                    rootHandle,
                    deviceTransformHandle,
                    channel);
 
                DUCE.CompositionTarget.SetRoot(
                    targetHandle, 
                    rootHandle, 
                    channel);
 
                channel.Commit();


                // ----------------------------------------------------------- 
                //   Render the freshly created target.
 
                RenderContext renderContext = new RenderContext(); 

                renderContext.Initialize(channel, rootHandle); 

                visual.Precompute();

                if (fRenderForBitmapEffect) 
                {
                    visual.RenderForBitmapEffect(renderContext, 0); 
                } 
                else
                { 
                    visual.Render(renderContext, 0);
                }

                // Mark the visible realizations. 
                RealizationContext realizationContext = new RealizationContext();
                realizationContext.WindowClip = (windowClip.IsEmpty) ? new Rect(0, 0, width, height) : windowClip; 
                List channels = new List(); 
                DUCE.ChannelSet channelSet = new DUCE.ChannelSet();
                channelSet.Channel = channel; 
                channels.Add(channelSet);
                realizationContext.BeginFrame(false /* full walk */, true /* walk for BitmapRenderTarget */);
                realizationContext.Channels = channels;
 
                realizationContext.TransformStack.Push(ref deviceTransform, /* combine */ false);
 
                if (fRenderForBitmapEffect) 
                {
                    visual.MarkVisibleRealizationsForBitmapEffect(realizationContext); 
                }
                else
                {
                    visual.MarkVisibleRealizations(realizationContext); 
                }
 
                realizationContext.TransformStack.Pop(); 

                // Execute the realization updates. 
                realizationContext.ExecuteRealizationsUpdateSchedule();


                // ------------------------------------------------------------ 
                //   Flush the channel and present the composition target.
 
                channel.Commit(); 
                channel.Present();
 
                MediaContext mediaContext = MediaContext.CurrentMediaContext;
                mediaContext.NotifySyncChannelMessage(channel);

                // 
                // Note: RealizationContext.EndFrame does not need to be called
                // here because we don't cache the realization context. 
                // 
            }
            finally 
            {
                // -----------------------------------------------------------
                //   Clean up and release the root visual.
 
                if (!rootHandle.IsNull)
                { 
                    DUCE.CompositionNode.RemoveAllChildren( 
                        rootHandle,
                        channel); 

                    if (fRenderForBitmapEffect)
                    {
                        visual.ReleaseOnChannelForBitmapEffect(channel); 
                    }
                    else 
                    { 
                        ((DUCE.IResource)visual).ReleaseOnChannel(channel);
                    } 

                    root.ReleaseOnChannel(channel);
                }
 

                // ------------------------------------------------------------ 
                //   Release the world transform. 

                if (!deviceTransformHandle.IsNull) 
                {
                    ((DUCE.IResource)mtDeviceTransform).ReleaseOnChannel(channel);
                }
 

                // ------------------------------------------------------------ 
                //   Clean up and release the composition target. 

                if (!targetHandle.IsNull) 
                {
                    DUCE.CompositionTarget.SetRoot(
                        targetHandle,
                        DUCE.ResourceHandle.Null, 
                        channel);
 
                    target.ReleaseOnChannel(channel); 
                }
 
                //
                // Since we initiate ReleaseOnChannel from the root, that
                // should not enqueue any delayed release.
                // 
                Debug.Assert(channel.IsRemoveAndReleaseQueueEmpty());
 
                // ----------------------------------------------------------- 
                //   Flush the channel and present the composition target.
 
                channel.Commit();
                channel.Present();

                MediaContext mediaContext = MediaContext.CurrentMediaContext; 
                mediaContext.NotifySyncChannelMessage(channel);
            } 
        } 
    }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK