예제 #1
0
            internal void CreateChannels() 
            {
                Invariant.Assert(_asyncChannel == null); 
                Invariant.Assert(_asyncOutOfBandChannel == null); 

                // Create a channel into the async composition device. 
                // Pass in a reference to the global mediasystem channel so that it uses
                // the same partition.
                _asyncChannel = new DUCE.Channel(
                    System.Windows.Media.MediaSystem.ServiceChannel, 
                    false,      // not out of band
                    System.Windows.Media.MediaSystem.Connection, 
                    false // [....] transport 
                    );
 
                _asyncOutOfBandChannel = new DUCE.Channel(
                    System.Windows.Media.MediaSystem.ServiceChannel,
                    true,       // out of band
                    System.Windows.Media.MediaSystem.Connection, 
                    false // [....] transport
                    ); 
            } 
예제 #2
0
 internal abstract DUCE.ResourceHandle GetHandleCore(DUCE.Channel channel);
예제 #3
0
        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------



        #region Public Properties



        #endregion Public Properties

        //------------------------------------------------------
        //
        //  Protected Methods
        //
        //------------------------------------------------------

        #region Protected Methods



        #endregion ProtectedMethods

        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods


        internal abstract DUCE.ResourceHandle AddRefOnChannelCore(DUCE.Channel channel);
예제 #4
0
 protected abstract void UpdateResourceCore(DUCE.Channel channel);
예제 #5
0
 /// <summary>
 /// This is only implemented by Visual and Visual3D.
 /// </summary>
 DUCE.ResourceHandle DUCE.IResource.Get3DHandle(DUCE.Channel channel)
 {
     throw new NotImplementedException();
 }
예제 #6
0
        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                Transform3D vTransform = Transform;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform3D.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }

                // Obtain handles for animated properties
                DUCE.ResourceHandle hNearPlaneDistanceAnimations = GetAnimationResourceHandle(NearPlaneDistanceProperty, channel);
                DUCE.ResourceHandle hFarPlaneDistanceAnimations  = GetAnimationResourceHandle(FarPlaneDistanceProperty, channel);
                DUCE.ResourceHandle hPositionAnimations          = GetAnimationResourceHandle(PositionProperty, channel);
                DUCE.ResourceHandle hLookDirectionAnimations     = GetAnimationResourceHandle(LookDirectionProperty, channel);
                DUCE.ResourceHandle hUpDirectionAnimations       = GetAnimationResourceHandle(UpDirectionProperty, channel);
                DUCE.ResourceHandle hWidthAnimations             = GetAnimationResourceHandle(WidthProperty, channel);

                // Pack & send command packet
                DUCE.MILCMD_ORTHOGRAPHICCAMERA data;
                unsafe
                {
                    data.Type       = MILCMD.MilCmdOrthographicCamera;
                    data.Handle     = _duceResource.GetHandle(channel);
                    data.htransform = hTransform;
                    if (hNearPlaneDistanceAnimations.IsNull)
                    {
                        data.nearPlaneDistance = NearPlaneDistance;
                    }
                    data.hNearPlaneDistanceAnimations = hNearPlaneDistanceAnimations;
                    if (hFarPlaneDistanceAnimations.IsNull)
                    {
                        data.farPlaneDistance = FarPlaneDistance;
                    }
                    data.hFarPlaneDistanceAnimations = hFarPlaneDistanceAnimations;
                    if (hPositionAnimations.IsNull)
                    {
                        data.position = CompositionResourceManager.Point3DToMilPoint3F(Position);
                    }
                    data.hPositionAnimations = hPositionAnimations;
                    if (hLookDirectionAnimations.IsNull)
                    {
                        data.lookDirection = CompositionResourceManager.Vector3DToMilPoint3F(LookDirection);
                    }
                    data.hLookDirectionAnimations = hLookDirectionAnimations;
                    if (hUpDirectionAnimations.IsNull)
                    {
                        data.upDirection = CompositionResourceManager.Vector3DToMilPoint3F(UpDirection);
                    }
                    data.hUpDirectionAnimations = hUpDirectionAnimations;
                    if (hWidthAnimations.IsNull)
                    {
                        data.width = Width;
                    }
                    data.hWidthAnimations = hWidthAnimations;

                    // Send packed command structure
                    channel.SendCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_ORTHOGRAPHICCAMERA));
                }
            }
        }
예제 #7
0
        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                Transform3D vTransform = Transform;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform3D.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }

                // Obtain handles for animated properties
                DUCE.ResourceHandle hColorAnimations                = GetAnimationResourceHandle(ColorProperty, channel);
                DUCE.ResourceHandle hPositionAnimations             = GetAnimationResourceHandle(PositionProperty, channel);
                DUCE.ResourceHandle hRangeAnimations                = GetAnimationResourceHandle(RangeProperty, channel);
                DUCE.ResourceHandle hConstantAttenuationAnimations  = GetAnimationResourceHandle(ConstantAttenuationProperty, channel);
                DUCE.ResourceHandle hLinearAttenuationAnimations    = GetAnimationResourceHandle(LinearAttenuationProperty, channel);
                DUCE.ResourceHandle hQuadraticAttenuationAnimations = GetAnimationResourceHandle(QuadraticAttenuationProperty, channel);
                DUCE.ResourceHandle hDirectionAnimations            = GetAnimationResourceHandle(DirectionProperty, channel);
                DUCE.ResourceHandle hOuterConeAngleAnimations       = GetAnimationResourceHandle(OuterConeAngleProperty, channel);
                DUCE.ResourceHandle hInnerConeAngleAnimations       = GetAnimationResourceHandle(InnerConeAngleProperty, channel);

                // Pack & send command packet
                DUCE.MILCMD_SPOTLIGHT data;
                unsafe
                {
                    data.Type       = MILCMD.MilCmdSpotLight;
                    data.Handle     = _duceResource.GetHandle(channel);
                    data.htransform = hTransform;
                    if (hColorAnimations.IsNull)
                    {
                        data.color = CompositionResourceManager.ColorToMilColorF(Color);
                    }
                    data.hColorAnimations = hColorAnimations;
                    if (hPositionAnimations.IsNull)
                    {
                        data.position = CompositionResourceManager.Point3DToMilPoint3F(Position);
                    }
                    data.hPositionAnimations = hPositionAnimations;
                    if (hRangeAnimations.IsNull)
                    {
                        data.range = Range;
                    }
                    data.hRangeAnimations = hRangeAnimations;
                    if (hConstantAttenuationAnimations.IsNull)
                    {
                        data.constantAttenuation = ConstantAttenuation;
                    }
                    data.hConstantAttenuationAnimations = hConstantAttenuationAnimations;
                    if (hLinearAttenuationAnimations.IsNull)
                    {
                        data.linearAttenuation = LinearAttenuation;
                    }
                    data.hLinearAttenuationAnimations = hLinearAttenuationAnimations;
                    if (hQuadraticAttenuationAnimations.IsNull)
                    {
                        data.quadraticAttenuation = QuadraticAttenuation;
                    }
                    data.hQuadraticAttenuationAnimations = hQuadraticAttenuationAnimations;
                    if (hDirectionAnimations.IsNull)
                    {
                        data.direction = CompositionResourceManager.Vector3DToMilPoint3F(Direction);
                    }
                    data.hDirectionAnimations = hDirectionAnimations;
                    if (hOuterConeAngleAnimations.IsNull)
                    {
                        data.outerConeAngle = OuterConeAngle;
                    }
                    data.hOuterConeAngleAnimations = hOuterConeAngleAnimations;
                    if (hInnerConeAngleAnimations.IsNull)
                    {
                        data.innerConeAngle = InnerConeAngle;
                    }
                    data.hInnerConeAngleAnimations = hInnerConeAngleAnimations;

                    // Send packed command structure
                    channel.SendCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_SPOTLIGHT));
                }
            }
        }
