public void UpdateImageConfiguration(BuildContext context, float width, float height) { _imageConfiguration = Unity.UIWidgets.widgets.ImageUtils.createLocalImageConfiguration( context, size: new Size(width, height) ); }
/** * Gets a new {@link Containerizer} that containerizes to a Docker daemon. * * @param dockerDaemonImage the {@link DockerDaemonImage} that defines target Docker daemon * @return a new {@link Containerizer} */ public static Containerizer To(DockerDaemonImage dockerDaemonImage) { dockerDaemonImage = dockerDaemonImage ?? throw new ArgumentNullException(nameof(dockerDaemonImage)); ImageConfiguration imageConfiguration = ImageConfiguration.CreateBuilder(dockerDaemonImage.GetImageReference()) .SetCredentialRetrievers(new List <CredentialRetriever> { () => Maybe.Of(dockerDaemonImage.Credential) }) .Build(); DockerClient.Builder dockerClientBuilder = DockerClient.CreateBuilder(); dockerDaemonImage.GetDockerExecutable().IfPresent(dockerClientBuilder.SetDockerExecutable); dockerClientBuilder.SetDockerEnvironment(ImmutableDictionary.CreateRange(dockerDaemonImage.GetDockerEnvironment())); return(new Containerizer( DescriptionForDockerDaemon, imageConfiguration, StepsRunnerFactory, false)); StepsRunner StepsRunnerFactory(BuildConfiguration buildConfiguration) => StepsRunner.Begin(buildConfiguration) .PullBaseImage(1) .PullAndCacheBaseImageLayers(2) .BuildAndCacheApplicationLayers(3) .BuildImage(4) .LoadDocker(dockerClientBuilder.Build(), 5); }
public override void paint(Canvas canvas, Offset offset, ImageConfiguration configuration) { LinearGradient gradient = _decoration.edgeGradient; if (gradient == null) { return; } TextDirection textDirection = configuration.textDirection; float deltaX = 0.0f; switch (textDirection) { case TextDirection.rtl: deltaX = configuration.size.width; break; case TextDirection.ltr: deltaX = -configuration.size.width; break; } Rect rect = (offset & configuration.size).translate(deltaX, 0.0f); Paint paint = new Paint() { shader = gradient.createShader(rect, textDirection: textDirection) }; canvas.drawRect(rect, paint); }
public _SwitchRenderObjectWidget( Key key = null, bool?value = null, Color activeColor = null, Color inactiveColor = null, ImageProvider activeThumbImage = null, ImageProvider inactiveThumbImage = null, Color activeTrackColor = null, Color inactiveTrackColor = null, ImageConfiguration configuration = null, ValueChanged <bool?> onChanged = null, TickerProvider vsync = null, BoxConstraints additionalConstraints = null, DragStartBehavior?dragStartBehavior = null ) : base(key: key) { D.assert(value != null); this.value = value.Value; this.activeColor = activeColor; this.inactiveColor = inactiveColor; this.activeThumbImage = activeThumbImage; this.inactiveThumbImage = inactiveThumbImage; this.activeTrackColor = activeTrackColor; this.inactiveTrackColor = inactiveTrackColor; this.configuration = configuration; this.onChanged = onChanged; this.vsync = vsync; this.additionalConstraints = additionalConstraints; this.dragStartBehavior = dragStartBehavior; }
protected override void ValidateConfiguration(ImageConfiguration configuration) { if (configuration.HasEmbeddedImage) { throw new InvalidOperationException("V1 encoder does not support embedded images."); } }
public _RenderSwitch( bool?value = null, Color activeColor = null, Color inactiveColor = null, ImageProvider activeThumbImage = null, ImageProvider inactiveThumbImage = null, Color activeTrackColor = null, Color inactiveTrackColor = null, ImageConfiguration configuration = null, BoxConstraints additionalConstraints = null, ValueChanged <bool?> onChanged = null, TickerProvider vsync = null, DragStartBehavior?dragStartBehavior = null ) : base( value: value, tristate: false, activeColor: activeColor, inactiveColor: inactiveColor, onChanged: onChanged, additionalConstraints: additionalConstraints, vsync: vsync ) { this._activeThumbImage = activeThumbImage; this._inactiveThumbImage = inactiveThumbImage; this._activeTrackColor = activeTrackColor; this._inactiveTrackColor = inactiveTrackColor; this._configuration = configuration; this._drag = new HorizontalDragGestureRecognizer { onStart = this._handleDragStart, onUpdate = this._handleDragUpdate, onEnd = this._handleDragEnd, dragStartBehavior = dragStartBehavior ?? DragStartBehavior.down }; }
public override void resolveStreamForKey( ImageConfiguration configuration, ImageStream stream, T key, ImageErrorListener handleError) { if (stream.completer != null || PaintingBinding.instance.imageCache.containsKey(key)) { imageProvider.resolveStreamForKey(configuration, stream, key, handleError); return; } if (context.context == null) { return; } if (Scrollable.recommendDeferredLoadingForContext(context.context)) { SchedulerBinding.instance.scheduleFrameCallback((_) => { async_.scheduleMicrotask( () => { resolveStreamForKey(configuration, stream, key, handleError); return(null); } ); }); return; } imageProvider.resolveStreamForKey(configuration, stream, key, handleError); }
void LoadImage(string url) { Dictionary <string, string> headers = new Dictionary <string, string>(); NetworkImage networkImage = new NetworkImage(url, headers: headers); ImageConfiguration imageConfig = new ImageConfiguration(); this._stream = networkImage.resolve(imageConfig); }
private CompressionOptions GenerateCompressionOptions(ImageConfiguration configuration) { if (!configuration.HasCompression || CanUseImageFormatCompression(configuration)) { return(null); } return(new CompressionOptions(configuration.Compression)); }
public void TestGetImageConfiguration_dockerDaemonImage() { Containerizer containerizer = Containerizer.To(DockerDaemonImage.Named("docker/daemon/image")); ImageConfiguration imageConfiguration = containerizer.GetImageConfiguration(); Assert.AreEqual("docker/daemon/image", imageConfiguration.GetImage().ToString()); Assert.AreEqual(0, imageConfiguration.GetCredentialRetrievers().Length); }
public void TestGetImageConfiguration_tarImage() { Containerizer containerizer = Containerizer.To(TarImage.Named("tar/image").SaveTo(Paths.Get("output/file"))); ImageConfiguration imageConfiguration = containerizer.GetImageConfiguration(); Assert.AreEqual("tar/image", imageConfiguration.GetImage().ToString()); Assert.AreEqual(0, imageConfiguration.GetCredentialRetrievers().Length); }
protected Chunk <TBody> GenerateChunk <TBody>(StructureType type, ImageConfiguration configuration, TBody body) where TBody : class { return(new Chunk <TBody>( new ChunkConfiguration( type, GenerateEncryptionOptions(configuration), GenerateCompressionOptions(configuration)), body)); }
public override void paint(Canvas canvas, Offset offset, ImageConfiguration configuration) { D.assert(configuration != null); D.assert(configuration.size != null); Rect rect = offset & configuration.size; Rect indicator = this._indicatorRectFor(rect).deflate(this.borderSide.width / 2.0f); Paint paint = this.borderSide.toPaint(); paint.strokeCap = StrokeCap.square; canvas.drawLine(indicator.bottomLeft, indicator.bottomRight, paint); }
protected virtual async Task <Stream> CreateImageWriterStreamAsync(ImageConfiguration configuration, Stream output, long totalBytes) { Imaging.ImageFormat imageFormat = ImageFormatFactory.GetFormat(configuration.Format); ImageOptions imageOptions = GenerateImageOptions(configuration, imageFormat, CalculateImageDimensions(imageFormat, totalBytes)); Stream imageStream = imageFormat.CreateWriter(imageOptions).CreateOutputStream(output, true, EncodingConfiguration.BufferSize); await WriteHeaderAsync(imageStream); return(imageStream); }
/** Instantiate with {@link #to}. */ private Containerizer( string description, ImageConfiguration imageConfiguration, Func <BuildConfiguration, StepsRunner> stepsRunnerFactory, bool mustBeOnline) { this.description = description; this.imageConfiguration = imageConfiguration; this.stepsRunnerFactory = stepsRunnerFactory; this.mustBeOnline = mustBeOnline; }
public Task <byte[]> FromStringToPngAsync(string html, int?height = null, int?width = null) { var imageConfiguration = new ImageConfiguration { Content = html, Format = ImageFormat.Png, Quality = 50, }; var resizedImage = ResizeImage(HtmlConverter.Core.HtmlConverter.ConvertHtmlToImage(imageConfiguration), height, width); return(Task.FromResult(resizedImage)); }
/// <summary> /// Converts given Url string to Image. /// </summary> /// <param name="configuration"></param> /// <returns>PDF as byte array.</returns> public static byte[] ConvertUrlToImage(ImageConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } var bytes = ConvertByUrl(configuration.WkhtmlPath, configuration.GetConvertOptions(), configuration.Url, WkhtmlImageExe); Store(configuration.OutputPath, bytes); return(bytes); }
public void TestGetContainerBuilder_BaseImage() { LayerConfiguration[] layerConfigurations = new[] { new LayerConfiguration("appLayer", ImmutableArray <LayerEntry> .Empty) }; var cliConfiguration = new FibCliConfiguration { ImageFormat = ImageFormat.OCI, ImageLayers = layerConfigurations, BaseImage = "reg.io/base-image:tag", Entrypoint = new[] { "Entrypoint" }, Cmd = new[] { "Program", "Arguments" }, Environment = new Dictionary <string, string> { ["Var"] = "Value" }, ImageWorkingDirectory = AbsoluteUnixPath.Get("/working/dir"), ImageUser = "******", Ports = new[] { Port.Tcp(5000) }, Volumes = new[] { AbsoluteUnixPath.Get("/volume") }, Labels = new Dictionary <string, string> { ["Label"] = "data" }, ReproducableBuild = true }; var builder = cliConfiguration.GetContainerBuilder(); var configuration = builder.ToBuildConfiguration(Containerizer.To(DockerDaemonImage.Named("target-image"))); Assert.AreEqual(ManifestFormat.OCI, configuration.GetTargetFormat()); Assert.AreEqual(layerConfigurations, configuration.GetLayerConfigurations()); ImageConfiguration imageConfiguration = configuration.GetBaseImageConfiguration(); Assert.AreEqual("reg.io", imageConfiguration.GetImageRegistry()); Assert.AreEqual("base-image", imageConfiguration.GetImageRepository()); Assert.AreEqual("tag", imageConfiguration.GetImageTag()); IContainerConfiguration containerConfiguration = configuration.GetContainerConfiguration(); Assert.AreEqual(new[] { "Entrypoint" }, containerConfiguration.GetEntrypoint()); Assert.AreEqual(new[] { "Program", "Arguments" }, containerConfiguration.GetProgramArguments()); Assert.AreEqual(new Dictionary <string, string> { ["Var"] = "Value" }, containerConfiguration.GetEnvironmentMap()); Assert.AreEqual(AbsoluteUnixPath.Get("/working/dir"), containerConfiguration.GetWorkingDirectory()); Assert.AreEqual("user", containerConfiguration.GetUser()); Assert.AreEqual(new[] { Port.Tcp(5000) }, containerConfiguration.GetExposedPorts()); Assert.AreEqual(new[] { AbsoluteUnixPath.Get("/volume") }, containerConfiguration.GetVolumes()); Assert.AreEqual(new Dictionary <string, string> { ["Label"] = "data" }, containerConfiguration.GetLabels()); Assert.AreEqual(ContainerConfiguration.DefaultCreationTime, containerConfiguration.GetCreationTime()); }
public async Task <ActionResult> CreateConfiguration([FromBody] ImageConfiguration config) { try { await _containerService.CreateConfigurationAsync(config); return(Ok(JsonConvert.SerializeObject($"Configuration created successfully: {config.Name}"))); } catch (AmazonECSException ex) { return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } }
private EncryptionOptions GenerateEncryptionOptions(ImageConfiguration configuration) { if (configuration.HasEncryption) { return(new EncryptionOptions( configuration.Encryption.Type, _entropyService.GenerateString(16), configuration.Encryption.IterationCount, _entropyService.GenerateBytes(16))); } return(null); }
public async Task SaveAsync(Stream outputStream, EncodingConfiguration encodingConfiguration) { var imageConfiguration = new ImageConfiguration( Format, EmbeddedImage, Directories, Metadata, EncryptionConfiguration, CompressionConfiguration); var encoder = new Codec.V2.ImageEncoder(encodingConfiguration); await encoder.EncodeAsync(imageConfiguration, outputStream); }
//public FibContainerBuilder AddImageCredential(Credential credential) //{ // credential = credential ?? throw new ArgumentNullException(nameof(credential)); //} public FibContainerBuilder(RegistryImage baseImage, BuildConfiguration.Builder buildConfigurationBuilder) { baseImage = baseImage ?? throw new ArgumentNullException(nameof(baseImage)); this.buildConfigurationBuilder = buildConfigurationBuilder ?? throw new ArgumentNullException(nameof(buildConfigurationBuilder)); ImageConfiguration imageConfiguration = ImageConfiguration.CreateBuilder(baseImage.GetImageReference()) .SetCredentialRetrievers(baseImage.GetCredentialRetrievers()) .Build(); buildConfigurationBuilder.SetBaseImageConfiguration(imageConfiguration); }
public void TestGetImageConfiguration_registryImage() { CredentialRetriever credentialRetriever = Mock.Of <CredentialRetriever>(); Containerizer containerizer = Containerizer.To( RegistryImage.Named("registry/image").AddCredentialRetriever(credentialRetriever)); ImageConfiguration imageConfiguration = containerizer.GetImageConfiguration(); Assert.AreEqual("registry/image", imageConfiguration.GetImage().ToString()); Assert.AreEqual( new[] { credentialRetriever }, imageConfiguration.GetCredentialRetrievers()); }
public void TestBuilder_missingValues() { // Target image is missing try { BuildConfiguration.CreateBuilder() .SetBaseImageConfiguration( ImageConfiguration.CreateBuilder(Mock.Of <IImageReference>()).Build()) .SetBaseImageLayersCacheDirectory(Paths.Get("ignored")) .SetApplicationLayersCacheDirectory(Paths.Get("ignored")) .Build(); Assert.Fail("Build configuration should not be built with missing values"); } catch (InvalidOperationException ex) { Assert.AreEqual("Required field is not set: target image configuration", ex.Message); } // Two required fields missing try { BuildConfiguration.CreateBuilder() .SetBaseImageLayersCacheDirectory(Paths.Get("ignored")) .SetApplicationLayersCacheDirectory(Paths.Get("ignored")) .Build(); Assert.Fail("Build configuration should not be built with missing values"); } catch (InvalidOperationException ex) { Assert.AreEqual( "Required fields are not set: base image configuration, target image configuration", ex.Message); } // All required fields missing try { BuildConfiguration.CreateBuilder().Build(); Assert.Fail("Build configuration should not be built with missing values"); } catch (InvalidOperationException ex) { Assert.AreEqual( "Required fields are not set: " + "base image configuration, " + "target image configuration, " + "base image layers cache directory, " + "application layers cache directory", ex.Message); } }
protected async override Task ExecuteEncodeAsync(ImageConfiguration configuration, Stream output) { var chunkLayoutBuilder = new ChunkLayoutBuilder(); var chunkWriter = new ChunkWriter(EncodingConfiguration); chunkLayoutBuilder.Append( GenerateChunk(StructureType.Metadata, configuration, new Metadata(configuration.Metadata)), chunkWriter, new MetadataSerializer()); IList <IList <File> > groupedFiles = _fileGroupingService.GroupFiles(configuration.Files, EncodingConfiguration.FileGroupSize); IDictionary <File, Output.File> mappedFiles = MapFiles(configuration.Files); ICollection <Directory> mappedDirectories = MapDirectories(mappedFiles, configuration.Directories).Values; var fileGroupSerializer = new FileGroupContentsSerializer(EncodingConfiguration); var fileGroups = new List <FileGroup>(); var fileStreams = new List <Stream>(); foreach (var group in groupedFiles) { fileGroups.Add(new FileGroup(group.Select(file => mappedFiles[file]))); var fileGroupStreams = group.Select(file => file.GetStream()).ToList(); fileStreams.AddRange(fileGroupStreams); chunkLayoutBuilder.Append(GenerateChunk( StructureType.FileGroupContents, configuration, new FileGroupContents(new CombinedStream(fileGroupStreams))), chunkWriter, fileGroupSerializer); } chunkLayoutBuilder.Prepend( GenerateChunk(StructureType.FileLayout, configuration, new FileLayout(mappedDirectories, fileGroups)), chunkWriter, new FileLayoutSerializer()); ChunkLayout chunkLayout = await chunkLayoutBuilder.BuildAsync(); var chunkLayoutBytes = await new ChunkLayoutSerializer().SerializeToBytesAsync(chunkLayout); long totalLength = CalculateTotalLength(chunkLayoutBytes, chunkLayout) + 1; //Plus one to force room for padding using (Stream imageStream = await CreateImageWriterStreamAsync(configuration, output, totalLength)) { await WriteBodyData(imageStream, chunkLayoutBytes, chunkLayoutBuilder); } fileStreams.ForEach(stream => stream.Close()); }
private (IList <byte[]> imageData, byte[] paletteData) EncodeImage(Bitmap image, int imageFormat, int paletteFormat = -1, IProgressContext progress = null) { // Create transcoder IImageTranscoder transcoder; if (IsIndexEncoding(imageFormat)) { var indexEncoding = _encodingDefinition.GetIndexEncoding(imageFormat).IndexEncoding; transcoder = ImageConfiguration.Clone() .ConfigureQuantization(options => options.WithColorCount(indexEncoding.MaxColors)) .TranscodeWith(size => indexEncoding) .TranscodePaletteWith(() => _encodingDefinition.GetPaletteEncoding(paletteFormat)) .Build(); } else { transcoder = ImageConfiguration.Clone() .TranscodeWith(size => _encodingDefinition.GetColorEncoding(imageFormat)) .Build(); } byte[] mainImageData = null; byte[] mainPaletteData = null; ExecuteActionWithProgress(() => (mainImageData, mainPaletteData) = transcoder.Encode(image, progress), progress); var imageData = new byte[ImageInfo.MipMapCount + 1][]; imageData[0] = mainImageData; // Decode palette if present, only when mip maps are needed IList <Color> decodedPalette = null; if (mainPaletteData != null && ImageInfo.MipMapCount > 0) { decodedPalette = DecodePalette(mainPaletteData); } // Encode mip maps var(width, height) = (image.Width / 2, image.Height / 2); for (var i = 0; i < ImageInfo.MipMapCount; i++) { imageData[i + 1] = EncodeMipMap(ResizeImage(image, width, height), imageFormat, decodedPalette); width /= 2; height /= 2; } return(imageData, mainPaletteData); }
public _RenderSwitch( bool?value = null, Color activeColor = null, Color inactiveColor = null, Color hoverColor = null, Color focusColor = null, ImageProvider activeThumbImage = null, ImageErrorListener onActiveThumbImageError = null, ImageProvider inactiveThumbImage = null, ImageErrorListener onInactiveThumbImageError = null, Color activeTrackColor = null, Color inactiveTrackColor = null, ImageConfiguration configuration = null, BoxConstraints additionalConstraints = null, TextDirection?textDirection = null, ValueChanged <bool?> onChanged = null, DragStartBehavior?dragStartBehavior = null, bool hasFocus = false, bool hovering = false, _SwitchState state = null ) : base( value: value, tristate: false, activeColor: activeColor, inactiveColor: inactiveColor, hoverColor: hoverColor, focusColor: focusColor, onChanged: onChanged, additionalConstraints: additionalConstraints, hasFocus: hasFocus, hovering: hovering, vsync: state ) { D.assert(textDirection != null); _activeThumbImage = activeThumbImage; _onActiveThumbImageError = onActiveThumbImageError; _inactiveThumbImage = inactiveThumbImage; _onInactiveThumbImageError = onInactiveThumbImageError; _activeTrackColor = activeTrackColor; _inactiveTrackColor = inactiveTrackColor; _configuration = configuration; _drag = new HorizontalDragGestureRecognizer { onStart = _handleDragStart, onUpdate = _handleDragUpdate, onEnd = _handleDragEnd, dragStartBehavior = dragStartBehavior ?? DragStartBehavior.down }; }
public override void paint(Canvas canvas, Size size) { this._needsPaint = false; this._painter = this._painter ?? this.indicator.createBoxPainter(this.markNeedsPaint); if (this.controller.indexIsChanging) { Rect targetRect = this.indicatorRect(size, this.controller.index); this._currentRect = Rect.lerp(targetRect, this._currentRect ?? targetRect, TabsUtils._indexChangeProgress(this.controller)); } else { int currentIndex = this.controller.index; Rect previous = currentIndex > 0 ? this.indicatorRect(size, currentIndex - 1) : null; Rect middle = this.indicatorRect(size, currentIndex); Rect next = currentIndex < this.maxTabIndex ? this.indicatorRect(size, currentIndex + 1) : null; float index = this.controller.index; float value = this.controller.animation.value; if (value == index - 1.0f) { this._currentRect = previous ?? middle; } else if (value == index + 1.0f) { this._currentRect = next ?? middle; } else if (value == index) { this._currentRect = middle; } else if (value < index) { this._currentRect = previous == null ? middle : Rect.lerp(middle, previous, index - value); } else { this._currentRect = next == null ? middle : Rect.lerp(middle, next, value - index); } } D.assert(this._currentRect != null); ImageConfiguration configuration = new ImageConfiguration( size: this._currentRect.size ); this._painter.paint(canvas, this._currentRect.topLeft, configuration); }
public Task EncodeAsync(ImageConfiguration configuration, Stream output) { if (configuration == null) { throw new ArgumentNullException("configuration"); } if (output == null) { throw new ArgumentNullException("output"); } ValidateConfiguration(configuration); return(ExecuteEncodeAsync(configuration, output)); }
public InkDecoration( Decoration decoration = null, ImageConfiguration configuration = null, MaterialInkController controller = null, RenderBox referenceBox = null, VoidCallback onRemoved = null ) : base(controller: controller, referenceBox: referenceBox, onRemoved: onRemoved) { D.assert(configuration != null); D.assert(controller != null); D.assert(referenceBox != null); _configuration = configuration; this.decoration = decoration; this.controller.addInkFeature(this); }