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);
}