예제 #8
0
 internal DUCE.ResourceHandle GetAnimationResourceHandle(DependencyProperty dp, DUCE.Channel channel)
 {
     if (channel != null && IAnimatable_HasAnimatedProperties)
     {
         return(IndependentAnimationStorage.GetResourceHandle(this, dp, channel));
     }
     else
     {
         return(DUCE.ResourceHandle.Null);
     }
 }
예제 #9
0
        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                Transform   vTransform         = Transform;
                Transform   vRelativeTransform = RelativeTransform;
                BitmapCache vBitmapCache       = BitmapCache;
                Visual      vInternalTarget    = InternalTarget;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hRelativeTransform;
                if (vRelativeTransform == null ||
                    Object.ReferenceEquals(vRelativeTransform, Transform.Identity)
                    )
                {
                    hRelativeTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hRelativeTransform = ((DUCE.IResource)vRelativeTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hBitmapCache = vBitmapCache != null ? ((DUCE.IResource)vBitmapCache).GetHandle(channel) : DUCE.ResourceHandle.Null;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hInternalTarget = vInternalTarget != null ? ((DUCE.IResource)vInternalTarget).GetHandle(channel) : DUCE.ResourceHandle.Null;

                // Obtain handles for animated properties
                DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel);

                // Pack & send command packet
                DUCE.MILCMD_BITMAPCACHEBRUSH data;
                unsafe
                {
                    data.Type   = MILCMD.MilCmdBitmapCacheBrush;
                    data.Handle = _duceResource.GetHandle(channel);
                    if (hOpacityAnimations.IsNull)
                    {
                        data.Opacity = Opacity;
                    }
                    data.hOpacityAnimations = hOpacityAnimations;
                    data.hTransform         = hTransform;
                    data.hRelativeTransform = hRelativeTransform;
                    data.hBitmapCache       = hBitmapCache;
                    data.hInternalTarget    = hInternalTarget;

                    // Send packed command structure
                    channel.SendCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_BITMAPCACHEBRUSH));
                }
            }
        }
예제 #10
0
        public void Invalidate(Int32Rect?dirtyRect)
        {
            SecurityHelper.DemandUnmanagedCode();

            // A null dirty rect indicates the entire bitmap should be
            // invalidated, while a value indicates that only a dirty rect
            // should be invalidated.
            if (dirtyRect.HasValue)
            {
                dirtyRect.Value.ValidateForDirtyRect("dirtyRect", _pixelWidth, _pixelHeight);

                if (!dirtyRect.Value.HasArea)
                {
                    // Nothing needs done.
                    return;
                }
            }

            WritePreamble();

            if (_unmanagedSource != null)
            {
                if (UsableWithoutCache)
                {
                    // For bitmap sources that do not require caching on the
                    // UI thread, we can just add a dirty rect to the
                    // CWICWrapperBitmap.  The render thread will respond by
                    // updating the affected realizations by copying from this
                    // bitmap.  Since this bitmap is not cached, it will get
                    // the most current bits.
                    unsafe
                    {
                        for (int i = 0, numChannels = _duceResource.GetChannelCount(); i < numChannels; ++i)
                        {
                            DUCE.Channel channel = _duceResource.GetChannel(i);

                            DUCE.MILCMD_BITMAP_INVALIDATE data;
                            data.Type   = MILCMD.MilCmdBitmapInvalidate;
                            data.Handle = _duceResource.GetHandle(channel);

                            bool useDirtyRect = dirtyRect.HasValue;
                            if (useDirtyRect)
                            {
                                data.DirtyRect.left   = dirtyRect.Value.X;
                                data.DirtyRect.top    = dirtyRect.Value.Y;
                                data.DirtyRect.right  = dirtyRect.Value.X + dirtyRect.Value.Width;
                                data.DirtyRect.bottom = dirtyRect.Value.Y + dirtyRect.Value.Height;
                            }

                            data.UseDirtyRect = (uint)(useDirtyRect ? 1 : 0);

                            channel.SendCommand((byte *)&data, sizeof(DUCE.MILCMD_BITMAP_INVALIDATE));
                        }
                    }
                }
                else
                {
                    // For bitmap sources that require caching on the
                    // UI thread, we can't just add a dirty rect to the
                    // CWICWrapperBitmap because it will just read the cached
                    // contents again.  We really need a caching bitmap
                    // implementation that understands dirty rects and will
                    // update its cache.  Unfortunately, today the caching
                    // bitmap is a standard WIC implementation, and does not
                    // support this functionality.
                    //
                    // For now, we just recreate the caching bitmap.  Setting
                    // _needsUpdate to true will cause BitmapSource to throw
                    // away the old DUCECompatiblePtr, and create a new caching
                    // bitmap to send to the render thread. Since the render
                    // thread sees a brand new bitmap, it will copy the bits out.
                    _needsUpdate = true;
                    RegisterForAsyncUpdateResource();
                }
            }

            WritePostscript();
        }
