public void RenderMask(ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset)
{
RectInt32 sourceRect = new RectInt32(renderOffset, dstMask.Size <ColorAlpha8>());
if (Interlocked.Exchange(ref this.haveFetchedStamp, 1) == 0)
{
this.lazyStampMaskDevBitmap.EnsureEvaluated();
}
foreach (PointInt32 num2 in this.tileMathHelper.EnumerateTileOffsets(sourceRect))
{
TileData tileData = this.GetTileData(num2);
RectInt32 tileSourceRect = this.tileMathHelper.GetTileSourceRect(num2);
RectInt32 num4 = RectInt32.Intersect(tileSourceRect, sourceRect);
PointInt32 num5 = new PointInt32(num4.X - tileSourceRect.X, num4.Y - tileSourceRect.Y);
RectInt32 bounds = new RectInt32(num4.X - sourceRect.X, num4.Y - sourceRect.Y, num4.Width, num4.Height);
ISurface <ColorAlpha8> surface = dstMask.CreateWindow <ColorAlpha8>(bounds);
object sync = tileData.Sync;
lock (sync)
{
this.UpdateTileWhileLocked(tileData);
if (tileData.Mask == null)
{
surface.Clear();
}
else
{
tileData.Mask.Render(surface, num5);
}
}
}
}
private BitmapLayerToolLayerOverlay <TTool, TChanges> CreateLayerOverlay(BitmapLayer layer, TChanges changes)
{
IRenderer <ColorAlpha8> renderer;
RectInt32 num;
this.tool.VerifyAccess <TTool>();
if (this.autoClipToSelection)
{
this.GetDefaultContentClip(changes, out num, out renderer);
}
else
{
this.tool.GetContentClip(changes, out num, out renderer);
}
ContentBlendMode blendMode = this.tool.GetBlendMode(changes);
IEnumerable <IMaskedRenderer <ColorBgra, ColorAlpha8> > contentRenderers = this.tool.CreateContentRenderers(layer, changes);
if (contentRenderers == null)
{
ExceptionUtil.ThrowInternalErrorException("OnCreateContentRenderer() returned null");
}
RectInt32 maxRenderBounds = changes.GetMaxRenderBounds();
return(new BitmapLayerToolLayerOverlay <TTool, TChanges>(layer, RectInt32.Intersect(layer.Bounds(), RectInt32.Intersect(num, maxRenderBounds)), changes, blendMode, contentRenderers, renderer));
}
private static unsafe void LoadOrSaveSurfaceRegion(Stream stream, Surface surface, RectInt32[] scans, bool trueForSave)
{
int length = scans.Length;
if (length != 0)
{
void *[] voidPtrArray;
ulong[] numArray;
RectInt32 b = surface.Bounds <ColorBgra>();
RectInt32 bounds = RectInt32.Intersect(scans.Bounds(), b);
int num5 = 0;
long num6 = (bounds.Width * bounds.Height) * 4L;
if (((length == 1) && (num6 <= 0xffffffffL)) && surface.IsContiguousMemoryRegion(bounds))
{
voidPtrArray = new void *[] { surface.GetPointAddressUnchecked(bounds.Location.ToGdipPoint()) };
numArray = new ulong[] { num6 };
}
else
{
for (int i = 0; i < length; i++)
{
RectInt32 num9 = RectInt32.Intersect(scans[i], b);
if ((num9.Width != 0) && (num9.Height != 0))
{
num5 += num9.Height;
}
}
int index = 0;
voidPtrArray = new void *[num5];
numArray = new ulong[num5];
for (int j = 0; j < length; j++)
{
RectInt32 num11 = RectInt32.Intersect(scans[j], b);
if ((num11.Width != 0) && (num11.Height != 0))
{
for (int k = num11.Y; k < (num11.Y + num11.Height); k++)
{
voidPtrArray[index] = (void *)surface.GetPointAddress(num11.X, k);
numArray[index] = (ulong)(num11.Width * 4L);
index++;
}
}
}
}
if (trueForSave)
{
WriteToStreamGather(stream, voidPtrArray, numArray);
}
else
{
ReadFromStreamScatter(stream, voidPtrArray, numArray);
}
}
}
public override HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace)
{
GeometryList cachedClippingMask = historyWorkspace.Selection.GetCachedClippingMask();
if (historyWorkspace.Selection.IsEmpty || (cachedClippingMask.Bounds.Area < 1.0))
{
return(null);
}
Document document = historyWorkspace.Document;
List <HistoryMemento> mementos = new List <HistoryMemento>(document.Layers.Count);
RectInt32 b = cachedClippingMask.Bounds.GetInt32Bound(1E-05);
RectInt32 sourceRect = RectInt32.Intersect(document.Bounds(), b);
Document document2 = new Document(sourceRect.Width, sourceRect.Height);
document2.ReplaceMetadataFrom(document);
RectInt32 rect = new RectInt32(0, 0, sourceRect.Width, sourceRect.Height);
IRenderer <ColorAlpha8> cachedClippingMaskRenderer = historyWorkspace.Selection.GetCachedClippingMaskRenderer(historyWorkspace.ToolSettings.Selection.RenderingQuality.Value);
IRenderer <ColorAlpha8> newClipMaskRenderer = new ClippedRenderer <ColorAlpha8>(cachedClippingMaskRenderer, sourceRect);
SelectionHistoryMemento item = new SelectionHistoryMemento(null, null, historyWorkspace);
mementos.Add(item);
base.EnterCriticalRegion();
int count = document.Layers.Count;
while (document.Layers.Count > 0)
{
BitmapLayer layer = (BitmapLayer)document.Layers[0];
Surface croppedSurface = layer.Surface.CreateWindow(sourceRect);
BitmapLayer newLayer = RetryManager.RunMemorySensitiveOperation <BitmapLayer>(() => new BitmapLayer(croppedSurface));
newLayer.LoadProperties(layer.SaveProperties());
HistoryMemento deleteLayerMemento = new DeleteLayerFunction(0).Execute(historyWorkspace);
mementos.Add(deleteLayerMemento);
Task task = Task.Factory.StartNew(delegate {
deleteLayerMemento.Flush();
}, TaskCreationOptions.LongRunning);
Parallel.ForEach <RectInt32>(rect.GetTiles(TilingStrategy.Tiles, 7), delegate(RectInt32 newTileRect) {
ISurface <ColorBgra> surface = newLayer.Surface.CreateWindow(newTileRect);
IRenderer <ColorAlpha8> mask = new ClippedRenderer <ColorAlpha8>(newClipMaskRenderer, newTileRect);
surface.MultiplyAlphaChannel(mask);
});
document2.Layers.Add(newLayer);
task.Wait();
if (document2.Layers.Count > count)
{
ExceptionUtil.ThrowInternalErrorException("newDocument.Layers.Count > oldLayerCount");
}
}
ReplaceDocumentHistoryMemento memento2 = new ReplaceDocumentHistoryMemento(null, null, historyWorkspace);
mementos.Add(memento2);
historyWorkspace.Document = document2;
return(HistoryMemento.Combine(HistoryMementoName, HistoryMementoImage, mementos));
}
public void BeforeRender(RectFloat clipRect)
{
if ((!this.afterRenderCalled || this.beforeRenderCalled) || this.renderCalled)
{
throw new PaintDotNet.InternalErrorException();
}
this.afterRenderCalled = false;
this.beforeRenderCalled = true;
bool flag = this.canvasView.RenderTarget.IsSupported(RenderTargetType.Software, null, null, null);
if (flag || this.IsActive)
{
this.renderStopwatch.Restart();
RectInt32 num2 = RectInt32.Intersect(clipRect.Int32Bound, this.owner.Document.Bounds());
bool flag2 = false;
if (num2.HasPositiveArea)
{
PointInt32 num7;
PointInt32[] array = this.nonCurrentTileOffsets.ToArrayEx <PointInt32>();
this.nonCurrentTileOffsets.Clear();
PointInt32 sourcePt = PointDouble.Round(this.owner.Owner.MouseLocation, MidpointRounding.AwayFromZero);
PointInt32 comparand = this.tileMathHelper.ConvertSourcePointToTileOffset(sourcePt);
CompareTileOffsetsByDistance comparer = new CompareTileOffsetsByDistance(comparand);
ListUtil.Sort <PointInt32, ArrayStruct <PointInt32>, CompareTileOffsetsByDistance>(array.AsStruct <PointInt32>(), comparer);
DequeSet <PointInt32> set = new DequeSet <PointInt32>(array);
int count = set.Count;
while (set.TryDequeue(out num7))
{
if (!this.isDeviceBitmapCurrent[num7.Y][num7.X])
{
if (flag2)
{
this.nonCurrentTileOffsets.TryEnqueue(num7);
}
else
{
if (!this.TryUpdateDeviceBitmap(num7))
{
this.nonCurrentTileOffsets.TryEnqueue(num7);
flag2 = true;
}
if ((!flag2 && !flag) && (this.renderStopwatch.ElapsedMilliseconds > 0x7fffffffffffffffL))
{
flag2 = true;
}
}
}
}
}
}
}
internal void NotifyTileCacheInvalidated(DocumentCanvasTileCache tileCache, RectInt32 sourceRect)
{
int mipLevel = tileCache.MipLevel;
this.mipLayers[mipLevel].NotifyTileCacheInvalidated(sourceRect);
if (this.mipLayers[mipLevel].IsActive)
{
RectInt32 num4 = RectInt32.Intersect(this.canvasView.GetVisibleCanvasBounds().Int32Bound, sourceRect);
if (num4.HasPositiveArea)
{
this.tileCaches[mipLevel].QueueInvalidTilesForRendering(num4, true);
}
}
}
private ColorBgra SampleCurrentLayer(int x, int y)
{
Surface surface = ((BitmapLayer)base.ActiveLayer).Surface;
if (this.currentSampleSize == 1)
{
return(surface[x, y]);
}
int num = (this.currentSampleSize - 1) / 2;
RectInt32 sampleArea = new RectInt32(x - num, y - num, this.currentSampleSize, this.currentSampleSize);
Rectangle bounds = surface.Bounds;
sampleArea.Intersect(new RectInt32(bounds.X, bounds.Y, bounds.Width, bounds.Height));
return(SampleArea(surface, sampleArea));
}
private ColorBgra SampleAllLayers(int x, int y)
{
if (this.currentSampleSize == 1)
{
this.allLayersDocumentRenderer.Render(this.allLayersRenderSurface, new PointInt32(x, y));
return(this.allLayersRenderSurface[0, 0]);
}
int num = (this.currentSampleSize - 1) / 2;
RectInt32 num2 = new RectInt32(x - num, y - num, this.currentSampleSize, this.currentSampleSize);
Rectangle bounds = base.Document.Bounds;
num2.Intersect(new RectInt32(bounds.X, bounds.Y, bounds.Width, bounds.Height));
PointInt32 location = num2.Location;
this.allLayersDocumentRenderer.Render(this.allLayersRenderSurface, location);
return(SampleArea(this.allLayersRenderSurface, new RectInt32(PointInt32.Zero, num2.Size)));
}
public void GetDefaultContentClip(TChanges changes, out RectInt32 clipRect, out IRenderer <ColorAlpha8> clipMaskRenderer)
{
if (this.tool.Selection.IsEmpty)
{
clipMaskRenderer = null;
clipRect = this.tool.Document.Bounds();
}
else
{
GeometryList cachedClippingMask = this.tool.Selection.GetCachedClippingMask();
clipRect = RectInt32.Intersect(cachedClippingMask.Bounds.Int32Bound, this.tool.Document.Bounds());
SelectionRenderingQuality drawingSettingValue = changes.GetDrawingSettingValue <SelectionRenderingQuality>(this.tool.ToolSettings.Selection.RenderingQuality);
Result <IRenderer <ColorAlpha8> > cachedLazyClippingMaskRenderer = this.tool.Selection.GetCachedLazyClippingMaskRenderer(drawingSettingValue);
SizeInt32 size = this.tool.Document.Size();
clipMaskRenderer = LazyRenderer.Create <ColorAlpha8>(size, cachedLazyClippingMaskRenderer);
}
}
public void Render(IDrawingContext dc, RectFloat clipRect, float opacity, BitmapInterpolationMode interpolationMode)
{
if (!this.beforeRenderCalled || this.afterRenderCalled)
{
throw new PaintDotNet.InternalErrorException();
}
this.renderCalled = true;
if (this.isRendering)
{
throw new InvalidOperationException("Render() is not reentrant");
}
RectInt32 sourceRect = RectInt32.Intersect(clipRect.Int32Bound, this.owner.Document.Bounds());
if (sourceRect.HasPositiveArea)
{
this.isRendering = true;
try
{
bool flag = dc.IsSupported(RenderTargetType.Software, null, null, null);
foreach (PointInt32 num3 in this.tileMathHelper.EnumerateTileOffsets(sourceRect))
{
if (flag)
{
IBitmap <ColorPbgra32> bitmap2 = this.tileBuffers[num3.Y][num3.X];
if ((bitmap2 != null) && bitmap2.IsDisposed)
{
continue;
}
}
IDeviceBitmap bitmap = this.deviceBitmaps[num3.Y][num3.X];
if (bitmap != null)
{
RectInt32 tileSourceRect = this.tileMathHelper.GetTileSourceRect(num3.X, num3.Y);
RectFloat?srcRect = null;
dc.DrawBitmap(bitmap, new RectFloat?(tileSourceRect), opacity, interpolationMode, srcRect);
}
}
}
finally
{
this.isRendering = false;
}
}
}
private static ISurface <ColorAlpha8> UseTileOrToSurfaceWithEdgePadding(IRenderer <ColorAlpha8> source, RectInt32 bounds, ColorAlpha8 padding)
{
if (source.Bounds <ColorAlpha8>().Contains(bounds))
{
return(source.UseTileOrToSurface(bounds));
}
ISurface <ColorAlpha8> surface = SurfaceAllocator.Alpha8.Allocate <ColorAlpha8>(bounds.Size, AllocationOptions.ZeroFillNotRequired);
surface.Clear(padding);
RectInt32 num2 = RectInt32.Intersect(source.Bounds <ColorAlpha8>(), bounds);
PointInt32 location = new PointInt32(num2.Location.X - bounds.Location.X, num2.Location.Y - bounds.Location.Y);
RectInt32 num4 = new RectInt32(location, num2.Size);
using (ISurfaceWindow <ColorAlpha8> window = surface.CreateWindow <ColorAlpha8>(num4))
{
source.Render(window, num2.Location);
}
return(surface);
}
protected override void OnMouseMove(MouseEventArgsF e)
{
base.OnMouseMove(e);
PointInt32 b = new PointInt32(e.X, e.Y);
if (this.moveOffsetMode)
{
VectorInt32 num2 = (VectorInt32)(b - this.lastPt);
this.downPt.X += num2.X;
this.downPt.Y += num2.Y;
}
if ((e.Button == MouseButtons.Left) && (this.mouseDown == MouseButtons.Left))
{
VectorDouble num3 = (VectorDouble)(b - this.downPt);
if (num3.Length >= 10.0)
{
goto Label_00B1;
}
}
if (!this.rect.HasPositiveArea)
{
if ((e.Button == MouseButtons.Middle) && (this.mouseDown == MouseButtons.Middle))
{
PointDouble documentScrollPosition = base.DocumentWorkspace.DocumentScrollPosition;
documentScrollPosition.X += b.X - this.lastPt.X;
documentScrollPosition.Y += b.Y - this.lastPt.Y;
base.DocumentWorkspace.DocumentScrollPosition = documentScrollPosition;
base.Update();
}
else
{
this.rect = RectInt32.Zero;
}
goto Label_0173;
}
Label_00B1:
this.rect = RectInt32Util.FromPixelPoints(this.downPt, b);
this.rect = RectInt32.Intersect(this.rect, base.ActiveLayer.Bounds());
this.UpdateDrawnRect();
Label_0173:
this.lastPt = b;
}
private void ProcessInvalidationQueue()
{
if (!base.IsDisposed)
{
RectInt32 num2;
base.VerifyAccess();
int count = this.invalidationQueue.Count;
RectInt32?nullable = null;
while ((count > 0) && this.invalidationQueue.TryDequeue(out num2))
{
nullable = new RectInt32?(RectInt32Util.Union(nullable, num2));
count--;
}
if (nullable.HasValue)
{
RectInt32 invalidRect = RectInt32.Intersect(this.Document.Bounds(), nullable.Value);
this.InvalidateCore(invalidRect);
}
}
}
public RectInt32 GetMaxRenderBounds()
{
RectInt32?cachedMaxRenderBounds;
lock (changes)
{
cachedMaxRenderBounds = this.cachedMaxRenderBounds;
}
RectInt32?nullable2 = cachedMaxRenderBounds;
RectInt32 num = nullable2.HasValue ? nullable2.GetValueOrDefault() : this.OnGetMaxRenderBounds();
lock (changes2)
{
this.cachedMaxRenderBounds = new RectInt32?(num);
}
if (num.IsEmpty)
{
return(TransactedToolChanges.MaxMaxRenderBounds);
}
return(RectInt32.Intersect(num, TransactedToolChanges.MaxMaxRenderBounds));
}
public void RenderMask(ISurface <ColorAlpha8> dstMask, PointInt32 renderOffset, ICancellationToken cancelToken)
{
Validate.Begin().IsNotNull <ISurface <ColorAlpha8> >(dstMask, "dstMask").IsNotNull <ICancellationToken>(cancelToken, "cancelToken").Check();
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
RectInt32 sourceRect = new RectInt32(renderOffset, dstMask.Size <ColorAlpha8>());
if (Interlocked.Exchange(ref this.haveFetchedStamp, 1) == 0)
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
this.lazyStampMaskDevBitmap.EnsureEvaluated();
}
foreach (PointInt32 num2 in this.tileMathHelper.EnumerateTileOffsets(sourceRect))
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
TileData tileData = this.GetTileData(num2);
RectInt32 tileSourceRect = this.tileMathHelper.GetTileSourceRect(num2);
RectInt32 num4 = RectInt32.Intersect(tileSourceRect, sourceRect);
PointInt32 num5 = new PointInt32(num4.X - tileSourceRect.X, num4.Y - tileSourceRect.Y);
RectInt32 bounds = new RectInt32(num4.X - sourceRect.X, num4.Y - sourceRect.Y, num4.Width, num4.Height);
ISurface <ColorAlpha8> surface = dstMask.CreateWindow <ColorAlpha8>(bounds);
object sync = tileData.Sync;
lock (sync)
{
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
this.UpdateTileWhileLocked(tileData, cancelToken);
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
if (tileData.Mask == null)
{
surface.Clear();
}
else
{
tileData.Mask.Render(surface, num5);
}
}
cancelToken.ThrowIfCancellationRequested <ICancellationToken>();
}
}
public void DrawScansBilinear(int cpuNumber)
{
int logicalCpuCount = Processor.LogicalCpuCount;
RectInt32 b = this.dst.Bounds <ColorBgra>();
for (int i = cpuNumber; i < this.dstScans.Length; i += logicalCpuCount)
{
RectInt32 num4 = RectInt32.Intersect(this.dstScans[i], b);
PointDouble pt = new PointDouble((double)num4.X, (double)num4.Y);
pt.X += 0.5;
pt.Y += 0.5;
pt = this.inverse.Transform(pt);
pt.X -= this.boundsX;
pt.Y -= this.boundsY;
pt.X -= 0.5;
pt.Y -= 0.5;
PointDouble num6 = pt;
for (int j = num4.Y; j < (num4.Y + num4.Height); j++)
{
PointDouble num8 = num6;
if (j >= 0)
{
for (int k = num4.X; k < (num4.X + num4.Width); k++)
{
float x = (float)num8.X;
float y = (float)num8.Y;
ColorBgra bilinearSampleClamped = this.src.GetBilinearSampleClamped(x, y);
*(this.dst.GetPointAddressUnchecked(k, j)) = bilinearSampleClamped;
num8.X += this.dsxddx;
num8.Y += this.dsyddx;
}
}
num6.X += this.dsxddy;
num6.Y += this.dsyddy;
}
}
}
public override HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace)
{
if (historyWorkspace.Selection.IsEmpty)
{
return(null);
}
SelectionHistoryMemento memento = new SelectionHistoryMemento(StaticName, StaticImage, historyWorkspace);
GeometryList selectedPath = historyWorkspace.Selection.GetCachedGeometryList();
SelectionRenderingQuality selectionRenderingQuality = historyWorkspace.ToolSettings.Selection.RenderingQuality.Value;
Result <IReadOnlyList <RectInt32> > selectedPathScansLazy = historyWorkspace.Selection.GetCachedLazyClippingMaskScans();
RectInt32 documentBounds = historyWorkspace.Document.Bounds();
Func <GeometryList> invertedPathFn = delegate {
if ((selectionRenderingQuality == SelectionRenderingQuality.Aliased) || selectedPath.IsPixelated)
{
GeometryList list2 = GeometryList.FromNonOverlappingSortedScans(selectedPathScansLazy.Value);
list2.AddRect(documentBounds);
SegmentedList <RectInt32> scans = new SegmentedList <RectInt32>();
foreach (RectInt32 num in list2.EnumerateInteriorScans())
{
if (documentBounds.Contains(num))
{
scans.Add(num);
}
else if (documentBounds.IntersectsWith(num))
{
scans.Add(RectInt32.Intersect(documentBounds, num));
}
}
return(GeometryList.FromNonOverlappingScans(scans));
}
GeometryList lhs = documentBounds.Contains(selectedPath.Bounds) ? selectedPath : GeometryList.ClipToRect(selectedPath, documentBounds);
return(GeometryList.Combine(lhs, GeometryCombineMode.Xor, documentBounds));
};
ThreadTask <GeometryList> task = historyWorkspace.TaskManager.StartNewThreadTask <GeometryList>(task => invertedPathFn(), ApartmentState.MTA);
ManualResetEvent taskFinishedEvent = new ManualResetEvent(false);
task.ResultAsync <GeometryList>().Receive(delegate(Result <GeometryList> r) {
taskFinishedEvent.Set();
}).Observe();
if (!taskFinishedEvent.WaitOne(0x3e8))
{
using (TaskProgressDialog dialog = new TaskProgressDialog())
{
dialog.Task = task;
dialog.Text = StaticName;
dialog.Icon = StaticImage.Reference.ToIcon();
dialog.HeaderText = PdnResources.GetString("SaveConfigDialog.Finishing.Text");
dialog.ShowDialog(historyWorkspace.Window);
}
}
Result <GeometryList> taskResult = task.TaskResult;
if (taskResult.IsError)
{
if (taskResult.Error is OutOfMemoryException)
{
throw new OutOfMemoryException(null, taskResult.Error);
}
throw new AggregateException(null, taskResult.Error);
}
GeometryList geometry = task.TaskResult.Value;
base.EnterCriticalRegion();
using (historyWorkspace.Selection.UseChangeScope())
{
historyWorkspace.Selection.Reset();
geometry.Freeze();
historyWorkspace.Selection.SetContinuation(geometry, SelectionCombineMode.Replace);
historyWorkspace.Selection.CommitContinuation();
}
return(memento);
}
public override HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace)
{
GeometryList cachedClippingMask = historyWorkspace.Selection.GetCachedClippingMask();
if (historyWorkspace.Selection.IsEmpty || (cachedClippingMask.Bounds.Area < 1.0))
{
return(null);
}
Document oldDocument = historyWorkspace.Document;
RectInt32 b = cachedClippingMask.Bounds.GetInt32Bound(1E-05);
RectInt32 oldClipBounds = RectInt32.Intersect(oldDocument.Bounds(), b);
Document document = new Document(oldClipBounds.Width, oldClipBounds.Height);
document.ReplaceMetadataFrom(oldDocument);
RectInt32 newClipBounds = new RectInt32(0, 0, oldClipBounds.Width, oldClipBounds.Height);
SelectionRenderingQuality quality = historyWorkspace.ToolSettings.Selection.RenderingQuality.Value;
Result <IRenderer <ColorAlpha8> > oldClipMaskRendererLazy = historyWorkspace.Selection.GetCachedLazyClippingMaskRenderer(quality);
LazyResult <ClippedRenderer <ColorAlpha8> > newClipMaskRendererLazy = LazyResult.New <ClippedRenderer <ColorAlpha8> >(() => new ClippedRenderer <ColorAlpha8>(oldClipMaskRendererLazy.Value, oldClipBounds), LazyThreadSafetyMode.ExecutionAndPublication, new VistaCriticalSection(0));
SelectionData selectionData = historyWorkspace.Selection.Save();
System.Threading.Tasks.Task <SelectionHistoryMemento> task = System.Threading.Tasks.Task.Factory.StartNew <SelectionHistoryMemento>(() => new SelectionHistoryMemento(null, null, historyWorkspace, selectionData));
System.Threading.Tasks.Task <ReplaceDocumentHistoryMemento> task2 = System.Threading.Tasks.Task.Factory.StartNew <ReplaceDocumentHistoryMemento>(() => new ReplaceDocumentHistoryMemento(null, null, historyWorkspace, oldDocument), TaskCreationOptions.LongRunning);
int count = oldDocument.Layers.Count;
System.Threading.Tasks.Task <BitmapLayer>[] items = new System.Threading.Tasks.Task <BitmapLayer> [count];
for (int i = 0; i < count; i++)
{
int iP = i;
items[iP] = System.Threading.Tasks.Task.Factory.StartNew <BitmapLayer>(delegate {
if (iP == 0)
{
newClipMaskRendererLazy.EnsureEvaluated();
}
BitmapLayer layer = (BitmapLayer)oldDocument.Layers[iP];
Surface croppedSurface = layer.Surface.CreateWindow(oldClipBounds);
BitmapLayer newLayer = RetryManager.RunMemorySensitiveOperation <BitmapLayer>(() => new BitmapLayer(croppedSurface));
newLayer.LoadProperties(layer.SaveProperties());
Parallel.ForEach <RectInt32>(newClipBounds.GetTiles(TilingStrategy.Tiles, 7), delegate(RectInt32 newTileRect) {
ISurface <ColorBgra> surface = newLayer.Surface.CreateWindow(newTileRect);
IRenderer <ColorAlpha8> mask = new ClippedRenderer <ColorAlpha8>(newClipMaskRendererLazy.Value, newTileRect);
surface.MultiplyAlphaChannel(mask);
});
return(newLayer);
});
}
List <TupleStruct <System.Threading.Tasks.Task, double> > collection = new List <TupleStruct <System.Threading.Tasks.Task, double> >();
collection.AddTuple <System.Threading.Tasks.Task, double>(task, 0.1);
collection.AddTuple <System.Threading.Tasks.Task, double>(task2, 1.0);
for (int j = 0; j < items.Length; j++)
{
collection.AddTuple <System.Threading.Tasks.Task, double>(items[j], 0.1);
}
PaintDotNet.Threading.Tasks.Task <Unit> task3 = historyWorkspace.TaskManager.CreateFrameworkTasksWrapper(collection);
historyWorkspace.WaitWithProgress(task3, HistoryMementoImage, HistoryMementoName, PdnResources.GetString("Effects.ApplyingDialog.Description"));
document.Layers.AddRange <Layer>(items.Select <System.Threading.Tasks.Task <BitmapLayer>, BitmapLayer>(t => t.Result));
SelectionHistoryMemento result = task.Result;
ReplaceDocumentHistoryMemento memento2 = task2.Result;
base.EnterCriticalRegion();
historyWorkspace.Document = document;
HistoryMemento[] mementos = new HistoryMemento[] { result, memento2 };
return(HistoryMemento.Combine(HistoryMementoName, HistoryMementoImage, mementos));
}
private void UpdateLayerOverlay()
{
this.tool.VerifyAccess <TTool>();
using (this.updateLayerOverlayRegion.UseEnterScope())
{
TChanges local;
RectInt32?nullable;
RectInt32?nullable2;
RectInt32?nullable3;
RectInt32?nullable4;
BitmapLayerToolLayerOverlay <TTool, TChanges> overlay2;
RectInt32 differentialMaxBounds;
RectInt32 num3;
BitmapLayerToolLayerOverlay <TTool, TChanges> layerOverlay = this.layerOverlay;
if (layerOverlay == null)
{
local = default(TChanges);
nullable = null;
nullable2 = null;
}
else
{
local = layerOverlay.Changes;
nullable = new RectInt32?(local.GetMaxRenderBounds());
nullable2 = new RectInt32?(layerOverlay.AffectedBounds);
}
TChanges changes = this.tool.Changes;
if (changes == null)
{
nullable3 = null;
nullable4 = null;
overlay2 = null;
}
else
{
nullable3 = new RectInt32?(changes.GetMaxRenderBounds());
overlay2 = this.CreateLayerOverlay(this.tool.ActiveLayer, changes);
if (overlay2 == null)
{
ExceptionUtil.ThrowInternalErrorException("CreateLayerOverlay() -> null");
}
nullable4 = new RectInt32?(overlay2.AffectedBounds);
}
RectInt32 num = this.tool.Document.Bounds();
if ((local == null) && (changes != null))
{
differentialMaxBounds = nullable3.Value;
num3 = nullable4.Value;
}
else if ((local != null) && (changes == null))
{
differentialMaxBounds = nullable.Value;
num3 = nullable2.Value;
}
else
{
differentialMaxBounds = this.tool.GetDifferentialMaxBounds(local, changes);
num3 = RectInt32.Union(nullable2.Value, nullable4.Value);
}
RectInt32 num4 = RectInt32.Intersect(differentialMaxBounds, num3);
this.layerOverlay = overlay2;
this.tool.DocumentCanvas.ReplaceLayerOverlay(this.tool.ActiveLayer, layerOverlay, overlay2, new RectInt32?(num4));
}
}
protected override void OnRender(IDrawingContext dc, RectFloat clipRect)
{
if (this.historyStack != null)
{
dc.Clear(new ColorRgba128Float?(this.BackColor));
using (dc.UseTranslateTransform(0f, (float)-this.scrollOffset, MatrixMultiplyOrder.Prepend))
{
int num7;
int num8;
int num11;
int num12;
RectDouble? nullable;
TextLayoutAlgorithm?nullable2;
int num = UIUtil.ScaleWidth(1);
int num2 = (this.itemHeight - this.imageHeight) / 2;
int num3 = UIUtil.ScaleWidth(2);
RectInt32 a = this.ClientRectangleToViewRectangle(base.ClientRectangle.ToRectInt32());
RectInt32 undoViewRectangle = this.UndoViewRectangle;
dc.FillRectangle(undoViewRectangle, PaintDotNet.UI.Media.SystemBrushes.Window);
RectInt32 num6 = RectInt32.Intersect(a, undoViewRectangle);
if ((num6.Width > 0) && (num6.Height > 0))
{
ItemType type;
this.ViewPointToStackIndex(num6.Location, out type, out num7);
this.ViewPointToStackIndex(new PointInt32(num6.Left, num6.Bottom - 1), out type, out num8);
}
else
{
num7 = 0;
num8 = -1;
}
for (int i = num7; i <= num8; i++)
{
DeviceBitmap deviceBitmap;
int imageHeight;
HighlightState hover;
ImageResource image = this.historyStack.UndoStack[i].Image;
if (image != null)
{
deviceBitmap = ImageResourceUtil.GetDeviceBitmap(image);
}
else
{
deviceBitmap = null;
}
if (deviceBitmap != null)
{
imageHeight = (deviceBitmap.PixelSize.Width * this.imageHeight) / deviceBitmap.PixelSize.Height;
}
else
{
imageHeight = this.imageHeight;
}
if (i == (this.historyStack.UndoStack.Count - 1))
{
hover = HighlightState.Checked;
}
else if (i == this.undoItemHighlight)
{
hover = HighlightState.Hover;
}
else
{
hover = HighlightState.Default;
}
RectInt32 bounds = new RectInt32(0, i * this.itemHeight, this.ViewWidth, this.itemHeight);
this.selectionHighlightRenderer.HighlightState = hover;
this.selectionHighlightRenderer.RenderBackground(dc, bounds);
PaintDotNet.UI.Media.Brush embeddedTextBrush = this.selectionHighlightRenderer.EmbeddedTextBrush;
if (deviceBitmap != null)
{
nullable = null;
dc.DrawBitmap(deviceBitmap, new RectDouble?(new RectInt32(bounds.X + num, bounds.Y + num2, imageHeight, this.imageHeight)), 1.0, BitmapInterpolationMode.Linear, nullable);
}
int x = (num + num3) + imageHeight;
RectInt32 num17 = new RectInt32(x, bounds.Y, this.ViewWidth - x, this.itemHeight);
nullable2 = null;
TextLayout textLayout = UIText.CreateLayout(dc, this.historyStack.UndoStack[i].Name, this.Font, nullable2, HotkeyRenderMode.Hide, (double)num17.Width, (double)num17.Height);
textLayout.WordWrapping = WordWrapping.Wrap;
textLayout.ParagraphAlignment = ParagraphAlignment.Center;
UIText.AdjustFontSizeToFitLayoutSize(dc, textLayout, (double)num17.Width, (double)num17.Height, 0.6);
dc.DrawTextLayout(num17.Location, textLayout, embeddedTextBrush, DrawTextOptions.None);
}
RectInt32 redoViewRectangle = this.RedoViewRectangle;
dc.FillRectangle(redoViewRectangle, slateGrayBrush);
RectInt32 num10 = RectInt32.Intersect(a, redoViewRectangle);
if ((num10.Width > 0) && (num10.Height > 0))
{
ItemType type2;
this.ViewPointToStackIndex(num10.Location, out type2, out num11);
this.ViewPointToStackIndex(new PointInt32(num10.Left, num10.Bottom - 1), out type2, out num12);
}
else
{
num11 = 0;
num12 = -1;
}
for (int j = num11; j <= num12; j++)
{
DeviceBitmap bitmap2;
int num20;
PaintDotNet.UI.Media.Brush inactiveCaptionText;
ImageResource imageResource = this.historyStack.RedoStack[j].Image;
if (imageResource != null)
{
bitmap2 = ImageResourceUtil.GetDeviceBitmap(imageResource);
}
else
{
bitmap2 = null;
}
if (bitmap2 != null)
{
num20 = (bitmap2.PixelSize.Width * this.imageHeight) / bitmap2.PixelSize.Height;
}
else
{
num20 = this.imageHeight;
}
RectInt32 num21 = new RectInt32(0, redoViewRectangle.Top + (j * this.itemHeight), this.ViewWidth, this.itemHeight);
if (j == this.redoItemHighlight)
{
this.selectionHighlightRenderer.HighlightState = HighlightState.Hover;
this.selectionHighlightRenderer.RenderBackground(dc, num21);
inactiveCaptionText = this.selectionHighlightRenderer.EmbeddedTextBrush;
}
else
{
inactiveCaptionText = PaintDotNet.UI.Media.SystemBrushes.InactiveCaptionText;
}
if (bitmap2 != null)
{
nullable = null;
dc.DrawBitmap(bitmap2, new RectDouble?(new RectInt32(num21.X + num, num21.Y + num2, num20, this.imageHeight)), 1.0, BitmapInterpolationMode.Linear, nullable);
}
int num22 = (num + num3) + num20;
RectInt32 num23 = new RectInt32(num22, num21.Y, this.ViewWidth - num22, this.itemHeight);
nullable2 = null;
TextLayout layout2 = UIText.CreateLayout(dc, this.historyStack.RedoStack[j].Name, this.Font, nullable2, HotkeyRenderMode.Hide, (double)num23.Width, (double)num23.Height);
layout2.WordWrapping = WordWrapping.NoWrap;
layout2.ParagraphAlignment = ParagraphAlignment.Center;
layout2.FontStyle = PaintDotNet.DirectWrite.FontStyle.Italic;
UIText.AdjustFontSizeToFitLayoutSize(dc, layout2, (double)num23.Width, (double)num23.Height, 0.6);
dc.DrawTextLayout(num23.Location, layout2, inactiveCaptionText, DrawTextOptions.None);
}
}
}
base.OnRender(dc, clipRect);
}
public unsafe void DrawScansNearestNeighbor(int cpuNumber)
{
int logicalCpuCount = Processor.LogicalCpuCount;
void * voidStar = this.src.Scan0.VoidStar;
int stride = this.src.Stride;
RectInt32 b = this.dst.Bounds <ColorBgra>();
for (int i = cpuNumber; i < this.dstScans.Length; i += logicalCpuCount)
{
RectInt32 num5 = RectInt32.Intersect(this.dstScans[i], b);
if ((num5.Width != 0) && (num5.Height != 0))
{
PointDouble pt = new PointDouble((double)num5.X, (double)num5.Y);
pt.X += 0.5;
pt.Y += 0.5;
pt = this.inverse.Transform(pt);
pt.X -= this.boundsX;
pt.Y -= this.boundsY;
pt.X -= 0.5;
pt.Y -= 0.5;
int num7 = (int)(pt.X * 16384.0);
int num8 = (int)(pt.Y * 16384.0);
for (int j = num5.Y; j < (num5.Y + num5.Height); j++)
{
int num10 = num7;
int num11 = num8;
num7 += this.fp_dsxddy;
num8 += this.fp_dsyddy;
if (j >= 0)
{
int x = num5.X;
ColorBgra *pointAddress = this.dst.GetPointAddress(x, j);
ColorBgra *bgraPtr2 = pointAddress + num5.Width;
int num13 = num10 + (this.fp_dsxddx * (num5.Width - 1));
int num14 = num11 + (this.fp_dsyddx * (num5.Width - 1));
while (pointAddress < bgraPtr2)
{
int num15 = (num10 + 0x1fff) >> 14;
int num16 = (num11 + 0x1fff) >> 14;
int num17 = Int32Util.Clamp(num15, 0, this.src.Width - 1);
int y = Int32Util.Clamp(num16, 0, this.src.Height - 1);
pointAddress[0] = this.src.GetPointUnchecked(num17, y);
pointAddress++;
num10 += this.fp_dsxddx;
num11 += this.fp_dsyddx;
if ((num17 == num15) && (y == num16))
{
break;
}
}
ColorBgra *bgraPtr3 = pointAddress;
pointAddress = bgraPtr2 - 1;
while (pointAddress >= bgraPtr3)
{
int num19 = (num13 + 0x1fff) >> 14;
int num20 = (num14 + 0x1fff) >> 14;
int num21 = Int32Util.Clamp(num19, 0, this.src.Width - 1);
int num22 = Int32Util.Clamp(num20, 0, this.src.Height - 1);
pointAddress[0] = this.src.GetPointUnchecked(num21, num22);
if ((num21 == num19) && (num22 == num20))
{
break;
}
pointAddress--;
num13 -= this.fp_dsxddx;
num14 -= this.fp_dsyddx;
}
ColorBgra *bgraPtr4 = pointAddress;
while (bgraPtr3 < bgraPtr4)
{
int num23 = (num10 + 0x1fff) >> 14;
int num24 = (num11 + 0x1fff) >> 14;
bgraPtr3->Bgra = (((IntPtr)(num23 * sizeof(ColorBgra))) + (voidStar + (num24 * stride))).Bgra;
bgraPtr3++;
num10 += this.fp_dsxddx;
num11 += this.fp_dsyddx;
}
}
}
}
}
}
private bool PerformActionImpl()
{
PointInt32 num2;
RectInt32 num3;
if (this.clipData == null)
{
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
CleanupManager.RequestCleanup();
this.clipData = PdnClipboard.GetDataObject();
}
}
catch (OutOfMemoryException exception)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.OutOfMemory"), exception);
return(false);
}
catch (Exception exception2)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.TransferFromClipboard"), exception2);
return(false);
}
}
bool handled = false;
if (this.documentWorkspace.Tool != null)
{
this.documentWorkspace.Tool.PerformPaste(this.clipData, out handled);
}
if (handled)
{
return(true);
}
if (this.maskedSurface == null)
{
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
this.maskedSurface = ClipboardUtil.GetClipboardImage(this.documentWorkspace, this.clipData);
}
}
catch (OutOfMemoryException exception3)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.OutOfMemory"), exception3);
return(false);
}
catch (Exception exception4)
{
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.TransferFromClipboard"), exception4);
return(false);
}
}
if (this.maskedSurface == null)
{
MessageBoxUtil.ErrorBox(this.documentWorkspace, PdnResources.GetString("PasteAction.Error.NoImage"));
return(false);
}
RectInt32 cachedGeometryMaskScansBounds = this.maskedSurface.GetCachedGeometryMaskScansBounds();
if ((cachedGeometryMaskScansBounds.Width > this.documentWorkspace.Document.Width) || (cachedGeometryMaskScansBounds.Height > this.documentWorkspace.Document.Height))
{
Surface surface;
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
surface = CreateThumbnail(this.maskedSurface);
}
}
catch (OutOfMemoryException)
{
surface = null;
}
DialogResult result = ShowExpandCanvasTaskDialog(this.documentWorkspace, surface);
int activeLayerIndex = this.documentWorkspace.ActiveLayerIndex;
ColorBgra background = this.documentWorkspace.ToolSettings.SecondaryColor.Value;
if (result != DialogResult.Cancel)
{
if (result != DialogResult.Yes)
{
if (result != DialogResult.No)
{
throw ExceptionUtil.InvalidEnumArgumentException <DialogResult>(result, "dr");
}
goto Label_031D;
}
using (new PushNullToolMode(this.documentWorkspace))
{
int width = Math.Max(cachedGeometryMaskScansBounds.Width, this.documentWorkspace.Document.Width);
Size newSize = new Size(width, Math.Max(cachedGeometryMaskScansBounds.Height, this.documentWorkspace.Document.Height));
Document document = CanvasSizeAction.ResizeDocument(this.documentWorkspace.Document, newSize, AnchorEdge.TopLeft, background);
if (document == null)
{
return(false);
}
SelectionHistoryMemento memento = new SelectionHistoryMemento(null, null, this.documentWorkspace);
ReplaceDocumentHistoryMemento memento2 = new ReplaceDocumentHistoryMemento(CanvasSizeAction.StaticName, CanvasSizeAction.StaticImage, this.documentWorkspace);
this.documentWorkspace.Document = document;
HistoryMemento[] actions = new HistoryMemento[] { memento, memento2 };
CompoundHistoryMemento memento3 = new CompoundHistoryMemento(CanvasSizeAction.StaticName, CanvasSizeAction.StaticImage, actions);
this.documentWorkspace.History.PushNewMemento(memento3);
this.documentWorkspace.ActiveLayer = (Layer)this.documentWorkspace.Document.Layers[activeLayerIndex];
goto Label_031D;
}
}
return(false);
}
Label_031D:
num3 = this.documentWorkspace.Document.Bounds();
RectDouble visibleDocumentRect = this.documentWorkspace.VisibleDocumentRect;
RectInt32? nullable = visibleDocumentRect.Int32Inset();
RectDouble num5 = nullable.HasValue ? ((RectDouble)nullable.Value) : visibleDocumentRect;
RectInt32 num6 = num5.Int32Bound;
if (num5.Contains(cachedGeometryMaskScansBounds))
{
num2 = new PointInt32(0, 0);
}
else
{
int num12;
int num13;
int num16;
int num17;
if (cachedGeometryMaskScansBounds.X < num5.Left)
{
num12 = -cachedGeometryMaskScansBounds.X + num6.X;
}
else if (cachedGeometryMaskScansBounds.Right > num6.Right)
{
num12 = (-cachedGeometryMaskScansBounds.X + num6.Right) - cachedGeometryMaskScansBounds.Width;
}
else
{
num12 = 0;
}
if (cachedGeometryMaskScansBounds.Y < num5.Top)
{
num13 = -cachedGeometryMaskScansBounds.Y + num6.Y;
}
else if (cachedGeometryMaskScansBounds.Bottom > num6.Bottom)
{
num13 = (-cachedGeometryMaskScansBounds.Y + num6.Bottom) - cachedGeometryMaskScansBounds.Height;
}
else
{
num13 = 0;
}
PointInt32 num14 = new PointInt32(num12, num13);
RectInt32 num15 = new RectInt32(cachedGeometryMaskScansBounds.X + num14.X, cachedGeometryMaskScansBounds.Y + num14.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
if (num15.X < 0)
{
num16 = num12 - num15.X;
}
else
{
num16 = num12;
}
if (num15.Y < 0)
{
num17 = num13 - num15.Y;
}
else
{
num17 = num13;
}
PointInt32 num18 = new PointInt32(num16, num17);
RectInt32 rect = new RectInt32(cachedGeometryMaskScansBounds.X + num18.X, cachedGeometryMaskScansBounds.Y + num18.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
if (num3.Contains(rect))
{
num2 = num18;
}
else
{
PointInt32 num20 = num18;
if (rect.Right > num3.Right)
{
int num21 = rect.Right - num3.Right;
int num22 = Math.Min(num21, rect.Left);
num20.X -= num22;
}
if (rect.Bottom > num3.Bottom)
{
int num23 = rect.Bottom - num3.Bottom;
int num24 = Math.Min(num23, rect.Top);
num20.Y -= num24;
}
num2 = num20;
}
}
RectInt32 b = this.documentWorkspace.VisibleDocumentRect.Int32Bound;
RectInt32 a = new RectInt32(cachedGeometryMaskScansBounds.X + num2.X, cachedGeometryMaskScansBounds.Y + num2.Y, cachedGeometryMaskScansBounds.Width, cachedGeometryMaskScansBounds.Height);
bool hasZeroArea = RectInt32.Intersect(a, b).HasZeroArea;
MoveTool.BeginPaste(this.documentWorkspace, PdnResources.GetString("CommonAction.Paste"), PdnResources.GetImageResource("Icons.MenuEditPasteIcon.png"), this.maskedSurface.SurfaceReadOnly, this.maskedSurface.GeometryMask, num2);
if (hasZeroArea)
{
PointInt32 num25 = new PointInt32(b.Left + (b.Width / 2), b.Top + (b.Height / 2));
PointInt32 num26 = new PointInt32(a.Left + (a.Width / 2), a.Top + (a.Height / 2));
SizeInt32 num27 = new SizeInt32(num26.X - num25.X, num26.Y - num25.Y);
PointDouble documentScrollPosition = this.documentWorkspace.DocumentScrollPosition;
PointDouble num29 = new PointDouble(documentScrollPosition.X + num27.Width, documentScrollPosition.Y + num27.Height);
this.documentWorkspace.DocumentScrollPosition = num29;
}
return(true);
}
public bool PerformAction()
{
bool flag = true;
if (!this.QueryCanPerformAction())
{
return(false);
}
try
{
using (new WaitCursorChanger(this.documentWorkspace))
{
IRenderer <ColorBgra> source = this.GetSource();
RectInt32 num = source.Bounds <ColorBgra>();
GeometryList cachedClippingMask = this.documentWorkspace.Selection.GetCachedClippingMask();
RectInt32 a = cachedClippingMask.Bounds.Int32Bound;
IRenderer <ColorAlpha8> cachedClippingMaskRenderer = this.documentWorkspace.Selection.GetCachedClippingMaskRenderer(this.documentWorkspace.ToolSettings.Selection.RenderingQuality.Value);
RectInt32 sourceRect = RectInt32.Intersect(a, source.Bounds <ColorBgra>());
IRenderer <ColorBgra> renderer3 = new ClippedRenderer <ColorBgra>(source, sourceRect);
IRenderer <ColorAlpha8> alpha = new ClippedRenderer <ColorAlpha8>(cachedClippingMaskRenderer, sourceRect);
IRenderer <ColorBgra> sourceRHS = new MultiplyAlphaChannelRendererBgra32(renderer3, alpha);
IRenderer <ColorBgra> sourceLHS = new SolidColorRendererBgra(sourceRHS.Width, sourceRHS.Height, ColorBgra.White);
IRenderer <ColorBgra> renderer = new BlendRendererBgra(sourceLHS, CompositionOps.Normal.Static, sourceRHS);
if ((a.Width > 0) && (a.Height > 0))
{
int num5 = 10;
while (num5 >= 0)
{
try
{
try
{
using (Clipboard.Transaction transaction = Clipboard.Open(this.documentWorkspace))
{
transaction.Empty();
using (MaskedSurface surface = MaskedSurface.CopyFrom(source, cachedClippingMask))
{
transaction.AddManagedData(surface);
using (Surface surface2 = surface.Surface.CreateWindow(new Rectangle(0, 0, a.Width, a.Height)))
{
sourceRHS.Parallelize <ColorBgra>(TilingStrategy.Tiles, 7, WorkItemQueuePriority.Normal).Render <ColorBgra>(surface2);
using (Bitmap copyBitmap = surface2.CreateAliasedBitmap(true))
{
transaction.AddRawNativeData("PNG", delegate(Stream dstStream) {
copyBitmap.Save(dstStream, ImageFormat.Png);
});
}
renderer.Parallelize <ColorBgra>(TilingStrategy.Tiles, 7, WorkItemQueuePriority.Normal).Render <ColorBgra>(surface2);
using (Bitmap bitmap = surface2.CreateAliasedBitmap(false))
{
transaction.AddDibV5(bitmap);
}
}
goto Label_0292;
}
}
}
catch (Exception exception)
{
if (num5 == 0)
{
flag = false;
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("CopyAction.Error.TransferToClipboard"), exception.ToString());
}
else
{
CleanupManager.RequestCleanup();
CleanupManager.WaitForPendingCleanup(50);
Thread.Sleep(50);
}
}
continue;
}
finally
{
num5--;
}
}
}
}
}
catch (OutOfMemoryException exception2)
{
flag = false;
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("CopyAction.Error.OutOfMemory"), exception2.ToString());
}
catch (Exception exception3)
{
flag = false;
ExceptionDialog.ShowErrorDialog(this.documentWorkspace, PdnResources.GetString("CopyAction.Error.Generic"), exception3.ToString());
}
Label_0292:
CleanupManager.RequestCleanup();
return(flag);
}