/// <summary>
/// Returns true if this type converter can convert to the given type.
/// </summary>
/// <returns>
/// bool - True if this converter can convert to the provided type, false if not.
/// </returns>
/// <param name="context"> The ITypeDescriptorContext for this call. </param>
/// <param name="destinationType"> The Type being queried for support. </param>
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
{
// When invoked by the serialization engine we can convert to string only for some instances
if (context != null && context.Instance != null)
{
if (!(context.Instance is PathFigureCollection))
{
throw new ArgumentException(SR.Get(SRID.General_Expected_Type, "PathFigureCollection"), "context");
}
PathFigureCollection value = (PathFigureCollection)context.Instance;
#pragma warning suppress 6506 // value is obviously not null
return(value.CanSerializeToString());
}
return(true);
}
return(base.CanConvertTo(context, destinationType));
}
/// <summary>
/// Unlocks the D3DImage
///
/// Can only be called while locked.
///
/// If you have dirtied the image with AddDirtyRect, Unlocking will trigger us to
/// copy the dirty regions from the back buffer to the front buffer. While this is
/// taking place, Lock will block. To avoid locking indefinitely, use TryLock.
/// </summary>
public void Unlock()
{
WritePreamble();
if (_lockCount == 0)
{
throw new InvalidOperationException(SR.Get(SRID.Image_MustBeLocked));
}
--_lockCount;
if (_isDirty && _lockCount == 0)
{
SubscribeToCommittingBatch();
}
if (_isChangePending)
{
_isChangePending = false;
WritePostscript();
}
}
/// <summary>
/// Approximate this figure with a polygonal PathFigure
/// </summary>
/// <param name="tolerance">The approximation error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
/// <returns>Returns the polygonal approximation as a PathFigure.</returns>
public PathFigure GetFlattenedPathFigure(double tolerance, ToleranceType type)
{
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(this);
PathGeometry flattenedGeometry = geometry.GetFlattenedPathGeometry(tolerance, type);
int count = flattenedGeometry.Figures.Count;
if (count == 0)
{
return(new PathFigure());
}
else if (count == 1)
{
return(flattenedGeometry.Figures[0]);
}
else
{
throw new InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
/// <summary>
/// DPI constructor
/// </summary>
public D3DImage(double dpiX, double dpiY)
{
SecurityHelper.DemandUnmanagedCode();
if (dpiX < 0)
{
throw new ArgumentOutOfRangeException("dpiX", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (dpiY < 0)
{
throw new ArgumentOutOfRangeException("dpiY", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
_canWriteEvent = new ManualResetEvent(true);
_availableCallback = Callback;
_sendPresentDelegate = SendPresent;
_dpiX = dpiX;
_dpiY = dpiY;
_listener = new WeakReference(this);
AppDomainShutdownMonitor.Add(_listener);
}
void ICollection.CopyTo(Array array, int index)
{
VerifyAPIReadOnly();
if (array == null)
{
throw new ArgumentNullException("array");
}
// The extra "index >= array.Length" check in because even if _collection.Count
// is 0 the index is not allowed to be equal or greater than the length
// (from the MSDN ICollection docs)
if (index < 0 || index >= array.Length || (index + _collection.Count) > array.Length)
{
throw new ArgumentOutOfRangeException("index");
}
if (array.Rank != 1)
{
throw new ArgumentException(SR.Get(SRID.Collection_BadRank));
}
// Elsewhere in the collection we throw an AE when the type is
// bad so we do it here as well to be consistent
try
{
int count = _collection.Count;
for (int i = 0; i < count; i++)
{
array.SetValue(_collection[i], index + i);
}
}
catch (InvalidCastException e)
{
throw new ArgumentException(SR.Get(SRID.Collection_BadDestArray, "Visual3DCollection"), e);
}
}
void ICollection.CopyTo(Array array, int index)
{
ReadPreamble();
if (array == null)
{
throw new ArgumentNullException("array");
}
// This will not throw in the case that we are copying
// from an empty collection. This is consistent with the
// BCL Collection implementations. (Windows 1587365)
if (index < 0 || (index + _collection.Count) > array.Length)
{
throw new ArgumentOutOfRangeException("index");
}
if (array.Rank != 1)
{
throw new ArgumentException(SR.Get(SRID.Collection_BadRank));
}
// Elsewhere in the collection we throw an AE when the type is
// bad so we do it here as well to be consistent
try
{
int count = _collection.Count;
for (int i = 0; i < count; i++)
{
array.SetValue(_collection[i], index + i);
}
}
catch (InvalidCastException e)
{
throw new ArgumentException(SR.Get(SRID.Collection_BadDestArray, this.GetType().Name), e);
}
}
/// <summary>
/// DisconnectChild
///
/// This method is called to remove the 2D visual child of the Viewport2DVisual3D
///
/// </summary>
private void RemoveVisualChild(Visual child)
{
if (child == null || child._parent == null)
{
return;
}
if (child._parent != this)
{
throw new ArgumentException(SR.Get(SRID.Visual_NotChild));
}
// NOTE: We'll let the VisualBrush handle final cleanup from the channel
//
child._parent = null;
// NOTE: We also let the VisualBrush handle any flag propagation issues (so Visual(3D).RemoveVisualChild for
// the things they propagate) as well as layout.
// Fire notifications
child.FireOnVisualParentChanged(this);
OnVisualChildrenChanged(null /* no child added */, child);
}
/// <summary>
/// AttachChild
///
/// This method is called to add a 2D Visual child to the Viewport2DVisual3D
///
/// </summary>
private void AddVisualChild(Visual child)
{
if (child == null)
{
return;
}
if (child._parent != null)
{
throw new ArgumentException(SR.Get(SRID.Visual_HasParent));
}
// Set the parent pointer.
child._parent = this;
// NOTE: Since the 2D object is on a VisualBrush, it will allow it to handle
// the dirtyness of the 2D object, realization information, as well as layout. See
// Visual(3D).AddVisualChild for the things they propagate on adding a new child
// Fire notifications
this.OnVisualChildrenChanged(child, null /* no removed child */);
child.FireOnVisualParentChanged(null);
}
private static bool UnsafeStartComposition(TextComposition composition)
{
if (composition == null)
{
throw new ArgumentNullException("composition");
}
if (composition._InputManager == null)
{
throw new ArgumentException(SR.Get(SRID.TextCompositionManager_NoInputManager, "composition"));
}
if (composition.Stage != TextCompositionStage.None)
{
throw new ArgumentException(SR.Get(SRID.TextCompositionManager_TextCompositionHasStarted, "composition"));
}
composition.Stage = TextCompositionStage.Started;
TextCompositionEventArgs textargs = new TextCompositionEventArgs(composition._InputDevice, composition);
textargs.RoutedEvent = TextCompositionManager.PreviewTextInputStartEvent;
textargs.Source = composition.Source;
return(composition._InputManager.ProcessInput(textargs));
}
public void CopyTo(KeyValuePair <XmlLanguage, string>[] array, int index)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
if (index >= array.Length)
{
throw new ArgumentException(SR.Get(SRID.Collection_CopyTo_IndexGreaterThanOrEqualToArrayLength, "index", "array"));
}
if (_innerDictionary.Count > array.Length - index)
{
throw new ArgumentException(SR.Get(SRID.Collection_CopyTo_NumberOfElementsExceedsArrayLength, index, "array"));
}
_innerDictionary.CopyTo(array, index);
}
/////////////////////////////////////////////////////////////////////
/// <summary>
/// [TBS]
/// </summary>
/// <param name="report">[TBS]</param>
/// <param name="tabletToElementTransform">[TBS]</param>
/// <param name="targetPlugInCollection">[TBS]</param>
internal RawStylusInput(
RawStylusInputReport report,
GeneralTransform tabletToElementTransform,
StylusPlugInCollection targetPlugInCollection)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
if (tabletToElementTransform.Inverse == null)
{
throw new ArgumentException(SR.Get(SRID.Stylus_MatrixNotInvertable), "tabletToElementTransform");
}
if (targetPlugInCollection == null)
{
throw new ArgumentNullException("targetPlugInCollection");
}
// We should always see this GeneralTransform is frozen since we access this from multiple threads.
System.Diagnostics.Debug.Assert(tabletToElementTransform.IsFrozen);
_report = report;
_tabletToElementTransform = tabletToElementTransform;
_targetPlugInCollection = targetPlugInCollection;
}
private void LoadFromStream(Stream cursorStream)
{
if (MS.Internal.CoreAppContextSwitches.AllowExternalProcessToBlockAccessToTemporaryFiles)
{
LegacyLoadFromStream(cursorStream);
return;
}
string filePath = null;
try
{
// Generate a temporary file based on the memory stream.
using (FileStream fileStream = FileHelper.CreateAndOpenTemporaryFile(out filePath))
{
cursorStream.CopyTo(fileStream);
}
// create a cursor from the temp file
_cursorHandle = UnsafeNativeMethods.LoadImageCursor(IntPtr.Zero,
filePath,
NativeMethods.IMAGE_CURSOR,
0, 0,
NativeMethods.LR_DEFAULTCOLOR |
NativeMethods.LR_LOADFROMFILE |
(_scaleWithDpi? NativeMethods.LR_DEFAULTSIZE : 0x0000));
if (_cursorHandle == null || _cursorHandle.IsInvalid)
{
throw new ArgumentException(SR.Get(SRID.Cursor_InvalidStream));
}
}
finally
{
FileHelper.DeleteTemporaryFile(filePath);
}
}
///<summary>
/// FromAValues - general constructor for multichannel color values with explicit alpha channel and color context, i.e. spectral colors
///</summary>
public static Color FromAValues(float a, float[] values, Uri profileUri)
{
Color c1 = Color.FromProfile(profileUri);
if (values == null)
{
throw new ArgumentException(SR.Get(SRID.Color_DimensionMismatch, null));
}
if (values.GetLength(0) != c1.nativeColorValue.GetLength(0))
{
throw new ArgumentException(SR.Get(SRID.Color_DimensionMismatch, null));
}
for (int numChannels = 0; numChannels < values.GetLength(0); numChannels++)
{
c1.nativeColorValue[numChannels] = values[numChannels];
}
c1.ComputeScRgbValues();
c1.scRgbColor.a = a;
if (a < 0.0f)
{
a = 0.0f;
}
else if (a > 1.0f)
{
a = 1.0f;
}
c1.sRgbColor.a = (byte)((a * 255.0f) + 0.5f);
c1.sRgbColor.r = ScRgbTosRgb(c1.scRgbColor.r);
c1.sRgbColor.g = ScRgbTosRgb(c1.scRgbColor.g);
c1.sRgbColor.b = ScRgbTosRgb(c1.scRgbColor.b);
return(c1);
}
protected void Activate()
{
if (_isActive)
{
throw new InvalidOperationException(SR.Get(SRID.Touch_DeviceAlreadyActivated));
}
PromotingToManipulation = false;
AddActiveDevice(this);
AttachTouchDevice();
Synchronize();
if (_activeDevices.Count == 1)
{
_isPrimary = true;
}
_isActive = true;
if (Activated != null)
{
Activated(this, EventArgs.Empty);
}
}
internal static ApplicationGesture[] GetApplicationGestureArrayAndVerify(IEnumerable <ApplicationGesture> applicationGestures)
{
if (applicationGestures == null)
{
// Null is not allowed as the argument value
throw new ArgumentNullException("applicationGestures");
}
uint count = 0;
//we need to make a disconnected copy
ICollection <ApplicationGesture> collection = applicationGestures as ICollection <ApplicationGesture>;
if (collection != null)
{
count = (uint)collection.Count;
}
else
{
foreach (ApplicationGesture gesture in applicationGestures)
{
count++;
}
}
// Cannot be empty
if (count == 0)
{
// An empty array is not allowed.
throw new ArgumentException(SR.Get(SRID.ApplicationGestureArrayLengthIsZero), "applicationGestures");
}
bool foundAllGestures = false;
List <ApplicationGesture> gestures = new List <ApplicationGesture>();
foreach (ApplicationGesture gesture in applicationGestures)
{
if (!ApplicationGestureHelper.IsDefined(gesture))
{
throw new ArgumentException(SR.Get(SRID.ApplicationGestureIsInvalid), "applicationGestures");
}
//check for allgestures
if (gesture == ApplicationGesture.AllGestures)
{
foundAllGestures = true;
}
//check for dupes
if (gestures.Contains(gesture))
{
throw new ArgumentException(SR.Get(SRID.DuplicateApplicationGestureFound), "applicationGestures");
}
gestures.Add(gesture);
}
// AllGesture cannot be specified with other gestures
if (foundAllGestures && gestures.Count != 1)
{
// no dupes allowed
throw new ArgumentException(SR.Get(SRID.AllGesturesMustExistAlone), "applicationGestures");
}
return(gestures.ToArray());
}
private void LegacyLoadFromStream(Stream cursorStream)
{
//Generate a temporal file based on the memory stream.
// GetTempFileName requires unrestricted Environment permission
// FileIOPermission.Write permission. However, since we don't
// know the path of the file to be created we have to give
// unrestricted permission here.
// GetTempFileName documentation does not mention that it throws
// any exception. However, if it does, CLR reverts the assert.
string filePath = Path.GetTempFileName();
try
{
using (BinaryReader reader = new BinaryReader(cursorStream))
{
using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Write, FileShare.None))
{
// Read the bytes from the stream, up to BUFFERSIZE
byte[] cursorData = reader.ReadBytes(BUFFERSIZE);
int dataSize;
// If the buffer is filled up, then write those bytes out and read more bytes up to BUFFERSIZE
for (dataSize = cursorData.Length;
dataSize >= BUFFERSIZE;
dataSize = reader.Read(cursorData, 0 /*index in array*/, BUFFERSIZE /*bytes to read*/))
{
fileStream.Write(cursorData, 0 /*index in array*/, BUFFERSIZE /*bytes to write*/);
}
// Write any remaining bytes
fileStream.Write(cursorData, 0 /*index in array*/, dataSize /*bytes to write*/);
}
}
// This method is called with File Write permission still asserted.
// However, this method just reads this file into an icon.
_cursorHandle = UnsafeNativeMethods.LoadImageCursor(IntPtr.Zero,
filePath,
NativeMethods.IMAGE_CURSOR,
0, 0,
NativeMethods.LR_DEFAULTCOLOR |
NativeMethods.LR_LOADFROMFILE |
(_scaleWithDpi? NativeMethods.LR_DEFAULTSIZE : 0x0000));
if (_cursorHandle == null || _cursorHandle.IsInvalid)
{
throw new ArgumentException(SR.Get(SRID.Cursor_InvalidStream));
}
}
finally
{
try
{
File.Delete(filePath);
}
catch (System.IO.IOException)
{
// We may not be able to delete the file if it's being used by some other process (e.g. Anti-virus check).
// There's nothing we can do in that case, so just eat the exception and leave the file behind
}
}
}
/// <summary>
/// Subtract operator - substracts each channel of the second color from each channel of the
/// first and returns the result
/// </summary>
/// <param name='color1'>The minuend</param>
/// <param name='color2'>The subtrahend</param>
/// <returns>Returns the unclamped differnce</returns>
public static Color operator -(Color color1, Color color2)
{
if (color1.context == null && color2.context == null)
{
Color c1 = FromScRgb(
color1.scRgbColor.a - color2.scRgbColor.a,
color1.scRgbColor.r - color2.scRgbColor.r,
color1.scRgbColor.g - color2.scRgbColor.g,
color1.scRgbColor.b - color2.scRgbColor.b
);
return(c1);
}
else if (color1.context == null || color2.context == null)
{
throw new ArgumentException(SR.Get(SRID.Color_ColorContextTypeMismatch, null));
}
else if (color1.context == color2.context)
{
Color c1 = new Color();
c1.context = color1.context;
#pragma warning suppress 6506 // c1.context is obviously not null - both color1.context AND color2.context are not null
c1.nativeColorValue = new float[c1.context.NumChannels];
for (int i = 0; i < c1.nativeColorValue.GetLength(0); i++)
{
c1.nativeColorValue[i] = color1.nativeColorValue[i] - color2.nativeColorValue[i];
}
Color c2 = Color.FromRgb(0, 0, 0);
c2.context = new ColorContext(PixelFormats.Bgra32);
ColorTransform colorTransform = new ColorTransform(c1.context, c2.context);
float[] sRGBValue = new float[3];
colorTransform.Translate(c1.nativeColorValue, sRGBValue);
if (sRGBValue[0] < 0.0f)
{
c1.sRgbColor.r = 0;
}
else if (sRGBValue[0] > 1.0f)
{
c1.sRgbColor.r = 255;
}
else
{
c1.sRgbColor.r = (byte)((sRGBValue[0] * 255.0f) + 0.5f);
}
if (sRGBValue[1] < 0.0f)
{
c1.sRgbColor.g = 0;
}
else if (sRGBValue[1] > 1.0f)
{
c1.sRgbColor.g = 255;
}
else
{
c1.sRgbColor.g = (byte)((sRGBValue[1] * 255.0f) + 0.5f);
}
if (sRGBValue[2] < 0.0f)
{
c1.sRgbColor.b = 0;
}
else if (sRGBValue[2] > 1.0f)
{
c1.sRgbColor.b = 255;
}
else
{
c1.sRgbColor.b = (byte)((sRGBValue[2] * 255.0f) + 0.5f);
}
c1.scRgbColor.r = sRgbToScRgb(c1.sRgbColor.r);
c1.scRgbColor.g = sRgbToScRgb(c1.sRgbColor.g);
c1.scRgbColor.b = sRgbToScRgb(c1.sRgbColor.b);
c1.scRgbColor.a = color1.scRgbColor.a - color2.scRgbColor.a;
if (c1.scRgbColor.a < 0.0f)
{
c1.scRgbColor.a = 0.0f;
c1.sRgbColor.a = 0;
}
else if (c1.scRgbColor.a > 1.0f)
{
c1.scRgbColor.a = 1.0f;
c1.sRgbColor.a = 255;
}
else
{
c1.sRgbColor.a = (byte)((c1.scRgbColor.a * 255.0f) + 0.5f);
}
return(c1);
}
else
{
throw new ArgumentException(SR.Get(SRID.Color_ColorContextTypeMismatch, null));
}
}
internal TextFormatterContext AcquireContext(
object owner,
IntPtr ploc
)
{
Invariant.Assert(owner != null);
TextFormatterContext context = null;
int c;
int contextCount = _contextList.Count;
for (c = 0; c < contextCount; c++)
{
context = (TextFormatterContext)_contextList[c];
if (ploc == IntPtr.Zero)
{
if (context.Owner == null)
{
break;
}
}
else if (ploc == context.Ploc.Value)
{
// LS requires that we use the exact same context for line
// destruction or hittesting (part of the reason is that LS
// actually caches some run info in the context). So here
// we use the actual PLSC as the context signature so we
// locate the one we want.
Debug.Assert(context.Owner == null);
break;
}
}
if (c == contextCount)
{
if (contextCount == 0 || !_multipleContextProhibited)
{
// no free one exists, create a new one
context = new TextFormatterContext();
_contextList.Add(context);
}
else
{
// This instance of TextFormatter only allows a single context, reentering the
// same TextFormatter in this case is not allowed.
//
// This requirement is currently enforced only during optimal break computation.
// Client implementing nesting of optimal break content inside another must create
// a separate TextFormatter instance for each content in different nesting level.
throw new InvalidOperationException(SR.Get(SRID.TextFormatterReentranceProhibited));
}
}
Debug.Assert(context != null);
context.Owner = owner;
return(context);
}
/// <summary>
/// Verify all text formatting arguments
/// </summary>
private void VerifyTextFormattingArguments(
TextSource textSource,
int firstCharIndex,
double paragraphWidth,
TextParagraphProperties paragraphProperties,
TextRunCache textRunCache
)
{
if (textSource == null)
{
throw new ArgumentNullException("textSource");
}
if (textRunCache == null)
{
throw new ArgumentNullException("textRunCache");
}
if (paragraphProperties == null)
{
throw new ArgumentNullException("paragraphProperties");
}
if (paragraphProperties.DefaultTextRunProperties == null)
{
throw new ArgumentNullException("paragraphProperties.DefaultTextRunProperties");
}
if (paragraphProperties.DefaultTextRunProperties.Typeface == null)
{
throw new ArgumentNullException("paragraphProperties.DefaultTextRunProperties.Typeface");
}
if (DoubleUtil.IsNaN(paragraphWidth))
{
throw new ArgumentOutOfRangeException("paragraphWidth", SR.Get(SRID.ParameterValueCannotBeNaN));
}
if (double.IsInfinity(paragraphWidth))
{
throw new ArgumentOutOfRangeException("paragraphWidth", SR.Get(SRID.ParameterValueCannotBeInfinity));
}
if (paragraphWidth < 0 ||
paragraphWidth > Constants.RealInfiniteWidth)
{
throw new ArgumentOutOfRangeException("paragraphWidth", SR.Get(SRID.ParameterMustBeBetween, 0, Constants.RealInfiniteWidth));
}
double realMaxFontRenderingEmSize = Constants.RealInfiniteWidth / Constants.GreatestMutiplierOfEm;
if (paragraphProperties.DefaultTextRunProperties.FontRenderingEmSize < 0 ||
paragraphProperties.DefaultTextRunProperties.FontRenderingEmSize > realMaxFontRenderingEmSize)
{
throw new ArgumentOutOfRangeException("paragraphProperties.DefaultTextRunProperties.FontRenderingEmSize", SR.Get(SRID.ParameterMustBeBetween, 0, realMaxFontRenderingEmSize));
}
if (paragraphProperties.Indent > Constants.RealInfiniteWidth)
{
throw new ArgumentOutOfRangeException("paragraphProperties.Indent", SR.Get(SRID.ParameterCannotBeGreaterThan, Constants.RealInfiniteWidth));
}
if (paragraphProperties.LineHeight > Constants.RealInfiniteWidth)
{
throw new ArgumentOutOfRangeException("paragraphProperties.LineHeight", SR.Get(SRID.ParameterCannotBeGreaterThan, Constants.RealInfiniteWidth));
}
if (paragraphProperties.DefaultIncrementalTab < 0 ||
paragraphProperties.DefaultIncrementalTab > Constants.RealInfiniteWidth)
{
throw new ArgumentOutOfRangeException("paragraphProperties.DefaultIncrementalTab", SR.Get(SRID.ParameterMustBeBetween, 0, Constants.RealInfiniteWidth));
}
}
public void SetBackBuffer(D3DResourceType backBufferType, IntPtr backBuffer, bool enableSoftwareFallback)
{
SecurityHelper.DemandUnmanagedCode();
WritePreamble();
if (_lockCount == 0)
{
throw new InvalidOperationException(SR.Get(SRID.Image_MustBeLocked));
}
// In case the user passed in something like "(D3DResourceType)-1"
if (backBufferType != D3DResourceType.IDirect3DSurface9)
{
throw new ArgumentOutOfRangeException("backBufferType");
}
// Early-out if the current back buffer equals the new one. If the front buffer
// is not available and software fallback is not enabled, _pUserSurfaceUnsafe
// will be null and this check will fail. We don't want a null backBuffer to
// early-out when the front buffer isn't available.
if (backBuffer != IntPtr.Zero && backBuffer == _pUserSurfaceUnsafe)
{
return;
}
SafeMILHandle newBitmap = null;
uint newPixelWidth = 0;
uint newPixelHeight = 0;
// Create a new CInteropDeviceBitmap. Note that a null backBuffer will result
// in a null _pInteropDeviceBitmap at the end
if (backBuffer != IntPtr.Zero)
{
HRESULT.Check(UnsafeNativeMethods.InteropDeviceBitmap.Create(
backBuffer,
_dpiX,
_dpiY,
++_version,
_availableCallback,
enableSoftwareFallback,
out newBitmap,
out newPixelWidth,
out newPixelHeight
));
}
//
// We need to completely disassociate with the old interop bitmap if it
// exists because it won't be deleted until the composition thread is done
// with it or until the garbage collector runs.
//
if (_pInteropDeviceBitmap != null)
{
// 1. Tell the old bitmap to stop sending front buffer messages because
// our new back buffer may be on a different adapter. Plus, tell the
// bitmap to release the back buffer in case the user wants to delete
// it immediately.
UnsafeNativeMethods.InteropDeviceBitmap.Detach(_pInteropDeviceBitmap);
// 2. If we were waiting for a present, unhook from commit
UnsubscribeFromCommittingBatch();
// 3. We are no longer dirty
_isDirty = false;
// Note: We don't need to do anything to the event because we're under
// the protection of Lock
}
// If anything about the new surface were unacceptible, we would have recieved
// a bad HRESULT from Create() so everything must be good
_pInteropDeviceBitmap = newBitmap;
_pUserSurfaceUnsafe = backBuffer;
_pixelWidth = newPixelWidth;
_pixelHeight = newPixelHeight;
_isSoftwareFallbackEnabled = enableSoftwareFallback;
// AddDirtyRect is usually what triggers Changed, but AddDirtyRect isn't allowed with
// no back buffer so we mark for Changed here
if (_pInteropDeviceBitmap == null)
{
_isChangePending = true;
}
RegisterForAsyncUpdateResource();
_waitingForUpdateResourceBecauseBitmapChanged = true;
// WritePostscript will happen at Unlock
}
internal static object Invoke(AutomationPeer peer, DispatcherOperationCallback work, object arg)
{
Dispatcher dispatcher = peer.Dispatcher;
// Null dispatcher likely means the visual is in bad shape!
if (dispatcher == null)
{
throw new ElementNotAvailableException();
}
Exception remoteException = null;
bool completed = false;
object retVal = dispatcher.Invoke(
DispatcherPriority.Send,
TimeSpan.FromMinutes(3),
(DispatcherOperationCallback) delegate(object unused)
{
try
{
return(work(arg));
}
catch (Exception e)
{
remoteException = e;
return(null);
}
catch //for non-CLS Compliant exceptions
{
remoteException = null;
return(null);
}
finally
{
completed = true;
}
},
null);
if (completed)
{
if (remoteException != null)
{
throw remoteException;
}
}
else
{
bool dispatcherInShutdown = dispatcher.HasShutdownStarted;
if (dispatcherInShutdown)
{
throw new InvalidOperationException(SR.Get(SRID.AutomationDispatcherShutdown));
}
else
{
throw new TimeoutException(SR.Get(SRID.AutomationTimeout));
}
}
return(retVal);
}
internal unsafe void AddFigureToList(bool isFilled, bool isClosed, MilPoint2F *pPoints, UInt32 pointCount, byte *pSegTypes, UInt32 segmentCount)
{
if (pointCount >= 1 && segmentCount >= 1)
{
PathFigure figure = new PathFigure();
figure.IsFilled = isFilled;
figure.StartPoint = new Point(pPoints->X, pPoints->Y);
int pointIndex = 1;
int sameSegCount = 0;
for (int segIndex = 0; segIndex < segmentCount; segIndex += sameSegCount)
{
byte segType = (byte)(pSegTypes[segIndex] & (byte)MILCoreSegFlags.SegTypeMask);
sameSegCount = 1;
// Look for a run of same-type segments for a PolyXXXSegment.
while (((segIndex + sameSegCount) < segmentCount) &&
(pSegTypes[segIndex] == pSegTypes[segIndex + sameSegCount]))
{
sameSegCount++;
}
bool fStroked = (pSegTypes[segIndex] & (byte)MILCoreSegFlags.SegIsAGap) == (byte)0;
bool fSmooth = (pSegTypes[segIndex] & (byte)MILCoreSegFlags.SegSmoothJoin) != (byte)0;
if (segType == (byte)MILCoreSegFlags.SegTypeLine)
{
if (pointIndex + sameSegCount > pointCount)
{
throw new System.InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
if (sameSegCount > 1)
{
PointCollection ptCollection = new PointCollection();
for (int i = 0; i < sameSegCount; i++)
{
ptCollection.Add(new Point(pPoints[pointIndex + i].X, pPoints[pointIndex + i].Y));
}
ptCollection.Freeze();
PolyLineSegment polySeg = new PolyLineSegment(ptCollection, fStroked, fSmooth);
polySeg.Freeze();
figure.Segments.Add(polySeg);
}
else
{
Debug.Assert(sameSegCount == 1);
figure.Segments.Add(new LineSegment(new Point(pPoints[pointIndex].X, pPoints[pointIndex].Y), fStroked, fSmooth));
}
pointIndex += sameSegCount;
}
else if (segType == (byte)MILCoreSegFlags.SegTypeBezier)
{
int pointBezierCount = sameSegCount * 3;
if (pointIndex + pointBezierCount > pointCount)
{
throw new System.InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
if (sameSegCount > 1)
{
PointCollection ptCollection = new PointCollection();
for (int i = 0; i < pointBezierCount; i++)
{
ptCollection.Add(new Point(pPoints[pointIndex + i].X, pPoints[pointIndex + i].Y));
}
ptCollection.Freeze();
PolyBezierSegment polySeg = new PolyBezierSegment(ptCollection, fStroked, fSmooth);
polySeg.Freeze();
figure.Segments.Add(polySeg);
}
else
{
Debug.Assert(sameSegCount == 1);
figure.Segments.Add(new BezierSegment(
new Point(pPoints[pointIndex].X, pPoints[pointIndex].Y),
new Point(pPoints[pointIndex + 1].X, pPoints[pointIndex + 1].Y),
new Point(pPoints[pointIndex + 2].X, pPoints[pointIndex + 2].Y),
fStroked,
fSmooth));
}
pointIndex += pointBezierCount;
}
else
{
throw new System.InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
if (isClosed)
{
figure.IsClosed = true;
}
figure.Freeze();
Figures.Add(figure);
// Do not bother adding empty figures.
}
}
/// <summary>
/// Viewport3DVisual does not yet support Geometry hit testing.
/// </summary>
protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters)
{
throw new NotSupportedException(SR.Get(SRID.HitTest_Invalid, typeof(GeometryHitTestParameters).Name, this.GetType().Name));
}
internal static IList <TextBreakpoint> CreateMultiple(
TextParagraphCache paragraphCache,
int firstCharIndex,
int maxLineWidth,
TextLineBreak previousLineBreak,
IntPtr penaltyRestriction,
out int bestFitIndex
)
{
Invariant.Assert(paragraphCache != null);
// grab full text state from paragraph cache
FullTextState fullText = paragraphCache.FullText;
Invariant.Assert(fullText != null);
FormatSettings settings = fullText.TextStore.Settings;
Invariant.Assert(settings != null);
// update formatting parameters at line start
settings.UpdateSettingsForCurrentLine(
maxLineWidth,
previousLineBreak,
(firstCharIndex == fullText.TextStore.CpFirst)
);
Invariant.Assert(settings.Formatter != null);
// acquiring LS context
TextFormatterContext context = settings.Formatter.AcquireContext(fullText, IntPtr.Zero);
IntPtr previousBreakRecord = IntPtr.Zero;
if (settings.PreviousLineBreak != null)
{
previousBreakRecord = settings.PreviousLineBreak.BreakRecord.Value;
}
// need not consider marker as tab since marker does not affect line metrics and it wasnt drawn.
fullText.SetTabs(context);
LsBreaks lsbreaks = new LsBreaks();
LsErr lserr = context.CreateBreaks(
fullText.GetBreakpointInternalCp(firstCharIndex),
previousBreakRecord,
paragraphCache.Ploparabreak.Value, // para breaking session
penaltyRestriction,
ref lsbreaks,
out bestFitIndex
);
// get the exception in context before it is released
Exception callbackException = context.CallbackException;
// release the context
context.Release();
if (lserr != LsErr.None)
{
if (callbackException != null)
{
// rethrow exception thrown in callbacks
throw callbackException;
}
else
{
// throw with LS error codes
TextFormatterContext.ThrowExceptionFromLsError(SR.Get(SRID.CreateBreaksFailure, lserr), lserr);
}
}
// keep context alive at least till here
GC.KeepAlive(context);
TextBreakpoint[] breakpoints = new TextBreakpoint[lsbreaks.cBreaks];
for (int i = 0; i < lsbreaks.cBreaks; i++)
{
breakpoints[i] = new FullTextBreakpoint(
fullText,
firstCharIndex,
maxLineWidth,
ref lsbreaks,
i // the current break
);
}
return(breakpoints);
}
protected virtual void AddText(string childText)
{
throw new InvalidOperationException(SR.Get(SRID.Animation_NoTextChildren));
}
/// <summary>
/// Recognize the strokes.
/// </summary>
/// <param name="strokes"></param>
/// <returns></returns>
internal GestureRecognitionResult[] Recognize(StrokeCollection strokes)
{
if (_disposed)
{
throw new ObjectDisposedException("NativeRecognizer");
}
//
// note that we validate this argument from GestureRecognizer
// but since this is marked TAS, we want to do it here as well
//
if (strokes == null)
{
throw new ArgumentNullException("strokes"); // Null is not allowed as the argument value
}
if (strokes.Count > 2)
{
throw new ArgumentException(SR.Get(SRID.StrokeCollectionCountTooBig), "strokes");
}
// Create an empty result.
GestureRecognitionResult[] recResults = new GestureRecognitionResult[] {};
if (strokes.Count == 0)
{
return(recResults);
}
int hr = 0;
try
{
// Reset the context
hr = MS.Win32.Recognizer.UnsafeNativeMethods.ResetContext(_hContext);
if (HRESULT.Failed(hr))
{
//finally block will clean up and throw
return(recResults);
}
// Add strokes
hr = AddStrokes(_hContext, strokes);
if (HRESULT.Failed(hr))
{
//AddStrokes's finally block will clean up this finally block will throw
return(recResults);
}
// recognize the ink
bool bIncremental;
hr = MS.Win32.Recognizer.UnsafeNativeMethods.Process(_hContext, out bIncremental);
if (HRESULT.Succeeded(hr))
{
if (s_GetAlternateListExists)
{
recResults = InvokeGetAlternateList();
}
else
{
recResults = InvokeGetLatticePtr();
}
}
}
finally
{
// Check if we should report any error.
if (HRESULT.Failed(hr))
{
//don't throw a com exception here, we don't need to pass out any details
throw new InvalidOperationException(SR.Get(SRID.UnspecifiedGestureException));
}
}
return(recResults);
}
private void Init()
{
if (_ploc.Value == System.IntPtr.Zero)
{
// Initializing context
LsErr lserr = LsErr.None;
LsContextInfo contextInfo = new LsContextInfo();
LscbkRedefined lscbkRedef = new LscbkRedefined();
_callbacks = new LineServicesCallbacks();
_callbacks.PopulateContextInfo(ref contextInfo, ref lscbkRedef);
contextInfo.version = 4; // we should set this right, they might check it in the future
contextInfo.pols = IntPtr.Zero; // This will be filled in the un-managed code
contextInfo.cEstimatedCharsPerLine = TextStore.TypicalCharactersPerLine;
contextInfo.fDontReleaseRuns = 1; // dont waste time
// There are 3 justification priorities right now with one considered good
// and the other two provided for emergency expansion.
// Future development to enable international justification will likely change this.
// e.g. Kashida justification would require more than one good priorities.
contextInfo.cJustPriorityLim = 3;
// Fill up text configuration
contextInfo.wchNull = '\u0000';
contextInfo.wchUndef = '\u0001';
contextInfo.wchTab = '\u0009';
contextInfo.wchPosTab = contextInfo.wchUndef;
contextInfo.wchEndPara1 = TextStore.CharParaSeparator; // Unicode para separator
contextInfo.wchEndPara2 = contextInfo.wchUndef;
contextInfo.wchSpace = '\u0020';
contextInfo.wchHyphen = MS.Internal.Text.TextInterface.TextAnalyzer.CharHyphen; //'\x002d';
contextInfo.wchNonReqHyphen = '\u00AD';
contextInfo.wchNonBreakHyphen = '\u2011';
contextInfo.wchEnDash = '\u2013';
contextInfo.wchEmDash = '\u2014';
contextInfo.wchEnSpace = '\u2002';
contextInfo.wchEmSpace = '\u2003';
contextInfo.wchNarrowSpace = '\u2009';
contextInfo.wchJoiner = '\u200D';
contextInfo.wchNonJoiner = '\u200C';
contextInfo.wchVisiNull = '\u2050';
contextInfo.wchVisiAltEndPara = '\u2051';
contextInfo.wchVisiEndLineInPara = '\u2052';
contextInfo.wchVisiEndPara = '\u2053';
contextInfo.wchVisiSpace = '\u2054';
contextInfo.wchVisiNonBreakSpace = '\u2055';
contextInfo.wchVisiNonBreakHyphen = '\u2056';
contextInfo.wchVisiNonReqHyphen = '\u2057';
contextInfo.wchVisiTab = '\u2058';
contextInfo.wchVisiPosTab = contextInfo.wchUndef;
contextInfo.wchVisiEmSpace = '\u2059';
contextInfo.wchVisiEnSpace = '\u205A';
contextInfo.wchVisiNarrowSpace = '\u205B';
contextInfo.wchVisiOptBreak = '\u205C';
contextInfo.wchVisiNoBreak = '\u205D';
contextInfo.wchVisiFESpace = '\u205E';
contextInfo.wchFESpace = '\u3000';
contextInfo.wchEscAnmRun = TextStore.CharParaSeparator;
contextInfo.wchAltEndPara = contextInfo.wchUndef;
contextInfo.wchEndLineInPara = TextStore.CharLineSeparator;
contextInfo.wchSectionBreak = contextInfo.wchUndef;
contextInfo.wchNonBreakSpace = '\u00A0';
contextInfo.wchNoBreak = contextInfo.wchUndef;
contextInfo.wchColumnBreak = contextInfo.wchUndef;
contextInfo.wchPageBreak = contextInfo.wchUndef;
contextInfo.wchOptBreak = contextInfo.wchUndef;
contextInfo.wchToReplace = contextInfo.wchUndef;
contextInfo.wchReplace = contextInfo.wchUndef;
IntPtr ploc = IntPtr.Zero;
IntPtr ppenaltyModule = IntPtr.Zero;
lserr = UnsafeNativeMethods.LoCreateContext(
ref contextInfo,
ref lscbkRedef,
out ploc
);
if (lserr != LsErr.None)
{
ThrowExceptionFromLsError(SR.Get(SRID.CreateContextFailure, lserr), lserr);
}
_ploc.Value = ploc;
GC.KeepAlive(contextInfo);
// There is a trick here to pass in this resolution as in twips
// (1/1440 an inch).
//
// LSCreateLine assumes the max width passed in is in twips so to
// allow its client to express their width in page unit. However
// it asks client to set up the real device resolution here so
// that it can internally translate the "twips" width into client
// actual device unit.
//
// We are not device dependent anyway, so instead of following the
// rule which will cause us to validate the context every time. We
// choose to cheat LS to think that our unit is twips.
//
LsDevRes devRes;
devRes.dxpInch = devRes.dxrInch = TwipsPerInch;
devRes.dypInch = devRes.dyrInch = TwipsPerInch;
SetDoc(
true, // Yes, we will be displaying
true, // Yes, reference and presentation are the same device
ref devRes // Device resolutions
);
SetBreaking(BreakStrategies.BreakCJK);
}
}
private void OpenMedia(Uri source)
{
string toOpen = null;
if (source != null && source.IsAbsoluteUri && source.Scheme == PackUriHelper.UriSchemePack)
{
try
{
source = BaseUriHelper.ConvertPackUriToAbsoluteExternallyVisibleUri(source);
}
catch (InvalidOperationException)
{
source = null;
_mediaEventsHelper.RaiseMediaFailed(new System.NotSupportedException(SR.Get(SRID.Media_PackURIsAreNotSupported, null)));
}
}
// Setting a null source effectively disconects the MediaElement.
if (source != null)
{
// keep whether we asserted permissions or not
bool elevated = false;
// get the base directory of the application; never expose this
Uri appBase = SecurityHelper.GetBaseDirectory(AppDomain.CurrentDomain);
// this extracts the URI to open
Uri uriToOpen = ResolveUri(source, appBase);
// access is allowed in the following cases (only 1 & 2 require elevation):
// 1) to any HTTPS media if app is NOT coming from HTTPS
// 2) to URI in the current directory of the fusion cache
// 3) to site of origin media
if (SecurityHelper.AreStringTypesEqual(uriToOpen.Scheme, Uri.UriSchemeHttps))
{
// target is HTTPS. Then, elevate ONLY if we are NOT coming from HTTPS (=XDomain HTTPS app to HTTPS media disallowed)
Uri appDeploymentUri = SecurityHelper.ExtractUriForClickOnceDeployedApp();
if (!SecurityHelper.AreStringTypesEqual(appDeploymentUri.Scheme, Uri.UriSchemeHttps))
{
new WebPermission(NetworkAccess.Connect, BindUriHelper.UriToString(uriToOpen)).Assert();
elevated = true;
}
}
else
{
// elevate to allow access to media in the app's directory in the fusion cache.
new FileIOPermission(FileIOPermissionAccess.Read, appBase.LocalPath).Assert();// BlessedAssert
elevated = true;
}
// demand permissions. if demands succeds, it means we are in one of the cases above.
try
{
toOpen = DemandPermissions(uriToOpen);
}
finally
{
if (elevated)
{
CodeAccessPermission.RevertAssert();
}
}
}
else
{
toOpen = null;
}
// We pass in exact same URI for which we demanded permissions so that we can be sure
// there is no discrepancy between the two.
HRESULT.Check(MILMedia.Open(_nativeMedia, toOpen));
}
/// <summary>
/// Creates a TextEffectCollection with all of the same elements as collection
/// </summary>
public TextEffectCollection(IEnumerable <TextEffect> collection)
{
// The WritePreamble and WritePostscript aren't technically necessary
// in the constructor as of 1/20/05 but they are put here in case
// their behavior changes at a later date
WritePreamble();
if (collection != null)
{
bool needsItemValidation = true;
ICollection <TextEffect> icollectionOfT = collection as ICollection <TextEffect>;
if (icollectionOfT != null)
{
_collection = new FrugalStructList <TextEffect>(icollectionOfT);
}
else
{
ICollection icollection = collection as ICollection;
if (icollection != null) // an IC but not and IC<T>
{
_collection = new FrugalStructList <TextEffect>(icollection);
}
else // not a IC or IC<T> so fall back to the slower Add
{
_collection = new FrugalStructList <TextEffect>();
foreach (TextEffect item in collection)
{
if (item == null)
{
throw new System.ArgumentException(SR.Get(SRID.Collection_NoNull));
}
TextEffect newValue = item;
OnFreezablePropertyChanged(/* oldValue = */ null, newValue);
_collection.Add(newValue);
}
needsItemValidation = false;
}
}
if (needsItemValidation)
{
foreach (TextEffect item in collection)
{
if (item == null)
{
throw new System.ArgumentException(SR.Get(SRID.Collection_NoNull));
}
OnFreezablePropertyChanged(/* oldValue = */ null, item);
}
}
WritePostscript();
}
else
{
throw new ArgumentNullException("collection");
}
}
// NOTE: The code here is highly similar to RemoveChildCore in ModelVisual3D,
// but slightly different because the parent is 2D here.
void IVisual3DContainer.RemoveChild(Visual3D child)
{
int index = child.ParentIndex;
// It is invalid to modify the children collection that we
// might be iterating during a property invalidation tree walk.
if (IsVisualChildrenIterationInProgress)
{
throw new InvalidOperationException(SR.Get(SRID.CannotModifyVisualChildrenDuringTreeWalk));
}
// invalid during a VisualTreeChanged event
VisualDiagnostics.VerifyVisualTreeChange(this);
Debug.Assert(child != null);
Debug.Assert(child.InternalVisualParent == this);
VisualDiagnostics.OnVisualChildChanged(this, child, false);
child.SetParent(/* newParent = */ (Visual)null); // CS0121: Call is ambigious without casting null to Visual.
// remove the inheritance context
if (_inheritanceContextForChildren != null)
{
_inheritanceContextForChildren.RemoveSelfAsInheritanceContext(child, null);
}
//
// Remove the child on all channels this visual is marshalled to.
//
for (int i = 0, limit = _proxy3D.Count; i < limit; i++)
{
DUCE.Channel channel = _proxy3D.GetChannel(i);
if (child.CheckFlagsAnd(channel, VisualProxyFlags.IsConnectedToParent))
{
child.SetFlags(channel, false, VisualProxyFlags.IsConnectedToParent);
DUCE.IResource childResource = (DUCE.IResource)child;
childResource.RemoveChildFromParent(this, channel);
childResource.ReleaseOnChannel(channel);
}
}
SetFlagsOnAllChannels(true, VisualProxyFlags.IsContentDirty);
//
// Force a full precompute and render pass for this visual.
//
Visual.PropagateFlags(
this,
VisualFlags.IsSubtreeDirtyForPrecompute,
VisualProxyFlags.IsSubtreeDirtyForRender);
//
child.FireOnVisualParentChanged(this);
OnVisualChildrenChanged(/* visualAdded = */ null, child);
}