예제 #11
0
        private void SendPresent(object sender, EventArgs args)
        {
            Debug.Assert(_isDirty);
            Debug.Assert(_isWaitingForPresent);
            Debug.Assert(_lockCount == 0);

            //
            // If we were waiting for present when the bitmap changed, SetBackBuffer removed
            // us from waiting for present. So if this is true then the NEW bitmap has been
            // dirtied before it has been sent to the render thread. We need to delay the
            // present until after the update resource because the D3DImage resource is still
            // referencing the old bitmap.
            //
            if (_waitingForUpdateResourceBecauseBitmapChanged)
            {
                return;
            }

            UnsubscribeFromCommittingBatch();

            unsafe
            {
                DUCE.MILCMD_D3DIMAGE_PRESENT data;
                DUCE.Channel channel = sender as DUCE.Channel;

                Debug.Assert(_duceResource.IsOnChannel(channel));

                data.Type   = MILCMD.MilCmdD3DImagePresent;
                data.Handle = _duceResource.GetHandle(channel);

                // We need to make sure the event stays alive in case we get collected before
                // the composition thread processes the packet
                IntPtr hDuplicate;
                IntPtr hCurrentProc = MS.Win32.UnsafeNativeMethods.GetCurrentProcess();
                if (!MS.Win32.UnsafeNativeMethods.DuplicateHandle(
                        hCurrentProc,
                        _canWriteEvent.SafeWaitHandle,
                        hCurrentProc,
                        out hDuplicate,
                        0,
                        false,
                        MS.Win32.UnsafeNativeMethods.DUPLICATE_SAME_ACCESS
                        ))
                {
                    throw new Win32Exception();
                }

                data.hEvent = (ulong)hDuplicate.ToPointer();

                // Send packed command structure

                // Note that the command is sent in its own batch (sendInSeparateBatch  == true) because this method is called under the
                // context of the MediaContext.CommitChannel and the command needs to make it into the current set of changes which are
                // being commited to the compositor.  If the command would not be added to a separate batch, it would go into the
                // "future" batch which would not get submitted this time around. This leads to a dead-lock situation which occurs when
                // the app calls Lock on the D3DImage because Lock waits on _canWriteEvent which the compositor sets when it sees the
                // Present command. However, since the compositor does not get the Present command, it will not set the event and the
                // UI thread will wait forever on the compositor which will cause the application to stop responding.

                channel.SendCommand(
                    (byte *)&data,
                    sizeof(DUCE.MILCMD_D3DIMAGE_PRESENT),
                    true /* sendInSeparateBatch */
                    );
            }

            _isDirty = false;

            // Block on next Lock
            _canWriteEvent.Reset();
        }
        /// <summary>
        /// This should be called at the end of any method that alters the
        /// storage in any way.  This method will make sure the peer dp is
        /// set correctly and notify Animatables if something changes.
        /// </summary>
        internal void WritePostscript()
        {
            DependencyObject d = (DependencyObject)_dependencyObject.Target;

            if (d == null)
            {
                return;
            }

            FrugalMap animatedPropertyMap = AnimatedPropertyMapField.GetValue(d);

            if (animatedPropertyMap.Count == 0 ||
                animatedPropertyMap[_dependencyProperty.GlobalIndex] == DependencyProperty.UnsetValue)
            {
                if (!IsEmpty)
                {
                    // This is kind of tricky:
                    //
                    // Because FrugalMap is a struct instead of a class, we must
                    // be sure to add this AnimationStorage to the map before
                    // setting the FrugalMap into the UncommonField storage. If
                    // we don't and the FrugalMap is empty then an empty FrugalMap
                    // will be set into the UncommonField storage. If we were to
                    // then add our AnimationStorage to the local FrugalMap, it
                    // would only allocate its own internal storage at that point
                    // which would not apply to the FrugalMap we set into the
                    // UncommonField storage. Once a FrugalMap has allocated its
                    // internal storage, though, that storage is copied with the
                    // FrugalMap. This is what will happen when we add our
                    // AnimationStorage to the FrugalMap first as we do below:

                    animatedPropertyMap[_dependencyProperty.GlobalIndex] = this;

                    // Since FrugalMap is a struct and adding a new value to it
                    // may re-allocate the storage, we need to set this value
                    // each time we make a change to the map.

                    AnimatedPropertyMapField.SetValue(d, animatedPropertyMap);

                    if (animatedPropertyMap.Count == 1)
                    {
                        d.IAnimatable_HasAnimatedProperties = true;
                    }

                    // If this the target is an Animatable we'll need to
                    // invalidate it so that the animation resource for this
                    // newly animated property will be passed across to the UCE.
                    Animatable a = d as Animatable;

                    if (a != null)
                    {
                        a.RegisterForAsyncUpdateResource();
                    }

                    // If this AnimationStorage is a resource, add it to the
                    // channel now.
                    DUCE.IResource animationResource = this as DUCE.IResource;

                    if (animationResource != null)
                    {
                        DUCE.IResource targetResource = d as DUCE.IResource;

                        if (targetResource != null)
                        {
                            using (CompositionEngineLock.Acquire())
                            {
                                int channelCount = targetResource.GetChannelCount();

                                for (int i = 0; i < channelCount; i++)
                                {
                                    DUCE.Channel channel = targetResource.GetChannel(i);
                                    if (!targetResource.GetHandle(channel).IsNull)
                                    {
                                        animationResource.AddRefOnChannel(channel);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                Debug.Assert(animatedPropertyMap.Count > 0);
                Debug.Assert(animatedPropertyMap[_dependencyProperty.GlobalIndex] != DependencyProperty.UnsetValue);

                if (IsEmpty)
                {
                    // If this AnimationStorage is a resource, release it from
                    // the channel now.
                    DUCE.IResource animationResource = this as DUCE.IResource;

                    if (animationResource != null)
                    {
                        DUCE.IResource targetResource = d as DUCE.IResource;

                        if (targetResource != null)
                        {
                            using (CompositionEngineLock.Acquire())
                            {
                                int channelCount = targetResource.GetChannelCount();

                                for (int i = 0; i < channelCount; i++)
                                {
                                    DUCE.Channel channel = targetResource.GetChannel(i);
                                    if (!targetResource.GetHandle(channel).IsNull)
                                    {
                                        animationResource.ReleaseOnChannel(channel);
                                    }
                                }
                            }
                        }
                    }

                    // If this the target is an Animatable we'll need to
                    // invalidate it so that the animation resource for this
                    // no longer animated property will no longer be passed
                    // across to the UCE.
                    Animatable a = d as Animatable;

                    if (a != null)
                    {
                        a.RegisterForAsyncUpdateResource();
                    }

                    animatedPropertyMap[_dependencyProperty.GlobalIndex] = DependencyProperty.UnsetValue;

                    if (animatedPropertyMap.Count == 0)
                    {
                        AnimatedPropertyMapField.ClearValue(d);

                        d.IAnimatable_HasAnimatedProperties = false;
                    }
                    else
                    {
                        AnimatedPropertyMapField.SetValue(d, animatedPropertyMap);
                    }

                    // We've removed animation storage for this DP, so if we were storing the local
                    // base value here then it has to go back to its non-animated storage spot.
                    if (_baseValue != DependencyProperty.UnsetValue)
                    {
                        d.SetValue(_dependencyProperty, _baseValue);
                    }
                }
            }

            // recompute animated value
            d.InvalidateProperty(_dependencyProperty);
        }
예제 #13
0
        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                Point3DCollection  vPositions          = Positions;
                Vector3DCollection vNormals            = Normals;
                PointCollection    vTextureCoordinates = TextureCoordinates;
                Int32Collection    vTriangleIndices    = TriangleIndices;

                // Store the count of this resource's contained collections in local variables.
                int PositionsCount          = (vPositions == null) ? 0 : vPositions.Count;
                int NormalsCount            = (vNormals == null) ? 0 : vNormals.Count;
                int TextureCoordinatesCount = (vTextureCoordinates == null) ? 0 : vTextureCoordinates.Count;
                int TriangleIndicesCount    = (vTriangleIndices == null) ? 0 : vTriangleIndices.Count;

                // Pack & send command packet
                DUCE.MILCMD_MESHGEOMETRY3D data;
                unsafe
                {
                    data.Type                   = MILCMD.MilCmdMeshGeometry3D;
                    data.Handle                 = _duceResource.GetHandle(channel);
                    data.PositionsSize          = (uint)(sizeof(MilPoint3F) * PositionsCount);
                    data.NormalsSize            = (uint)(sizeof(MilPoint3F) * NormalsCount);
                    data.TextureCoordinatesSize = (uint)(sizeof(Point) * TextureCoordinatesCount);
                    data.TriangleIndicesSize    = (uint)(sizeof(Int32) * TriangleIndicesCount);

                    channel.BeginCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_MESHGEOMETRY3D),
                        (int)(data.PositionsSize +
                              data.NormalsSize +
                              data.TextureCoordinatesSize +
                              data.TriangleIndicesSize)
                        );


                    // Copy this collection's elements (or their handles) to reserved data
                    for (int i = 0; i < PositionsCount; i++)
                    {
                        MilPoint3F resource = CompositionResourceManager.Point3DToMilPoint3F(vPositions.Internal_GetItem(i));
                        channel.AppendCommandData(
                            (byte *)&resource,
                            sizeof(MilPoint3F)
                            );
                    }

                    // Copy this collection's elements (or their handles) to reserved data
                    for (int i = 0; i < NormalsCount; i++)
                    {
                        MilPoint3F resource = CompositionResourceManager.Vector3DToMilPoint3F(vNormals.Internal_GetItem(i));
                        channel.AppendCommandData(
                            (byte *)&resource,
                            sizeof(MilPoint3F)
                            );
                    }

                    // Copy this collection's elements (or their handles) to reserved data
                    for (int i = 0; i < TextureCoordinatesCount; i++)
                    {
                        Point resource = vTextureCoordinates.Internal_GetItem(i);
                        channel.AppendCommandData(
                            (byte *)&resource,
                            sizeof(Point)
                            );
                    }

                    // Copy this collection's elements (or their handles) to reserved data
                    for (int i = 0; i < TriangleIndicesCount; i++)
                    {
                        Int32 resource = vTriangleIndices.Internal_GetItem(i);
                        channel.AppendCommandData(
                            (byte *)&resource,
                            sizeof(Int32)
                            );
                    }

                    channel.EndCommand();
                }
            }
        }
예제 #14
0
        private static void ConnectTransport()
        { 
            if (IsTransportConnected)
            { 
                throw new System.InvalidOperationException(SR.Get(SRID.MediaSystem_OutOfOrderConnectOrDisconnect)); 
            }
 
            //
            // Create a default transport to be used by this media system.
            // If creation fails, fall back to a local transport.
            // 

            HRESULT.Check(UnsafeNativeMethods.WgxConnection_Create( 
                false, // false means asynchronous transport 
                out s_pConnection));
 
            // Create service channel used by global glyph cache. This channel is
            // the first channel created for the app, and by creating it with
            // a null channel reference it creates a new partition.
            // All subsequent channel creates will pass in a reference to this 
            // channel thus using its partition.
            s_serviceChannel = new DUCE.Channel( 
                null, 
                false,       // not out of band
                s_pConnection, 
                false);

            IsTransportConnected = true;
        } 
예제 #15
0
 internal override DUCE.ResourceHandle GetHandleCore(DUCE.Channel channel)
 {
     // Note that we are in a lock here already.
     return(_duceResource.GetHandle(channel));
 }
        /// <summary>
        /// If the visual is on channel, its reference count is increased.
        /// Otherwise, a new resource is created on that channel.
        /// </summary>
        internal bool CreateOrAddRefOnChannel(
            object instance,
            DUCE.Channel channel,
            DUCE.ResourceType resourceType)
        {
            int index = Find(channel);
            int count = Count;

            if (index == PROXY_NOT_FOUND)
            {
                //
                // This is the case where we have to create a new resource.
                //

                if (_head.Channel == null)
                {
                    //
                    // We're adding the first proxy.
                    //
                    // Before:        [empty]
                    // After insert:  [ head]
                    //

                    Debug.Assert(count == 0);

                    _head.Channel = channel;
                    _head.Flags   = VisualProxyFlags.None;

                    channel.CreateOrAddRefOnChannel(
                        instance,
                        ref _head.Handle,
                        resourceType);
                }
                else
                {
                    if (_tail == null)
                    {
                        //
                        // We're adding the second proxy.
                        //
                        // Before:        [head]
                        // After resize:  [head] [ empty] [empty]
                        // After insert:  [head] [tail 0] [empty]
                        //                       ----------------

                        Debug.Assert(count == 1);

                        _tail = new Proxy[2];
                    }
                    else if (count > _tail.Length)
                    {
                        //
                        // Increase the tail size by 2.
                        //
                        // Before:        [head] [tail 0] ... [tail c-2]
                        // After resize:  [head] [tail 0] ... [tail c-2] [   empty] [empty]
                        // After insert:  [head] [tail 0] ... [tail c-3] [tail c-2] [empty]
                        //                       ------------------------------------------
                        //

                        ResizeTail(2);
                    }

                    //
                    // Now that we have a tail, fill in the first free element.
                    //

                    Proxy proxy;

                    proxy.Channel = channel;
                    proxy.Flags   = VisualProxyFlags.None;
                    proxy.Handle  = DUCE.ResourceHandle.Null;

                    channel.CreateOrAddRefOnChannel(
                        instance,
                        ref proxy.Handle,
                        resourceType);

                    _tail[count - 1] = proxy;
                }

                return /* created */ (true);
            }
            else if (index == PROXY_STORED_INLINE)
            {
                //
                // We simply need to increase the reference count on head...
                //

                channel.CreateOrAddRefOnChannel(
                    instance,
                    ref _head.Handle,
                    resourceType);
            }
            else
            {
                //
                // Increase the reference count on one of the tail proxies...
                //

                channel.CreateOrAddRefOnChannel(
                    instance,
                    ref _tail[index].Handle,
                    resourceType);
            }

            return /* not created */ (false);
        }
        /// <summary>
        /// If visual is on channel, its reference count is increased.
        /// Otherwise, a new resource is created on that channel.
        /// </summary>
        internal bool ReleaseOnChannel(DUCE.Channel channel)
        {
            int  index        = Find(channel);
            bool proxyRemoved = false;
            int  count        = Count;

            if (index == PROXY_STORED_INLINE)
            {
                if (channel.ReleaseOnChannel(_head.Handle))
                {
                    //
                    // Need to move the last of the non-empty tail to head
                    // or clear the head. Erase the head if that was the last
                    // proxy.
                    //

                    if (count == 1)
                    {
                        _head = new Proxy();
                    }
                    else
                    {
                        _head = _tail[count - 2];
                    }

                    proxyRemoved = true;
                }
            }
            else if (index >= 0)
            {
                if (channel.ReleaseOnChannel(_tail[index].Handle))
                {
                    //
                    // Need to move the last of the non-empty tail to the
                    // removed index. Avoid in-place copying.
                    //

                    if (index != count - 2)
                    {
                        _tail[index] = _tail[count - 2];
                    }

                    proxyRemoved = true;
                }
            }
            else
            {
                Debug.Assert(index != PROXY_NOT_FOUND);
                return(false);
            }

            if (proxyRemoved)
            {
                if (_tail != null)
                {
                    //
                    // Keep the tail short. We allow for one extra free element
                    // in tail to avoid constant allocations / reallocations.
                    //

                    if (count == 2)
                    {
                        //                        ------------------
                        // Before removal: [head] [tail c-1] [empty]
                        // Here and now:   [head] [ deleted] [empty]
                        // After removal:  [head]
                        //

                        _tail = null;
                    }
                    else if (count == _tail.Length)
                    {
                        //                        ---------------------------------------------------
                        // Before removal: [head] [tail 0] [tail 1] ... [tail c-3] [tail c-2] [empty]
                        // Here and now:   [head] [tail 0] [tail 1] ... [tail c-3] [ deleted] [empty]
                        // After removal:  [head] [tail 0] [tail 1] ... [tail c-3]
                        //

                        ResizeTail(-2);
                    }
                    else
                    {
                        //                        ------------------------------------------------------
                        // Before removal: [head] [tail 0] [tail 1] ... [tail c-4] [tail c-3] [tail c-2]
                        // Here and now:   [head] [tail 0] [tail 1] ... [tail c-4] [tail c-3] [ deleted]
                        // After removal:  [head] [tail 0] [tail 1] ... [tail c-4] [tail c-3] [   empty]
                        //

                        _tail[count - 2] = new Proxy();
                    }
                }
            }

            return(proxyRemoved);
        }
예제 #18
0
 /// <summary>
 /// UpdateResource - this implements the prototype required by ResourcesUpdatedHandler
 /// The method which implements this prototype is also often called in situations where
 /// the resource is known to be "on channel" - in those cases, "true" is passed for the second
 /// parameter (allowing the implementation to skip the check).
 /// </summary>
 internal virtual void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
 {
     Animatable_IsResourceInvalidationNecessary = true;
 }
        // ----------------------------------------------------------------
        //
        //   Internal Methods: resource handle getters
        //
        // ----------------------------------------------------------------

        #region Internal Methods: resource handle getters

        /// <summary>
        /// Returns the handle the visual has on a specific channel.
        /// </summary>
        internal DUCE.ResourceHandle GetHandle(DUCE.Channel channel)
        {
            return(GetHandle(Find(channel) + 1)); // Find's results are -1 based, adjust by one.
        }
예제 #20
0
        /// <summary>
        /// Render visual to printer.
        /// </summary>
        /// <param name="visual">Root of the visual to render</param>
        /// <param name="worldTransform">World transform to apply to the root visual</param>
        /// <param name="windowClip">The window clip of the outermost window or Empty</param>
        /// <param name="fRenderForBitmapEffect">True if we are rendering the visual
        /// to apply an effect to it</param>
        ///
        internal void Render(Visual visual, Matrix worldTransform, Rect windowClip)
        {
            if (visual == null)
            {
                throw new ArgumentNullException("visual");
            }

            // If the bitmapTarget we're writing to is frozen then we can't proceed.  Note that
            // it's possible for the BitmapVisualManager to be constructed with a mutable BitmapImage
            // and for the app to later freeze it.  Such an application is misbehaving if
            // they subsequently try to render to the BitmapImage.
            if (_bitmapTarget.IsFrozen)
            {
                throw new ArgumentException(SR.Get(SRID.Image_CantBeFrozen));
            }

            int    sizeX = _bitmapTarget.PixelWidth;
            int    sizeY = _bitmapTarget.PixelHeight;
            double dpiX  = _bitmapTarget.DpiX;
            double dpiY  = _bitmapTarget.DpiY;

            Debug.Assert((sizeX > 0) && (sizeY > 0));
            Debug.Assert((dpiX > 0) && (dpiY > 0));

            // validate the data
            if ((sizeX <= 0) || (sizeY <= 0))
            {
                return; // nothing to draw
            }

            if ((dpiX <= 0) || (dpiY <= 0))
            {
                dpiX = 96;
                dpiY = 96;
            }

            SafeMILHandle renderTargetBitmap = _bitmapTarget.MILRenderTarget;

            Debug.Assert(renderTargetBitmap != null, "Render Target is null");

            IntPtr pIRenderTargetBitmap = IntPtr.Zero;

            try
            {
                //
                // Allocate a fresh synchronous channel.
                //

                MediaContext mctx    = MediaContext.CurrentMediaContext;
                DUCE.Channel channel = mctx.AllocateSyncChannel();


                //
                // Acquire the target bitmap.
                //

                Guid iidRTB = MILGuidData.IID_IMILRenderTargetBitmap;

                HRESULT.Check(UnsafeNativeMethods.MILUnknown.QueryInterface(
                                  renderTargetBitmap,
                                  ref iidRTB,
                                  out pIRenderTargetBitmap));


                //
                // Render the visual on the synchronous channel.
                //

                Renderer.Render(
                    pIRenderTargetBitmap,
                    channel,
                    visual,
                    sizeX,
                    sizeY,
                    dpiX,
                    dpiY,
                    worldTransform,
                    windowClip);

                //
                // Release the synchronous channel. This way we can
                // re-use that channel later.
                //

                mctx.ReleaseSyncChannel(channel);
            }
            finally
            {
                UnsafeNativeMethods.MILUnknown.ReleaseInterface(ref pIRenderTargetBitmap);
            }

            _bitmapTarget.RenderTargetContentsChanged();
        }
        // ----------------------------------------------------------------
        //
        //   Internal Methods: visual proxy flags
        //
        // ----------------------------------------------------------------

        #region Internal Methods: visual proxy flags

        /// <summary>
        /// Returns the flags the visual has on a specific channel.
        /// </summary>
        internal VisualProxyFlags GetFlags(DUCE.Channel channel)
        {
            return(GetFlags(Find(channel) + 1)); // Find's results are -1 based, adjust by one.
        }
예제 #22
0
 /// <summary>
 /// This is only implemented by Visual and Visual3D.
 /// </summary>
 void DUCE.IResource.RemoveChildFromParent(DUCE.IResource parent, DUCE.Channel channel)
 {
     throw new NotImplementedException();
 }
예제 #23
0
        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                Transform vTransform         = Transform;
                Transform vRelativeTransform = RelativeTransform;
                Visual    vVisual            = Visual;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hRelativeTransform;
                if (vRelativeTransform == null ||
                    Object.ReferenceEquals(vRelativeTransform, Transform.Identity)
                    )
                {
                    hRelativeTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hRelativeTransform = ((DUCE.IResource)vRelativeTransform).GetHandle(channel);
                }

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hVisual = vVisual != null ? ((DUCE.IResource)vVisual).GetHandle(channel) : DUCE.ResourceHandle.Null;

                // Obtain handles for animated properties
                DUCE.ResourceHandle hOpacityAnimations  = GetAnimationResourceHandle(OpacityProperty, channel);
                DUCE.ResourceHandle hViewportAnimations = GetAnimationResourceHandle(ViewportProperty, channel);
                DUCE.ResourceHandle hViewboxAnimations  = GetAnimationResourceHandle(ViewboxProperty, channel);

                // Pack & send command packet
                DUCE.MILCMD_VISUALBRUSH data;
                unsafe
                {
                    data.Type   = MILCMD.MilCmdVisualBrush;
                    data.Handle = _duceResource.GetHandle(channel);
                    if (hOpacityAnimations.IsNull)
                    {
                        data.Opacity = Opacity;
                    }
                    data.hOpacityAnimations = hOpacityAnimations;
                    data.hTransform         = hTransform;
                    data.hRelativeTransform = hRelativeTransform;
                    data.ViewportUnits      = ViewportUnits;
                    data.ViewboxUnits       = ViewboxUnits;
                    if (hViewportAnimations.IsNull)
                    {
                        data.Viewport = Viewport;
                    }
                    data.hViewportAnimations = hViewportAnimations;
                    if (hViewboxAnimations.IsNull)
                    {
                        data.Viewbox = Viewbox;
                    }
                    data.hViewboxAnimations = hViewboxAnimations;
                    data.Stretch            = Stretch;
                    data.TileMode           = TileMode;
                    data.AlignmentX         = AlignmentX;
                    data.AlignmentY         = AlignmentY;
                    data.CachingHint        = (CachingHint)GetValue(RenderOptions.CachingHintProperty);
                    data.CacheInvalidationThresholdMinimum = (double)GetValue(RenderOptions.CacheInvalidationThresholdMinimumProperty);
                    data.CacheInvalidationThresholdMaximum = (double)GetValue(RenderOptions.CacheInvalidationThresholdMaximumProperty);
                    data.hVisual = hVisual;

                    // Send packed command structure
                    channel.SendCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_VISUALBRUSH));
                }
            }
        }
