Example #1
0
        /// <summary>
        /// This method is used to create all uce resources either on Startup or session connect
        /// </summary>
        internal virtual void CreateUCEResources(DUCE.Channel channel, DUCE.Channel outOfBandChannel)
        {
            Debug.Assert(channel != null);
            Debug.Assert(!_contentRoot.IsOnChannel(channel));

            Debug.Assert(outOfBandChannel != null);
            Debug.Assert(!_contentRoot.IsOnChannel(outOfBandChannel));

            //
            // Create root visual on the current channel and send
            // this command out of band to ensure that composition node is
            // created by the time this visual target is available for hosting
            // and to avoid life-time issues when we are working with this node
            // from the different channels.
            //

            bool resourceCreated = _contentRoot.CreateOrAddRefOnChannel(this, outOfBandChannel, s_contentRootType);

            Debug.Assert(resourceCreated);
            _contentRoot.DuplicateHandle(outOfBandChannel, channel);
            outOfBandChannel.CloseBatch();
            outOfBandChannel.Commit();
        }
        static internal void Render(
            IntPtr pRenderTarget,
            DUCE.Channel channel,
            Visual visual,
            int width,
            int height,
            double dpiX,
            double dpiY,
            Matrix worldTransform,
            Rect windowClip
            )
        {
            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(target, channel, DUCE.ResourceType.TYPE_GENERICRENDERTARGET);
                targetHandle = target.Handle;

                DUCE.CompositionTarget.PrintInitialize(
                    targetHandle,
                    pRenderTarget,
                    width,
                    height,
                    channel);

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

                DUCE.CompositionNode.SetTransform(
                    rootHandle,
                    deviceTransformHandle,
                    channel);

                DUCE.CompositionTarget.SetRoot(
                    targetHandle,
                    rootHandle,
                    channel);

                channel.CloseBatch();
                channel.Commit();


                // ------------------------------------------------------------
                //   Render the freshly created target.

                RenderContext renderContext = new RenderContext();

                renderContext.Initialize(channel, rootHandle);

                visual.Precompute();

                visual.Render(renderContext, 0);

                // ------------------------------------------------------------
                //   Flush the channel and present the composition target.

                channel.CloseBatch();
                channel.Commit();
                channel.Present();

                MediaContext mediaContext = MediaContext.CurrentMediaContext;
                mediaContext.NotifySyncChannelMessage(channel);
            }
            finally
            {
                // ------------------------------------------------------------
                //   Clean up and release the root visual.

                if (!rootHandle.IsNull)
                {
                    DUCE.CompositionNode.RemoveAllChildren(
                        rootHandle,
                        channel);

                    ((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);
                }

                // ------------------------------------------------------------
                //   Flush the channel and present the composition target.

                channel.CloseBatch();
                channel.Commit();
                channel.Present();

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