private static void EnableClearTypePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
BitmapCache target = ((BitmapCache)d);
target.PropertyChanged(EnableClearTypeProperty);
}
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
private static void RenderAtScalePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
BitmapCache target = ((BitmapCache)d);
target.PropertyChanged(RenderAtScaleProperty);
}
private static void SnapsToDevicePixelsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
BitmapCache target = ((BitmapCache)d);
target.PropertyChanged(SnapsToDevicePixelsProperty);
}
internal override void ReleaseOnChannelCore(DUCE.Channel channel)
{
Debug.Assert(_duceResource.IsOnChannel(channel));
if (_duceResource.ReleaseOnChannel(channel))
{
Transform vTransform = Transform;
if (vTransform != null)
{
((DUCE.IResource)vTransform).ReleaseOnChannel(channel);
}
Transform vRelativeTransform = RelativeTransform;
if (vRelativeTransform != null)
{
((DUCE.IResource)vRelativeTransform).ReleaseOnChannel(channel);
}
BitmapCache vBitmapCache = BitmapCache;
if (vBitmapCache != null)
{
((DUCE.IResource)vBitmapCache).ReleaseOnChannel(channel);
}
Visual vInternalTarget = InternalTarget;
if (vInternalTarget != null)
{
vInternalTarget.ReleaseOnChannelForCyclicBrush(this, channel);
}
ReleaseOnChannelAnimations(channel);
}
}
internal override DUCE.ResourceHandle AddRefOnChannelCore(DUCE.Channel channel)
{
if (_duceResource.CreateOrAddRefOnChannel(this, channel, System.Windows.Media.Composition.DUCE.ResourceType.TYPE_BITMAPCACHEBRUSH))
{
Transform vTransform = Transform;
if (vTransform != null)
{
((DUCE.IResource)vTransform).AddRefOnChannel(channel);
}
Transform vRelativeTransform = RelativeTransform;
if (vRelativeTransform != null)
{
((DUCE.IResource)vRelativeTransform).AddRefOnChannel(channel);
}
BitmapCache vBitmapCache = BitmapCache;
if (vBitmapCache != null)
{
((DUCE.IResource)vBitmapCache).AddRefOnChannel(channel);
}
Visual vInternalTarget = InternalTarget;
if (vInternalTarget != null)
{
vInternalTarget.AddRefOnChannelForCyclicBrush(this, channel);
}
AddRefOnChannelAnimations(channel);
UpdateResource(channel, true /* skip "on channel" check - we already know that we're on channel */);
}
return(_duceResource.GetHandle(channel));
}
private void chkCache_Click(object sender, RoutedEventArgs e)
{
if (chkCache.IsChecked == true)
{
BitmapCache bitmapCache = new BitmapCache();
pathBackground.CacheMode = new BitmapCache();
}
else
{
pathBackground.CacheMode = null;
}
}
/// <summary>
/// Parse - this method is called by the type converter to parse a CacheMode's string
/// (provided in "value").
/// </summary>
/// <returns>
/// A CacheMode which was created by parsing the "value" argument.
/// </returns>
/// <param name="value"> String representation of a CacheMode. Cannot be null/empty. </param>
internal static CacheMode Parse(string value)
{
CacheMode cacheMode = null;
if (value == "BitmapCache")
{
cacheMode = new BitmapCache();
}
else
{
throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
}
return cacheMode;
}
public RadarCanvas()
{
CacheMode = new BitmapCache();
ClipToBounds = true;
CanvasData.OnCanvasSizeChanged += (before, after) =>
{
// Scene drawings are specific to a canvas size.
// Changing canvas size means we have to redraw them all.
Drawings.Relative.Clear();
Drawings.Static.Clear();
Clip = CanvasData.ClipRegion;
};
}
/// <summary>
/// Parse - this method is called by the type converter to parse a CacheMode's string
/// (provided in "value").
/// </summary>
/// <returns>
/// A CacheMode which was created by parsing the "value" argument.
/// </returns>
/// <param name="value"> String representation of a CacheMode. Cannot be null/empty. </param>
internal static CacheMode Parse(string value)
{
CacheMode cacheMode = null;
if (value == "BitmapCache")
{
cacheMode = new BitmapCache();
}
else
{
throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
}
return(cacheMode);
}
private void chkCache_Click(object sender, RoutedEventArgs e)
{
if (chkCache.IsChecked == true)
{
BitmapCache bitmapCache = new BitmapCache();
bitmapCache.RenderAtScale = 5;
cmd.CacheMode = bitmapCache;
img.CacheMode = new BitmapCache();
}
else
{
cmd.CacheMode = null;
img.CacheMode = null;
}
}
private static void BitmapCachePropertyChanged(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;
}
BitmapCacheBrush target = ((BitmapCacheBrush)d);
BitmapCache oldV = (BitmapCache)e.OldValue;
BitmapCache newV = (BitmapCache)e.NewValue;
System.Windows.Threading.Dispatcher dispatcher = target.Dispatcher;
if (dispatcher != null)
{
DUCE.IResource targetResource = (DUCE.IResource)target;
using (CompositionEngineLock.Acquire())
{
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);
target.ReleaseResource(oldV, channel);
target.AddRefResource(newV, channel);
}
}
}
target.PropertyChanged(BitmapCacheProperty);
}
//------------------------------------------------------
//
// 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));
}
}
}
private void RenderTile()
{
if (_visual != null)
{
_visual = null;
this.RemoveVisualChild(_visual);
this.RemoveLogicalChild(_visual);
}
_visual = new DrawingVisual();
Width = Source.Width * Scale;
Height = Source.Height * Scale;
var dc = _visual.RenderOpen();
//BitmapImage test = (BitmapImage)Source;
Width = Source.Width * Scale;
Height = Source.Height * Scale;
WriteableBitmap test = new WriteableBitmap((BitmapSource)Source);
//BitmapImage test = (BitmapImage)Source;
int w = (int)test.PixelWidth;
int h = (int)test.PixelHeight;
Int32Rect rect = new Int32Rect(0, 0, w, h);
int b = test.Format.BitsPerPixel;
Byte[] pixels = new Byte[w * h * b / 8];
int stride = w * b / 8;
test.CopyPixels(pixels, stride, 0);
double sc = Scale;
/*//if (Modified == true)
//{
//Drawing DrawObj = new Drawing();
Byte[] output;// = pixels ;
//Thread MulThread = new Thread(delegate()
//{
output = Drawing.DrawImage(pixels, w, h, b, value);
//});
// MulThread.Start();
BitmapSource image = BitmapSource.Create(w, h, 96, 96, test.Format, null, output, stride);
/*MemoryStream mStream = new MemoryStream(output);
mStream.Seek(0, SeekOrigin.Begin);
BitmapImage _bitmap = new BitmapImage();
_bitmap.BeginInit();
_bitmap.StreamSource = mStream;
_bitmap.CacheOption = BitmapCacheOption.OnLoad;
_bitmap.EndInit();
Source = _bitmap;
test.WritePixels(rect, output, stride, 0);
//Source = test;
//Scale = sc;
}*/
dc.DrawImage(Source, new Rect(0, 0, Width, Height));
dc.Close();
CacheMode = new BitmapCache(1 / Scale);
// catch (Exception e)
// Animate opacity
Opacity = 0;
BeginAnimation(OpacityProperty, _opacityAnimation);
}
private void RenderTile()
{
_visual = new DrawingVisual();
Width = Source.Width * Scale;
Height = Source.Height * Scale;
var dc = _visual.RenderOpen();
dc.DrawImage(Source, new Rect(0, 0, Width, Height));
dc.Close();
CacheMode = new BitmapCache(1 / Scale);
// Animate opacity
Opacity = 0;
BeginAnimation(OpacityProperty, _opacityAnimation);
}
public Animation()
{
//ObjectTracker.Track(this);
CacheMode = new BitmapCache();
}