예제 #24
0
        internal static DUCE.ResourceHandle GetResourceHandle(DependencyObject d, DependencyProperty dp, DUCE.Channel channel)
        {
            Debug.Assert(d != null);
            Debug.Assert(dp != null);
            Debug.Assert(d is Animatable ? ((Animatable)d).HasAnimatedProperties : true);

            IndependentAnimationStorage storage = AnimationStorage.GetStorage(d, dp) as IndependentAnimationStorage;

            if (storage == null)
            {
                return(DUCE.ResourceHandle.Null);
            }
            else
            {
                Debug.Assert(storage._duceResource.IsOnChannel(channel));

                return(((DUCE.IResource)storage).GetHandle(channel));
            }
        }
예제 #25
0
        private void ManualUpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                Transform vTransform                  = Transform;
                Transform vRelativeTransform          = RelativeTransform;
                GradientStopCollection vGradientStops = GradientStops;

                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hRelativeTransform;
                if (vRelativeTransform == null ||
                    Object.ReferenceEquals(vRelativeTransform, Transform.Identity)
                    )
                {
                    hRelativeTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hRelativeTransform = ((DUCE.IResource)vRelativeTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hOpacityAnimations        = GetAnimationResourceHandle(OpacityProperty, channel);
                DUCE.ResourceHandle hCenterAnimations         = GetAnimationResourceHandle(CenterProperty, channel);
                DUCE.ResourceHandle hRadiusXAnimations        = GetAnimationResourceHandle(RadiusXProperty, channel);
                DUCE.ResourceHandle hRadiusYAnimations        = GetAnimationResourceHandle(RadiusYProperty, channel);
                DUCE.ResourceHandle hGradientOriginAnimations = GetAnimationResourceHandle(GradientOriginProperty, channel);

                DUCE.MILCMD_RADIALGRADIENTBRUSH data;
                unsafe
                {
                    data.Type   = MILCMD.MilCmdRadialGradientBrush;
                    data.Handle = _duceResource.GetHandle(channel);
                    double tempOpacity = Opacity;
                    DUCE.CopyBytes((byte *)&data.Opacity, (byte *)&tempOpacity, 8);
                    data.hOpacityAnimations     = hOpacityAnimations;
                    data.hTransform             = hTransform;
                    data.hRelativeTransform     = hRelativeTransform;
                    data.ColorInterpolationMode = ColorInterpolationMode;
                    data.MappingMode            = MappingMode;
                    data.SpreadMethod           = SpreadMethod;

                    Point tempCenter = Center;
                    DUCE.CopyBytes((byte *)&data.Center, (byte *)&tempCenter, 16);
                    data.hCenterAnimations = hCenterAnimations;
                    double tempRadiusX = RadiusX;
                    DUCE.CopyBytes((byte *)&data.RadiusX, (byte *)&tempRadiusX, 8);
                    data.hRadiusXAnimations = hRadiusXAnimations;
                    double tempRadiusY = RadiusY;
                    DUCE.CopyBytes((byte *)&data.RadiusY, (byte *)&tempRadiusY, 8);
                    data.hRadiusYAnimations = hRadiusYAnimations;
                    Point tempGradientOrigin = GradientOrigin;
                    DUCE.CopyBytes((byte *)&data.GradientOrigin, (byte *)&tempGradientOrigin, 16);
                    data.hGradientOriginAnimations = hGradientOriginAnimations;

                    // NTRAID#Longhorn-1011154-2004/8/12-asecchia GradientStopCollection:  Need to enforce upper-limit of gradient stop capacity

                    int count = (vGradientStops == null) ? 0 : vGradientStops.Count;
                    data.GradientStopsSize = (UInt32)(sizeof(DUCE.MIL_GRADIENTSTOP) * count);

                    channel.BeginCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_RADIALGRADIENTBRUSH),
                        sizeof(DUCE.MIL_GRADIENTSTOP) * count
                        );

                    for (int i = 0; i < count; i++)
                    {
                        DUCE.MIL_GRADIENTSTOP stopCmd;
                        GradientStop          gradStop = vGradientStops.Internal_GetItem(i);

                        double temp = gradStop.Offset;
                        DUCE.CopyBytes((byte *)&stopCmd.Position, (byte *)&temp, sizeof(double));
                        stopCmd.Color = CompositionResourceManager.ColorToMilColorF(gradStop.Color);

                        channel.AppendCommandData(
                            (byte *)&stopCmd,
                            sizeof(DUCE.MIL_GRADIENTSTOP)
                            );
                    }

                    channel.EndCommand();
                }
            }
        }
