/// <inheritdoc/>
public void Bind(IPageContainer container, object db, object r)
{
foreach (var layer in container.Layers)
{
Bind(layer, db, r);
}
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
/// <param name="ic"></param>
public void SetClipboard(IPageContainer container, IImageCache ic)
{
try
{
if (container == null || container.Template == null)
{
return;
}
using (var bitmap = new Bitmap((int)container.Template.Width, (int)container.Template.Height))
{
using (var ms = MakeMetafileStream(bitmap, container, ic))
{
var data = new WPF.DataObject();
data.SetData(WPF.DataFormats.EnhancedMetafile, ms);
WPF.Clipboard.SetDataObject(data, true);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
private void Remove(IPageContainer container)
{
if (container == null)
{
return;
}
container.PropertyChanged -= ObservePage;
if (container.Background != null)
{
container.Background.PropertyChanged -= ObserveTemplateBackgroud;
}
if (container.Layers != null)
{
Remove(container.Layers);
}
if (container.Data != null)
{
Remove(container.Data);
}
if (container.WorkingLayer != null)
{
container.WorkingLayer.InvalidateLayer -= ObserveInvalidateLayer;
}
if (container.HelperLayer != null)
{
container.HelperLayer.InvalidateLayer -= ObserveInvalidateLayer;
}
}
/// <inheritdoc/>
public void Save(Stream stream, IPageContainer container)
{
using var wstream = new SKManagedWStream(stream);
using var writer = new SKXmlStreamWriter(wstream);
using var canvas = SKSvgCanvas.Create(SKRect.Create(0, 0, (int)container.Width, (int)container.Height), writer);
_presenter.Render(canvas, _renderer, container, 0, 0);
}
/// <inheritdoc/>
void IProjectExporter.Save(string path, IPageContainer container)
{
using (var pdf = new PdfDocument())
{
Add(pdf, container);
pdf.Save(path);
}
}
private void Save(string path, IPageContainer container)
{
using (var stream = new SKFileWStream(path))
using (var writer = new SKXmlStreamWriter(stream))
using (var canvas = SKSvgCanvas.Create(SKRect.Create(0, 0, (int)container.Width, (int)container.Height), writer))
{
_presenter.Render(canvas, _renderer, container, 0, 0);
}
}
/// <inheritdoc/>
public void Render(object dc, IShapeRenderer renderer, IPageContainer container, double dx, double dy)
{
renderer.Fill(dc, dx, dy, container.Width, container.Height, container.Background);
if (container.Template != null)
{
renderer.Draw(dc, container.Template, dx, dy);
}
}
/// <summary>
///
/// </summary>
/// <param name="stream"></param>
/// <param name="container"></param>
/// <param name="ic"></param>
public void Save(Stream stream, IPageContainer container, IImageCache ic)
{
if (container != null && container.Template != null)
{
using var bitmap = new Bitmap((int)container.Template.Width, (int)container.Template.Height);
using var ms = MakeMetafileStream(bitmap, container, ic);
ms.WriteTo(stream);
}
}
/// <summary>
/// Set page template.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="page">The page instance.</param>
/// <param name="template">The template instance.</param>
public static void ApplyTemplate(this IProjectContainer project, IPageContainer page, IPageContainer template)
{
if (page != null && template != null)
{
var previous = page.Template;
var next = template;
project?.History?.Snapshot(previous, next, (p) => page.Template = p);
page.Template = next;
}
}
internal Page CloneWithoutChildPages(IPageContainer pageContainer)
{
var clone = new Page(pageContainer, Name, Title, Template, Navigation, Description);
foreach (var item in contents)
{
clone.contents[item.Key] = item.Value;
}
return(clone);
}
/// <inheritdoc/>
void IProjectExporter.Save(string path, IPageContainer container)
{
_outputPath = System.IO.Path.GetDirectoryName(path);
var dxf = new DXF.DxfDocument(DXFH.DxfVersion.AutoCad2010);
Add(dxf, container);
dxf.Save(path);
ClearCache(isZooming: false);
}
/// <summary>
/// Remove template.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="template">The template instance</param>
public static void RemoveTemplate(this IProjectContainer project, IPageContainer template)
{
if (project?.Templates != null && template != null)
{
var previous = project.Templates;
var next = project.Templates.Remove(template);
project?.History?.Snapshot(previous, next, (p) => project.Templates = p);
project.Templates = next;
}
}
/// <summary>
/// Add layer.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="container">The container instance.</param>
/// <param name="layer">The layer instance.</param>
public static void AddLayer(this IProjectContainer project, IPageContainer container, ILayerContainer layer)
{
if (container != null && container.Layers != null && layer != null)
{
var previous = container.Layers;
var next = container.Layers.Add(layer);
project?.History?.Snapshot(previous, next, (p) => container.Layers = p);
container.Layers = next;
}
}
/// <inheritdoc/>
void IProjectExporter.Save(string path, IPageContainer container)
{
using (var stream = new SKFileWStream(path))
{
using (var pdf = SKDocument.CreatePdf(stream, _targetDpi))
{
Add(pdf, container);
pdf.Close();
}
}
}
private void SetClipboard(IPageContainer container, IImageCache ic)
{
var writer = new EmfWriter(_serviceProvider);
using (var bitmap = new Bitmap((int)container.Template.Width, (int)container.Template.Height))
{
using (var ms = writer.MakeMetafileStream(bitmap, container, ic))
{
SetClipboard(ms);
}
}
}
/// <inheritdoc/>
public void Render(object dc, IShapeRenderer renderer, IPageContainer container, double dx, double dy)
{
renderer.Fill(dc, dx, dy, container.Width, container.Height, container.Background);
var db = container.Data == null ? default : container.Data.Properties;
var r = container.Data == null ? default : container.Data.Record;
if (container.Template != null)
{
renderer.Draw(dc, container.Template, dx, dy, db, r);
}
}
/// <inheritdoc/>
public void Save(Stream stream, IPageContainer container)
{
var info = new SKImageInfo((int)container.Width, (int)container.Height);
using var bitmap = new SKBitmap(info);
using (var canvas = new SKCanvas(bitmap))
{
_presenter.Render(canvas, _renderer, container, 0, 0);
}
using var image = SKImage.FromBitmap(bitmap);
using var data = image.Encode(SKEncodedImageFormat.Webp, 100);
data.SaveTo(stream);
}
public Page(IPageContainer pageContainer, string name, string title, string template, bool navigation, string description)
{
this.pageContainer = pageContainer;
this.name = name;
Title = title;
Template = template;
Navigation = navigation;
Description = description;
Pages = new List <Page>();
contents = new Dictionary <string, string>();
Path = BuildPath();
}
/// <summary>
/// Replace page at specified index.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="document">The document instance.</param>
/// <param name="page">The page instance.</param>
/// <param name="index">The page index.</param>
public static void ReplacePage(this IProjectContainer project, IDocumentContainer document, IPageContainer page, int index)
{
if (document != null && page != null && index >= 0)
{
var builder = document.Pages.ToBuilder();
builder[index] = page;
var previous = document.Pages;
var next = builder.ToImmutable();
project?.History?.Snapshot(previous, next, (p) => document.Pages = p);
document.Pages = next;
}
}
internal static Page GetCurrentPage(this Page currentPage)
{
if (currentPage.NavigationProxy.ModalStack.LastOrDefault() is Page modal)
{
return(modal);
}
return(currentPage switch
{
MasterDetailPage mdp => GetCurrentPage(mdp.Detail),
Shell shell when shell.CurrentItem?.CurrentItem is IShellSectionController ssc => ssc.PresentedPage,
IPageContainer <Page> pc => GetCurrentPage(pc.CurrentPage),
_ => currentPage
});
/// <inheritdoc/>
public void Render(object dc, IShapeRenderer renderer, IPageContainer container, double dx, double dy)
{
renderer.Draw(dc, container, dx, dy);
if (container.WorkingLayer != null)
{
renderer.Draw(dc, container.WorkingLayer, dx, dy);
}
if (container.HelperLayer != null)
{
renderer.Draw(dc, container.HelperLayer, dx, dy);
}
}
/// <inheritdoc/>
public void Save(Stream stream, IPageContainer container)
{
var info = new SKImageInfo((int)container.Width, (int)container.Height, SKImageInfo.PlatformColorType, SKAlphaType.Unpremul);
using var bitmap = new SKBitmap(info);
using (var canvas = new SKCanvas(bitmap))
{
canvas.Clear();
_presenter.Render(canvas, _renderer, container, 0, 0);
}
using var image = SKImage.FromBitmap(bitmap);
using var data = image.Encode(SKEncodedImageFormat.Jpeg, 100);
data.SaveTo(stream);
}
/// <summary>
///
/// </summary>
/// <param name="bitmap"></param>
/// <param name="container"></param>
/// <param name="ic"></param>
/// <returns></returns>
public MemoryStream MakeMetafileStream(Bitmap bitmap, IPageContainer container, IImageCache ic)
{
var g = default(Graphics);
var mf = default(Metafile);
var ms = new MemoryStream();
try
{
using (g = Graphics.FromImage(bitmap))
{
var hdc = g.GetHdc();
mf = new Metafile(ms, hdc);
g.ReleaseHdc(hdc);
}
using (g = Graphics.FromImage(mf))
{
var r = new WinFormsRenderer(_serviceProvider, 72.0 / 96.0);
r.State.DrawShapeState.Flags = ShapeStateFlags.Printable;
r.State.ImageCache = ic;
g.SmoothingMode = SmoothingMode.HighQuality;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
g.CompositingQuality = CompositingQuality.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.PageUnit = GraphicsUnit.Display;
r.Draw(g, container.Template, 0.0, 0.0);
r.Draw(g, container, 0.0, 0.0);
r.ClearCache(isZooming: false);
}
}
finally
{
if (g != null)
{
g.Dispose();
}
if (mf != null)
{
mf.Dispose();
}
}
return(ms);
}
private void Add(DXF.DxfDocument dxf, IPageContainer container)
{
if (container.Template != null)
{
_pageWidth = container.Template.Width;
_pageHeight = container.Template.Height;
Draw(dxf, container.Template, 0.0, 0.0, (object)container.Data.Properties, (object)container.Data.Record);
}
else
{
throw new NullReferenceException("Container template must be set.");
}
Draw(dxf, container, 0.0, 0.0, (object)container.Data.Properties, (object)container.Data.Record);
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="container"></param>
/// <param name="ic"></param>
public void Save(string path, IPageContainer container, IImageCache ic)
{
if (container != null && container.Template != null)
{
using (var bitmap = new Bitmap((int)container.Template.Width, (int)container.Template.Height))
{
using (var ms = MakeMetafileStream(bitmap, container, ic))
{
using (var fs = File.Create(path))
{
ms.WriteTo(fs);
}
}
}
}
}
/// <summary>
/// Remove page object from owner document <see cref="IDocumentContainer.Pages"/> collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="page">The page object to remove from document <see cref="IDocumentContainer.Pages"/> collection.</param>
/// <returns>The owner document.</returns>
public static IDocumentContainer RemovePage(this IProjectContainer project, IPageContainer page)
{
if (project?.Documents != null && page != null)
{
var document = project.Documents.FirstOrDefault(d => d.Pages.Contains(page));
if (document != null)
{
var previous = document.Pages;
var next = document.Pages.Remove(page);
project?.History?.Snapshot(previous, next, (p) => document.Pages = p);
document.Pages = next;
}
return(document);
}
return(null);
}
public MainWindow(IServiceProvider serviceProvider, IStepProvider stepProvider, IPageContainer pageContainer, IControllerContainer controllerContainer, IDialogService dialogService)
{
ServiceProvider = serviceProvider;
StepProvider = stepProvider;
PageContainer = pageContainer;
ControllerContainer = controllerContainer;
DialogService = dialogService;
ViewModel.Set("Eject", CreateEjectViewModel());
ViewModel.Step = CreateSteps();
ViewModel.Step.PropertyChanging += Step_PropertyChanging;
ViewModel.Step.PropertyChanged += Step_PropertyChanged;
InitializeComponent();
DataContext = ViewModel;
}
/// <inheritdoc/>
public void Render(object dc, IShapeRenderer renderer, IPageContainer container, double dx, double dy)
{
var flags = renderer.State.DrawShapeState.Flags;
renderer.State.DrawShapeState.Flags = ShapeStateFlags.Printable;
renderer.Fill(dc, dx, dy, container.Width, container.Height, container.Background);
if (container.Template != null)
{
renderer.Draw(dc, container.Template, dx, dy);
}
renderer.Draw(dc, container, dx, dy);
renderer.State.DrawShapeState.Flags = flags;
}
/// <inheritdoc/>
public void Save(Stream stream, IPageContainer container)
{
if (stream is FileStream fileStream)
{
_outputPath = System.IO.Path.GetDirectoryName(fileStream.Name);
}
else
{
_outputPath = string.Empty;
}
var dxf = new DXF.DxfDocument(DXFH.DxfVersion.AutoCad2010);
Add(dxf, container);
dxf.Save(stream);
ClearCache(isZooming: false);
}
private void Save(string path, IPageContainer container)
{
var info = new SKImageInfo((int)container.Width, (int)container.Height);
using (var bitmap = new SKBitmap(info))
{
using (var canvas = new SKCanvas(bitmap))
{
_presenter.Render(canvas, _renderer, container, 0, 0);
}
using (var image = SKImage.FromBitmap(bitmap))
using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
using (var stream = File.OpenWrite(path))
{
data.SaveTo(stream);
}
}
}