예제 #26
0
 internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
 {
     ManualUpdateResource(channel, skipOnChannelCheck);
     base.UpdateResource(channel, skipOnChannelCheck);
 }
예제 #27
0
        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Obtain handles for animated properties
                DUCE.ResourceHandle hScaleXAnimations  = GetAnimationResourceHandle(ScaleXProperty, channel);
                DUCE.ResourceHandle hScaleYAnimations  = GetAnimationResourceHandle(ScaleYProperty, channel);
                DUCE.ResourceHandle hScaleZAnimations  = GetAnimationResourceHandle(ScaleZProperty, channel);
                DUCE.ResourceHandle hCenterXAnimations = GetAnimationResourceHandle(CenterXProperty, channel);
                DUCE.ResourceHandle hCenterYAnimations = GetAnimationResourceHandle(CenterYProperty, channel);
                DUCE.ResourceHandle hCenterZAnimations = GetAnimationResourceHandle(CenterZProperty, channel);

                // Pack & send command packet
                DUCE.MILCMD_SCALETRANSFORM3D data;
                unsafe
                {
                    data.Type   = MILCMD.MilCmdScaleTransform3D;
                    data.Handle = _duceResource.GetHandle(channel);
                    if (hScaleXAnimations.IsNull)
                    {
                        data.scaleX = ScaleX;
                    }
                    data.hScaleXAnimations = hScaleXAnimations;
                    if (hScaleYAnimations.IsNull)
                    {
                        data.scaleY = ScaleY;
                    }
                    data.hScaleYAnimations = hScaleYAnimations;
                    if (hScaleZAnimations.IsNull)
                    {
                        data.scaleZ = ScaleZ;
                    }
                    data.hScaleZAnimations = hScaleZAnimations;
                    if (hCenterXAnimations.IsNull)
                    {
                        data.centerX = CenterX;
                    }
                    data.hCenterXAnimations = hCenterXAnimations;
                    if (hCenterYAnimations.IsNull)
                    {
                        data.centerY = CenterY;
                    }
                    data.hCenterYAnimations = hCenterYAnimations;
                    if (hCenterZAnimations.IsNull)
                    {
                        data.centerZ = CenterZ;
                    }
                    data.hCenterZAnimations = hCenterZAnimations;

                    // Send packed command structure
                    channel.SendCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_SCALETRANSFORM3D));
                }
            }
        }
예제 #28
0
 internal abstract void ReleaseOnChannelCore(DUCE.Channel channel);
예제 #29
0
 /// <summary>
 /// Derived classes implement this function.
 /// </summary>
 void DUCE.IResource.ReleaseOnChannel(DUCE.Channel channel)
 {
     // Just return instead of throwing an exception, since some
     // derived classes like BitmapEffect do their own addref/release.
 }
예제 #30
0
        internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck)
        {
            // If we're told we can skip the channel check, then we must be on channel
            Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel));

            if (skipOnChannelCheck || _duceResource.IsOnChannel(channel))
            {
                base.UpdateResource(channel, skipOnChannelCheck);

                // Read values of properties into local variables
                DrawingCollection vChildren     = Children;
                Geometry          vClipGeometry = ClipGeometry;
                Brush             vOpacityMask  = OpacityMask;
                Transform         vTransform    = Transform;
                GuidelineSet      vGuidelineSet = GuidelineSet;

                // Obtain handles for properties that implement DUCE.IResource
                DUCE.ResourceHandle hClipGeometry = vClipGeometry != null ? ((DUCE.IResource)vClipGeometry).GetHandle(channel) : DUCE.ResourceHandle.Null;
                DUCE.ResourceHandle hOpacityMask  = vOpacityMask != null ? ((DUCE.IResource)vOpacityMask).GetHandle(channel) : DUCE.ResourceHandle.Null;
                DUCE.ResourceHandle hTransform;
                if (vTransform == null ||
                    Object.ReferenceEquals(vTransform, Transform.Identity)
                    )
                {
                    hTransform = DUCE.ResourceHandle.Null;
                }
                else
                {
                    hTransform = ((DUCE.IResource)vTransform).GetHandle(channel);
                }
                DUCE.ResourceHandle hGuidelineSet = vGuidelineSet != null ? ((DUCE.IResource)vGuidelineSet).GetHandle(channel) : DUCE.ResourceHandle.Null;

                // Obtain handles for animated properties
                DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel);

                // Store the count of this resource's contained collections in local variables.
                int ChildrenCount = (vChildren == null) ? 0 : vChildren.Count;

                // Pack & send command packet
                DUCE.MILCMD_DRAWINGGROUP data;
                unsafe
                {
                    data.Type          = MILCMD.MilCmdDrawingGroup;
                    data.Handle        = _duceResource.GetHandle(channel);
                    data.ChildrenSize  = (uint)(sizeof(DUCE.ResourceHandle) * ChildrenCount);
                    data.hClipGeometry = hClipGeometry;
                    if (hOpacityAnimations.IsNull)
                    {
                        data.Opacity = Opacity;
                    }
                    data.hOpacityAnimations = hOpacityAnimations;
                    data.hOpacityMask       = hOpacityMask;
                    data.hTransform         = hTransform;
                    data.hGuidelineSet      = hGuidelineSet;
                    data.EdgeMode           = (EdgeMode)GetValue(RenderOptions.EdgeModeProperty);
                    data.bitmapScalingMode  = (BitmapScalingMode)GetValue(RenderOptions.BitmapScalingModeProperty);
                    data.ClearTypeHint      = (ClearTypeHint)GetValue(RenderOptions.ClearTypeHintProperty);

                    channel.BeginCommand(
                        (byte *)&data,
                        sizeof(DUCE.MILCMD_DRAWINGGROUP),
                        (int)(data.ChildrenSize)
                        );


                    // Copy this collection's elements (or their handles) to reserved data
                    for (int i = 0; i < ChildrenCount; i++)
                    {
                        DUCE.ResourceHandle resource = ((DUCE.IResource)vChildren.Internal_GetItem(i)).GetHandle(channel);;
                        channel.AppendCommandData(
                            (byte *)&resource,
                            sizeof(DUCE.ResourceHandle)
                            );
                    }

                    channel.EndCommand();
                }
            }
        }
예제 #31
0
 /// <summary>
 /// Derived classes implement this function.
 /// </summary>
 DUCE.ResourceHandle DUCE.IResource.GetHandle(DUCE.Channel channel)
 {
     // Just return null instead of throwing an exception, since some
     // derived classes like BitmapEffect do their own addref/release.
     return(DUCE.ResourceHandle.Null);
 }
예제 #32
0
        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------

        private static void ChildrenPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            // The first change to the default value of a mutable collection property (e.g. GeometryGroup.Children)
            // will promote the property value from a default value to a local value. This is technically a sub-property
            // change because the collection was changed and not a new collection set (GeometryGroup.Children.
            // Add versus GeometryGroup.Children = myNewChildrenCollection). However, we never marshalled
            // the default value to the compositor. If the property changes from a default value, the new local value
            // needs to be marshalled to the compositor. We detect this scenario with the second condition
            // e.OldValueSource != e.NewValueSource. Specifically in this scenario the OldValueSource will be
            // Default and the NewValueSource will be Local.
            if (e.IsASubPropertyChange &&
                (e.OldValueSource == e.NewValueSource))
            {
                return;
            }


            DrawingGroup target = ((DrawingGroup)d);


            // If this is both non-null and mutable, we need to unhook the Changed event.
            DrawingCollection oldCollection = null;
            DrawingCollection newCollection = null;

            if ((e.OldValueSource != BaseValueSourceInternal.Default) || e.IsOldValueModified)
            {
                oldCollection = (DrawingCollection)e.OldValue;
                if ((oldCollection != null) && !oldCollection.IsFrozen)
                {
                    oldCollection.ItemRemoved  -= target.ChildrenItemRemoved;
                    oldCollection.ItemInserted -= target.ChildrenItemInserted;
                }
            }

            // If this is both non-null and mutable, we need to hook the Changed event.
            if ((e.NewValueSource != BaseValueSourceInternal.Default) || e.IsNewValueModified)
            {
                newCollection = (DrawingCollection)e.NewValue;
                if ((newCollection != null) && !newCollection.IsFrozen)
                {
                    newCollection.ItemInserted += target.ChildrenItemInserted;
                    newCollection.ItemRemoved  += target.ChildrenItemRemoved;
                }
            }
            if (oldCollection != newCollection && target.Dispatcher != null)
            {
                using (CompositionEngineLock.Acquire())
                {
                    DUCE.IResource targetResource = (DUCE.IResource)target;
                    int            channelCount   = targetResource.GetChannelCount();

                    for (int channelIndex = 0; channelIndex < channelCount; channelIndex++)
                    {
                        DUCE.Channel channel = targetResource.GetChannel(channelIndex);
                        Debug.Assert(!channel.IsOutOfBandChannel);
                        Debug.Assert(!targetResource.GetHandle(channel).IsNull);
                        // resource shouldn't be null because
                        // 1) If the field is one of our collections, we don't allow null elements
                        // 2) Codegen already made sure the collection contains DUCE.IResources
                        // ... so we'll Assert it

                        if (newCollection != null)
                        {
                            int count = newCollection.Count;
                            for (int i = 0; i < count; i++)
                            {
                                DUCE.IResource resource = newCollection.Internal_GetItem(i) as DUCE.IResource;
                                Debug.Assert(resource != null);
                                resource.AddRefOnChannel(channel);
                            }
                        }

                        if (oldCollection != null)
                        {
                            int count = oldCollection.Count;
                            for (int i = 0; i < count; i++)
                            {
                                DUCE.IResource resource = oldCollection.Internal_GetItem(i) as DUCE.IResource;
                                Debug.Assert(resource != null);
                                resource.ReleaseOnChannel(channel);
                            }
                        }
                    }
                }
            }
            target.PropertyChanged(ChildrenProperty);
        }
예제 #33
0
            internal DUCE.Channel AllocateSyncChannel()
            {
                DUCE.Channel syncChannel;
 
                if (_pSyncConnection == IntPtr.Zero)
                { 
                    HRESULT.Check(UnsafeNativeMethods.WgxConnection_Create( 
                        true, // true means synchronous transport
                        out _pSyncConnection)); 
                }

                if (_freeSyncChannels == null)
                { 
                    //
                    // Ensure the free [....] channels queue... 
                    // 

                    _freeSyncChannels = new Queue<DUCE.Channel>(3); 
                }

                if (_freeSyncChannels.Count > 0)
                { 
                    //
                    // If there is a free [....] channel in the queue, we're done: 
                    // 

                    return _freeSyncChannels.Dequeue(); 
                }
                else
                {
                    // 
                    // Otherwise, create a new channel. We will try to cache it
                    // when the ReleaseSyncChannel call is made. Also ensure the 
                    // synchronous service channel and glyph cache. 
                    //
 
                    if (_syncServiceChannel == null)
                    {
                        _syncServiceChannel  = new DUCE.Channel(
                            null, 
                            false,      // not out of band
                            _pSyncConnection, 
                            true        // synchronous 
                            );
                    } 

                    syncChannel = new DUCE.Channel(
                        _syncServiceChannel,
                        false,      // not out of band 
                        _pSyncConnection,
                        true        // synchronous 
                        ); 

                    return syncChannel; 
                }
            }